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

package/src/tools/sass/sass-service.js

@@ -1,213 +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.SassWorkerImplementation = void 0;
-const node_path_1 = require("node:path");
-const node_url_1 = require("node:url");
-const node_worker_threads_1 = require("node:worker_threads");
-const environment_options_1 = require("../../utils/environment-options");
-/**
- * The maximum number of Workers that will be created to execute render requests.
- */
-const MAX_RENDER_WORKERS = environment_options_1.maxWorkers;
-/**
- * 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.
- */
-class SassWorkerImplementation {
-    rebase;
-    workers = [];
-    availableWorkers = [];
-    requests = new Map();
-    workerPath = (0, node_path_1.join)(__dirname, './worker.js');
-    idCounter = 1;
-    nextWorkerIndex = 0;
-    constructor(rebase = false) {
-        this.rebase = rebase;
-    }
-    /**
-     * Provides information about the Sass implementation.
-     * This mimics enough of the `dart-sass` value to be used with the `sass-loader`.
-     */
-    get info() {
-        return 'dart-sass\tworker';
-    }
-    /**
-     * The synchronous render function is not used by the `sass-loader`.
-     */
-    compileString() {
-        throw new Error('Sass compileString is not supported.');
-    }
-    /**
-     * 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, options) {
-        // The `functions`, `logger` and `importer` options are JavaScript functions that cannot be transferred.
-        // If any additional function options are added in the future, they must be excluded as well.
-        const { functions, importers, url, logger, ...serializableOptions } = options;
-        // The CLI's configuration does not use or expose the ability to defined custom Sass functions
-        if (functions && Object.keys(functions).length > 0) {
-            throw new Error('Sass custom functions are not supported.');
-        }
-        return new Promise((resolve, reject) => {
-            let workerIndex = this.availableWorkers.pop();
-            if (workerIndex === undefined) {
-                if (this.workers.length < MAX_RENDER_WORKERS) {
-                    workerIndex = this.workers.length;
-                    this.workers.push(this.createWorker());
-                }
-                else {
-                    workerIndex = this.nextWorkerIndex++;
-                    if (this.nextWorkerIndex >= this.workers.length) {
-                        this.nextWorkerIndex = 0;
-                    }
-                }
-            }
-            const callback = (error, result) => {
-                if (error) {
-                    const url = error.span?.url;
-                    if (url) {
-                        error.span.url = (0, node_url_1.pathToFileURL)(url);
-                    }
-                    reject(error);
-                    return;
-                }
-                if (!result) {
-                    reject(new Error('No result.'));
-                    return;
-                }
-                resolve(result);
-            };
-            const request = this.createRequest(workerIndex, callback, logger, importers);
-            this.requests.set(request.id, request);
-            this.workers[workerIndex].postMessage({
-                id: request.id,
-                source,
-                hasImporter: !!importers?.length,
-                hasLogger: !!logger,
-                rebase: this.rebase,
-                options: {
-                    ...serializableOptions,
-                    // URL is not serializable so to convert to string here and back to URL in the worker.
-                    url: url ? (0, node_url_1.fileURLToPath)(url) : undefined,
-                },
-            });
-        });
-    }
-    /**
-     * Shutdown the Sass render worker.
-     * Executing this method will stop any pending render requests.
-     */
-    close() {
-        for (const worker of this.workers) {
-            try {
-                void worker.terminate();
-            }
-            catch { }
-        }
-        this.requests.clear();
-    }
-    createWorker() {
-        const { port1: mainImporterPort, port2: workerImporterPort } = new node_worker_threads_1.MessageChannel();
-        const importerSignal = new Int32Array(new SharedArrayBuffer(4));
-        const worker = new node_worker_threads_1.Worker(this.workerPath, {
-            workerData: { workerImporterPort, importerSignal },
-            transferList: [workerImporterPort],
-        });
-        worker.on('message', (response) => {
-            const request = this.requests.get(response.id);
-            if (!request) {
-                return;
-            }
-            this.requests.delete(response.id);
-            this.availableWorkers.push(request.workerIndex);
-            if (response.warnings && request.logger?.warn) {
-                for (const { message, span, ...options } of response.warnings) {
-                    request.logger.warn(message, {
-                        ...options,
-                        span: span && {
-                            ...span,
-                            url: span.url ? (0, node_url_1.pathToFileURL)(span.url) : undefined,
-                        },
-                    });
-                }
-            }
-            if (response.result) {
-                request.callback(undefined, {
-                    ...response.result,
-                    // URL is not serializable so in the worker we convert to string and here back to URL.
-                    loadedUrls: response.result.loadedUrls.map((p) => (0, node_url_1.pathToFileURL)(p)),
-                });
-            }
-            else {
-                request.callback(response.error);
-            }
-        });
-        mainImporterPort.on('message', ({ id, url, options }) => {
-            const request = this.requests.get(id);
-            if (!request?.importers) {
-                mainImporterPort.postMessage(null);
-                Atomics.store(importerSignal, 0, 1);
-                Atomics.notify(importerSignal, 0);
-                return;
-            }
-            this.processImporters(request.importers, url, {
-                ...options,
-                // URL is not serializable so in the worker we convert to string and here back to URL.
-                containingUrl: options.containingUrl
-                    ? (0, node_url_1.pathToFileURL)(options.containingUrl)
-                    : null,
-            })
-                .then((result) => {
-                mainImporterPort.postMessage(result);
-            })
-                .catch((error) => {
-                mainImporterPort.postMessage(error);
-            })
-                .finally(() => {
-                Atomics.store(importerSignal, 0, 1);
-                Atomics.notify(importerSignal, 0);
-            });
-        });
-        mainImporterPort.unref();
-        return worker;
-    }
-    async processImporters(importers, url, options) {
-        for (const importer of importers) {
-            if (!this.isFileImporter(importer)) {
-                // Importer
-                throw new Error('Only File Importers are supported.');
-            }
-            // File importer (Can be sync or aync).
-            const result = await importer.findFileUrl(url, options);
-            if (result) {
-                return (0, node_url_1.fileURLToPath)(result);
-            }
-        }
-        return null;
-    }
-    createRequest(workerIndex, callback, logger, importers) {
-        return {
-            id: this.idCounter++,
-            workerIndex,
-            callback,
-            logger,
-            importers,
-        };
-    }
-    isFileImporter(value) {
-        return 'findFileUrl' in value;
-    }
-}
-exports.SassWorkerImplementation = SassWorkerImplementation;

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

