@angular-devkit/build-angular 16.1.0-rc.0 → 16.1.1

package/src/tools/esbuild/watcher.js

@@ -0,0 +1,107 @@
+"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.createWatcher = exports.ChangedFiles = void 0;
+const chokidar_1 = require("chokidar");
+class ChangedFiles {
+    constructor() {
+        this.added = new Set();
+        this.modified = new Set();
+        this.removed = new Set();
+    }
+    toDebugString() {
+        const content = {
+            added: Array.from(this.added),
+            modified: Array.from(this.modified),
+            removed: Array.from(this.removed),
+        };
+        return JSON.stringify(content, null, 2);
+    }
+}
+exports.ChangedFiles = ChangedFiles;
+function createWatcher(options) {
+    const watcher = new chokidar_1.FSWatcher({
+        usePolling: options?.polling,
+        interval: options?.interval,
+        ignored: options?.ignored,
+        disableGlobbing: true,
+        ignoreInitial: true,
+    });
+    const nextQueue = [];
+    let currentChanges;
+    let nextWaitTimeout;
+    watcher.on('all', (event, path) => {
+        switch (event) {
+            case 'add':
+                currentChanges ?? (currentChanges = new ChangedFiles());
+                currentChanges.added.add(path);
+                break;
+            case 'change':
+                currentChanges ?? (currentChanges = new ChangedFiles());
+                currentChanges.modified.add(path);
+                break;
+            case 'unlink':
+                currentChanges ?? (currentChanges = new ChangedFiles());
+                currentChanges.removed.add(path);
+                break;
+            default:
+                return;
+        }
+        // Wait 250ms from next change to better capture groups of file save operations.
+        if (!nextWaitTimeout) {
+            nextWaitTimeout = setTimeout(() => {
+                nextWaitTimeout = undefined;
+                const next = nextQueue.shift();
+                if (next) {
+                    const value = currentChanges;
+                    currentChanges = undefined;
+                    next(value);
+                }
+            }, 250);
+            nextWaitTimeout?.unref();
+        }
+    });
+    return {
+        [Symbol.asyncIterator]() {
+            return this;
+        },
+        async next() {
+            if (currentChanges && nextQueue.length === 0) {
+                const result = { value: currentChanges };
+                currentChanges = undefined;
+                return result;
+            }
+            return new Promise((resolve) => {
+                nextQueue.push((value) => resolve(value ? { value } : { done: true, value }));
+            });
+        },
+        add(paths) {
+            watcher.add(paths);
+        },
+        remove(paths) {
+            watcher.unwatch(paths);
+        },
+        async close() {
+            try {
+                await watcher.close();
+                if (nextWaitTimeout) {
+                    clearTimeout(nextWaitTimeout);
+                }
+            }
+            finally {
+                let next;
+                while ((next = nextQueue.shift()) !== undefined) {
+                    next();
+                }
+            }
+        },
+    };
+}
+exports.createWatcher = createWatcher;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2F0Y2hlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2FuZ3VsYXJfZGV2a2l0L2J1aWxkX2FuZ3VsYXIvc3JjL3Rvb2xzL2VzYnVpbGQvd2F0Y2hlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7OztHQU1HOzs7QUFFSCx1Q0FBcUM7QUFFckMsTUFBYSxZQUFZO0lBQXpCO1FBQ1csVUFBSyxHQUFHLElBQUksR0FBRyxFQUFVLENBQUM7UUFDMUIsYUFBUSxHQUFHLElBQUksR0FBRyxFQUFVLENBQUM7UUFDN0IsWUFBTyxHQUFHLElBQUksR0FBRyxFQUFVLENBQUM7SUFXdkMsQ0FBQztJQVRDLGFBQWE7UUFDWCxNQUFNLE9BQU8sR0FBRztZQUNkLEtBQUssRUFBRSxLQUFLLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUM7WUFDN0IsUUFBUSxFQUFFLEtBQUssQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQztZQUNuQyxPQUFPLEVBQUUsS0FBSyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDO1NBQ2xDLENBQUM7UUFFRixPQUFPLElBQUksQ0FBQyxTQUFTLENBQUMsT0FBTyxFQUFFLElBQUksRUFBRSxDQUFDLENBQUMsQ0FBQztJQUMxQyxDQUFDO0NBQ0Y7QUFkRCxvQ0FjQztBQVFELFNBQWdCLGFBQWEsQ0FBQyxPQUk3QjtJQUNDLE1BQU0sT0FBTyxHQUFHLElBQUksb0JBQVMsQ0FBQztRQUM1QixVQUFVLEVBQUUsT0FBTyxFQUFFLE9BQU87UUFDNUIsUUFBUSxFQUFFLE9BQU8sRUFBRSxRQUFRO1FBQzNCLE9BQU8sRUFBRSxPQUFPLEVBQUUsT0FBTztRQUN6QixlQUFlLEVBQUUsSUFBSTtRQUNyQixhQUFhLEVBQUUsSUFBSTtLQUNwQixDQUFDLENBQUM7SUFFSCxNQUFNLFNBQVMsR0FBdUMsRUFBRSxDQUFDO0lBQ3pELElBQUksY0FBd0MsQ0FBQztJQUM3QyxJQUFJLGVBQTJDLENBQUM7SUFFaEQsT0FBTyxDQUFDLEVBQUUsQ0FBQyxLQUFLLEVBQUUsQ0FBQyxLQUFLLEVBQUUsSUFBSSxFQUFFLEVBQUU7UUFDaEMsUUFBUSxLQUFLLEVBQUU7WUFDYixLQUFLLEtBQUs7Z0JBQ1IsY0FBYyxLQUFkLGNBQWMsR0FBSyxJQUFJLFlBQVksRUFBRSxFQUFDO2dCQUN0QyxjQUFjLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsQ0FBQztnQkFDL0IsTUFBTTtZQUNSLEtBQUssUUFBUTtnQkFDWCxjQUFjLEtBQWQsY0FBYyxHQUFLLElBQUksWUFBWSxFQUFFLEVBQUM7Z0JBQ3RDLGNBQWMsQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDO2dCQUNsQyxNQUFNO1lBQ1IsS0FBSyxRQUFRO2dCQUNYLGNBQWMsS0FBZCxjQUFjLEdBQUssSUFBSSxZQUFZLEVBQUUsRUFBQztnQkFDdEMsY0FBYyxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUM7Z0JBQ2pDLE1BQU07WUFDUjtnQkFDRSxPQUFPO1NBQ1Y7UUFFRCxnRkFBZ0Y7UUFDaEYsSUFBSSxDQUFDLGVBQWUsRUFBRTtZQUNwQixlQUFlLEdBQUcsVUFBVSxDQUFDLEdBQUcsRUFBRTtnQkFDaEMsZUFBZSxHQUFHLFNBQVMsQ0FBQztnQkFDNUIsTUFBTSxJQUFJLEdBQUcsU0FBUyxDQUFDLEtBQUssRUFBRSxDQUFDO2dCQUMvQixJQUFJLElBQUksRUFBRTtvQkFDUixNQUFNLEtBQUssR0FBRyxjQUFjLENBQUM7b0JBQzdCLGNBQWMsR0FBRyxTQUFTLENBQUM7b0JBQzNCLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztpQkFDYjtZQUNILENBQUMsRUFBRSxHQUFHLENBQUMsQ0FBQztZQUNSLGVBQWUsRUFBRSxLQUFLLEVBQUUsQ0FBQztTQUMxQjtJQUNILENBQUMsQ0FBQyxDQUFDO0lBRUgsT0FBTztRQUNMLENBQUMsTUFBTSxDQUFDLGFBQWEsQ0FBQztZQUNwQixPQUFPLElBQUksQ0FBQztRQUNkLENBQUM7UUFFRCxLQUFLLENBQUMsSUFBSTtZQUNSLElBQUksY0FBYyxJQUFJLFNBQVMsQ0FBQyxNQUFNLEtBQUssQ0FBQyxFQUFFO2dCQUM1QyxNQUFNLE1BQU0sR0FBRyxFQUFFLEtBQUssRUFBRSxjQUFjLEVBQUUsQ0FBQztnQkFDekMsY0FBYyxHQUFHLFNBQVMsQ0FBQztnQkFFM0IsT0FBTyxNQUFNLENBQUM7YUFDZjtZQUVELE9BQU8sSUFBSSxPQUFPLENBQUMsQ0FBQyxPQUFPLEVBQUUsRUFBRTtnQkFDN0IsU0FBUyxDQUFDLElBQUksQ0FBQyxDQUFDLEtBQUssRUFBRSxFQUFFLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsRUFBRSxLQUFLLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRSxJQUFJLEVBQUUsSUFBSSxFQUFFLEtBQUssRUFBRSxDQUFDLENBQUMsQ0FBQztZQUNoRixDQUFDLENBQUMsQ0FBQztRQUNMLENBQUM7UUFFRCxHQUFHLENBQUMsS0FBSztZQUNQLE9BQU8sQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDckIsQ0FBQztRQUVELE1BQU0sQ0FBQyxLQUFLO1lBQ1YsT0FBTyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUN6QixDQUFDO1FBRUQsS0FBSyxDQUFDLEtBQUs7WUFDVCxJQUFJO2dCQUNGLE1BQU0sT0FBTyxDQUFDLEtBQUssRUFBRSxDQUFDO2dCQUN0QixJQUFJLGVBQWUsRUFBRTtvQkFDbkIsWUFBWSxDQUFDLGVBQWUsQ0FBQyxDQUFDO2lCQUMvQjthQUNGO29CQUFTO2dCQUNSLElBQUksSUFBSSxDQUFDO2dCQUNULE9BQU8sQ0FBQyxJQUFJLEdBQUcsU0FBUyxDQUFDLEtBQUssRUFBRSxDQUFDLEtBQUssU0FBUyxFQUFFO29CQUMvQyxJQUFJLEVBQUUsQ0FBQztpQkFDUjthQUNGO1FBQ0gsQ0FBQztLQUNGLENBQUM7QUFDSixDQUFDO0FBMUZELHNDQTBGQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQgeyBGU1dhdGNoZXIgfSBmcm9tICdjaG9raWRhcic7XG5cbmV4cG9ydCBjbGFzcyBDaGFuZ2VkRmlsZXMge1xuICByZWFkb25seSBhZGRlZCA9IG5ldyBTZXQ8c3RyaW5nPigpO1xuICByZWFkb25seSBtb2RpZmllZCA9IG5ldyBTZXQ8c3RyaW5nPigpO1xuICByZWFkb25seSByZW1vdmVkID0gbmV3IFNldDxzdHJpbmc+KCk7XG5cbiAgdG9EZWJ1Z1N0cmluZygpOiBzdHJpbmcge1xuICAgIGNvbnN0IGNvbnRlbnQgPSB7XG4gICAgICBhZGRlZDogQXJyYXkuZnJvbSh0aGlzLmFkZGVkKSxcbiAgICAgIG1vZGlmaWVkOiBBcnJheS5mcm9tKHRoaXMubW9kaWZpZWQpLFxuICAgICAgcmVtb3ZlZDogQXJyYXkuZnJvbSh0aGlzLnJlbW92ZWQpLFxuICAgIH07XG5cbiAgICByZXR1cm4gSlNPTi5zdHJpbmdpZnkoY29udGVudCwgbnVsbCwgMik7XG4gIH1cbn1cblxuZXhwb3J0IGludGVyZmFjZSBCdWlsZFdhdGNoZXIgZXh0ZW5kcyBBc3luY0l0ZXJhYmxlSXRlcmF0b3I8Q2hhbmdlZEZpbGVzPiB7XG4gIGFkZChwYXRoczogc3RyaW5nIHwgcmVhZG9ubHkgc3RyaW5nW10pOiB2b2lkO1xuICByZW1vdmUocGF0aHM6IHN0cmluZyB8IHJlYWRvbmx5IHN0cmluZ1tdKTogdm9pZDtcbiAgY2xvc2UoKTogUHJvbWlzZTx2b2lkPjtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGNyZWF0ZVdhdGNoZXIob3B0aW9ucz86IHtcbiAgcG9sbGluZz86IGJvb2xlYW47XG4gIGludGVydmFsPzogbnVtYmVyO1xuICBpZ25vcmVkPzogc3RyaW5nW107XG59KTogQnVpbGRXYXRjaGVyIHtcbiAgY29uc3Qgd2F0Y2hlciA9IG5ldyBGU1dhdGNoZXIoe1xuICAgIHVzZVBvbGxpbmc6IG9wdGlvbnM/LnBvbGxpbmcsXG4gICAgaW50ZXJ2YWw6IG9wdGlvbnM/LmludGVydmFsLFxuICAgIGlnbm9yZWQ6IG9wdGlvbnM/Lmlnbm9yZWQsXG4gICAgZGlzYWJsZUdsb2JiaW5nOiB0cnVlLFxuICAgIGlnbm9yZUluaXRpYWw6IHRydWUsXG4gIH0pO1xuXG4gIGNvbnN0IG5leHRRdWV1ZTogKCh2YWx1ZT86IENoYW5nZWRGaWxlcykgPT4gdm9pZClbXSA9IFtdO1xuICBsZXQgY3VycmVudENoYW5nZXM6IENoYW5nZWRGaWxlcyB8IHVuZGVmaW5lZDtcbiAgbGV0IG5leHRXYWl0VGltZW91dDogTm9kZUpTLlRpbWVvdXQgfCB1bmRlZmluZWQ7XG5cbiAgd2F0Y2hlci5vbignYWxsJywgKGV2ZW50LCBwYXRoKSA9PiB7XG4gICAgc3dpdGNoIChldmVudCkge1xuICAgICAgY2FzZSAnYWRkJzpcbiAgICAgICAgY3VycmVudENoYW5nZXMgPz89IG5ldyBDaGFuZ2VkRmlsZXMoKTtcbiAgICAgICAgY3VycmVudENoYW5nZXMuYWRkZWQuYWRkKHBhdGgpO1xuICAgICAgICBicmVhaztcbiAgICAgIGNhc2UgJ2NoYW5nZSc6XG4gICAgICAgIGN1cnJlbnRDaGFuZ2VzID8/PSBuZXcgQ2hhbmdlZEZpbGVzKCk7XG4gICAgICAgIGN1cnJlbnRDaGFuZ2VzLm1vZGlmaWVkLmFkZChwYXRoKTtcbiAgICAgICAgYnJlYWs7XG4gICAgICBjYXNlICd1bmxpbmsnOlxuICAgICAgICBjdXJyZW50Q2hhbmdlcyA/Pz0gbmV3IENoYW5nZWRGaWxlcygpO1xuICAgICAgICBjdXJyZW50Q2hhbmdlcy5yZW1vdmVkLmFkZChwYXRoKTtcbiAgICAgICAgYnJlYWs7XG4gICAgICBkZWZhdWx0OlxuICAgICAgICByZXR1cm47XG4gICAgfVxuXG4gICAgLy8gV2FpdCAyNTBtcyBmcm9tIG5leHQgY2hhbmdlIHRvIGJldHRlciBjYXB0dXJlIGdyb3VwcyBvZiBmaWxlIHNhdmUgb3BlcmF0aW9ucy5cbiAgICBpZiAoIW5leHRXYWl0VGltZW91dCkge1xuICAgICAgbmV4dFdhaXRUaW1lb3V0ID0gc2V0VGltZW91dCgoKSA9PiB7XG4gICAgICAgIG5leHRXYWl0VGltZW91dCA9IHVuZGVmaW5lZDtcbiAgICAgICAgY29uc3QgbmV4dCA9IG5leHRRdWV1ZS5zaGlmdCgpO1xuICAgICAgICBpZiAobmV4dCkge1xuICAgICAgICAgIGNvbnN0IHZhbHVlID0gY3VycmVudENoYW5nZXM7XG4gICAgICAgICAgY3VycmVudENoYW5nZXMgPSB1bmRlZmluZWQ7XG4gICAgICAgICAgbmV4dCh2YWx1ZSk7XG4gICAgICAgIH1cbiAgICAgIH0sIDI1MCk7XG4gICAgICBuZXh0V2FpdFRpbWVvdXQ/LnVucmVmKCk7XG4gICAgfVxuICB9KTtcblxuICByZXR1cm4ge1xuICAgIFtTeW1ib2wuYXN5bmNJdGVyYXRvcl0oKSB7XG4gICAgICByZXR1cm4gdGhpcztcbiAgICB9LFxuXG4gICAgYXN5bmMgbmV4dCgpIHtcbiAgICAgIGlmIChjdXJyZW50Q2hhbmdlcyAmJiBuZXh0UXVldWUubGVuZ3RoID09PSAwKSB7XG4gICAgICAgIGNvbnN0IHJlc3VsdCA9IHsgdmFsdWU6IGN1cnJlbnRDaGFuZ2VzIH07XG4gICAgICAgIGN1cnJlbnRDaGFuZ2VzID0gdW5kZWZpbmVkO1xuXG4gICAgICAgIHJldHVybiByZXN1bHQ7XG4gICAgICB9XG5cbiAgICAgIHJldHVybiBuZXcgUHJvbWlzZSgocmVzb2x2ZSkgPT4ge1xuICAgICAgICBuZXh0UXVldWUucHVzaCgodmFsdWUpID0+IHJlc29sdmUodmFsdWUgPyB7IHZhbHVlIH0gOiB7IGRvbmU6IHRydWUsIHZhbHVlIH0pKTtcbiAgICAgIH0pO1xuICAgIH0sXG5cbiAgICBhZGQocGF0aHMpIHtcbiAgICAgIHdhdGNoZXIuYWRkKHBhdGhzKTtcbiAgICB9LFxuXG4gICAgcmVtb3ZlKHBhdGhzKSB7XG4gICAgICB3YXRjaGVyLnVud2F0Y2gocGF0aHMpO1xuICAgIH0sXG5cbiAgICBhc3luYyBjbG9zZSgpIHtcbiAgICAgIHRyeSB7XG4gICAgICAgIGF3YWl0IHdhdGNoZXIuY2xvc2UoKTtcbiAgICAgICAgaWYgKG5leHRXYWl0VGltZW91dCkge1xuICAgICAgICAgIGNsZWFyVGltZW91dChuZXh0V2FpdFRpbWVvdXQpO1xuICAgICAgICB9XG4gICAgICB9IGZpbmFsbHkge1xuICAgICAgICBsZXQgbmV4dDtcbiAgICAgICAgd2hpbGUgKChuZXh0ID0gbmV4dFF1ZXVlLnNoaWZ0KCkpICE9PSB1bmRlZmluZWQpIHtcbiAgICAgICAgICBuZXh0KCk7XG4gICAgICAgIH1cbiAgICAgIH1cbiAgICB9LFxuICB9O1xufVxuIl19

