Merge pull request #392 from sass/merge-main

Merge main into feature.v2

Author: nex3

.github/workflows/ci.yml

@@ -117,17 +117,7 @@ jobs:
         working-directory: sass-spec
 
       - name: Compile
-        run: |
-          npm run compile
-          if [[ "$RUNNER_OS" == "Windows" ]]; then
-            # Avoid copying the entire Dart Sass build directory on Windows,
-            # since it may contain symlinks that cp will choke on.
-            mkdir -p dist/lib/src/vendor/dart-sass/
-            cp {`pwd`/,dist/}lib/src/vendor/dart-sass/sass.bat
-            cp {`pwd`/,dist/}lib/src/vendor/dart-sass/sass.snapshot
-          else
-            ln -s {`pwd`/,dist/}lib/src/vendor/dart-sass
-          fi
+        run: npm run compile
 
       - name: Run tests
         run: npm run js-api-spec -- --sassPackage .. --sassSassRepo ../language

CHANGELOG.md

@@ -1,3 +1,72 @@
+## 1.91.0
+
+* **Potentially breaking change:** `meta.inspect()` (as well as other systems
+  that use it such as `@debug` and certain error messages) now emits numbers
+  with as high precision as is available instead of rounding to the nearest
+  1e⁻¹⁰ as we do when serializing to CSS. This better fits the purpose of
+  `meta.inspect()`, which is to provide full information about the structure of
+  a Sass value.
+
+* Passing a rest argument (`$arg...`) before a positional or named argument when
+  calling a function or mixin is now deprecated. This was always outside the
+  specified syntax, but it was historically treated the same as passing the rest
+  argument at the end of the argument list whether or not that matched the
+  visual order of the arguments.
+
+## 1.90.0
+
+* Allow a `@forward`ed module to be loaded with a configuration when that module
+  has already been loaded with a different configuration *and* the module
+  doesn't define any variables that would have been configured anyway.
+
+## 1.89.2
+
+### Embedded Host
+
+* Fixed a compilation error caused by an outdated `buf` dependency.
+
+## 1.89.1
+
+* No user-visible changes.
+
+## 1.89.0
+
+* Allow the Node package importer to load files even when there are multiple
+  potential resolutions, as long as those resolutions all point to the same
+  file.
+
+## 1.88.0
+
+* Allow custom properties with empty values (such as `--var:;`).
+
+* Fix a bug when calculating source spans for interpolations.
+
+### Dart and JS APIs
+
+* **Potentially breaking bug fix:** Throw an error when passing a function or
+  mixin object from one compilation to another.
+
+### Dart API
+
+* Deprecate passing a relative URL to `compileString()` and related functions.
+
+## 1.87.0
+
+* **Potentially breaking bug fix:** When a plain CSS file with a top-level
+  nesting selector `&` is loaded into a nested Sass context via
+  `meta.load-css()` or `@import`, Sass now emits plain CSS nesting rather than
+  incorrectly combining it with the parent selector using a descendant
+  combinator.
+
+## 1.86.3
+
+* Fix a bug introduced in 1.86.1 where Sass fails to resolve paths starting with
+  a `..` segment.
+
+## 1.86.2
+
+* No user-visible changes.
+
 ## 1.86.1
 
 * Improve the performance of `file:` URL case canonicalization on Windows and

bin/sass.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 import * as child_process from 'child_process';
+import * as path from 'path';
 import {compilerCommand} from '../lib/src/compiler-path';
 
 // TODO npm/cmd-shim#152 and yarnpkg/berry#6422 - If and when the package