@@ -1,8 +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
- */
-export {};

package/src/tools/sass/worker.js

@@ -1,164 +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 });
-const remapping_1 = __importDefault(require("@ampproject/remapping"));
-const node_path_1 = require("node:path");
-const node_url_1 = require("node:url");
-const node_worker_threads_1 = require("node:worker_threads");
-const sass_1 = require("sass");
-const rebasing_importer_1 = require("./rebasing-importer");
-if (!node_worker_threads_1.parentPort || !node_worker_threads_1.workerData) {
-    throw new Error('Sass worker must be executed as a Worker.');
-}
-// The importer variables are used to proxy import requests to the main thread
-const { workerImporterPort, importerSignal } = node_worker_threads_1.workerData;
-node_worker_threads_1.parentPort.on('message', (message) => {
-    if (!node_worker_threads_1.parentPort) {
-        throw new Error('"parentPort" is not defined. Sass worker must be executed as a Worker.');
-    }
-    const { id, hasImporter, hasLogger, source, options, rebase } = message;
-    const entryDirectory = (0, node_path_1.dirname)(options.url);
-    let warnings;
-    try {
-        const directoryCache = new Map();
-        const rebaseSourceMaps = options.sourceMap ? new Map() : undefined;
-        if (hasImporter) {
-            // When a custom importer function is present, the importer request must be proxied
-            // back to the main thread where it can be executed.
-            // This process must be synchronous from the perspective of dart-sass. The `Atomics`
-            // functions combined with the shared memory `importSignal` and the Node.js
-            // `receiveMessageOnPort` function are used to ensure synchronous behavior.
-            const proxyImporter = {
-                findFileUrl: (url, options) => {
-                    Atomics.store(importerSignal, 0, 0);
-                    workerImporterPort.postMessage({
-                        id,
-                        url,
-                        options: {
-                            ...options,
-                            containingUrl: options.containingUrl ? (0, node_url_1.fileURLToPath)(options.containingUrl) : null,
-                        },
-                    });
-                    Atomics.wait(importerSignal, 0, 0);
-                    const result = (0, node_worker_threads_1.receiveMessageOnPort)(workerImporterPort)?.message;
-                    return result ? (0, node_url_1.pathToFileURL)(result) : null;
-                },
-            };
-            options.importers = [
-                rebase
-                    ? (0, rebasing_importer_1.sassBindWorkaround)(new rebasing_importer_1.ModuleUrlRebasingImporter(entryDirectory, directoryCache, rebaseSourceMaps, proxyImporter.findFileUrl))
-                    : proxyImporter,
-            ];
-        }
-        if (rebase && options.loadPaths?.length) {
-            options.importers ??= [];
-            options.importers.push((0, rebasing_importer_1.sassBindWorkaround)(new rebasing_importer_1.LoadPathsUrlRebasingImporter(entryDirectory, directoryCache, rebaseSourceMaps, options.loadPaths)));
-            options.loadPaths = undefined;
-        }
-        let relativeImporter;
-        if (rebase) {
-            relativeImporter = (0, rebasing_importer_1.sassBindWorkaround)(new rebasing_importer_1.RelativeUrlRebasingImporter(entryDirectory, directoryCache, rebaseSourceMaps));
-        }
-        // The synchronous Sass render function can be up to two times faster than the async variant
-        const result = (0, sass_1.compileString)(source, {
-            ...options,
-            // URL is not serializable so to convert to string in the parent and back to URL here.
-            url: (0, node_url_1.pathToFileURL)(options.url),
-            // The `importer` option (singular) handles relative imports
-            importer: relativeImporter,
-            logger: hasLogger
-                ? {
-                    warn(message, { deprecation, span, stack }) {
-                        warnings ??= [];
-                        warnings.push({
-                            message,
-                            deprecation,
-                            stack,
-                            span: span && convertSourceSpan(span),
-                        });
-                    },
-                }
-                : undefined,
-        });
-        if (result.sourceMap && rebaseSourceMaps?.size) {
-            // Merge the intermediate rebasing source maps into the final Sass generated source map.
-            // Casting is required due to small but compatible differences in typings between the packages.
-            result.sourceMap = (0, remapping_1.default)(result.sourceMap, 
-            // To prevent an infinite lookup loop, skip getting the source when the rebasing source map
-            // is referencing its original self.
-            (file, context) => (file !== context.importer ? rebaseSourceMaps.get(file) : null));
-        }
-        node_worker_threads_1.parentPort.postMessage({
-            id,
-            warnings,
-            result: {
-                ...result,
-                // URL is not serializable so to convert to string here and back to URL in the parent.
-                loadedUrls: result.loadedUrls.map((p) => (0, node_url_1.fileURLToPath)(p)),
-            },
-        });
-    }
-    catch (error) {
-        // Needed because V8 will only serialize the message and stack properties of an Error instance.
-        if (error instanceof sass_1.Exception) {
-            const { span, message, stack, sassMessage, sassStack } = error;
-            node_worker_threads_1.parentPort.postMessage({
-                id,
-                warnings,
-                error: {
-                    span: convertSourceSpan(span),
-                    message,
-                    stack,
-                    sassMessage,
-                    sassStack,
-                },
-            });
-        }
-        else if (error instanceof Error) {
-            const { message, stack } = error;
-            node_worker_threads_1.parentPort.postMessage({ id, warnings, error: { message, stack } });
-        }
-        else {
-            node_worker_threads_1.parentPort.postMessage({
-                id,
-                warnings,
-                error: { message: 'An unknown error has occurred.' },
-            });
-        }
-    }
-});
-/**
- * Converts a Sass SourceSpan object into a serializable form.
- * The SourceSpan object contains a URL property which must be converted into a string.
- * Also, most of the interface's properties are get accessors and are not automatically
- * serialized when sent back from the worker.
- *
- * @param span The Sass SourceSpan object to convert.
- * @returns A serializable form of the SourceSpan object.
- */
-function convertSourceSpan(span) {
-    return {
-        text: span.text,
-        context: span.context,
-        end: {
-            column: span.end.column,
-            offset: span.end.offset,
-            line: span.end.line,
-        },
-        start: {
-            column: span.start.column,
-            offset: span.start.offset,
-            line: span.start.line,
-        },
-        url: span.url ? (0, node_url_1.fileURLToPath)(span.url) : undefined,
-    };
-}

