evilebottnawi

sokra

jhnns

sass-loader

Object.defineProperty(exports, "__esModule", {

var _path = _interopRequireDefault(require("path"));

var _schemaUtils = require("schema-utils");

var _loaderUtils = require("loader-utils");

var _options = _interopRequireDefault(require("./options.json"));

var _SassError = _interopRequireDefault(require("./SassError"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 * The sass-loader makes node-sass and dart-sass available to webpack modules.

  const options = (0, _loaderUtils.getOptions)(this);

  (0, _schemaUtils.validate)(_options.default, options, {

  const implementation = (0, _utils.getSassImplementation)(this, options.implementation);

  const useSourceMap = typeof options.sourceMap === "boolean" ? options.sourceMap : this.sourceMap;

  const sassOptions = await (0, _utils.getSassOptions)(this, options, content, implementation, useSourceMap);

  const shouldUseWebpackImporter = typeof options.webpackImporter === "boolean" ? options.webpackImporter : true;

    sassOptions.importer.push((0, _utils.getWebpackImporter)(this, implementation, includePaths));

  const render = (0, _utils.getRenderFunctionFromSassImplementation)(implementation);

  render(sassOptions, (error, result) => {

      // There are situations when the `file` property do not exist

        // `node-sass` returns POSIX paths

        this.addDependency(_path.default.normalize(error.file));

      callback(new _SassError.default(error));

    let map = result.map ? JSON.parse(result.map) : null;

    // Modify source paths only for webpack, otherwise we do nothing

      map = (0, _utils.normalizeSourceMap)(map, this.rootContext);

    result.stats.includedFiles.forEach(includedFile => {

      const normalizedIncludedFile = _path.default.normalize(includedFile);

      // Custom `importer` can return only `contents` so includedFile will be relative

      if (_path.default.isAbsolute(normalizedIncludedFile)) {

        this.addDependency(normalizedIncludedFile);

    callback(null, result.css.toString(), map);

    // Keep original error if `sassError.formatted` is unavailable

    this.message = `${this.name}: ${this.originalSassError.message}`;

    if (this.originalSassError.formatted) {

      this.message = `${this.name}: ${this.originalSassError.formatted.replace(/^Error: /, "")}`;

      // Instruct webpack to hide the JS stack from the console.

      // Usually you're only interested in the SASS stack in this case.

      Error.captureStackTrace(this, this.constructor);

var _default = exports.default = SassError;

exports.getRenderFunctionFromSassImplementation = getRenderFunctionFromSassImplementation;

exports.getSassImplementation = getSassImplementation;

exports.getWebpackImporter = getWebpackImporter;

exports.getWebpackResolver = getWebpackResolver;

exports.isSupportedFibers = isSupportedFibers;

exports.normalizeSourceMap = normalizeSourceMap;

var _url = _interopRequireDefault(require("url"));

var _semver = _interopRequireDefault(require("semver"));

var _neoAsync = _interopRequireDefault(require("neo-async"));

function getDefaultSassImplementation() {

        require.resolve("sass-embedded");

  // eslint-disable-next-line import/no-dynamic-require, global-require

 * 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.

function getSassImplementation(loaderContext, implementation) {

  let resolvedImplementation = implementation;

      resolvedImplementation = getDefaultSassImplementation();

    loaderContext.emitError(new Error("Unknown Sass implementation."));

    loaderContext.emitError(new Error(`Unknown Sass implementation "${info}".`));

  const [implementationName, version] = infoParts;

  if (implementationName === "dart-sass") {

    if (!_semver.default.satisfies(version, "^1.3.0")) {

      loaderContext.emitError(new Error(`Dart Sass version ${version} is incompatible with ^1.3.0.`));

    // eslint-disable-next-line consistent-return

  } else if (implementationName === "node-sass") {

    if (!_semver.default.satisfies(version, "^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0")) {

      loaderContext.emitError(new Error(`Node Sass version ${version} is incompatible with ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0.`));

    if (!_semver.default.satisfies(version, "^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0 || ^9.0.0")) {

      loaderContext.emitError(new Error(`Node Sass version ${version} is incompatible with ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0 || ^9.0.0.`));

  } else if (implementationName === "sass-embedded") {

  loaderContext.emitError(new Error(`Unknown Sass implementation "${implementationName}".`));

  const [nodeVersion] = process.versions.node.split(".");

function isProductionLikeMode(loaderContext) {

  return loaderContext.mode === "production" || !loaderContext.mode;

function proxyCustomImporters(importers, loaderContext) {

  return [].concat(importers).map(importer => function proxyImporter(...args) {

    this.webpackLoaderContext = loaderContext;

 * Derives the sass options from the loader context and normalizes its values with sane defaults.

async function getSassOptions(loaderContext, loaderOptions, content, implementation, useSourceMap) {

  const options = (0, _full.klona)(loaderOptions.sassOptions ? typeof loaderOptions.sassOptions === "function" ? loaderOptions.sassOptions(loaderContext) || {} : loaderOptions.sassOptions : {});

  const isDartSass = implementation.info.includes("dart-sass");

  if (isDartSass && isSupportedFibers()) {

    const shouldTryToResolveFibers = !options.fiber && options.fiber !== false;

        fibers = require.resolve("fibers");

        // eslint-disable-next-line global-require, import/no-dynamic-require

    } else if (options.fiber === false) {

      // Don't pass the `fiber` option for `sass` (`Dart Sass`)

    // Don't pass the `fiber` option for `node-sass`

  options.file = loaderContext.resourcePath;

  options.data = loaderOptions.additionalData ? typeof loaderOptions.additionalData === "function" ? await loaderOptions.additionalData(content, loaderContext) : `${loaderOptions.additionalData}\n${content}` : content;

  if (!options.outputStyle && isProductionLikeMode(loaderContext)) {

    // Deliberately overriding the sourceMap option here.

    // node-sass won't produce source maps if the data option is used and options.sourceMap is not a string.

    // In case it is a string, options.sourceMap should be a path where the source map is written.

    // But since we're using the data option, the source map will not actually be written, but

    // all paths in sourceMap.sources will be relative to that path.

    options.outFile = _path.default.join(loaderContext.rootContext, "style.css.map");

  const ext = _path.default.extname(resourcePath);

  // If we are compiling sass and indentedSyntax isn't set, automatically set it.

  if (ext && ext.toLowerCase() === ".sass" && typeof options.indentedSyntax === "undefined") {

    options.indentedSyntax = Boolean(options.indentedSyntax);

  // Allow passing custom importers to `sass`/`node-sass`. Accepts `Function` or an array of `Function`s.

  options.importer = options.importer ? proxyCustomImporters(Array.isArray(options.importer) ? options.importer : [options.importer], loaderContext) : [];

  options.includePaths = [].concat(process.cwd()).concat(

  // We use `includePaths` in context for resolver, so it should be always absolute

  (options.includePaths || []).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" ? ";" : ":") : []);

  "description": "Sass loader for webpack",

  "repository": "webpack-contrib/sass-loader",

  "homepage": "https://github.com/webpack-contrib/sass-loader",

  "bugs": "https://github.com/webpack-contrib/sass-loader/issues",

    "url": "https://opencollective.com/webpack"

    "build": "cross-env NODE_ENV=production babel src -d dist --copy-files",

    "commitlint": "commitlint --from=master",

    "lint:prettier": "prettier --list-different .",

    "lint": "npm-run-all -l -p \"lint:**\"",

    "test:only": "cross-env NODE_ENV=test jest",

    "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",

    "node-sass": "^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0 || ^9.0.0",

    "@commitlint/config-conventional": "^11.0.0",

    "@webpack-contrib/defaults": "^6.3.0",

    "@webpack-contrib/eslint-config-webpack": "^3.0.0",

		@@ -69,3 +69,2 @@ "use strict";
		}
		var _default = loader;
		exports.default = _default;
		var _default = exports.default = loader;

		@@ -29,3 +29,2 @@ "use strict";
		}
		var _default = SassError;
		exports.default = _default;
		var _default = exports.default = SassError;

		{
		"name": "sass-loader",
		"version": "10.5.1",
		"version": "10.5.2",
		"description": "Sass loader for webpack",
		@@ -5,0 +5,0 @@ "license": "MIT",

		@@ -78,4 +78,4 @@ "use strict";
		} else if (implementationName === "node-sass") {
		if (!_semver.default.satisfies(version, "^4.0.0 \|\| ^5.0.0 \|\| ^6.0.0 \|\| ^7.0.0 \|\| ^8.0.0")) {
		loaderContext.emitError(new Error(`Node Sass version ${version} is incompatible with ^4.0.0 \|\| ^5.0.0 \|\| ^6.0.0 \|\| ^7.0.0 \|\| ^8.0.0.`));
		if (!_semver.default.satisfies(version, "^4.0.0 \|\| ^5.0.0 \|\| ^6.0.0 \|\| ^7.0.0 \|\| ^8.0.0 \|\| ^9.0.0")) {
		loaderContext.emitError(new Error(`Node Sass version ${version} is incompatible with ^4.0.0 \|\| ^5.0.0 \|\| ^6.0.0 \|\| ^7.0.0 \|\| ^8.0.0 \|\| ^9.0.0.`));
		}
		@@ -82,0 +82,0 @@

Worsened metrics