@angular-devkit/build-angular 16.2.0-next.2 → 16.2.0-next.4

package/src/tools/esbuild/stylesheets/sass-language.js

@@ -48,16 +48,19 @@ exports.SassStylesheetLanguage = Object.freeze({
     fileFilter: /\.s[ac]ss$/,
     process(data, file, format, options, build) {
         const syntax = format === 'sass' ? 'indented' : 'scss';
-        const resolveUrl = async (url, previousResolvedModules) => {
+        const resolveUrl = async (url, options) => {
             let result = await build.resolve(url, {
                 kind: 'import-rule',
-                // This should ideally be the directory of the importer file from Sass
-                // but that is not currently available from the Sass importer API.
-                resolveDir: build.initialOptions.absWorkingDir,
+                // Use the provided resolve directory from the custom Sass service if available
+                resolveDir: options.resolveDir ?? build.initialOptions.absWorkingDir,
             });
-            // Workaround to support Yarn PnP without access to the importer file from Sass
-            if (!result.path && previousResolvedModules?.size) {
-                for (const previous of previousResolvedModules) {
+            // If a resolve directory is provided, no additional speculative resolutions are required
+            if (options.resolveDir) {
+                return result;
+            }
+            // Workaround to support Yarn PnP and pnpm without access to the importer file from Sass
+            if (!result.path && options.previousResolvedModules?.size) {
+                for (const previous of options.previousResolvedModules) {
                     result = await build.resolve(url, {
                         kind: 'import-rule',
                         resolveDir: previous,
@@ -72,12 +75,42 @@ exports.SassStylesheetLanguage = Object.freeze({
         return compileString(data, file, syntax, options, resolveUrl);
     },
 });
+function parsePackageName(url) {
+    const parts = url.split('/');
+    const hasScope = parts.length >= 2 && parts[0].startsWith('@');
+    const [nameOrScope, nameOrFirstPath, ...pathPart] = parts;
+    const packageName = hasScope ? `${nameOrScope}/${nameOrFirstPath}` : nameOrScope;
+    return {
+        packageName,
+        get pathSegments() {
+            return !hasScope && nameOrFirstPath ? [nameOrFirstPath, ...pathPart] : pathPart;
+        },
+    };
+}
+class Cache extends Map {
+    async getOrCreate(key, creator) {
+        let value = this.get(key);
+        if (value === undefined) {
+            value = await creator();
+            this.set(key, value);
+        }
+        return value;
+    }
+}
 async function compileString(data, filePath, syntax, options, resolveUrl) {
     // Lazily load Sass when a Sass file is found
     if (sassWorkerPool === undefined) {
         const sassService = await Promise.resolve().then(() => __importStar(require('../../sass/sass-service')));
         sassWorkerPool = new sassService.SassWorkerImplementation(true);
     }
+    // Cache is currently local to individual compile requests.
+    // Caching follows Sass behavior where a given url will always resolve to the same value
+    // regardless of its importer's path.
+    // A null value indicates that the cached resolution attempt failed to find a location and
+    // later stage resolution should be attempted. This avoids potentially expensive repeat
+    // failing resolution attempts.
+    const resolutionCache = new Cache();
+    const packageRootCache = new Cache();
     const warnings = [];
     try {
         const { css, sourceMap, loadedUrls } = await sassWorkerPool.compileStringAsync(data, {
@@ -90,33 +123,30 @@ async function compileString(data, filePath, syntax, options, resolveUrl) {
             quietDeps: true,
             importers: [
                 {
-                    findFileUrl: async (url, { previousResolvedModules }) => {
-                        let result = await resolveUrl(url);
+                    findFileUrl: (url, options) => resolutionCache.getOrCreate(url, async () => {
+                        const result = await resolveUrl(url, options);
                         if (result.path) {
                             return (0, node_url_1.pathToFileURL)(result.path);
                         }
                         // Check for package deep imports
-                        const parts = url.split('/');
-                        const hasScope = parts.length >= 2 && parts[0].startsWith('@');
-                        const [nameOrScope, nameOrFirstPath, ...pathPart] = parts;
-                        const packageName = hasScope ? `${nameOrScope}/${nameOrFirstPath}` : nameOrScope;
-                        let packageResult = await resolveUrl(packageName + '/package.json');
-                        if (packageResult.path) {
-                            return (0, node_url_1.pathToFileURL)((0, node_path_1.join)((0, node_path_1.dirname)(packageResult.path), !hasScope && nameOrFirstPath ? nameOrFirstPath : '', ...pathPart));
-                        }
-                        // Check with Yarn PnP workaround using previous resolved modules.
-                        // This is done last to avoid a performance penalty for common cases.
-                        result = await resolveUrl(url, previousResolvedModules);
-                        if (result.path) {
-                            return (0, node_url_1.pathToFileURL)(result.path);
-                        }
-                        packageResult = await resolveUrl(packageName + '/package.json', previousResolvedModules);
-                        if (packageResult.path) {
-                            return (0, node_url_1.pathToFileURL)((0, node_path_1.join)((0, node_path_1.dirname)(packageResult.path), !hasScope && nameOrFirstPath ? nameOrFirstPath : '', ...pathPart));
+                        const { packageName, pathSegments } = parsePackageName(url);
+                        // Caching package root locations is particularly beneficial for `@material/*` packages
+                        // which extensively use deep imports.
+                        const packageRoot = await packageRootCache.getOrCreate(packageName, async () => {
+                            // Use the required presence of a package root `package.json` file to resolve the location
+                            const packageResult = await resolveUrl(packageName + '/package.json', options);
+                            return packageResult.path ? (0, node_path_1.dirname)(packageResult.path) : null;
+                        });
+                        // Package not found could be because of an error or the specifier is intended to be found
+                        // via a later stage of the resolution process (`loadPaths`, etc.).
+                        // Errors are reported after the full completion of the resolution process. Exceptions for
+                        // not found packages should not be raised here.
+                        if (packageRoot) {
+                            return (0, node_url_1.pathToFileURL)((0, node_path_1.join)(packageRoot, ...pathSegments));
                         }
                         // Not found
                         return null;
-                    },
+                    }),
                 },
             ],
             logger: {
@@ -166,4 +196,4 @@ function sourceMapToUrlComment(sourceMap, root) {
     const urlSourceMap = Buffer.from(JSON.stringify(sourceMap), 'utf-8').toString('base64');
     return `/*# sourceMappingURL=data:application/json;charset=utf-8;base64,${urlSourceMap} */`;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sass-language.js","sourceRoot":"","sources":["../../../../../../../../../../packages/angular_devkit/build_angular/src/tools/esbuild/stylesheets/sass-language.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport type { OnLoadResult, PartialMessage, ResolveResult } from 'esbuild';\nimport { dirname, join, relative } from 'node:path';\nimport { fileURLToPath, pathToFileURL } from 'node:url';\nimport type { CompileResult, Exception, Syntax } from 'sass';\nimport type {\n  FileImporterWithRequestContextOptions,\n  SassWorkerImplementation,\n} from '../../sass/sass-service';\nimport { StylesheetLanguage, StylesheetPluginOptions } from './stylesheet-plugin-factory';\n\nlet sassWorkerPool: SassWorkerImplementation | undefined;\n\nfunction isSassException(error: unknown): error is Exception {\n  return !!error && typeof error === 'object' && 'sassMessage' in error;\n}\n\nexport function shutdownSassWorkerPool(): void {\n  sassWorkerPool?.close();\n  sassWorkerPool = undefined;\n}\n\nexport const SassStylesheetLanguage = Object.freeze<StylesheetLanguage>({\n  name: 'sass',\n  componentFilter: /^s[ac]ss;/,\n  fileFilter: /\\.s[ac]ss$/,\n  process(data, file, format, options, build) {\n    const syntax = format === 'sass' ? 'indented' : 'scss';\n    const resolveUrl = async (url: string, previousResolvedModules?: Set<string>) => {\n      let result = await build.resolve(url, {\n        kind: 'import-rule',\n        // This should ideally be the directory of the importer file from Sass\n        // but that is not currently available from the Sass importer API.\n        resolveDir: build.initialOptions.absWorkingDir,\n      });\n\n      // Workaround to support Yarn PnP without access to the importer file from Sass\n      if (!result.path && previousResolvedModules?.size) {\n        for (const previous of previousResolvedModules) {\n          result = await build.resolve(url, {\n            kind: 'import-rule',\n            resolveDir: previous,\n          });\n          if (result.path) {\n            break;\n          }\n        }\n      }\n\n      return result;\n    };\n\n    return compileString(data, file, syntax, options, resolveUrl);\n  },\n});\n\nasync function compileString(\n  data: string,\n  filePath: string,\n  syntax: Syntax,\n  options: StylesheetPluginOptions,\n  resolveUrl: (url: string, previousResolvedModules?: Set<string>) => Promise<ResolveResult>,\n): Promise<OnLoadResult> {\n  // Lazily load Sass when a Sass file is found\n  if (sassWorkerPool === undefined) {\n    const sassService = await import('../../sass/sass-service');\n    sassWorkerPool = new sassService.SassWorkerImplementation(true);\n  }\n\n  const warnings: PartialMessage[] = [];\n  try {\n    const { css, sourceMap, loadedUrls } = await sassWorkerPool.compileStringAsync(data, {\n      url: pathToFileURL(filePath),\n      style: 'expanded',\n      syntax,\n      loadPaths: options.includePaths,\n      sourceMap: options.sourcemap,\n      sourceMapIncludeSources: options.sourcemap,\n      quietDeps: true,\n      importers: [\n        {\n          findFileUrl: async (\n            url,\n            { previousResolvedModules }: FileImporterWithRequestContextOptions,\n          ): Promise<URL | null> => {\n            let result = await resolveUrl(url);\n            if (result.path) {\n              return pathToFileURL(result.path);\n            }\n\n            // Check for package deep imports\n            const parts = url.split('/');\n            const hasScope = parts.length >= 2 && parts[0].startsWith('@');\n            const [nameOrScope, nameOrFirstPath, ...pathPart] = parts;\n            const packageName = hasScope ? `${nameOrScope}/${nameOrFirstPath}` : nameOrScope;\n\n            let packageResult = await resolveUrl(packageName + '/package.json');\n\n            if (packageResult.path) {\n              return pathToFileURL(\n                join(\n                  dirname(packageResult.path),\n                  !hasScope && nameOrFirstPath ? nameOrFirstPath : '',\n                  ...pathPart,\n                ),\n              );\n            }\n\n            // Check with Yarn PnP workaround using previous resolved modules.\n            // This is done last to avoid a performance penalty for common cases.\n\n            result = await resolveUrl(url, previousResolvedModules);\n            if (result.path) {\n              return pathToFileURL(result.path);\n            }\n\n            packageResult = await resolveUrl(\n              packageName + '/package.json',\n              previousResolvedModules,\n            );\n\n            if (packageResult.path) {\n              return pathToFileURL(\n                join(\n                  dirname(packageResult.path),\n                  !hasScope && nameOrFirstPath ? nameOrFirstPath : '',\n                  ...pathPart,\n                ),\n              );\n            }\n\n            // Not found\n            return null;\n          },\n        },\n      ],\n      logger: {\n        warn: (text, { deprecation, span }) => {\n          warnings.push({\n            text: deprecation ? 'Deprecation' : text,\n            location: span && {\n              file: span.url && fileURLToPath(span.url),\n              lineText: span.context,\n              // Sass line numbers are 0-based while esbuild's are 1-based\n              line: span.start.line + 1,\n              column: span.start.column,\n            },\n            notes: deprecation ? [{ text }] : undefined,\n          });\n        },\n      },\n    });\n\n    return {\n      loader: 'css',\n      contents: sourceMap ? `${css}\\n${sourceMapToUrlComment(sourceMap, dirname(filePath))}` : css,\n      watchFiles: loadedUrls.map((url) => fileURLToPath(url)),\n      warnings,\n    };\n  } catch (error) {\n    if (isSassException(error)) {\n      const file = error.span.url ? fileURLToPath(error.span.url) : undefined;\n\n      return {\n        loader: 'css',\n        errors: [\n          {\n            text: error.message,\n          },\n        ],\n        warnings,\n        watchFiles: file ? [file] : undefined,\n      };\n    }\n\n    throw error;\n  }\n}\n\nfunction sourceMapToUrlComment(\n  sourceMap: Exclude<CompileResult['sourceMap'], undefined>,\n  root: string,\n): string {\n  // Remove `file` protocol from all sourcemap sources and adjust to be relative to the input file.\n  // This allows esbuild to correctly process the paths.\n  sourceMap.sources = sourceMap.sources.map((source) => relative(root, fileURLToPath(source)));\n\n  const urlSourceMap = Buffer.from(JSON.stringify(sourceMap), 'utf-8').toString('base64');\n\n  return `/*# sourceMappingURL=data:application/json;charset=utf-8;base64,${urlSourceMap} */`;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sass-language.js","sourceRoot":"","sources":["../../../../../../../../../../packages/angular_devkit/build_angular/src/tools/esbuild/stylesheets/sass-language.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport type { OnLoadResult, PartialMessage, ResolveResult } from 'esbuild';\nimport { dirname, join, relative } from 'node:path';\nimport { fileURLToPath, pathToFileURL } from 'node:url';\nimport type { CompileResult, Exception, Syntax } from 'sass';\nimport type {\n  FileImporterWithRequestContextOptions,\n  SassWorkerImplementation,\n} from '../../sass/sass-service';\nimport { StylesheetLanguage, StylesheetPluginOptions } from './stylesheet-plugin-factory';\n\nlet sassWorkerPool: SassWorkerImplementation | undefined;\n\nfunction isSassException(error: unknown): error is Exception {\n  return !!error && typeof error === 'object' && 'sassMessage' in error;\n}\n\nexport function shutdownSassWorkerPool(): void {\n  sassWorkerPool?.close();\n  sassWorkerPool = undefined;\n}\n\nexport const SassStylesheetLanguage = Object.freeze<StylesheetLanguage>({\n  name: 'sass',\n  componentFilter: /^s[ac]ss;/,\n  fileFilter: /\\.s[ac]ss$/,\n  process(data, file, format, options, build) {\n    const syntax = format === 'sass' ? 'indented' : 'scss';\n    const resolveUrl = async (url: string, options: FileImporterWithRequestContextOptions) => {\n      let result = await build.resolve(url, {\n        kind: 'import-rule',\n        // Use the provided resolve directory from the custom Sass service if available\n        resolveDir: options.resolveDir ?? build.initialOptions.absWorkingDir,\n      });\n\n      // If a resolve directory is provided, no additional speculative resolutions are required\n      if (options.resolveDir) {\n        return result;\n      }\n\n      // Workaround to support Yarn PnP and pnpm without access to the importer file from Sass\n      if (!result.path && options.previousResolvedModules?.size) {\n        for (const previous of options.previousResolvedModules) {\n          result = await build.resolve(url, {\n            kind: 'import-rule',\n            resolveDir: previous,\n          });\n          if (result.path) {\n            break;\n          }\n        }\n      }\n\n      return result;\n    };\n\n    return compileString(data, file, syntax, options, resolveUrl);\n  },\n});\n\nfunction parsePackageName(url: string): { packageName: string; readonly pathSegments: string[] } {\n  const parts = url.split('/');\n  const hasScope = parts.length >= 2 && parts[0].startsWith('@');\n  const [nameOrScope, nameOrFirstPath, ...pathPart] = parts;\n  const packageName = hasScope ? `${nameOrScope}/${nameOrFirstPath}` : nameOrScope;\n\n  return {\n    packageName,\n    get pathSegments() {\n      return !hasScope && nameOrFirstPath ? [nameOrFirstPath, ...pathPart] : pathPart;\n    },\n  };\n}\n\nclass Cache<K, V> extends Map<K, V> {\n  async getOrCreate(key: K, creator: () => V | Promise<V>): Promise<V> {\n    let value = this.get(key);\n\n    if (value === undefined) {\n      value = await creator();\n      this.set(key, value);\n    }\n\n    return value;\n  }\n}\n\nasync function compileString(\n  data: string,\n  filePath: string,\n  syntax: Syntax,\n  options: StylesheetPluginOptions,\n  resolveUrl: (\n    url: string,\n    options: FileImporterWithRequestContextOptions,\n  ) => Promise<ResolveResult>,\n): Promise<OnLoadResult> {\n  // Lazily load Sass when a Sass file is found\n  if (sassWorkerPool === undefined) {\n    const sassService = await import('../../sass/sass-service');\n    sassWorkerPool = new sassService.SassWorkerImplementation(true);\n  }\n\n  // Cache is currently local to individual compile requests.\n  // Caching follows Sass behavior where a given url will always resolve to the same value\n  // regardless of its importer's path.\n  // A null value indicates that the cached resolution attempt failed to find a location and\n  // later stage resolution should be attempted. This avoids potentially expensive repeat\n  // failing resolution attempts.\n  const resolutionCache = new Cache<string, URL | null>();\n  const packageRootCache = new Cache<string, string | null>();\n\n  const warnings: PartialMessage[] = [];\n  try {\n    const { css, sourceMap, loadedUrls } = await sassWorkerPool.compileStringAsync(data, {\n      url: pathToFileURL(filePath),\n      style: 'expanded',\n      syntax,\n      loadPaths: options.includePaths,\n      sourceMap: options.sourcemap,\n      sourceMapIncludeSources: options.sourcemap,\n      quietDeps: true,\n      importers: [\n        {\n          findFileUrl: (url, options: FileImporterWithRequestContextOptions) =>\n            resolutionCache.getOrCreate(url, async () => {\n              const result = await resolveUrl(url, options);\n              if (result.path) {\n                return pathToFileURL(result.path);\n              }\n\n              // Check for package deep imports\n              const { packageName, pathSegments } = parsePackageName(url);\n\n              // Caching package root locations is particularly beneficial for `@material/*` packages\n              // which extensively use deep imports.\n              const packageRoot = await packageRootCache.getOrCreate(packageName, async () => {\n                // Use the required presence of a package root `package.json` file to resolve the location\n                const packageResult = await resolveUrl(packageName + '/package.json', options);\n\n                return packageResult.path ? dirname(packageResult.path) : null;\n              });\n\n              // Package not found could be because of an error or the specifier is intended to be found\n              // via a later stage of the resolution process (`loadPaths`, etc.).\n              // Errors are reported after the full completion of the resolution process. Exceptions for\n              // not found packages should not be raised here.\n              if (packageRoot) {\n                return pathToFileURL(join(packageRoot, ...pathSegments));\n              }\n\n              // Not found\n              return null;\n            }),\n        },\n      ],\n      logger: {\n        warn: (text, { deprecation, span }) => {\n          warnings.push({\n            text: deprecation ? 'Deprecation' : text,\n            location: span && {\n              file: span.url && fileURLToPath(span.url),\n              lineText: span.context,\n              // Sass line numbers are 0-based while esbuild's are 1-based\n              line: span.start.line + 1,\n              column: span.start.column,\n            },\n            notes: deprecation ? [{ text }] : undefined,\n          });\n        },\n      },\n    });\n\n    return {\n      loader: 'css',\n      contents: sourceMap ? `${css}\\n${sourceMapToUrlComment(sourceMap, dirname(filePath))}` : css,\n      watchFiles: loadedUrls.map((url) => fileURLToPath(url)),\n      warnings,\n    };\n  } catch (error) {\n    if (isSassException(error)) {\n      const file = error.span.url ? fileURLToPath(error.span.url) : undefined;\n\n      return {\n        loader: 'css',\n        errors: [\n          {\n            text: error.message,\n          },\n        ],\n        warnings,\n        watchFiles: file ? [file] : undefined,\n      };\n    }\n\n    throw error;\n  }\n}\n\nfunction sourceMapToUrlComment(\n  sourceMap: Exclude<CompileResult['sourceMap'], undefined>,\n  root: string,\n): string {\n  // Remove `file` protocol from all sourcemap sources and adjust to be relative to the input file.\n  // This allows esbuild to correctly process the paths.\n  sourceMap.sources = sourceMap.sources.map((source) => relative(root, fileURLToPath(source)));\n\n  const urlSourceMap = Buffer.from(JSON.stringify(sourceMap), 'utf-8').toString('base64');\n\n  return `/*# sourceMappingURL=data:application/json;charset=utf-8;base64,${urlSourceMap} */`;\n}\n"]}

package/src/tools/sass/lexer.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * Scans a CSS or Sass file and locates all valid url function values as defined by the
+ * syntax specification.
+ * @param contents A string containing a CSS or Sass file to scan.
+ * @returns An iterable that yields each CSS url function value found.
+ */
+export declare function findUrls(contents: string): Iterable<{
+    start: number;
+    end: number;
+    value: string;
+}>;
+/**
+ * Scans a CSS or Sass file and locates all valid import/use directive values as defined by the
+ * syntax specification.
+ * @param contents A string containing a CSS or Sass file to scan.
+ * @returns An iterable that yields each CSS directive value found.
+ */
+export declare function findImports(contents: string): Iterable<{
+    start: number;
+    end: number;
+    specifier: string;
+}>;

package/src/tools/sass/lexer.js

@@ -0,0 +1,248 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findImports = exports.findUrls = void 0;
+// TODO: Combine everything into a single pass lexer
+/**
+ * Determines if a unicode code point is a CSS whitespace character.
+ * @param code The unicode code point to test.
+ * @returns true, if the code point is CSS whitespace; false, otherwise.
+ */
+function isWhitespace(code) {
+    // Based on https://www.w3.org/TR/css-syntax-3/#whitespace
+    switch (code) {
+        case 0x0009: // tab
+        case 0x0020: // space
+        case 0x000a: // line feed
+        case 0x000c: // form feed
+        case 0x000d: // carriage return
+            return true;
+        default:
+            return false;
+    }
+}
+/**
+ * Scans a CSS or Sass file and locates all valid url function values as defined by the
+ * syntax specification.
+ * @param contents A string containing a CSS or Sass file to scan.
+ * @returns An iterable that yields each CSS url function value found.
+ */
+function* findUrls(contents) {
+    let pos = 0;
+    let width = 1;
+    let current = -1;
+    const next = () => {
+        pos += width;
+        current = contents.codePointAt(pos) ?? -1;
+        width = current > 0xffff ? 2 : 1;
+        return current;
+    };
+    // Based on https://www.w3.org/TR/css-syntax-3/#consume-ident-like-token
+    while ((pos = contents.indexOf('url(', pos)) !== -1) {
+        // Set to position of the (
+        pos += 3;
+        width = 1;
+        // Consume all leading whitespace
+        while (isWhitespace(next())) {
+            /* empty */
+        }
+        // Initialize URL state
+        const url = { start: pos, end: -1, value: '' };
+        let complete = false;
+        // If " or ', then consume the value as a string
+        if (current === 0x0022 || current === 0x0027) {
+            const ending = current;
+            // Based on https://www.w3.org/TR/css-syntax-3/#consume-string-token
+            while (!complete) {
+                switch (next()) {
+                    case -1: // EOF
+                        return;
+                    case 0x000a: // line feed
+                    case 0x000c: // form feed
+                    case 0x000d: // carriage return
+                        // Invalid
+                        complete = true;
+                        break;
+                    case 0x005c: // \ -- character escape
+                        // If not EOF or newline, add the character after the escape
+                        switch (next()) {
+                            case -1:
+                                return;
+                            case 0x000a: // line feed
+                            case 0x000c: // form feed
+                            case 0x000d: // carriage return
+                                // Skip when inside a string
+                                break;
+                            default:
+                                // TODO: Handle hex escape codes
+                                url.value += String.fromCodePoint(current);
+                                break;
+                        }
+                        break;
+                    case ending:
+                        // Full string position should include the quotes for replacement
+                        url.end = pos + 1;
+                        complete = true;
+                        yield url;
+                        break;
+                    default:
+                        url.value += String.fromCodePoint(current);
+                        break;
+                }
+            }
+            next();
+            continue;
+        }
+        // Based on https://www.w3.org/TR/css-syntax-3/#consume-url-token
+        while (!complete) {
+            switch (current) {
+                case -1: // EOF
+                    return;
+                case 0x0022: // "
+                case 0x0027: // '
+                case 0x0028: // (
+                    // Invalid
+                    complete = true;
+                    break;
+                case 0x0029: // )
+                    // URL is valid and complete
+                    url.end = pos;
+                    complete = true;
+                    break;
+                case 0x005c: // \ -- character escape
+                    // If not EOF or newline, add the character after the escape
+                    switch (next()) {
+                        case -1: // EOF
+                            return;
+                        case 0x000a: // line feed
+                        case 0x000c: // form feed
+                        case 0x000d: // carriage return
+                            // Invalid
+                            complete = true;
+                            break;
+                        default:
+                            // TODO: Handle hex escape codes
+                            url.value += String.fromCodePoint(current);
+                            break;
+                    }
+                    break;
+                default:
+                    if (isWhitespace(current)) {
+                        while (isWhitespace(next())) {
+                            /* empty */
+                        }
+                        // Unescaped whitespace is only valid before the closing )
+                        if (current === 0x0029) {
+                            // URL is valid
+                            url.end = pos;
+                        }
+                        complete = true;
+                    }
+                    else {
+                        // Add the character to the url value
+                        url.value += String.fromCodePoint(current);
+                    }
+                    break;
+            }
+            next();
+        }
+        // An end position indicates a URL was found
+        if (url.end !== -1) {
+            yield url;
+        }
+    }
+}
+exports.findUrls = findUrls;
+/**
+ * Scans a CSS or Sass file and locates all valid import/use directive values as defined by the
+ * syntax specification.
+ * @param contents A string containing a CSS or Sass file to scan.
+ * @returns An iterable that yields each CSS directive value found.
+ */
+function* findImports(contents) {
+    yield* find(contents, '@import ');
+    yield* find(contents, '@use ');
+}
+exports.findImports = findImports;
+/**
+ * Scans a CSS or Sass file and locates all valid function/directive values as defined by the
+ * syntax specification.
+ * @param contents A string containing a CSS or Sass file to scan.
+ * @param prefix The prefix to start a valid segment.
+ * @returns An iterable that yields each CSS url function value found.
+ */
+function* find(contents, prefix) {
+    let pos = 0;
+    let width = 1;
+    let current = -1;
+    const next = () => {
+        pos += width;
+        current = contents.codePointAt(pos) ?? -1;
+        width = current > 0xffff ? 2 : 1;
+        return current;
+    };
+    // Based on https://www.w3.org/TR/css-syntax-3/#consume-ident-like-token
+    while ((pos = contents.indexOf(prefix, pos)) !== -1) {
+        // Set to position of the last character in prefix
+        pos += prefix.length - 1;
+        width = 1;
+        // Consume all leading whitespace
+        while (isWhitespace(next())) {
+            /* empty */
+        }
+        // Initialize URL state
+        const url = { start: pos, end: -1, specifier: '' };
+        let complete = false;
+        // If " or ', then consume the value as a string
+        if (current === 0x0022 || current === 0x0027) {
+            const ending = current;
+            // Based on https://www.w3.org/TR/css-syntax-3/#consume-string-token
+            while (!complete) {
+                switch (next()) {
+                    case -1: // EOF
+                        return;
+                    case 0x000a: // line feed
+                    case 0x000c: // form feed
+                    case 0x000d: // carriage return
+                        // Invalid
+                        complete = true;
+                        break;
+                    case 0x005c: // \ -- character escape
+                        // If not EOF or newline, add the character after the escape
+                        switch (next()) {
+                            case -1:
+                                return;
+                            case 0x000a: // line feed
+                            case 0x000c: // form feed
+                            case 0x000d: // carriage return
+                                // Skip when inside a string
+                                break;
+                            default:
+                                // TODO: Handle hex escape codes
+                                url.specifier += String.fromCodePoint(current);
+                                break;
+                        }
+                        break;
+                    case ending:
+                        // Full string position should include the quotes for replacement
+                        url.end = pos + 1;
+                        complete = true;
+                        yield url;
+                        break;
+                    default:
+                        url.specifier += String.fromCodePoint(current);
+                        break;
+                }
+            }
+            next();
+            continue;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lexer.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/tools/sass/lexer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n// TODO: Combine everything into a single pass lexer\n\n/**\n * Determines if a unicode code point is a CSS whitespace character.\n * @param code The unicode code point to test.\n * @returns true, if the code point is CSS whitespace; false, otherwise.\n */\nfunction isWhitespace(code: number): boolean {\n  // Based on https://www.w3.org/TR/css-syntax-3/#whitespace\n  switch (code) {\n    case 0x0009: // tab\n    case 0x0020: // space\n    case 0x000a: // line feed\n    case 0x000c: // form feed\n    case 0x000d: // carriage return\n      return true;\n    default:\n      return false;\n  }\n}\n\n/**\n * Scans a CSS or Sass file and locates all valid url function values as defined by the\n * syntax specification.\n * @param contents A string containing a CSS or Sass file to scan.\n * @returns An iterable that yields each CSS url function value found.\n */\nexport function* findUrls(\n  contents: string,\n): Iterable<{ start: number; end: number; value: string }> {\n  let pos = 0;\n  let width = 1;\n  let current = -1;\n  const next = () => {\n    pos += width;\n    current = contents.codePointAt(pos) ?? -1;\n    width = current > 0xffff ? 2 : 1;\n\n    return current;\n  };\n\n  // Based on https://www.w3.org/TR/css-syntax-3/#consume-ident-like-token\n  while ((pos = contents.indexOf('url(', pos)) !== -1) {\n    // Set to position of the (\n    pos += 3;\n    width = 1;\n\n    // Consume all leading whitespace\n    while (isWhitespace(next())) {\n      /* empty */\n    }\n\n    // Initialize URL state\n    const url = { start: pos, end: -1, value: '' };\n    let complete = false;\n\n    // If \" or ', then consume the value as a string\n    if (current === 0x0022 || current === 0x0027) {\n      const ending = current;\n      // Based on https://www.w3.org/TR/css-syntax-3/#consume-string-token\n      while (!complete) {\n        switch (next()) {\n          case -1: // EOF\n            return;\n          case 0x000a: // line feed\n          case 0x000c: // form feed\n          case 0x000d: // carriage return\n            // Invalid\n            complete = true;\n            break;\n          case 0x005c: // \\ -- character escape\n            // If not EOF or newline, add the character after the escape\n            switch (next()) {\n              case -1:\n                return;\n              case 0x000a: // line feed\n              case 0x000c: // form feed\n              case 0x000d: // carriage return\n                // Skip when inside a string\n                break;\n              default:\n                // TODO: Handle hex escape codes\n                url.value += String.fromCodePoint(current);\n                break;\n            }\n            break;\n          case ending:\n            // Full string position should include the quotes for replacement\n            url.end = pos + 1;\n            complete = true;\n            yield url;\n            break;\n          default:\n            url.value += String.fromCodePoint(current);\n            break;\n        }\n      }\n\n      next();\n      continue;\n    }\n\n    // Based on https://www.w3.org/TR/css-syntax-3/#consume-url-token\n    while (!complete) {\n      switch (current) {\n        case -1: // EOF\n          return;\n        case 0x0022: // \"\n        case 0x0027: // '\n        case 0x0028: // (\n          // Invalid\n          complete = true;\n          break;\n        case 0x0029: // )\n          // URL is valid and complete\n          url.end = pos;\n          complete = true;\n          break;\n        case 0x005c: // \\ -- character escape\n          // If not EOF or newline, add the character after the escape\n          switch (next()) {\n            case -1: // EOF\n              return;\n            case 0x000a: // line feed\n            case 0x000c: // form feed\n            case 0x000d: // carriage return\n              // Invalid\n              complete = true;\n              break;\n            default:\n              // TODO: Handle hex escape codes\n              url.value += String.fromCodePoint(current);\n              break;\n          }\n          break;\n        default:\n          if (isWhitespace(current)) {\n            while (isWhitespace(next())) {\n              /* empty */\n            }\n            // Unescaped whitespace is only valid before the closing )\n            if (current === 0x0029) {\n              // URL is valid\n              url.end = pos;\n            }\n            complete = true;\n          } else {\n            // Add the character to the url value\n            url.value += String.fromCodePoint(current);\n          }\n          break;\n      }\n      next();\n    }\n\n    // An end position indicates a URL was found\n    if (url.end !== -1) {\n      yield url;\n    }\n  }\n}\n\n/**\n * Scans a CSS or Sass file and locates all valid import/use directive values as defined by the\n * syntax specification.\n * @param contents A string containing a CSS or Sass file to scan.\n * @returns An iterable that yields each CSS directive value found.\n */\nexport function* findImports(\n  contents: string,\n): Iterable<{ start: number; end: number; specifier: string }> {\n  yield* find(contents, '@import ');\n  yield* find(contents, '@use ');\n}\n\n/**\n * Scans a CSS or Sass file and locates all valid function/directive values as defined by the\n * syntax specification.\n * @param contents A string containing a CSS or Sass file to scan.\n * @param prefix The prefix to start a valid segment.\n * @returns An iterable that yields each CSS url function value found.\n */\nfunction* find(\n  contents: string,\n  prefix: string,\n): Iterable<{ start: number; end: number; specifier: string }> {\n  let pos = 0;\n  let width = 1;\n  let current = -1;\n  const next = () => {\n    pos += width;\n    current = contents.codePointAt(pos) ?? -1;\n    width = current > 0xffff ? 2 : 1;\n\n    return current;\n  };\n\n  // Based on https://www.w3.org/TR/css-syntax-3/#consume-ident-like-token\n  while ((pos = contents.indexOf(prefix, pos)) !== -1) {\n    // Set to position of the last character in prefix\n    pos += prefix.length - 1;\n    width = 1;\n\n    // Consume all leading whitespace\n    while (isWhitespace(next())) {\n      /* empty */\n    }\n\n    // Initialize URL state\n    const url = { start: pos, end: -1, specifier: '' };\n    let complete = false;\n\n    // If \" or ', then consume the value as a string\n    if (current === 0x0022 || current === 0x0027) {\n      const ending = current;\n      // Based on https://www.w3.org/TR/css-syntax-3/#consume-string-token\n      while (!complete) {\n        switch (next()) {\n          case -1: // EOF\n            return;\n          case 0x000a: // line feed\n          case 0x000c: // form feed\n          case 0x000d: // carriage return\n            // Invalid\n            complete = true;\n            break;\n          case 0x005c: // \\ -- character escape\n            // If not EOF or newline, add the character after the escape\n            switch (next()) {\n              case -1:\n                return;\n              case 0x000a: // line feed\n              case 0x000c: // form feed\n              case 0x000d: // carriage return\n                // Skip when inside a string\n                break;\n              default:\n                // TODO: Handle hex escape codes\n                url.specifier += String.fromCodePoint(current);\n                break;\n            }\n            break;\n          case ending:\n            // Full string position should include the quotes for replacement\n            url.end = pos + 1;\n            complete = true;\n            yield url;\n            break;\n          default:\n            url.specifier += String.fromCodePoint(current);\n            break;\n        }\n      }\n\n      next();\n      continue;\n    }\n  }\n}\n"]}

package/src/tools/sass/rebasing-importer.d.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { RawSourceMap } from '@ampproject/remapping';
-import type { FileImporter, Importer, ImporterResult } from 'sass';
+import type { Importer, ImporterResult } from 'sass';
 /**
  * A preprocessed cache entry for the files and directories within a previously searched
  * directory when performing Sass import resolution.
@@ -76,7 +76,10 @@ export declare class RelativeUrlRebasingImporter extends UrlRebasingImporter {
  */
 export declare class ModuleUrlRebasingImporter extends RelativeUrlRebasingImporter {
     private finder;
-    constructor(entryDirectory: string, directoryCache: Map<string, DirectoryEntry>, rebaseSourceMaps: Map<string, RawSourceMap> | undefined, finder: FileImporter<'sync'>['findFileUrl']);
+    constructor(entryDirectory: string, directoryCache: Map<string, DirectoryEntry>, rebaseSourceMaps: Map<string, RawSourceMap> | undefined, finder: (specifier: string, options: {
+        fromImport: boolean;
+        resolveDir?: string;
+    }) => URL | null);
     canonicalize(url: string, options: {
         fromImport: boolean;
     }): URL | null;