package/src/tools/vite/angular-memory-plugin.d.ts

@@ -1,24 +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 type { Connect, Plugin } from 'vite';
-export interface AngularMemoryPluginOptions {
-    workspaceRoot: string;
-    virtualProjectRoot: string;
-    outputFiles: Map<string, {
-        contents: Uint8Array;
-        servable: boolean;
-    }>;
-    assets: Map<string, string>;
-    ssr: boolean;
-    external?: string[];
-    extensionMiddleware?: Connect.NextHandleFunction[];
-    extraHeaders?: Record<string, string>;
-    indexHtmlTransformer?: (content: string) => Promise<string>;
-    normalizePath: (path: string) => string;
-}
-export declare function createAngularMemoryPlugin(options: AngularMemoryPluginOptions): Plugin;

package/src/tools/vite/angular-memory-plugin.js

@@ -1,268 +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.createAngularMemoryPlugin = void 0;
-const remapping_1 = __importDefault(require("@ampproject/remapping"));
-const mrmime_1 = require("mrmime");
-const node_assert_1 = __importDefault(require("node:assert"));
-const promises_1 = require("node:fs/promises");
-const node_path_1 = require("node:path");
-const render_page_1 = require("../../utils/server-rendering/render-page");
-// eslint-disable-next-line max-lines-per-function
-function createAngularMemoryPlugin(options) {
-    const { workspaceRoot, virtualProjectRoot, outputFiles, assets, external, ssr, extensionMiddleware, extraHeaders, indexHtmlTransformer, normalizePath, } = options;
-    return {
-        name: 'vite:angular-memory',
-        // Ensures plugin hooks run before built-in Vite hooks
-        enforce: 'pre',
-        async resolveId(source, importer) {
-            // Prevent vite from resolving an explicit external dependency (`externalDependencies` option)
-            if (external?.includes(source)) {
-                // This is still not ideal since Vite will still transform the import specifier to
-                // `/@id/${source}` but is currently closer to a raw external than a resolved file path.
-                return source;
-            }
-            if (importer && source[0] === '.' && importer.startsWith(virtualProjectRoot)) {
-                // Remove query if present
-                const [importerFile] = importer.split('?', 1);
-                source =
-                    '/' + normalizePath((0, node_path_1.join)((0, node_path_1.dirname)((0, node_path_1.relative)(virtualProjectRoot, importerFile)), source));
-            }
-            const [file] = source.split('?', 1);
-            if (outputFiles.has(file)) {
-                return (0, node_path_1.join)(virtualProjectRoot, source);
-            }
-        },
-        async load(id) {
-            const [file] = id.split('?', 1);
-            const relativeFile = '/' + normalizePath((0, node_path_1.relative)(virtualProjectRoot, file));
-            const codeContents = outputFiles.get(relativeFile)?.contents;
-            if (codeContents === undefined) {
-                if (relativeFile.endsWith('/node_modules/vite/dist/client/client.mjs')) {
-                    return {
-                        code: await loadViteClientCode(file),
-                        map: await (0, promises_1.readFile)(file + '.map', 'utf-8'),
-                    };
-                }
-                return;
-            }
-            const code = Buffer.from(codeContents).toString('utf-8');
-            const mapContents = outputFiles.get(relativeFile + '.map')?.contents;
-            return {
-                // Remove source map URL comments from the code if a sourcemap is present.
-                // Vite will inline and add an additional sourcemap URL for the sourcemap.
-                code: mapContents ? code.replace(/^\/\/# sourceMappingURL=[^\r\n]*/gm, '') : code,
-                map: mapContents && Buffer.from(mapContents).toString('utf-8'),
-            };
-        },
-        // eslint-disable-next-line max-lines-per-function
-        configureServer(server) {
-            const originalssrTransform = server.ssrTransform;
-            server.ssrTransform = async (code, map, url, originalCode) => {
-                const result = await originalssrTransform(code, null, url, originalCode);
-                if (!result || !result.map || !map) {
-                    return result;
-                }
-                const remappedMap = (0, remapping_1.default)([result.map, map], () => null);
-                // Set the sourcemap root to the workspace root. This is needed since we set a virtual path as root.
-                remappedMap.sourceRoot = normalizePath(workspaceRoot) + '/';
-                return {
-                    ...result,
-                    map: remappedMap,
-                };
-            };
-            // Assets and resources get handled first
-            server.middlewares.use(function angularAssetsMiddleware(req, res, next) {
-                if (req.url === undefined || res.writableEnded) {
-                    return;
-                }
-                // Parse the incoming request.
-                // The base of the URL is unused but required to parse the URL.
-                const pathname = pathnameWithoutBasePath(req.url, server.config.base);
-                const extension = (0, node_path_1.extname)(pathname);
-                // Rewrite all build assets to a vite raw fs URL
-                const assetSourcePath = assets.get(pathname);
-                if (assetSourcePath !== undefined) {
-                    // Workaround to disable Vite transformer middleware.
-                    // See: https://github.com/vitejs/vite/blob/746a1daab0395f98f0afbdee8f364cb6cf2f3b3f/packages/vite/src/node/server/middlewares/transform.ts#L201 and
-                    // https://github.com/vitejs/vite/blob/746a1daab0395f98f0afbdee8f364cb6cf2f3b3f/packages/vite/src/node/server/transformRequest.ts#L204-L206
-                    req.headers.accept = 'text/html';
-                    // The encoding needs to match what happens in the vite static middleware.
-                    // ref: https://github.com/vitejs/vite/blob/d4f13bd81468961c8c926438e815ab6b1c82735e/packages/vite/src/node/server/middlewares/static.ts#L163
-                    req.url = `${server.config.base}@fs/${encodeURI(assetSourcePath)}`;
-                    next();
-                    return;
-                }
-                // HTML fallbacking
-                // This matches what happens in the vite html fallback middleware.
-                // ref: https://github.com/vitejs/vite/blob/main/packages/vite/src/node/server/middlewares/htmlFallback.ts#L9
-                const htmlAssetSourcePath = pathname[pathname.length - 1] === '/'
-                    ? // Trailing slash check for `index.html`.
-                        assets.get(pathname + 'index.html')
-                    : // Non-trailing slash check for fallback `.html`
-                        assets.get(pathname + '.html');
-                if (htmlAssetSourcePath) {
-                    req.url = `${server.config.base}@fs/${encodeURI(htmlAssetSourcePath)}`;
-                    next();
-                    return;
-                }
-                // Resource files are handled directly.
-                // Global stylesheets (CSS files) are currently considered resources to workaround
-                // dev server sourcemap issues with stylesheets.
-                if (extension !== '.js' && extension !== '.html') {
-                    const outputFile = outputFiles.get(pathname);
-                    if (outputFile?.servable) {
-                        const mimeType = (0, mrmime_1.lookup)(extension);
-                        if (mimeType) {
-                            res.setHeader('Content-Type', mimeType);
-                        }
-                        res.setHeader('Cache-Control', 'no-cache');
-                        if (extraHeaders) {
-                            Object.entries(extraHeaders).forEach(([name, value]) => res.setHeader(name, value));
-                        }
-                        res.end(outputFile.contents);
-                        return;
-                    }
-                }
-                next();
-            });
-            if (extensionMiddleware?.length) {
-                extensionMiddleware.forEach((middleware) => server.middlewares.use(middleware));
-            }
-            // Returning a function, installs middleware after the main transform middleware but
-            // before the built-in HTML middleware
-            return () => {
-                server.middlewares.use(angularHtmlFallbackMiddleware);
-                function angularSSRMiddleware(req, res, next) {
-                    const url = req.originalUrl;
-                    if (!req.url ||
-                        // Skip if path is not defined.
-                        !url ||
-                        // Skip if path is like a file.
-                        // NOTE: We use a mime type lookup to mitigate against matching requests like: /browse/pl.0ef59752c0cd457dbf1391f08cbd936f
-                        lookupMimeTypeFromRequest(url)) {
-                        next();
-                        return;
-                    }
-                    const rawHtml = outputFiles.get('/index.server.html')?.contents;
-                    if (!rawHtml) {
-                        next();
-                        return;
-                    }
-                    transformIndexHtmlAndAddHeaders(req.url, rawHtml, res, next, async (html) => {
-                        const resolvedUrls = server.resolvedUrls;
-                        const baseUrl = resolvedUrls?.local[0] ?? resolvedUrls?.network[0];
-                        const { content } = await (0, render_page_1.renderPage)({
-                            document: html,
-                            route: new URL(req.originalUrl ?? '/', baseUrl).toString(),
-                            serverContext: 'ssr',
-                            loadBundle: (uri) => 
-                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                            server.ssrLoadModule(uri.slice(1)),
-                            // Files here are only needed for critical CSS inlining.
-                            outputFiles: {},
-                            // TODO: add support for critical css inlining.
-                            inlineCriticalCss: false,
-                        });
-                        return indexHtmlTransformer && content ? await indexHtmlTransformer(content) : content;
-                    });
-                }
-                if (ssr) {
-                    server.middlewares.use(angularSSRMiddleware);
-                }
-                server.middlewares.use(function angularIndexMiddleware(req, res, next) {
-                    if (!req.url) {
-                        next();
-                        return;
-                    }
-                    // Parse the incoming request.
-                    // The base of the URL is unused but required to parse the URL.
-                    const pathname = pathnameWithoutBasePath(req.url, server.config.base);
-                    if (pathname === '/' || pathname === `/index.html`) {
-                        const rawHtml = outputFiles.get('/index.html')?.contents;
-                        if (rawHtml) {
-                            transformIndexHtmlAndAddHeaders(req.url, rawHtml, res, next, indexHtmlTransformer);
-                            return;
-                        }
-                    }
-                    next();
-                });
-            };
-            function transformIndexHtmlAndAddHeaders(url, rawHtml, res, next, additionalTransformer) {
-                server
-                    .transformIndexHtml(url, Buffer.from(rawHtml).toString('utf-8'))
-                    .then(async (processedHtml) => {
-                    if (additionalTransformer) {
-                        const content = await additionalTransformer(processedHtml);
-                        if (!content) {
-                            next();
-                            return;
-                        }
-                        processedHtml = content;
-                    }
-                    res.setHeader('Content-Type', 'text/html');
-                    res.setHeader('Cache-Control', 'no-cache');
-                    if (extraHeaders) {
-                        Object.entries(extraHeaders).forEach(([name, value]) => res.setHeader(name, value));
-                    }
-                    res.end(processedHtml);
-                })
-                    .catch((error) => next(error));
-            }
-        },
-    };
-}
-exports.createAngularMemoryPlugin = createAngularMemoryPlugin;
-/**
- * Reads the resolved Vite client code from disk and updates the content to remove
- * an unactionable suggestion to update the Vite configuration file to disable the
- * error overlay. The Vite configuration file is not present when used in the Angular
- * CLI.
- * @param file The absolute path to the Vite client code.
- * @returns
- */
-async function loadViteClientCode(file) {
-    const originalContents = await (0, promises_1.readFile)(file, 'utf-8');
-    const updatedContents = originalContents.replace(`h('br'), 'You can also disable this overlay by setting ', ` +
-        `h('code', { part: 'config-option-name' }, 'server.hmr.overlay'), '` +
-        ` to ', h('code', { part: 'config-option-value' }, 'false'), ' in ', h('code', { part: 'config-file-name' }, hmrConfigName), '.'`, '');
-    (0, node_assert_1.default)(originalContents !== updatedContents, 'Failed to update Vite client error overlay text.');
-    return updatedContents;
-}
-function pathnameWithoutBasePath(url, basePath) {
-    const parsedUrl = new URL(url, 'http://localhost');
-    const pathname = decodeURIComponent(parsedUrl.pathname);
-    // slice(basePath.length - 1) to retain the trailing slash
-    return basePath !== '/' && pathname.startsWith(basePath)
-        ? pathname.slice(basePath.length - 1)
-        : pathname;
-}
-function angularHtmlFallbackMiddleware(req, res, next) {
-    // Similar to how it is handled in vite
-    // https://github.com/vitejs/vite/blob/main/packages/vite/src/node/server/middlewares/htmlFallback.ts#L15C19-L15C45
-    if ((req.method === 'GET' || req.method === 'HEAD') &&
-        (!req.url || !lookupMimeTypeFromRequest(req.url)) &&
-        (!req.headers.accept ||
-            req.headers.accept.includes('text/html') ||
-            req.headers.accept.includes('text/*') ||
-            req.headers.accept.includes('*/*'))) {
-        req.url = '/index.html';
-    }
-    next();
-}
-function lookupMimeTypeFromRequest(url) {
-    const extension = (0, node_path_1.extname)(url.split('?')[0]);
-    if (extension === '.ico') {
-        return 'image/x-icon';
-    }
-    return extension && (0, mrmime_1.lookup)(extension);
-}