You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: lib.rs
    path of file: ./repos/farm/rust-plugins/sass/src
    
    the code of the file until where you have to start completion: #![deny(clippy::all)]
use std::collections::HashMap;

use farmfe_core::{
  config::Config,
  context::CompilationContext,
  module::{ModuleId, ModuleType},
  plugin::{Plugin, PluginHookContext, PluginResolveHookParam, ResolveKind},
  relative_path::RelativePath,
  serde_json::{self, Value},
};
use farmfe_macro_plugin::farm_plugin;
use farmfe_toolkit::{fs, regex::Regex};
use sass_embedded::{
  FileImporter, OutputStyle, Sass, StringOptions, StringOptionsBuilder, Syntax, Url,
};
use std::path::PathBuf;
use std::sync::Arc;
use std::{env, fmt::Debug};
use std::{
  env::consts::{ARCH, OS},
  fmt::Formatter,
};

const PKG_NAME: &str = "@farmfe/plugin-sass";

#[farm_plugin]
pub struct FarmPluginSass {
  sass_options: String,
  regex: Regex,
}

impl FarmPluginSass {
  pub fn new(_config: &Config, options: String) -> Self {
    Self {
      sass_options: options,
      regex: Regex::new(r#"\.(sass|scss)$"#).unwrap(),
    }
  }

  pub fn get_sass_options(
    &self,
    resolved_path_with_query: String,
    sourcemap_enabled: bool,
  ) -> (StringOptions, 
    
fn get_exe_path(context: &Arc<CompilationContext>) -> PathBuf {
  let os = get_os();
  let arch = get_arch();
  let entry_file = if let "win32" = os {
    "dart-sass-embedded.bat"
  } else {
    "dart-sass-embedded"
  };

  let cur_dir = env::current_dir().unwrap();

  // user manually installs related dependencies
  let manual_installation_path = RelativePath::new(&format!(
    "node_modules/sass-embedded-{os}-{arch}/dart-sass-embedded/{entry_file}"
  ))
  .to_logical_path(&cur_dir);

  if manual_installation_path.exists() {
    return manual_installation_path;
  }

  let pkg_dir = context
    .plugin_driver
    .resolve(
      &PluginResolveHookParam {
        source: PKG_NAME.to_string(),
        importer: None,
        kind: ResolveKind::Import,
      },
      context,
      &PluginHookContext::default(),
    )
    .unwrap()
    .unwrap_or_else(|| {
      panic!(
        "can not resolve @farmfe/plugin-sass start from {}",
        cur_dir.to_string_lossy()
      )
    })
    .resolved_path;

  // find closest node_modules start from pkg_dir
  let mut cur_dir = PathBuf::from(pkg_dir).parent().unwrap().to_path_buf();

  while !cur_dir.join("node_modules").exists() {
    if cur_dir.parent().is_none() {
      panic!("can not find node_modules in @farmfe/plugin-sass");
    }

    cur_dir = cur_dir.parent().unwrap().to_path_buf();
  }

  let default_path = RelativePath::new("node_modules")
    .join(format!("sass-embedded-{os}-{arch}"))
    .join(format!("dart-sass-embedded/{entry_file}"))
    .to_logical_path(&cur_dir);

  default_path
}