sass-loader 16.0.4 → 16.0.6

package/README.md

@@ -13,6 +13,7 @@
 [![coverage][cover]][cover-url]
 [![discussion][discussion]][discussion-url]
 [![size][size]][size-url]
+[![discord-invite][discord-invite]][discord-url]
 
 # sass-loader
 
@@ -44,7 +45,7 @@ pnpm add -D sass-loader sass webpack
 
 `sass-loader` requires you to install either [Dart Sass](https://github.com/sass/dart-sass), [Node Sass](https://github.com/sass/node-sass) on your own (more documentation can be found below) or [Sass Embedded](https://github.com/sass/embedded-host-node).
 
-This allows you to control the versions of all your dependencies, and to choose which Sass implementation to use.
+This allows you to control the versions of all your dependencies and to choose which Sass implementation to use.
 
 > [!NOTE]
 >
@@ -54,7 +55,7 @@ This allows you to control the versions of all your dependencies, and to choose
 >
 > [Node Sass](https://github.com/sass/node-sass) does not work with [Yarn PnP](https://classic.yarnpkg.com/en/docs/pnp/) and doesn't support [@use rule](https://sass-lang.com/documentation/at-rules/use).
 
-Chain the `sass-loader` with the [css-loader](https://github.com/webpack-contrib/css-loader) and the [style-loader](https://github.com/webpack-contrib/style-loader) to immediately apply all styles to the DOM or the [mini-css-extract-plugin](https://github.com/webpack-contrib/mini-css-extract-plugin) to extract it into a separate file.
+Chain the `sass-loader` with the [css-loader](https://github.com/webpack/css-loader) and the [style-loader](https://github.com/webpack/style-loader) to immediately apply all styles to the DOM, or with the [mini-css-extract-plugin](https://github.com/webpack/mini-css-extract-plugin) to extract it into a separate file.
 
 Then add the loader to your webpack configuration. For example:
 
@@ -96,7 +97,7 @@ module.exports = {
 };
 ```
 
-Finally run `webpack` via your preferred method.
+Finally run `webpack` via your preferred method (e.g., via CLI or an npm script).
 
 ### The `style` (new API, by default since 16 version) and `outputStyle` (old API) options in `production` mode
 
@@ -106,13 +107,14 @@ For `production` mode, the `style` (new API, by default since 16 version) and `o
 
 Webpack provides an [advanced mechanism to resolve files](https://webpack.js.org/concepts/module-resolution/).
 
-The `sass-loader` uses Sass's custom importer feature to pass all queries to the webpack resolving engine enabling you to import your Sass modules from `node_modules`.
+The `sass-loader` uses Sass's custom importer feature to pass all queries to the webpack resolving engine, enabling you to import your Sass modules from `node_modules`.
 
 ```scss
 @import "bootstrap";
 ```
 
 Using `~` is deprecated and should be removed from your code, but we still support it for historical reasons.
+
 Why can you remove it? The loader will first try to resolve `@import` as a relative path. If it cannot be resolved, then the loader will try to resolve `@import` inside [`node_modules`](https://webpack.js.org/configuration/resolve/#resolvemodules).
 
 Prepending module paths with a `~` tells webpack to search through [`node_modules`](https://webpack.js.org/configuration/resolve/#resolvemodules).
@@ -122,22 +124,25 @@ Prepending module paths with a `~` tells webpack to search through [`node_module
 ```
 
 It's important to prepend the path with only `~`, because `~/` resolves to the home directory.
+
 Webpack needs to distinguish between `bootstrap` and `~bootstrap` because CSS and Sass files have no special syntax for importing relative files.
+
 Writing `@import "style.scss"` is the same as `@import "./style.scss";`
 
 ### Problems with `url(...)`
 
 Since Sass implementations don't provide [url rewriting](https://github.com/sass/libsass/issues/532), all linked assets must be relative to the output.
 
-- If you pass the generated CSS on to the `css-loader`, all urls must be relative to the entry-file (e.g. `main.scss`).
-- If you're just generating CSS without passing it to the `css-loader`, it must be relative to your web root.
+- If you pass the generated CSS on to the `css-loader`, all URLs must be relative to the entry-file (e.g. `main.scss`).
+- If you're just generating CSS without passing it to the `css-loader`, URLs must be relative to your web root.
 
 You might be surprised by this first issue, as it is natural to expect relative references to be resolved against the `.sass`/`.scss` file in which they are specified (like in regular `.css` files).
 
 Thankfully there are two solutions to this problem:
 
-- Add the missing url rewriting using the [resolve-url-loader](https://github.com/bholloway/resolve-url-loader). Place it before `sass-loader` in the loader chain.
-- Library authors usually provide a variable to modify the asset path. [bootstrap-sass](https://github.com/twbs/bootstrap-sass) for example has an `$icon-font-path`.
+- Add the missing URL rewriting using the [resolve-url-loader](https://github.com/bholloway/resolve-url-loader). Place it before `sass-loader` in the loader chain.
+
+- Library authors usually provide a variable to modify the asset path. [bootstrap-sass](https://github.com/twbs/bootstrap-sass) for example, has an `$icon-font-path`.
 
 ## Options
 
@@ -164,7 +169,7 @@ The special `implementation` option determines which implementation of Sass to u
 By default, the loader resolves the implementation based on your dependencies.
 Just add the desired implementation to your `package.json` (`sass`, `sass-embedded`, or `node-sass` package) and install dependencies.
 
-Example where the `sass-loader` loader uses the `sass` (`dart-sass`) implementation:
+Example where the `sass-loader` uses the `sass` (`dart-sass`) implementation:
 
 **package.json**
 
@@ -177,7 +182,7 @@ Example where the `sass-loader` loader uses the `sass` (`dart-sass`) implementat
 }
 ```
 
-Example where the `sass-loader` loader uses the `node-sass` implementation:
+Example where the `sass-loader` uses the `node-sass` implementation:
 
 **package.json**
 
@@ -190,7 +195,7 @@ Example where the `sass-loader` loader uses the `node-sass` implementation:
 }
 ```
 
-Example where the `sass-loader` loader uses the `sass-embedded` implementation:
+Example where the `sass-loader` uses the `sass-embedded` implementation:
 
 **package.json**
 
@@ -208,8 +213,7 @@ Example where the `sass-loader` loader uses the `sass-embedded` implementation:
 
 > [!NOTE]
 >
-> Using `optionalDependencies` means that `sass-loader` can fallback to `sass`
-> when running on an operating system not supported by `sass-embedded`
+> Using `optionalDependencies` means that `sass-loader` can fallback to `sass` when running on an operating system not supported by `sass-embedded`
 
 Be aware of the order that `sass-loader` will resolve the implementation:
 
@@ -221,7 +225,7 @@ You can specify a specific implementation by using the `implementation` option,
 
 #### `object`
 
-For example, to always use Dart Sass, you'd pass:
+For example, to always use `Dart Sass`, you'd pass:
 
 ```js
 module.exports = {
@@ -293,11 +297,11 @@ Options for [Dart Sass](http://sass-lang.com/dart-sass) or [Node Sass](https://g
 
 > [!NOTE]
 >
-> The `charset` option is `true` by default for `dart-sass`, we strongly discourage setting this to `false`, because webpack doesn't support files other than `utf-8`.
+> The `charset` option is `true` by default for `dart-sass`. We strongly discourage setting this to `false` because webpack doesn't support files other than `utf-8`.
 
 > [!NOTE]
 >
-> The `syntax` (new API, by default since 16 version)`and`indentedSyntax`(old API) option is`scss`for the`scss`extension,`indented`for the`sass`extension and`css`for the`css` extension.
+> The `syntax` (new API, by default since 16 version) and `indentedSyntax` (old API) option is `scss` for the `scss` extension, `indented` for the `sass` extension, and `css` for the `css` extension.
 
 > [!NOTE]
 >
@@ -336,7 +340,7 @@ module.exports = {
             loader: "sass-loader",
             options: {
               sassOptions: {
-                style: `compressed`,
+                style: "compressed",
                 loadPaths: ["absolute/path/a", "absolute/path/b"],
               },
             },
@@ -398,7 +402,7 @@ type sourceMap = boolean;
 
 Default: depends on the `compiler.devtool` value
 
-Enables/Disables generation of source maps.
+Enables/disables generation of source maps.
 
 By default generation of source maps depends on the [`devtool`](https://webpack.js.org/configuration/devtool/) option.
 All values enable source map generation except `eval` and `false`.
@@ -434,9 +438,9 @@ module.exports = {
 };
 ```
 
-> ℹ In some rare cases `node-sass` can output invalid source maps (it is a `node-sass` bug).
+> ℹ In some rare cases `node-sass` can output invalid source maps (this is a `node-sass` bug).
 >
-> In order to avoid this, you can try to update `node-sass` to latest version, or you can try to set within `sassOptions` the `outputStyle` option to `compressed`.
+> In order to avoid this, you can try to update `node-sass` to the latest version, or you can try to set within `sassOptions` the `outputStyle` option to `compressed`.
 
 **webpack.config.js**
 
@@ -496,7 +500,7 @@ module.exports = {
           {
             loader: "sass-loader",
             options: {
-              additionalData: "$env: " + process.env.NODE_ENV + ";",
+              additionalData: `$env: ${process.env.NODE_ENV};`,
             },
           },
         ],
@@ -528,10 +532,10 @@ module.exports = {
                 const relativePath = path.relative(rootContext, resourcePath);
 
                 if (relativePath === "styles/foo.scss") {
-                  return "$value: 100px;" + content;
+                  return `$value: 100px;${content}`;
                 }
 
-                return "$value: 200px;" + content;
+                return `$value: 200px;${content}`;
               },
             },
           },
@@ -562,10 +566,10 @@ module.exports = {
                 const relativePath = path.relative(rootContext, resourcePath);
 
                 if (relativePath === "styles/foo.scss") {
-                  return "$value: 100px;" + content;
+                  return `$value: 100px;${content}`;
                 }
 
-                return "$value: 200px;" + content;
+                return `$value: 200px;${content}`;
               },
             },
           },
@@ -586,10 +590,10 @@ type webpackImporter = boolean;
 
 Default: `true`
 
-Enables/Disables the default webpack importer.
+Enables/disables the default webpack importer.
 
 This can improve performance in some cases, though use it with caution because aliases and `@import` at-rules starting with `~` will not work.
-You can pass your own `importer` to solve this (see [`importer docs`](https://github.com/sass/node-sass#importer--v200---experimental)).
+You can pass your own `importer` to solve this (see [`importer` docs](https://github.com/sass/node-sass#importer--v200---experimental)).
 
 **webpack.config.js**
 
@@ -649,7 +653,7 @@ $known-prefixes: webkit, moz, ms, o;
 }
 ```
 
-The presented code will throw a webpack warning instead logging.
+The presented code will throw a webpack warning instead of logging.
 
 To ignore unnecessary warnings you can use the [ignoreWarnings](https://webpack.js.org/configuration/other-options/#ignorewarnings) option.
 
@@ -691,11 +695,11 @@ Allows you to switch between the `legacy` and `modern` APIs. You can find more i
 
 > [!NOTE]
 >
-> Using `modern-compiler` and `sass-embedded` together significantly improve performance and decrease built time. We strongly recommend their use. We will enable them by default in a future major release.
+> Using `modern-compiler` and `sass-embedded` together significantly improves performance and decreases build time. We strongly recommend their use. We will enable them by default in a future major release.
 
 > [!WARNING]
 >
-> The sass options are different for the `legacy` and `modern` APIs. Please look at [docs](https://sass-lang.com/documentation/js-api) how to migrate to the modern options.
+> The Sass options are different for the `legacy` and `modern` APIs. Please look at [docs](https://sass-lang.com/documentation/js-api) to learn how to migrate to the modern options.
 
 **webpack.config.js**
 
@@ -726,7 +730,7 @@ module.exports = {
 
 ## How to enable `@debug` output
 
-By default, the output of `@debug` messages are disabled.
+By default, the output of `@debug` messages is disabled.
 Add the following to **webpack.config.js** to enable them:
 
 ```js
@@ -742,11 +746,11 @@ module.exports = {
 
 ### Extracts CSS into separate files
 
-For production builds it's recommended to extract the CSS from your bundle to be able to use parallel loading of CSS/JS resources later on.
+For production builds, it's recommended to extract the CSS from your bundle to enable parallel loading of CSS/JS resources.
 
 There are four recommended ways to extract a stylesheet from a bundle:
 
-#### 1. [mini-css-extract-plugin](https://github.com/webpack-contrib/mini-css-extract-plugin)
+#### 1. [mini-css-extract-plugin](https://github.com/webpack/mini-css-extract-plugin)
 
 **webpack.config.js**
 
@@ -785,8 +789,10 @@ module.exports = {
 **webpack.config.js**
 
 ```js
+const path = require("node:path");
+
 module.exports = {
-  entry: [__dirname + "/src/scss/app.scss"],
+  entry: [path.resolve(__dirname, "./src/scss/app.scss")],
   module: {
     rules: [
       {
@@ -815,8 +821,10 @@ module.exports = {
 **webpack.config.js**
 
 ```js
+const path = require("node:path");
+
 module.exports = {
-  entry: [__dirname + "/src/scss/app.scss"],
+  entry: [path.resolve(__dirname, "./src/scss/app.scss")],
   module: {
     rules: [
       {
@@ -844,9 +852,9 @@ module.exports = {
 
 ### Source maps
 
-Enables/Disables generation of source maps.
+Enables/disables generation of source maps.
 
-To enable CSS source maps, you'll need to pass the `sourceMap` option to the `sass-loader` _and_ the `css-loader`.
+To enable CSS source maps, you'll need to pass the `sourceMap` option to both the `sass-loader` _and_ the `css-loader`.
 
 **webpack.config.js**
 
@@ -878,11 +886,13 @@ module.exports = {
 };
 ```
 
-If you want to edit the original Sass files inside Chrome, [there's a good blog post](https://medium.com/@toolmantim/getting-started-with-css-sourcemaps-and-in-browser-sass-editing-b4daab987fb0). Checkout [test/sourceMap](https://github.com/webpack-contrib/sass-loader/tree/master/test) for a running example.
+If you want to edit the original Sass files inside Chrome, [there's a good blog post](https://medium.com/@toolmantim/getting-started-with-css-sourcemaps-and-in-browser-sass-editing-b4daab987fb0).
+Checkout [test/sourceMap](https://github.com/webpack/sass-loader/tree/main/test) for a working example.
 
 ## Contributing
 
-Please take a moment to read our contributing guidelines if you haven't yet done so.
+We welcome all contributions!
+If you're new here, please take a moment to review our contributing guidelines before submitting issues or pull requests.
 
 [CONTRIBUTING](./.github/CONTRIBUTING.md)
 
@@ -894,11 +904,13 @@ Please take a moment to read our contributing guidelines if you haven't yet done
 [npm-url]: https://npmjs.com/package/sass-loader
 [node]: https://img.shields.io/node/v/sass-loader.svg
 [node-url]: https://nodejs.org
-[tests]: https://github.com/webpack-contrib/sass-loader/workflows/sass-loader/badge.svg
-[tests-url]: https://github.com/webpack-contrib/sass-loader/actions
-[cover]: https://codecov.io/gh/webpack-contrib/sass-loader/branch/master/graph/badge.svg
-[cover-url]: https://codecov.io/gh/webpack-contrib/sass-loader
+[tests]: https://github.com/webpack/sass-loader/workflows/sass-loader/badge.svg
+[tests-url]: https://github.com/webpack/sass-loader/actions
+[cover]: https://codecov.io/gh/webpack/sass-loader/branch/main/graph/badge.svg
+[cover-url]: https://codecov.io/gh/webpack/sass-loader
 [discussion]: https://img.shields.io/github/discussions/webpack/webpack
 [discussion-url]: https://github.com/webpack/webpack/discussions
 [size]: https://packagephobia.now.sh/badge?p=sass-loader
 [size-url]: https://packagephobia.now.sh/result?p=sass-loader
+[discord-invite]: https://img.shields.io/discord/1180618526436888586?style=flat&logo=discord&logoColor=white&label=discord
+[discord-url]: https://discord.gg/ARKBCXBu

package/dist/index.js

@@ -4,16 +4,16 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-var _url = _interopRequireDefault(require("url"));
-var _path = _interopRequireDefault(require("path"));
+var _nodePath = _interopRequireDefault(require("node:path"));
+var _nodeUrl = _interopRequireDefault(require("node:url"));
 var _options = _interopRequireDefault(require("./options.json"));
 var _utils = require("./utils");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// eslint-disable-next-line jsdoc/no-restricted-syntax
 /**
  * The sass-loader makes node-sass and dart-sass available to webpack modules.
- *
- * @this {object}
- * @param {string} content
+ * @this {LoaderContext<{ string: any }>}
+ * @param {string} content content
  */
 async function loader(content) {
   const options = this.getOptions(_options.default);
@@ -57,19 +57,19 @@ async function loader(content) {
     // There are situations when the `file`/`span.url` property do not exist
     // Modern API
     if (error.span && typeof error.span.url !== "undefined") {
-      this.addDependency(_url.default.fileURLToPath(error.span.url));
+      this.addDependency(_nodeUrl.default.fileURLToPath(error.span.url));
     }
     // Legacy API
     else if (typeof error.file !== "undefined") {
       // `node-sass` returns POSIX paths
-      this.addDependency(_path.default.normalize(error.file));
+      this.addDependency(_nodePath.default.normalize(error.file));
     }
     callback((0, _utils.errorFactory)(error));
     return;
   }
   let map =
   // Modern API, then legacy API
-  result.sourceMap ? result.sourceMap : result.map ? JSON.parse(result.map) : null;
+  result.sourceMap || (result.map ? JSON.parse(result.map) : null);
 
   // Modify source paths only for webpack, otherwise we do nothing
   if (map && useSourceMap) {
@@ -78,25 +78,25 @@ async function loader(content) {
 
   // Modern API
   if (typeof result.loadedUrls !== "undefined") {
-    result.loadedUrls.filter(loadedUrl => loadedUrl.protocol === "file:").forEach(includedFile => {
-      const normalizedIncludedFile = _url.default.fileURLToPath(includedFile);
+    for (const includedFile of result.loadedUrls.filter(loadedUrl => loadedUrl.protocol === "file:")) {
+      const normalizedIncludedFile = _nodeUrl.default.fileURLToPath(includedFile);
 
       // Custom `importer` can return only `contents` so includedFile will be relative
-      if (_path.default.isAbsolute(normalizedIncludedFile)) {
+      if (_nodePath.default.isAbsolute(normalizedIncludedFile)) {
         this.addDependency(normalizedIncludedFile);
       }
-    });
+    }
   }
   // Legacy API
   else if (typeof result.stats !== "undefined" && typeof result.stats.includedFiles !== "undefined") {
-    result.stats.includedFiles.forEach(includedFile => {
-      const normalizedIncludedFile = _path.default.normalize(includedFile);
+    for (const includedFile of result.stats.includedFiles) {
+      const normalizedIncludedFile = _nodePath.default.normalize(includedFile);
 
       // Custom `importer` can return only `contents` so includedFile will be relative
-      if (_path.default.isAbsolute(normalizedIncludedFile)) {
+      if (_nodePath.default.isAbsolute(normalizedIncludedFile)) {
         this.addDependency(normalizedIncludedFile);
       }
-    });
+    }
   }
   callback(null, result.css.toString(), map);
 }

package/dist/options.json

@@ -4,7 +4,7 @@
   "properties": {
     "implementation": {
       "description": "The implementation of the sass to be used.",
-      "link": "https://github.com/webpack-contrib/sass-loader#implementation",
+      "link": "https://github.com/webpack/sass-loader#implementation",
       "anyOf": [
         {
           "type": "string"
@@ -16,12 +16,12 @@
     },
     "api": {
       "description": "Switch between old and modern API for `sass` (`Dart Sass`) and `Sass Embedded` implementations.",
-      "link": "https://github.com/webpack-contrib/sass-loader#sassoptions",
+      "link": "https://github.com/webpack/sass-loader#sassoptions",
       "enum": ["legacy", "modern", "modern-compiler"]
     },
     "sassOptions": {
       "description": "Options for `node-sass` or `sass` (`Dart Sass`) implementation.",
-      "link": "https://github.com/webpack-contrib/sass-loader#sassoptions",
+      "link": "https://github.com/webpack/sass-loader#sassoptions",
       "anyOf": [
         {
           "type": "object",
@@ -34,7 +34,7 @@
     },
     "additionalData": {
       "description": "Prepends/Appends `Sass`/`SCSS` code before the actual entry file.",
-      "link": "https://github.com/webpack-contrib/sass-loader#additionaldata",
+      "link": "https://github.com/webpack/sass-loader#additionaldata",
       "anyOf": [
         {
           "type": "string"
@@ -46,17 +46,17 @@
     },
     "sourceMap": {
       "description": "Enables/Disables generation of source maps.",
-      "link": "https://github.com/webpack-contrib/sass-loader#sourcemap",
+      "link": "https://github.com/webpack/sass-loader#sourcemap",
       "type": "boolean"
     },
     "webpackImporter": {
       "description": "Enables/Disables default `webpack` importer.",
-      "link": "https://github.com/webpack-contrib/sass-loader#webpackimporter",
+      "link": "https://github.com/webpack/sass-loader#webpackimporter",
       "type": "boolean"
     },
     "warnRuleAsWarning": {
       "description": "Treats the '@warn' rule as a webpack warning.",
-      "link": "https://github.com/webpack-contrib/sass-loader#warnruleaswarning",
+      "link": "https://github.com/webpack/sass-loader#warnruleaswarning",
       "type": "boolean"
     }
   },

package/dist/utils.js

@@ -11,33 +11,47 @@ exports.getSassOptions = getSassOptions;
 exports.getWebpackImporter = getWebpackImporter;
 exports.getWebpackResolver = getWebpackResolver;
 exports.normalizeSourceMap = normalizeSourceMap;
-var _url = _interopRequireDefault(require("url"));
-var _path = _interopRequireDefault(require("path"));
+var _nodePath = _interopRequireDefault(require("node:path"));
+var _nodeUrl = _interopRequireDefault(require("node:url"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/** @typedef {import("sass")} Sass */
+/** @typedef {import("sass").StringOptionsWithImporter} SassSassOptions */
+/** @typedef {import("sass-embedded")} SassEmbedded */
+/** @typedef {import("sass-embedded").StringOptionsWithImporter} SassEmbeddedOptions */
+
+/** @typedef {Sass | SassEmbedded} SassImplementation */
+/** @typedef {SassSassOptions | SassEmbeddedOptions} SassOptions */
+// eslint-disable-next-line jsdoc/no-restricted-syntax
+/** @typedef {Record<string, any>} LoaderOptions */
+
+/**
+ * @returns {Sass | SassEmbedded} sass implementation
+ */
 function getDefaultSassImplementation() {
   let sassImplPkg = "sass";
   try {
     require.resolve("sass-embedded");
     sassImplPkg = "sass-embedded";
-  } catch (ignoreError) {
+  } catch {
     try {
       require.resolve("sass");
-    } catch (_ignoreError) {
+    } catch {
       try {
         require.resolve("node-sass");
         sassImplPkg = "node-sass";
-      } catch (__ignoreError) {
+      } catch {
         sassImplPkg = "sass";
       }
     }
   }
-
-  // eslint-disable-next-line import/no-dynamic-require, global-require
   return require(sassImplPkg);
 }
 
 /**
  * This function is not Webpack-specific and can be used by tools wishing to mimic `sass-loader`'s behaviour, so its signature should not be changed.
+ * @param {LoaderContext} loaderContext loader context
+ * @param {SassImplementation} implementation sass implementation
+ * @returns {SassImplementation} resolved sass implementation
  */
 function getSassImplementation(loaderContext, implementation) {
   let resolvedImplementation = implementation;
@@ -45,7 +59,6 @@ function getSassImplementation(loaderContext, implementation) {
     resolvedImplementation = getDefaultSassImplementation();
   }
   if (typeof resolvedImplementation === "string") {
-    // eslint-disable-next-line import/no-dynamic-require, global-require
     resolvedImplementation = require(resolvedImplementation);
   }
   const {
@@ -60,27 +73,30 @@ function getSassImplementation(loaderContext, implementation) {
   }
   const [implementationName] = infoParts;
   if (implementationName === "dart-sass") {
-    // eslint-disable-next-line consistent-return
     return resolvedImplementation;
   } else if (implementationName === "node-sass") {
-    // eslint-disable-next-line consistent-return
     return resolvedImplementation;
   } else if (implementationName === "sass-embedded") {
-    // eslint-disable-next-line consistent-return
     return resolvedImplementation;
   }
   throw new Error(`Unknown Sass implementation "${implementationName}".`);
 }
 
 /**
- * @param {any} loaderContext
- * @returns {boolean}
+ * @param {LoaderContext} loaderContext loader context
+ * @returns {boolean} true when mode is production, otherwise false
  */
 function isProductionLikeMode(loaderContext) {
   return loaderContext.mode === "production" || !loaderContext.mode;
 }
+
+/**
+ * @param {Importer[]} importers importers
+ * @param {LoaderContext} loaderContext loader context
+ * @returns {Importer[]} proxied importers
+ */
 function proxyCustomImporters(importers, loaderContext) {
-  return [].concat(importers).map(importer => function proxyImporter(...args) {
+  return [importers].flat().map(importer => function proxyImporter(...args) {
     const self = {
       ...this,
       webpackLoaderContext: loaderContext
@@ -91,14 +107,13 @@ function proxyCustomImporters(importers, loaderContext) {
 
 /**
  * Derives the sass options from the loader context and normalizes its values with sane defaults.
- *
- * @param {object} loaderContext
- * @param {object} loaderOptions
- * @param {string} content
- * @param {object} implementation
- * @param {boolean} useSourceMap
- * @param {"legacy" | "modern" | "modern-compiler"} apiType
- * @returns {Object}
+ * @param {LoaderContext} loaderContext loader context
+ * @param {LoaderOptions} loaderOptions loader options
+ * @param {string} content content
+ * @param {SassImplementation} implementation sass implementation
+ * @param {boolean} useSourceMap true when need to generate source maps, otherwise false
+ * @param {"legacy" | "modern" | "modern-compiler"} apiType api type
+ * @returns {SassOptions} sass options
  */
 async function getSassOptions(loaderContext, loaderOptions, content, implementation, useSourceMap, apiType) {
   const options = loaderOptions.sassOptions ? typeof loaderOptions.sassOptions === "function" ? loaderOptions.sassOptions(loaderContext) || {} : loaderOptions.sassOptions : {};
@@ -151,7 +166,7 @@ async function getSassOptions(loaderContext, loaderOptions, content, implementat
     resourcePath
   } = loaderContext;
   if (isModernAPI) {
-    sassOptions.url = _url.default.pathToFileURL(resourcePath);
+    sassOptions.url = _nodeUrl.default.pathToFileURL(resourcePath);
 
     // opt.outputStyle
     if (!sassOptions.style && isProductionLikeMode(loaderContext)) {
@@ -164,7 +179,7 @@ async function getSassOptions(loaderContext, loaderOptions, content, implementat
 
     // If we are compiling sass and indentedSyntax isn't set, automatically set it.
     if (typeof sassOptions.syntax === "undefined") {
-      const ext = _path.default.extname(resourcePath);
+      const ext = _nodePath.default.extname(resourcePath);
       if (ext && ext.toLowerCase() === ".scss") {
         sassOptions.syntax = "scss";
       } else if (ext && ext.toLowerCase() === ".sass") {
@@ -173,10 +188,10 @@ async function getSassOptions(loaderContext, loaderOptions, content, implementat
         sassOptions.syntax = "css";
       }
     }
-    sassOptions.loadPaths = [].concat(
+    sassOptions.loadPaths = [
     // We use `loadPaths` in context for resolver, so it should be always absolute
-    (sassOptions.loadPaths ? sassOptions.loadPaths.slice() : []).map(includePath => _path.default.isAbsolute(includePath) ? includePath : _path.default.join(process.cwd(), includePath))).concat(process.env.SASS_PATH ? process.env.SASS_PATH.split(process.platform === "win32" ? ";" : ":") : []);
-    sassOptions.importers = sassOptions.importers ? Array.isArray(sassOptions.importers) ? sassOptions.importers.slice() : [sassOptions.importers] : [];
+    ...(sassOptions.loadPaths ? [...sassOptions.loadPaths] : []).map(includePath => _nodePath.default.isAbsolute(includePath) ? includePath : _nodePath.default.join(process.cwd(), includePath)), ...(process.env.SASS_PATH ? process.env.SASS_PATH.split(process.platform === "win32" ? ";" : ":") : [])];
+    sassOptions.importers = sassOptions.importers ? Array.isArray(sassOptions.importers) ? [...sassOptions.importers] : [sassOptions.importers] : [];
   } else {
     sassOptions.file = resourcePath;
 
@@ -192,12 +207,12 @@ async function getSassOptions(loaderContext, loaderOptions, content, implementat
       // all paths in sourceMap.sources will be relative to that path.
       // Pretty complicated... :(
       sassOptions.sourceMap = true;
-      sassOptions.outFile = _path.default.join(loaderContext.rootContext, "style.css.map");
+      sassOptions.outFile = _nodePath.default.join(loaderContext.rootContext, "style.css.map");
       sassOptions.sourceMapContents = true;
       sassOptions.omitSourceMapUrl = true;
       sassOptions.sourceMapEmbed = false;
     }
-    const ext = _path.default.extname(resourcePath);
+    const ext = _nodePath.default.extname(resourcePath);
 
     // If we are compiling sass and indentedSyntax isn't set, automatically set it.
     if (ext && ext.toLowerCase() === ".sass" && typeof sassOptions.indentedSyntax === "undefined") {
@@ -207,16 +222,15 @@ async function getSassOptions(loaderContext, loaderOptions, content, implementat
     }
 
     // Allow passing custom importers to `sass`/`node-sass`. Accepts `Function` or an array of `Function`s.
-    sassOptions.importer = sassOptions.importer ? proxyCustomImporters(Array.isArray(sassOptions.importer) ? sassOptions.importer.slice() : [sassOptions.importer], loaderContext) : [];
+    sassOptions.importer = sassOptions.importer ? proxyCustomImporters(Array.isArray(sassOptions.importer) ? [...sassOptions.importer] : [sassOptions.importer], loaderContext) : [];
 
     // Regression on the `sass-embedded` side
     if (loaderOptions.webpackImporter === false && sassOptions.importer.length === 0) {
-      // eslint-disable-next-line no-undefined
       sassOptions.importer = undefined;
     }
-    sassOptions.includePaths = [].concat(process.cwd()).concat(
+    sassOptions.includePaths = [process.cwd(), ...
     // We use `includePaths` in context for resolver, so it should be always absolute
-    (sassOptions.includePaths ? sassOptions.includePaths.slice() : []).map(includePath => _path.default.isAbsolute(includePath) ? includePath : _path.default.join(process.cwd(), includePath))).concat(process.env.SASS_PATH ? process.env.SASS_PATH.split(process.platform === "win32" ? ";" : ":") : []);
+    (sassOptions.includePaths ? [...sassOptions.includePaths] : []).map(includePath => _nodePath.default.isAbsolute(includePath) ? includePath : _nodePath.default.join(process.cwd(), includePath)), ...(process.env.SASS_PATH ? process.env.SASS_PATH.split(process.platform === "win32" ? ";" : ":") : [])];
     if (typeof sassOptions.charset === "undefined") {
       sassOptions.charset = true;
     }
@@ -243,15 +257,12 @@ const IS_PKG_SCHEME = /^pkg:/i;
  *
  * We don't need emulate `dart-sass` "It's not clear which file to import." errors (when "file.ext" and "_file.ext" files are present simultaneously in the same directory).
  * This reduces performance and `dart-sass` always do it on own side.
- *
- * @param {string} url
- * @param {boolean} forWebpackResolver
- * @param {boolean} fromImport
- * @returns {Array<string>}
+ * @param {string} url url
+ * @param {boolean} forWebpackResolver true when for webpack resolver, otherwise false
+ * @param {boolean} fromImport true when from `@import`, otherwise false
+ * @returns {string[]} possible requests
  */
-function getPossibleRequests(
-// eslint-disable-next-line no-shadow
-url, forWebpackResolver = false, fromImport = false) {
+function getPossibleRequests(url, forWebpackResolver = false, fromImport = false) {
   let request = url;
 
   // In case there is module request, send this to webpack resolver
@@ -270,8 +281,8 @@ url, forWebpackResolver = false, fromImport = false) {
   }
 
   // Keep in mind: ext can also be something like '.datepicker' when the true extension is omitted and the filename contains a dot.
-  // @see https://github.com/webpack-contrib/sass-loader/issues/167
-  const extension = _path.default.extname(request).toLowerCase();
+  // @see https://github.com/webpack/sass/issues/167
+  const extension = _nodePath.default.extname(request).toLowerCase();
 
   // Because @import is also defined in CSS, Sass needs a way of compiling plain CSS @imports without trying to import the files at compile time.
   // To accomplish this, and to ensure SCSS is as much of a superset of CSS as possible, Sass will compile any @imports with the following characteristics to plain CSS imports:
@@ -281,15 +292,21 @@ url, forWebpackResolver = false, fromImport = false) {
   //  - imports that have media queries.
   //
   // The `node-sass` package sends `@import` ending on `.css` to importer, it is bug, so we skip resolve
+  // Also sass outputs as is `@import "style.css"`, but `@use "style.css"` should include CSS content
   if (extension === ".css") {
-    return [];
+    return fromImport ? [] : [url];
   }
-  const dirname = _path.default.dirname(request);
+  const dirname = _nodePath.default.dirname(request);
   const normalizedDirname = dirname === "." ? "" : `${dirname}/`;
-  const basename = _path.default.basename(request);
-  const basenameWithoutExtension = _path.default.basename(request, extension);
-  return [...new Set([].concat(fromImport ? [`${normalizedDirname}_${basenameWithoutExtension}.import${extension}`, `${normalizedDirname}${basenameWithoutExtension}.import${extension}`] : []).concat([`${normalizedDirname}_${basename}`, `${normalizedDirname}${basename}`]).concat(forWebpackResolver ? [url] : []))];
+  const basename = _nodePath.default.basename(request);
+  const basenameWithoutExtension = _nodePath.default.basename(request, extension);
+  return [...new Set([...[fromImport ? [`${normalizedDirname}_${basenameWithoutExtension}.import${extension}`, `${normalizedDirname}${basenameWithoutExtension}.import${extension}`] : []].flat(), `${normalizedDirname}_${basename}`, `${normalizedDirname}${basename}`, ...(forWebpackResolver ? [url] : [])])];
 }
+
+/**
+ * @param {(context: string, request: string, callback: (error: Error | null, result: string) => void) => void} callbackResolve callback resolve
+ * @returns {(context: string, request: string) => Promise<string>} promise resolve
+ */
 function promiseResolve(callbackResolve) {
   return (context, request) => new Promise((resolve, reject) => {
     callbackResolve(context, request, (error, result) => {
@@ -301,15 +318,20 @@ function promiseResolve(callbackResolve) {
     });
   });
 }
+
+/**
+ * @param {ResolutionMap} resolutionMap resolution map
+ * @returns {Promise<string>} resolved value
+ */
 async function startResolving(resolutionMap) {
   if (resolutionMap.length === 0) {
-    return Promise.reject();
+    throw new Error("Next");
   }
   const [{
     possibleRequests
   }] = resolutionMap;
   if (possibleRequests.length === 0) {
-    return Promise.reject();
+    throw new Error("Next");
   }
   const [{
     resolve,
@@ -317,14 +339,12 @@ async function startResolving(resolutionMap) {
   }] = resolutionMap;
   try {
     return await resolve(context, possibleRequests[0]);
-  } catch (_ignoreError) {
+  } catch {
     const [, ...tailResult] = possibleRequests;
     if (tailResult.length === 0) {
       const [, ...tailResolutionMap] = resolutionMap;
       return startResolving(tailResolutionMap);
     }
-
-    // eslint-disable-next-line no-param-reassign
     resolutionMap[0].possibleRequests = tailResult;
     return startResolving(resolutionMap);
   }
@@ -334,20 +354,15 @@ const IS_SPECIAL_MODULE_IMPORT = /^~[^/]+$/;
 const IS_NATIVE_WIN32_PATH = /^[a-z]:[/\\]|^\\\\/i;
 
 /**
- * @public
  * Create the resolve function used in the custom Sass importer.
- *
  * Can be used by external tools to mimic how `sass-loader` works, for example
  * in a Jest transform. Such usages will want to wrap `resolve.create` from
  * [`enhanced-resolve`]{@link https://github.com/webpack/enhanced-resolve} to
  * pass as the `resolverFactory` argument.
- *
- * @param {Function} resolverFactory - A factory function for creating a Webpack
- *   resolver.
- * @param {Object} implementation - The imported Sass implementation, both
- *   `sass` (Dart Sass) and `node-sass` are supported.
- * @param {string[]} [includePaths] - The list of include paths passed to Sass.
- *
+ * @param {ResolveFactory} resolverFactory a factory function for creating a Webpack resolver.
+ * @param {Sass} implementation the imported Sass implementation, both `sass` (Dart Sass) and `node-sass` are supported.
+ * @param {string[]=} includePaths the list of include paths passed to Sass.
+ * @returns {Resolver} webpack resolver
  * @throws If a compatible Sass implementation cannot be found.
  */
 function getWebpackResolver(resolverFactory, implementation, includePaths = []) {
@@ -408,17 +423,15 @@ function getWebpackResolver(resolverFactory, implementation, includePaths = [])
     // See https://github.com/webpack/webpack/issues/12340
     // Because `node-sass` calls our importer before `1. Filesystem imports relative to the base file.`
     // custom importer may not return `{ file: '/path/to/name.ext' }` and therefore our `context` will be relative
-    if (!isModernSass && !_path.default.isAbsolute(context)) {
+    if (!isModernSass && !_nodePath.default.isAbsolute(context)) {
       return Promise.reject();
     }
     const originalRequest = request;
     const isFileScheme = originalRequest.slice(0, 5).toLowerCase() === "file:";
     if (isFileScheme) {
       try {
-        // eslint-disable-next-line no-param-reassign
-        request = _url.default.fileURLToPath(originalRequest);
-      } catch (ignoreError) {
-        // eslint-disable-next-line no-param-reassign
+        request = _nodeUrl.default.fileURLToPath(originalRequest);
+      } catch {
         request = request.slice(7);
       }
     }
@@ -447,32 +460,35 @@ function getWebpackResolver(resolverFactory, implementation, includePaths = [])
 
       // `node-sass` calls our importer before `1. Filesystem imports relative to the base file.`, so we need emulate this too
       if (!isModernSass) {
-        resolutionMap = resolutionMap.concat({
+        resolutionMap = [...resolutionMap, {
           resolve: fromImport ? sassImportResolve : sassModuleResolve,
-          context: _path.default.dirname(context),
+          context: _nodePath.default.dirname(context),
           possibleRequests: sassPossibleRequests
-        });
+        }];
       }
-      resolutionMap = resolutionMap.concat(
-      // eslint-disable-next-line no-shadow
-      includePaths.map(context => {
-        return {
-          resolve: fromImport ? sassImportResolve : sassModuleResolve,
-          context,
-          possibleRequests: sassPossibleRequests
-        };
-      }));
+      resolutionMap = [...resolutionMap, ...includePaths.map(context => ({
+        resolve: fromImport ? sassImportResolve : sassModuleResolve,
+        context,
+        possibleRequests: sassPossibleRequests
+      }))];
     }
     const webpackPossibleRequests = getPossibleRequests(request, true, fromImport);
-    resolutionMap = resolutionMap.concat({
+    resolutionMap = [...resolutionMap, {
       resolve: fromImport ? webpackImportResolve : webpackModuleResolve,
-      context: _path.default.dirname(context),
+      context: _nodePath.default.dirname(context),
       possibleRequests: webpackPossibleRequests
-    });
+    }];
     return startResolving(resolutionMap);
   };
 }
 const MATCH_CSS = /\.css$/i;
+
+/**
+ * @param {LoaderContext} loaderContext loader context
+ * @param {SassImplementation} implementation sass implementation
+ * @param {string[]} loadPaths load paths
+ * @returns {Importer} the modern webpack importer
+ */
 function getModernWebpackImporter(loaderContext, implementation, loadPaths) {
   const resolve = getWebpackResolver(loaderContext.getResolve, implementation, loadPaths);
   return {
@@ -480,19 +496,19 @@ function getModernWebpackImporter(loaderContext, implementation, loadPaths) {
       const {
         fromImport
       } = context;
-      const prev = context.containingUrl ? _url.default.fileURLToPath(context.containingUrl.toString()) : loaderContext.resourcePath;
+      const prev = context.containingUrl ? _nodeUrl.default.fileURLToPath(context.containingUrl.toString()) : loaderContext.resourcePath;
       let result;
       try {
         result = await resolve(prev, originalUrl, fromImport);
-      } catch (err) {
+      } catch {
         // If no stylesheets are found, the importer should return null.
         return null;
       }
-      loaderContext.addDependency(_path.default.normalize(result));
-      return _url.default.pathToFileURL(result);
+      loaderContext.addDependency(_nodePath.default.normalize(result));
+      return _nodeUrl.default.pathToFileURL(result);
     },
     async load(canonicalUrl) {
-      const ext = _path.default.extname(canonicalUrl.pathname);
+      const ext = _nodePath.default.extname(canonicalUrl.pathname);
       let syntax;
       if (ext && ext.toLowerCase() === ".scss") {
         syntax = "scss";
@@ -505,17 +521,16 @@ function getModernWebpackImporter(loaderContext, implementation, loadPaths) {
         syntax = "scss";
       }
       try {
-        // eslint-disable-next-line no-shadow
         const contents = await new Promise((resolve, reject) => {
           // Old version of `enhanced-resolve` supports only path as a string
           // TODO simplify in the next major release and pass URL
-          const canonicalPath = _url.default.fileURLToPath(canonicalUrl);
-          loaderContext.fs.readFile(canonicalPath, "utf8", (err, content) => {
+          const canonicalPath = _nodeUrl.default.fileURLToPath(canonicalUrl);
+          loaderContext.fs.readFile(canonicalPath, (err, content) => {
             if (err) {
               reject(err);
               return;
             }
-            resolve(content);
+            resolve(content.toString("utf8"));
           });
         });
         return {
@@ -523,23 +538,32 @@ function getModernWebpackImporter(loaderContext, implementation, loadPaths) {
           syntax,
           sourceMapUrl: canonicalUrl
         };
-      } catch (err) {
+      } catch {
         return null;
       }
     }
   };
 }
+
+/**
+ * @param {LoaderContext} loaderContext loader context
+ * @param {SassImplementation} implementation sass implementation
+ * @param {string[]} includePaths include paths
+ * @returns {Importer} the webpack importer
+ */
 function getWebpackImporter(loaderContext, implementation, includePaths) {
   const resolve = getWebpackResolver(loaderContext.getResolve, implementation, includePaths);
   return function importer(originalUrl, prev, done) {
     const {
       fromImport
     } = this;
-    resolve(prev, originalUrl, fromImport).then(result => {
+    resolve(prev, originalUrl,
+    // For `node-sass`
+    typeof fromImport === "undefined" ? true : fromImport).then(result => {
       // Add the result as dependency.
       // Although we're also using stats.includedFiles, this might come in handy when an error occurs.
       // In this case, we don't get stats.includedFiles from node-sass/sass.
-      loaderContext.addDependency(_path.default.normalize(result));
+      loaderContext.addDependency(_nodePath.default.normalize(result));
 
       // By removing the CSS file extension, we trigger node-sass to include the CSS file instead of just linking it.
       done({
@@ -559,11 +583,10 @@ const sassModernCompilers = new WeakMap();
 
 /**
  * Verifies that the implementation and version of Sass is supported by this loader.
- *
- * @param {Object} loaderContext
- * @param {Object} implementation
- * @param {"legacy" | "modern" | "modern-compiler"} apiType
- * @returns {Function}
+ * @param {LoaderContext} loaderContext loader context
+ * @param {SassImplementation} implementation sass implementation
+ * @param {"legacy" | "modern" | "modern-compiler"} apiType api type
+ * @returns {SassCompileFunction} compile function
  */
 function getCompileFn(loaderContext, implementation, apiType) {
   if (typeof implementation.compileStringAsync !== "undefined") {
@@ -578,7 +601,6 @@ function getCompileFn(loaderContext, implementation, apiType) {
     }
     if (apiType === "modern-compiler") {
       return async sassOptions => {
-        // eslint-disable-next-line no-underscore-dangle
         const webpackCompiler = loaderContext._compiler;
         const {
           data,
@@ -628,8 +650,9 @@ function getCompileFn(loaderContext, implementation, apiType) {
   // We need to use a job queue to make sure that one thread is always available to the UV lib
   if (nodeSassJobQueue === null) {
     const threadPoolSize = Number(process.env.UV_THREADPOOL_SIZE || 4);
+
     // Only used for `node-sass`, so let's load it lazily
-    // eslint-disable-next-line global-require
+
     const async = require("neo-async");
     nodeSassJobQueue = async.queue(implementation.render.bind(implementation), threadPoolSize - 1);
   }
@@ -646,8 +669,8 @@ function getCompileFn(loaderContext, implementation, apiType) {
 const ABSOLUTE_SCHEME = /^[A-Za-z0-9+\-.]+:/;
 
 /**
- * @param {string} source
- * @returns {"absolute" | "scheme-relative" | "path-absolute" | "path-absolute"}
+ * @param {string} source source
+ * @returns {"absolute" | "scheme-relative" | "path-absolute" | "path-absolute"} a type of URL
  */
 function getURLType(source) {
   if (source[0] === "/") {
@@ -661,44 +684,47 @@ function getURLType(source) {
   }
   return ABSOLUTE_SCHEME.test(source) ? "absolute" : "path-relative";
 }
+
+/**
+ * @param {RawSourceMap} map source map
+ * @param {string} rootContext root context
+ * @returns {RawSourceMap} normalized source map
+ */
 function normalizeSourceMap(map, rootContext) {
   const newMap = map;
 
   // result.map.file is an optional property that provides the output filename.
   // Since we don't know the final filename in the webpack build chain yet, it makes no sense to have it.
-  // eslint-disable-next-line no-param-reassign
+
   if (typeof newMap.file !== "undefined") {
     delete newMap.file;
   }
-
-  // eslint-disable-next-line no-param-reassign
   newMap.sourceRoot = "";
 
   // node-sass returns POSIX paths, that's why we need to transform them back to native paths.
   // This fixes an error on windows where the source-map module cannot resolve the source maps.
-  // @see https://github.com/webpack-contrib/sass-loader/issues/366#issuecomment-279460722
-  // eslint-disable-next-line no-param-reassign
+  // @see https://github.com/webpack/sass-loader/issues/366#issuecomment-279460722
+
   newMap.sources = newMap.sources.map(source => {
     const sourceType = getURLType(source);
 
     // Do no touch `scheme-relative`, `path-absolute` and `absolute` types (except `file:`)
     if (sourceType === "absolute" && /^file:/i.test(source)) {
-      return _url.default.fileURLToPath(source);
+      return _nodeUrl.default.fileURLToPath(source);
     } else if (sourceType === "path-relative") {
-      return _path.default.resolve(rootContext, _path.default.normalize(source));
+      return _nodePath.default.resolve(rootContext, _nodePath.default.normalize(source));
     }
     return source;
   });
   return newMap;
 }
+
+/**
+ * @param {Error | SassError} error the original sass error
+ * @returns {Error} a new error
+ */
 function errorFactory(error) {
-  let message;
-  if (error.formatted) {
-    message = error.formatted.replace(/^(.+)?Error: /, "");
-  } else {
-    // Keep original error if `sassError.formatted` is unavailable
-    message = (error.message || error.toString()).replace(/^(.+)?Error: /, "");
-  }
+  const message = error.formatted ? error.formatted.replace(/^(.+)?Error: /, "") : (error.message || error.toString()).replace(/^(.+)?Error: /, "");
   const obj = new Error(message, {
     cause: error
   });

package/package.json

@@ -1,35 +1,41 @@
 {
   "name": "sass-loader",
-  "version": "16.0.4",
+  "version": "16.0.6",
   "description": "Sass loader for webpack",
-  "license": "MIT",
-  "repository": "webpack-contrib/sass-loader",
-  "author": "J. Tangelder",
-  "homepage": "https://github.com/webpack-contrib/sass-loader",
-  "bugs": "https://github.com/webpack-contrib/sass-loader/issues",
+  "keywords": [
+    "sass",
+    "libsass",
+    "webpack",
+    "loader"
+  ],
+  "homepage": "https://github.com/webpack/sass-loader",
+  "bugs": "https://github.com/webpack/sass-loader/issues",
+  "repository": "webpack/sass-loader",
   "funding": {
     "type": "opencollective",
     "url": "https://opencollective.com/webpack"
   },
+  "license": "MIT",
+  "author": "J. Tangelder",
   "main": "dist/cjs.js",
-  "engines": {
-    "node": ">= 18.12.0"
-  },
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "start": "npm run build -- -w",
     "clean": "del-cli dist",
     "prebuild": "npm run clean",
     "build": "cross-env NODE_ENV=production babel src -d dist --copy-files",
-    "commitlint": "commitlint --from=master",
+    "commitlint": "commitlint --from=main",
     "security": "npm audit --production",
     "lint:prettier": "prettier --cache --list-different .",
-    "lint:js": "eslint --cache .",
+    "lint:code": "eslint --cache .",
     "lint:spelling": "cspell --cache --no-must-find-files --quiet \"**/*.*\"",
     "lint": "npm-run-all -l -p \"lint:**\"",
     "test:only": "cross-env NODE_ENV=test jest",
-    "fix:js": "npm run lint:js -- --fix",
+    "fix:code": "npm run lint:code -- --fix",
     "fix:prettier": "npm run lint:prettier -- --write",
-    "fix": "npm-run-all -l fix:js fix:prettier",
+    "fix": "npm-run-all -l fix:code fix:prettier",
     "test:watch": "npm run test:only -- --watch",
     "test:manual": "npm run build && webpack-dev-server test/manual/src/index.js --open --config test/manual/webpack.config.js",
     "test:coverage": "npm run test:only -- --collectCoverageFrom=\"src/**/*.js\" --coverage",
@@ -38,9 +44,59 @@
     "prepare": "husky && npm run build",
     "release": "standard-version"
   },
-  "files": [
-    "dist"
-  ],
+  "dependencies": {
+    "neo-async": "^2.6.2"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.28.0",
+    "@babel/core": "^7.28.0",
+    "@babel/preset-env": "^7.28.0",
+    "@commitlint/cli": "^19.8.1",
+    "@commitlint/config-conventional": "^19.8.1",
+    "@eslint/js": "^9.32.0",
+    "@eslint/markdown": "^7.0.0",
+    "@stylistic/eslint-plugin": "^5.2.2",
+    "bootstrap-sass": "^3.4.1",
+    "bootstrap-v4": "npm:bootstrap@^4.5.3",
+    "bootstrap-v5": "npm:bootstrap@^5.3.7",
+    "cross-env": "^7.0.3",
+    "cspell": "^8.19.4",
+    "css-loader": "^6.9.0",
+    "del": "^6.1.1",
+    "del-cli": "^5.1.0",
+    "enhanced-resolve": "^5.18.2",
+    "eslint": "^9.32.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-config-webpack": "^4.5.1",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-jest": "^29.0.1",
+    "eslint-plugin-jsdoc": "^52.0.0",
+    "eslint-plugin-n": "^17.21.0",
+    "eslint-plugin-prettier": "^5.5.3",
+    "eslint-plugin-unicorn": "^60.0.0",
+    "file-loader": "^6.2.0",
+    "foundation-sites": "^6.7.5",
+    "globals": "^16.3.0",
+    "husky": "^9.1.3",
+    "jest": "^30.0.5",
+    "lint-staged": "^15.5.2",
+    "material-components-web": "^9.0.0",
+    "memfs": "^4.23.0",
+    "node-sass": "^9.0.0",
+    "node-sass-glob-importer": "^5.3.2",
+    "npm-run-all": "^4.1.5",
+    "prettier": "^3.6.2",
+    "sass": "^1.89.2",
+    "sass-embedded": "^1.89.2",
+    "semver": "^7.7.2",
+    "standard-version": "^9.3.1",
+    "style-loader": "^3.3.4",
+    "typescript": "^5.9.2",
+    "typescript-eslint": "^8.39.0",
+    "webpack": "^5.101.0",
+    "webpack-cli": "^6.0.1",
+    "webpack-dev-server": "^5.2.2"
+  },
   "peerDependencies": {
     "@rspack/core": "0.x || 1.x",
     "node-sass": "^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0 || ^9.0.0",
@@ -65,54 +121,7 @@
       "optional": true
     }
   },
-  "dependencies": {
-    "neo-async": "^2.6.2"
-  },
-  "devDependencies": {
-    "@babel/cli": "^7.23.4",
-    "@babel/core": "^7.24.0",
-    "@babel/preset-env": "^7.24.0",
-    "@commitlint/cli": "^19.3.0",
-    "@commitlint/config-conventional": "^19.2.2",
-    "@webpack-contrib/eslint-config-webpack": "^3.0.0",
-    "babel-jest": "^29.6.2",
-    "bootstrap-sass": "^3.4.1",
-    "bootstrap-v4": "npm:bootstrap@^4.5.3",
-    "bootstrap-v5": "npm:bootstrap@^5.0.1",
-    "cross-env": "^7.0.3",
-    "cspell": "^8.6.0",
-    "css-loader": "^6.9.0",
-    "del": "^6.1.1",
-    "del-cli": "^5.1.0",
-    "enhanced-resolve": "^5.15.1",
-    "eslint": "^8.57.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-import": "^2.28.0",
-    "file-loader": "^6.2.0",
-    "foundation-sites": "^6.7.5",
-    "husky": "^9.1.3",
-    "jest": "^29.6.2",
-    "jest-environment-node-single-context": "^29.1.0",
-    "lint-staged": "^15.2.0",
-    "material-components-web": "^9.0.0",
-    "memfs": "^4.7.7",
-    "node-sass": "^9.0.0",
-    "node-sass-glob-importer": "^5.3.2",
-    "npm-run-all": "^4.1.5",
-    "prettier": "^3.2.2",
-    "sass": "^1.71.1",
-    "sass-embedded": "^1.71.1",
-    "semver": "^7.5.4",
-    "standard-version": "^9.3.1",
-    "style-loader": "^3.3.4",
-    "webpack": "^5.93.0",
-    "webpack-cli": "^5.1.4",
-    "webpack-dev-server": "^5.0.4"
-  },
-  "keywords": [
-    "sass",
-    "libsass",
-    "webpack",
-    "loader"
-  ]
+  "engines": {
+    "node": ">= 18.12.0"
+  }
 }