@@ -12,6 +13,10 @@ try {
     compilerCommand[0],
     [...compilerCommand.slice(1), ...process.argv.slice(2)],
     {
+      // Node blocks launching .bat and .cmd without a shell due to CVE-2024-27980
+      shell: ['.bat', '.cmd'].includes(
+        path.extname(compilerCommand[0]).toLowerCase(),
+      ),
       stdio: 'inherit',
       windowsHide: true,
     },

lib/src/compiler-module.ts

@@ -0,0 +1,34 @@
+// Copyright 2025 Google LLC. Use of this source code is governed by an
+// MIT-style license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+import * as p from 'path';
+import {getElfInterpreter} from './elf';
+
+/**
+ * Detect if the given binary is linked with musl libc by checking if
+ * the interpreter basename starts with "ld-musl-"
+ */
+function isLinuxMusl(path: string): boolean {
+  try {
+    const interpreter = getElfInterpreter(path);
+    return p.basename(interpreter).startsWith('ld-musl-');
+  } catch (error) {
+    console.warn(
+      `Warning: Failed to detect linux-musl, fallback to linux-gnu: ${error.message}`,
+    );
+    return false;
+  }
+}
+
+/** The module name for the embedded compiler executable. */
+export const compilerModule = (() => {
+  const platform =
+    process.platform === 'linux' && isLinuxMusl(process.execPath)
+      ? 'linux-musl'
+      : (process.platform as string);
+
+  const arch = process.arch;
+
+  return `sass-embedded-${platform}-${arch}`;
+})();

lib/src/compiler-path.ts

@@ -2,78 +2,55 @@
 // MIT-style license that can be found in the LICENSE file or at
 // https://opensource.org/licenses/MIT.
 
-import * as fs from 'fs';
 import * as p from 'path';
-import {getElfInterpreter} from './elf';
-import {isErrnoException} from './utils';
-
-/**
- * Detect if the given binary is linked with musl libc by checking if
- * the interpreter basename starts with "ld-musl-"
- */
-function isLinuxMusl(path: string): boolean {
-  try {
-    const interpreter = getElfInterpreter(path);
-    return p.basename(interpreter).startsWith('ld-musl-');
-  } catch (error) {
-    console.warn(
-      `Warning: Failed to detect linux-musl, fallback to linux-gnu: ${error.message}`,
-    );
-    return false;
-  }
-}
+import {compilerModule} from './compiler-module';
 
 /** The full command for the embedded compiler executable. */
 export const compilerCommand = (() => {
-  const platform =
-    process.platform === 'linux' && isLinuxMusl(process.execPath)
-      ? 'linux-musl'
-      : (process.platform as string);
-
-  const arch = process.arch;
-
-  // find for development
-  for (const path of ['vendor', '../../../lib/src/vendor']) {
-    const executable = p.resolve(
-      __dirname,
-      path,
-      `dart-sass/sass${platform === 'win32' ? '.bat' : ''}`,
-    );
-
-    if (fs.existsSync(executable)) return [executable];
-  }
-
   try {
     return [
       require.resolve(
-        `sass-embedded-${platform}-${arch}/dart-sass/src/dart` +
-          (platform === 'win32' ? '.exe' : ''),
-      ),
-      require.resolve(
-        `sass-embedded-${platform}-${arch}/dart-sass/src/sass.snapshot`,
+        `${compilerModule}/dart-sass/src/dart` +
+          (process.platform === 'win32' ? '.exe' : ''),
       ),
+      require.resolve(`${compilerModule}/dart-sass/src/sass.snapshot`),
     ];
-  } catch (ignored) {
-    // ignored
+  } catch (e) {
+    if (e.code !== 'MODULE_NOT_FOUND') {
+      throw e;
+    }
   }
 
   try {
     return [
       require.resolve(
-        `sass-embedded-${platform}-${arch}/dart-sass/sass` +
-          (platform === 'win32' ? '.bat' : ''),
+        `${compilerModule}/dart-sass/sass` +
+          (process.platform === 'win32' ? '.bat' : ''),
       ),
     ];
-  } catch (e: unknown) {
-    if (!(isErrnoException(e) && e.code === 'MODULE_NOT_FOUND')) {
+  } catch (e) {
+    if (e.code !== 'MODULE_NOT_FOUND') {
+      throw e;
+    }
+  }
+
+  try {
+    return [
+      process.execPath,
+      // This is a fallback which is required indirectly through
+      // sass-embedded-all-unknown.
+      // eslint-disable-next-line n/no-extraneous-require
+      p.join(p.dirname(require.resolve('sass')), 'sass.js'),
+    ];
+  } catch (e) {
+    if (e.code !== 'MODULE_NOT_FOUND') {
       throw e;
     }
   }
 
   throw new Error(
     "Embedded Dart Sass couldn't find the embedded compiler executable. " +
-      'Please make sure the optional dependency ' +
-      `sass-embedded-${platform}-${arch} is installed in ` +
-      'node_modules.',
+      `Please make sure the optional dependency ${compilerModule} or sass is ` +
+      'installed in node_modules.',
   );
 })();

lib/src/function-registry.ts

@@ -18,6 +18,11 @@ import {Value} from './value';
  * execute them.
  */
 export class FunctionRegistry<sync extends 'sync' | 'async'> {
+  /**
+   * The globally unique identifier of the current compilation used for tracking
+   * the ownership of CompilerFunction and CompilerMixin objects.
+   */
+  public readonly compileContext = Symbol();
   private readonly functionsByName = new Map<string, CustomFunction<sync>>();
   private readonly functionsById = new Map<number, CustomFunction<sync>>();
   private readonly idsByFunction = new Map<CustomFunction<sync>, number>();

lib/src/protofier.ts

@@ -44,7 +44,7 @@ export class Protofier {
   get accessedArgumentLists(): number[] {
     return this.argumentLists
       .filter(list => list.keywordsAccessed)
-      .map(list => list.id);
+      .map(list => list.id!);
   }
 
   constructor(
@@ -85,15 +85,21 @@ export class Protofier {
       });
       result.value = {case: 'list', value: list};
     } else if (value instanceof SassArgumentList) {
-      const list = create(proto.Value_ArgumentListSchema, {
-        id: value.id,
-        separator: this.protofySeparator(value.separator),
-        contents: value.asList.map(element => this.protofy(element)).toArray(),
-      });
-      for (const [key, mapValue] of value.keywordsInternal) {
-        list.keywords[key] = this.protofy(mapValue);
+      if (value.compileContext === this.functions.compileContext) {
+        const list = create(proto.Value_ArgumentListSchema, {id: value.id});
+        result.value = {case: 'argumentList', value: list};
+      } else {
+        const list = create(proto.Value_ArgumentListSchema, {
+          separator: this.protofySeparator(value.separator),
+          contents: value.asList
+            .map(element => this.protofy(element))
+            .toArray(),
+        });
+        for (const [key, mapValue] of value.keywordsInternal) {
+          list.keywords[key] = this.protofy(mapValue);
+        }
+        result.value = {case: 'argumentList', value: list};
       }
-      result.value = {case: 'argumentList', value: list};
     } else if (value instanceof SassMap) {
       const map = create(proto.Value_MapSchema, {
         entries: value.contents.toArray().map(([key, value]) => ({
@@ -104,6 +110,11 @@ export class Protofier {
       result.value = {case: 'map', value: map};
     } else if (value instanceof SassFunction) {
       if (value.id !== undefined) {
+        if (value.compileContext !== this.functions.compileContext) {
+          throw utils.compilerError(
+            `Value ${value} does not belong to this compilation`,
+          );
+        }
         const fn = create(proto.Value_CompilerFunctionSchema, value);
         result.value = {case: 'compilerFunction', value: fn};
       } else {
@@ -114,6 +125,11 @@ export class Protofier {
         result.value = {case: 'hostFunction', value: fn};
       }
     } else if (value instanceof SassMixin) {
+      if (value.compileContext !== this.functions.compileContext) {
+        throw utils.compilerError(
+          `Value ${value} does not belong to this compilation`,
+        );
+      }
       const mixin = create(proto.Value_CompilerMixinSchema, value);
       result.value = {case: 'compilerMixin', value: mixin};
     } else if (value instanceof SassCalculation) {
@@ -349,6 +365,7 @@ export class Protofier {
           ),
           separator,
           list.id,
+          this.functions.compileContext,
         );
         this.argumentLists.push(result);
         return result;
@@ -369,15 +386,21 @@ export class Protofier {
         );
 
       case 'compilerFunction':
-        return new SassFunction(value.value.value.id);
+        return new SassFunction(
+          value.value.value.id,
+          this.functions.compileContext,
+        );
 
       case 'hostFunction':
         throw utils.compilerError(
           'The compiler may not send Value.host_function.',
         );
 
       case 'compilerMixin':
-        return new SassMixin(value.value.value.id);
+        return new SassMixin(
+          value.value.value.id,
+          this.functions.compileContext,
+        );
 
       case 'calculation':
         return this.deprotofyCalculation(value.value.value);

lib/src/request-tracker.test.ts

@@ -36,14 +36,14 @@ describe('request tracker', () => {
     });
 
     it('errors if the request ID is invalid', () => {
-      expect(() => tracker.add(-1, 'compileResponse')).toThrowError(
+      expect(() => tracker.add(-1, 'compileResponse')).toThrow(
         'Invalid request ID -1.',
       );
     });
 
     it('errors if the request ID overlaps that of an existing in-flight request', () => {
       tracker.add(0, 'compileResponse');
-      expect(() => tracker.add(0, 'compileResponse')).toThrowError(
+      expect(() => tracker.add(0, 'compileResponse')).toThrow(
         'Request ID 0 is already in use by an in-flight request.',
       );
     });
@@ -74,14 +74,14 @@ describe('request tracker', () => {
     });
 
     it('errors if the response ID does not match any existing request IDs', () => {
-      expect(() => tracker.resolve(0, 'compileResponse')).toThrowError(
+      expect(() => tracker.resolve(0, 'compileResponse')).toThrow(
         'Response ID 0 does not match any pending requests.',
       );
     });
 
     it('errors if the response type does not match what the request is expecting', () => {
       tracker.add(0, 'importResponse');
-      expect(() => tracker.resolve(0, 'fileImportResponse')).toThrowError(
+      expect(() => tracker.resolve(0, 'fileImportResponse')).toThrow(
         "Response with ID 0 does not match pending request's type. Expected " +
           'importResponse but received fileImportResponse.',
       );