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

package/src/tools/sass/lexer.js

@@ -1,161 +0,0 @@
-"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.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;

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

@@ -1,101 +0,0 @@
-/**
- * @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
- */
-import { RawSourceMap } from '@ampproject/remapping';
-import type { CanonicalizeContext, Importer, ImporterResult } from 'sass';
-/**
- * A preprocessed cache entry for the files and directories within a previously searched
- * directory when performing Sass import resolution.
- */
-export interface DirectoryEntry {
-    files: Set<string>;
-    directories: Set<string>;
-}
-/**
- * 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.
- */
-declare abstract class UrlRebasingImporter implements Importer<'sync'> {
-    private entryDirectory;
-    private rebaseSourceMaps?;
-    /**
-     * @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: string, rebaseSourceMaps?: Map<string, RawSourceMap> | undefined);
-    abstract canonicalize(url: string, options: {
-        fromImport: boolean;
-    }): URL | null;
-    load(canonicalUrl: URL): ImporterResult | null;
-}
-/**
- * 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.
- */
-export declare class RelativeUrlRebasingImporter extends UrlRebasingImporter {
-    private directoryCache;
-    constructor(entryDirectory: string, directoryCache?: Map<string, DirectoryEntry>, rebaseSourceMaps?: Map<string, RawSourceMap>);
-    canonicalize(url: string, options: {
-        fromImport: boolean;
-    }): URL | null;
-    /**
-     * 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.
-     */
-    private resolveImport;
-    /**
-     * 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.
-     */
-    private checkFound;
-}
-/**
- * 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.
- */
-export declare class ModuleUrlRebasingImporter extends RelativeUrlRebasingImporter {
-    private finder;
-    constructor(entryDirectory: string, directoryCache: Map<string, DirectoryEntry>, rebaseSourceMaps: Map<string, RawSourceMap> | undefined, finder: (specifier: string, options: CanonicalizeContext) => URL | null);
-    canonicalize(url: string, options: CanonicalizeContext): URL | null;
-}
-/**
- * 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.
- */
-export declare class LoadPathsUrlRebasingImporter extends RelativeUrlRebasingImporter {
-    private loadPaths;
-    constructor(entryDirectory: string, directoryCache: Map<string, DirectoryEntry>, rebaseSourceMaps: Map<string, RawSourceMap> | undefined, loadPaths: Iterable<string>);
-    canonicalize(url: string, options: {
-        fromImport: boolean;
-    }): URL | null;
-}
-/**
- * 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.
- */
-export declare function sassBindWorkaround<T extends Importer>(importer: T): T;
-export {};

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

@@ -1,337 +0,0 @@
-"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");
-const lexer_1 = require("./lexer");
-/**
- * Ensures that a bare specifier URL path that is intended to be treated as
- * a relative path has a leading `./` or `../` prefix.
- *
- * @param url A bare specifier URL path that should be considered relative.
- * @returns
- */
-function ensureRelative(url) {
-    // Empty
-    if (!url) {
-        return url;
-    }
-    // Already relative
-    if (url[0] === '.' && (url[1] === '/' || (url[1] === '.' && url[2] === '/'))) {
-        return url;
-    }
-    // Needs prefix
-    return './' + 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 {
-    entryDirectory;
-    rebaseSourceMaps;
-    /**
-     * @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 (0, lexer_1.findUrls)(contents)) {
-            // Skip if value is empty or Webpack-specific prefix
-            if (value.length === 0 || value[0] === '~' || value[0] === '^') {
-                continue;
-            }
-            // Skip if value is a Sass variable.
-            // Sass variable usage either starts with a `$` or contains a namespace and a `.$`
-            if (value[0] === '$' || /^\w+\.\$/.test(value)) {
-                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 = ensureRelative(rebasedPath.replace(/\\/g, '/').replace(/[()\s'"]/g, '\\$&'));
-            updatedContents ??= new magic_string_1.default(contents);
-            // Always quote the URL to avoid potential downstream parsing problems
-            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: 'boundary',
-                    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,
-        };
-    }
-}
-/**
- * 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 {
-    directoryCache;
-    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) {
-                let isDirectory;
-                let isFile;
-                if (entry.isSymbolicLink()) {
-                    const stats = (0, node_fs_1.statSync)((0, node_path_1.join)(entry.path, entry.name));
-                    isDirectory = stats.isDirectory();
-                    isFile = stats.isFile();
-                }
-                else {
-                    isDirectory = entry.isDirectory();
-                    isFile = entry.isFile();
-                }
-                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) {
-                        hasPotentialIndex = true;
-                    }
-                }
-                if (!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 {
-    finder;
-    constructor(entryDirectory, directoryCache, rebaseSourceMaps, finder) {
-        super(entryDirectory, directoryCache, rebaseSourceMaps);
-        this.finder = finder;
-    }
-    canonicalize(url, options) {
-        if (url.startsWith('file://')) {
-            return super.canonicalize(url, options);
-        }
-        let result = this.finder(url, options);
-        result &&= super.canonicalize(result.href, options);
-        return result;
-    }
-}
-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 {
-    loadPaths;
-    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;

package/src/tools/sass/sass-service.d.ts

@@ -1,49 +0,0 @@
-/**
- * @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
- */
-import { CompileResult, StringOptions } from 'sass';
-/**
- * A Sass renderer implementation that provides an interface that can be used by Webpack's
- * `sass-loader`. The implementation uses a Worker thread to perform the Sass rendering
- * with the `dart-sass` package.  The `dart-sass` synchronous render function is used within
- * the worker which can be up to two times faster than the asynchronous variant.
- */
-export declare class SassWorkerImplementation {
-    private rebase;
-    private readonly workers;
-    private readonly availableWorkers;
-    private readonly requests;
-    private readonly workerPath;
-    private idCounter;
-    private nextWorkerIndex;
-    constructor(rebase?: boolean);
-    /**
-     * Provides information about the Sass implementation.
-     * This mimics enough of the `dart-sass` value to be used with the `sass-loader`.
-     */
-    get info(): string;
-    /**
-     * The synchronous render function is not used by the `sass-loader`.
-     */
-    compileString(): never;
-    /**
-     * Asynchronously request a Sass stylesheet to be renderered.
-     *
-     * @param source The contents to compile.
-     * @param options The `dart-sass` options to use when rendering the stylesheet.
-     */
-    compileStringAsync(source: string, options: StringOptions<'async'>): Promise<CompileResult>;
-    /**
-     * Shutdown the Sass render worker.
-     * Executing this method will stop any pending render requests.
-     */
-    close(): void;
-    private createWorker;
-    private processImporters;
-    private createRequest;
-    private isFileImporter;
-}