package/src/tools/sass/rebasing-importer.js

@@ -0,0 +1,445 @@
+"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
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sassBindWorkaround = exports.LoadPathsUrlRebasingImporter = exports.ModuleUrlRebasingImporter = exports.RelativeUrlRebasingImporter = void 0;
+const magic_string_1 = __importDefault(require("magic-string"));
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_url_1 = require("node:url");
+/**
+ * A Sass Importer base class that provides the load logic to rebase all `url()` functions
+ * within a stylesheet. The rebasing will ensure that the URLs in the output of the Sass compiler
+ * reflect the final filesystem location of the output CSS file.
+ *
+ * This class provides the core of the rebasing functionality. To ensure that each file is processed
+ * by this importer's load implementation, the Sass compiler requires the importer's canonicalize
+ * function to return a non-null value with the resolved location of the requested stylesheet.
+ * Concrete implementations of this class must provide this canonicalize functionality for rebasing
+ * to be effective.
+ */
+class UrlRebasingImporter {
+    /**
+     * @param entryDirectory The directory of the entry stylesheet that was passed to the Sass compiler.
+     * @param rebaseSourceMaps When provided, rebased files will have an intermediate sourcemap added to the Map
+     * which can be used to generate a final sourcemap that contains original sources.
+     */
+    constructor(entryDirectory, rebaseSourceMaps) {
+        this.entryDirectory = entryDirectory;
+        this.rebaseSourceMaps = rebaseSourceMaps;
+    }
+    load(canonicalUrl) {
+        const stylesheetPath = (0, node_url_1.fileURLToPath)(canonicalUrl);
+        const stylesheetDirectory = (0, node_path_1.dirname)(stylesheetPath);
+        let contents = (0, node_fs_1.readFileSync)(stylesheetPath, 'utf-8');
+        // Rebase any URLs that are found
+        let updatedContents;
+        for (const { start, end, value } of findUrls(contents)) {
+            // Skip if value is empty or a Sass variable
+            if (value.length === 0 || value.startsWith('$')) {
+                continue;
+            }
+            // Skip if root-relative, absolute or protocol relative url
+            if (/^((?:\w+:)?\/\/|data:|chrome:|#|\/)/.test(value)) {
+                continue;
+            }
+            const rebasedPath = (0, node_path_1.relative)(this.entryDirectory, (0, node_path_1.join)(stylesheetDirectory, value));
+            // Normalize path separators and escape characters
+            // https://developer.mozilla.org/en-US/docs/Web/CSS/url#syntax
+            const rebasedUrl = './' + rebasedPath.replace(/\\/g, '/').replace(/[()\s'"]/g, '\\$&');
+            updatedContents ?? (updatedContents = new magic_string_1.default(contents));
+            updatedContents.update(start, end, rebasedUrl);
+        }
+        if (updatedContents) {
+            contents = updatedContents.toString();
+            if (this.rebaseSourceMaps) {
+                // Generate an intermediate source map for the rebasing changes
+                const map = updatedContents.generateMap({
+                    hires: true,
+                    includeContent: true,
+                    source: canonicalUrl.href,
+                });
+                this.rebaseSourceMaps.set(canonicalUrl.href, map);
+            }
+        }
+        let syntax;
+        switch ((0, node_path_1.extname)(stylesheetPath).toLowerCase()) {
+            case '.css':
+                syntax = 'css';
+                break;
+            case '.sass':
+                syntax = 'indented';
+                break;
+            default:
+                syntax = 'scss';
+                break;
+        }
+        return {
+            contents,
+            syntax,
+            sourceMapUrl: canonicalUrl,
+        };
+    }
+}
+/**
+ * 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 CSS
+ * 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;
+        }
+    }
+}
+/**
+ * Provides the Sass importer logic to resolve relative stylesheet imports via both import and use rules
+ * and also rebase any `url()` function usage within those stylesheets. The rebasing will ensure that
+ * the URLs in the output of the Sass compiler reflect the final filesystem location of the output CSS file.
+ */
+class RelativeUrlRebasingImporter extends UrlRebasingImporter {
+    constructor(entryDirectory, directoryCache = new Map(), rebaseSourceMaps) {
+        super(entryDirectory, rebaseSourceMaps);
+        this.directoryCache = directoryCache;
+    }
+    canonicalize(url, options) {
+        return this.resolveImport(url, options.fromImport, true);
+    }
+    /**
+     * Attempts to resolve a provided URL to a stylesheet file using the Sass compiler's resolution algorithm.
+     * Based on https://github.com/sass/dart-sass/blob/44d6bb6ac72fe6b93f5bfec371a1fffb18e6b76d/lib/src/importer/utils.dart
+     * @param url The file protocol URL to resolve.
+     * @param fromImport If true, URL was from an import rule; otherwise from a use rule.
+     * @param checkDirectory If true, try checking for a directory with the base name containing an index file.
+     * @returns A full resolved URL of the stylesheet file or `null` if not found.
+     */
+    resolveImport(url, fromImport, checkDirectory) {
+        let stylesheetPath;
+        try {
+            stylesheetPath = (0, node_url_1.fileURLToPath)(url);
+        }
+        catch {
+            // Only file protocol URLs are supported by this importer
+            return null;
+        }
+        const directory = (0, node_path_1.dirname)(stylesheetPath);
+        const extension = (0, node_path_1.extname)(stylesheetPath);
+        const hasStyleExtension = extension === '.scss' || extension === '.sass' || extension === '.css';
+        // Remove the style extension if present to allow adding the `.import` suffix
+        const filename = (0, node_path_1.basename)(stylesheetPath, hasStyleExtension ? extension : undefined);
+        const importPotentials = new Set();
+        const defaultPotentials = new Set();
+        if (hasStyleExtension) {
+            if (fromImport) {
+                importPotentials.add(filename + '.import' + extension);
+                importPotentials.add('_' + filename + '.import' + extension);
+            }
+            defaultPotentials.add(filename + extension);
+            defaultPotentials.add('_' + filename + extension);
+        }
+        else {
+            if (fromImport) {
+                importPotentials.add(filename + '.import.scss');
+                importPotentials.add(filename + '.import.sass');
+                importPotentials.add(filename + '.import.css');
+                importPotentials.add('_' + filename + '.import.scss');
+                importPotentials.add('_' + filename + '.import.sass');
+                importPotentials.add('_' + filename + '.import.css');
+            }
+            defaultPotentials.add(filename + '.scss');
+            defaultPotentials.add(filename + '.sass');
+            defaultPotentials.add(filename + '.css');
+            defaultPotentials.add('_' + filename + '.scss');
+            defaultPotentials.add('_' + filename + '.sass');
+            defaultPotentials.add('_' + filename + '.css');
+        }
+        let foundDefaults;
+        let foundImports;
+        let hasPotentialIndex = false;
+        let cachedEntries = this.directoryCache.get(directory);
+        if (cachedEntries) {
+            // If there is a preprocessed cache of the directory, perform an intersection of the potentials
+            // and the directory files.
+            const { files, directories } = cachedEntries;
+            foundDefaults = [...defaultPotentials].filter((potential) => files.has(potential));
+            foundImports = [...importPotentials].filter((potential) => files.has(potential));
+            hasPotentialIndex = checkDirectory && !hasStyleExtension && directories.has(filename);
+        }
+        else {
+            // If no preprocessed cache exists, get the entries from the file system and, while searching,
+            // generate the cache for later requests.
+            let entries;
+            try {
+                entries = (0, node_fs_1.readdirSync)(directory, { withFileTypes: true });
+            }
+            catch {
+                return null;
+            }
+            foundDefaults = [];
+            foundImports = [];
+            cachedEntries = { files: new Set(), directories: new Set() };
+            for (const entry of entries) {
+                const isDirectory = entry.isDirectory();
+                if (isDirectory) {
+                    cachedEntries.directories.add(entry.name);
+                }
+                // Record if the name should be checked as a directory with an index file
+                if (checkDirectory && !hasStyleExtension && entry.name === filename && isDirectory) {
+                    hasPotentialIndex = true;
+                }
+                if (!entry.isFile()) {
+                    continue;
+                }
+                cachedEntries.files.add(entry.name);
+                if (importPotentials.has(entry.name)) {
+                    foundImports.push(entry.name);
+                }
+                if (defaultPotentials.has(entry.name)) {
+                    foundDefaults.push(entry.name);
+                }
+            }
+            this.directoryCache.set(directory, cachedEntries);
+        }
+        // `foundImports` will only contain elements if `options.fromImport` is true
+        const result = this.checkFound(foundImports) ?? this.checkFound(foundDefaults);
+        if (result !== null) {
+            return (0, node_url_1.pathToFileURL)((0, node_path_1.join)(directory, result));
+        }
+        if (hasPotentialIndex) {
+            // Check for index files using filename as a directory
+            return this.resolveImport(url + '/index', fromImport, false);
+        }
+        return null;
+    }
+    /**
+     * Checks an array of potential stylesheet files to determine if there is a valid
+     * stylesheet file. More than one discovered file may indicate an error.
+     * @param found An array of discovered stylesheet files.
+     * @returns A fully resolved path for a stylesheet file or `null` if not found.
+     * @throws If there are ambiguous files discovered.
+     */
+    checkFound(found) {
+        if (found.length === 0) {
+            // Not found
+            return null;
+        }
+        // More than one found file may be an error
+        if (found.length > 1) {
+            // Presence of CSS files alongside a Sass file does not cause an error
+            const foundWithoutCss = found.filter((element) => (0, node_path_1.extname)(element) !== '.css');
+            // If the length is zero then there are two or more css files
+            // If the length is more than one than there are two or more sass/scss files
+            if (foundWithoutCss.length !== 1) {
+                throw new Error('Ambiguous import detected.');
+            }
+            // Return the non-CSS file (sass/scss files have priority)
+            // https://github.com/sass/dart-sass/blob/44d6bb6ac72fe6b93f5bfec371a1fffb18e6b76d/lib/src/importer/utils.dart#L44-L47
+            return foundWithoutCss[0];
+        }
+        return found[0];
+    }
+}
+exports.RelativeUrlRebasingImporter = RelativeUrlRebasingImporter;
+/**
+ * Provides the Sass importer logic to resolve module (npm package) stylesheet imports via both import and
+ * use rules and also rebase any `url()` function usage within those stylesheets. The rebasing will ensure that
+ * the URLs in the output of the Sass compiler reflect the final filesystem location of the output CSS file.
+ */
+class ModuleUrlRebasingImporter extends RelativeUrlRebasingImporter {
+    constructor(entryDirectory, directoryCache, rebaseSourceMaps, finder) {
+        super(entryDirectory, directoryCache, rebaseSourceMaps);
+        this.finder = finder;
+    }
+    canonicalize(url, options) {
+        if (url.startsWith('file://')) {
+            return super.canonicalize(url, options);
+        }
+        const result = this.finder(url, options);
+        return result ? super.canonicalize(result.href, options) : null;
+    }
+}
+exports.ModuleUrlRebasingImporter = ModuleUrlRebasingImporter;
+/**
+ * Provides the Sass importer logic to resolve load paths located stylesheet imports via both import and
+ * use rules and also rebase any `url()` function usage within those stylesheets. The rebasing will ensure that
+ * the URLs in the output of the Sass compiler reflect the final filesystem location of the output CSS file.
+ */
+class LoadPathsUrlRebasingImporter extends RelativeUrlRebasingImporter {
+    constructor(entryDirectory, directoryCache, rebaseSourceMaps, loadPaths) {
+        super(entryDirectory, directoryCache, rebaseSourceMaps);
+        this.loadPaths = loadPaths;
+    }
+    canonicalize(url, options) {
+        if (url.startsWith('file://')) {
+            return super.canonicalize(url, options);
+        }
+        let result = null;
+        for (const loadPath of this.loadPaths) {
+            result = super.canonicalize((0, node_url_1.pathToFileURL)((0, node_path_1.join)(loadPath, url)).href, options);
+            if (result !== null) {
+                break;
+            }
+        }
+        return result;
+    }
+}
+exports.LoadPathsUrlRebasingImporter = LoadPathsUrlRebasingImporter;
+/**
+ * Workaround for Sass not calling instance methods with `this`.
+ * The `canonicalize` and `load` methods will be bound to the class instance.
+ * @param importer A Sass importer to bind.
+ * @returns The bound Sass importer.
+ */
+function sassBindWorkaround(importer) {
+    importer.canonicalize = importer.canonicalize.bind(importer);
+    importer.load = importer.load.bind(importer);
+    return importer;
+}
+exports.sassBindWorkaround = sassBindWorkaround;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rebasing-importer.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/tools/sass/rebasing-importer.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 { RawSourceMap } from '@ampproject/remapping';\nimport MagicString from 'magic-string';\nimport { readFileSync, readdirSync } from 'node:fs';\nimport { basename, dirname, extname, join, relative } from 'node:path';\nimport { fileURLToPath, pathToFileURL } from 'node:url';\nimport type { FileImporter, Importer, ImporterResult, Syntax } from 'sass';\n\n/**\n * A preprocessed cache entry for the files and directories within a previously searched\n * directory when performing Sass import resolution.\n */\nexport interface DirectoryEntry {\n  files: Set<string>;\n  directories: Set<string>;\n}\n\n/**\n * A Sass Importer base class that provides the load logic to rebase all `url()` functions\n * within a stylesheet. The rebasing will ensure that the URLs in the output of the Sass compiler\n * reflect the final filesystem location of the output CSS file.\n *\n * This class provides the core of the rebasing functionality. To ensure that each file is processed\n * by this importer's load implementation, the Sass compiler requires the importer's canonicalize\n * function to return a non-null value with the resolved location of the requested stylesheet.\n * Concrete implementations of this class must provide this canonicalize functionality for rebasing\n * to be effective.\n */\nabstract class UrlRebasingImporter implements Importer<'sync'> {\n  /**\n   * @param entryDirectory The directory of the entry stylesheet that was passed to the Sass compiler.\n   * @param rebaseSourceMaps When provided, rebased files will have an intermediate sourcemap added to the Map\n   * which can be used to generate a final sourcemap that contains original sources.\n   */\n  constructor(\n    private entryDirectory: string,\n    private rebaseSourceMaps?: Map<string, RawSourceMap>,\n  ) {}\n\n  abstract canonicalize(url: string, options: { fromImport: boolean }): URL | null;\n\n  load(canonicalUrl: URL): ImporterResult | null {\n    const stylesheetPath = fileURLToPath(canonicalUrl);\n    const stylesheetDirectory = dirname(stylesheetPath);\n    let contents = readFileSync(stylesheetPath, 'utf-8');\n\n    // Rebase any URLs that are found\n    let updatedContents;\n    for (const { start, end, value } of findUrls(contents)) {\n      // Skip if value is empty or a Sass variable\n      if (value.length === 0 || value.startsWith('$')) {\n        continue;\n      }\n\n      // Skip if root-relative, absolute or protocol relative url\n      if (/^((?:\\w+:)?\\/\\/|data:|chrome:|#|\\/)/.test(value)) {\n        continue;\n      }\n\n      const rebasedPath = relative(this.entryDirectory, join(stylesheetDirectory, value));\n\n      // Normalize path separators and escape characters\n      // https://developer.mozilla.org/en-US/docs/Web/CSS/url#syntax\n      const rebasedUrl = './' + rebasedPath.replace(/\\\\/g, '/').replace(/[()\\s'\"]/g, '\\\\$&');\n\n      updatedContents ??= new MagicString(contents);\n      updatedContents.update(start, end, rebasedUrl);\n    }\n\n    if (updatedContents) {\n      contents = updatedContents.toString();\n      if (this.rebaseSourceMaps) {\n        // Generate an intermediate source map for the rebasing changes\n        const map = updatedContents.generateMap({\n          hires: true,\n          includeContent: true,\n          source: canonicalUrl.href,\n        });\n        this.rebaseSourceMaps.set(canonicalUrl.href, map as RawSourceMap);\n      }\n    }\n\n    let syntax: Syntax | undefined;\n    switch (extname(stylesheetPath).toLowerCase()) {\n      case '.css':\n        syntax = 'css';\n        break;\n      case '.sass':\n        syntax = 'indented';\n        break;\n      default:\n        syntax = 'scss';\n        break;\n    }\n\n    return {\n      contents,\n      syntax,\n      sourceMapUrl: canonicalUrl,\n    };\n  }\n}\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 CSS\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 */\nfunction* findUrls(contents: string): 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 * Provides the Sass importer logic to resolve relative stylesheet imports via both import and use rules\n * and also rebase any `url()` function usage within those stylesheets. The rebasing will ensure that\n * the URLs in the output of the Sass compiler reflect the final filesystem location of the output CSS file.\n */\nexport class RelativeUrlRebasingImporter extends UrlRebasingImporter {\n  constructor(\n    entryDirectory: string,\n    private directoryCache = new Map<string, DirectoryEntry>(),\n    rebaseSourceMaps?: Map<string, RawSourceMap>,\n  ) {\n    super(entryDirectory, rebaseSourceMaps);\n  }\n\n  canonicalize(url: string, options: { fromImport: boolean }): URL | null {\n    return this.resolveImport(url, options.fromImport, true);\n  }\n\n  /**\n   * Attempts to resolve a provided URL to a stylesheet file using the Sass compiler's resolution algorithm.\n   * Based on https://github.com/sass/dart-sass/blob/44d6bb6ac72fe6b93f5bfec371a1fffb18e6b76d/lib/src/importer/utils.dart\n   * @param url The file protocol URL to resolve.\n   * @param fromImport If true, URL was from an import rule; otherwise from a use rule.\n   * @param checkDirectory If true, try checking for a directory with the base name containing an index file.\n   * @returns A full resolved URL of the stylesheet file or `null` if not found.\n   */\n  private resolveImport(url: string, fromImport: boolean, checkDirectory: boolean): URL | null {\n    let stylesheetPath;\n    try {\n      stylesheetPath = fileURLToPath(url);\n    } catch {\n      // Only file protocol URLs are supported by this importer\n      return null;\n    }\n\n    const directory = dirname(stylesheetPath);\n    const extension = extname(stylesheetPath);\n    const hasStyleExtension =\n      extension === '.scss' || extension === '.sass' || extension === '.css';\n    // Remove the style extension if present to allow adding the `.import` suffix\n    const filename = basename(stylesheetPath, hasStyleExtension ? extension : undefined);\n\n    const importPotentials = new Set<string>();\n    const defaultPotentials = new Set<string>();\n\n    if (hasStyleExtension) {\n      if (fromImport) {\n        importPotentials.add(filename + '.import' + extension);\n        importPotentials.add('_' + filename + '.import' + extension);\n      }\n      defaultPotentials.add(filename + extension);\n      defaultPotentials.add('_' + filename + extension);\n    } else {\n      if (fromImport) {\n        importPotentials.add(filename + '.import.scss');\n        importPotentials.add(filename + '.import.sass');\n        importPotentials.add(filename + '.import.css');\n        importPotentials.add('_' + filename + '.import.scss');\n        importPotentials.add('_' + filename + '.import.sass');\n        importPotentials.add('_' + filename + '.import.css');\n      }\n      defaultPotentials.add(filename + '.scss');\n      defaultPotentials.add(filename + '.sass');\n      defaultPotentials.add(filename + '.css');\n      defaultPotentials.add('_' + filename + '.scss');\n      defaultPotentials.add('_' + filename + '.sass');\n      defaultPotentials.add('_' + filename + '.css');\n    }\n\n    let foundDefaults;\n    let foundImports;\n    let hasPotentialIndex = false;\n\n    let cachedEntries = this.directoryCache.get(directory);\n    if (cachedEntries) {\n      // If there is a preprocessed cache of the directory, perform an intersection of the potentials\n      // and the directory files.\n      const { files, directories } = cachedEntries;\n      foundDefaults = [...defaultPotentials].filter((potential) => files.has(potential));\n      foundImports = [...importPotentials].filter((potential) => files.has(potential));\n      hasPotentialIndex = checkDirectory && !hasStyleExtension && directories.has(filename);\n    } else {\n      // If no preprocessed cache exists, get the entries from the file system and, while searching,\n      // generate the cache for later requests.\n      let entries;\n      try {\n        entries = readdirSync(directory, { withFileTypes: true });\n      } catch {\n        return null;\n      }\n\n      foundDefaults = [];\n      foundImports = [];\n      cachedEntries = { files: new Set<string>(), directories: new Set<string>() };\n      for (const entry of entries) {\n        const isDirectory = entry.isDirectory();\n        if (isDirectory) {\n          cachedEntries.directories.add(entry.name);\n        }\n\n        // Record if the name should be checked as a directory with an index file\n        if (checkDirectory && !hasStyleExtension && entry.name === filename && isDirectory) {\n          hasPotentialIndex = true;\n        }\n\n        if (!entry.isFile()) {\n          continue;\n        }\n\n        cachedEntries.files.add(entry.name);\n\n        if (importPotentials.has(entry.name)) {\n          foundImports.push(entry.name);\n        }\n\n        if (defaultPotentials.has(entry.name)) {\n          foundDefaults.push(entry.name);\n        }\n      }\n\n      this.directoryCache.set(directory, cachedEntries);\n    }\n\n    // `foundImports` will only contain elements if `options.fromImport` is true\n    const result = this.checkFound(foundImports) ?? this.checkFound(foundDefaults);\n    if (result !== null) {\n      return pathToFileURL(join(directory, result));\n    }\n\n    if (hasPotentialIndex) {\n      // Check for index files using filename as a directory\n      return this.resolveImport(url + '/index', fromImport, false);\n    }\n\n    return null;\n  }\n\n  /**\n   * Checks an array of potential stylesheet files to determine if there is a valid\n   * stylesheet file. More than one discovered file may indicate an error.\n   * @param found An array of discovered stylesheet files.\n   * @returns A fully resolved path for a stylesheet file or `null` if not found.\n   * @throws If there are ambiguous files discovered.\n   */\n  private checkFound(found: string[]): string | null {\n    if (found.length === 0) {\n      // Not found\n      return null;\n    }\n\n    // More than one found file may be an error\n    if (found.length > 1) {\n      // Presence of CSS files alongside a Sass file does not cause an error\n      const foundWithoutCss = found.filter((element) => extname(element) !== '.css');\n      // If the length is zero then there are two or more css files\n      // If the length is more than one than there are two or more sass/scss files\n      if (foundWithoutCss.length !== 1) {\n        throw new Error('Ambiguous import detected.');\n      }\n\n      // Return the non-CSS file (sass/scss files have priority)\n      // https://github.com/sass/dart-sass/blob/44d6bb6ac72fe6b93f5bfec371a1fffb18e6b76d/lib/src/importer/utils.dart#L44-L47\n      return foundWithoutCss[0];\n    }\n\n    return found[0];\n  }\n}\n\n/**\n * Provides the Sass importer logic to resolve module (npm package) stylesheet imports via both import and\n * use rules and also rebase any `url()` function usage within those stylesheets. The rebasing will ensure that\n * the URLs in the output of the Sass compiler reflect the final filesystem location of the output CSS file.\n */\nexport class ModuleUrlRebasingImporter extends RelativeUrlRebasingImporter {\n  constructor(\n    entryDirectory: string,\n    directoryCache: Map<string, DirectoryEntry>,\n    rebaseSourceMaps: Map<string, RawSourceMap> | undefined,\n    private finder: FileImporter<'sync'>['findFileUrl'],\n  ) {\n    super(entryDirectory, directoryCache, rebaseSourceMaps);\n  }\n\n  override canonicalize(url: string, options: { fromImport: boolean }): URL | null {\n    if (url.startsWith('file://')) {\n      return super.canonicalize(url, options);\n    }\n\n    const result = this.finder(url, options);\n\n    return result ? super.canonicalize(result.href, options) : null;\n  }\n}\n\n/**\n * Provides the Sass importer logic to resolve load paths located stylesheet imports via both import and\n * use rules and also rebase any `url()` function usage within those stylesheets. The rebasing will ensure that\n * the URLs in the output of the Sass compiler reflect the final filesystem location of the output CSS file.\n */\nexport class LoadPathsUrlRebasingImporter extends RelativeUrlRebasingImporter {\n  constructor(\n    entryDirectory: string,\n    directoryCache: Map<string, DirectoryEntry>,\n    rebaseSourceMaps: Map<string, RawSourceMap> | undefined,\n    private loadPaths: Iterable<string>,\n  ) {\n    super(entryDirectory, directoryCache, rebaseSourceMaps);\n  }\n\n  override canonicalize(url: string, options: { fromImport: boolean }): URL | null {\n    if (url.startsWith('file://')) {\n      return super.canonicalize(url, options);\n    }\n\n    let result = null;\n    for (const loadPath of this.loadPaths) {\n      result = super.canonicalize(pathToFileURL(join(loadPath, url)).href, options);\n      if (result !== null) {\n        break;\n      }\n    }\n\n    return result;\n  }\n}\n\n/**\n * Workaround for Sass not calling instance methods with `this`.\n * The `canonicalize` and `load` methods will be bound to the class instance.\n * @param importer A Sass importer to bind.\n * @returns The bound Sass importer.\n */\nexport function sassBindWorkaround<T extends Importer>(importer: T): T {\n  importer.canonicalize = importer.canonicalize.bind(importer);\n  importer.load = importer.load.bind(importer);\n\n  return importer;\n}\n"]}