@angular-devkit/build-angular 16.1.0-next.2 → 16.1.0

package/src/tools/esbuild/global-scripts.js

@@ -0,0 +1,139 @@
+"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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGlobalScriptsBundleOptions = void 0;
+const magic_string_1 = __importStar(require("magic-string"));
+const node_assert_1 = __importDefault(require("node:assert"));
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const error_1 = require("../../utils/error");
+const load_result_cache_1 = require("./load-result-cache");
+const sourcemap_ignorelist_plugin_1 = require("./sourcemap-ignorelist-plugin");
+const virtual_module_plugin_1 = require("./virtual-module-plugin");
+/**
+ * Create an esbuild 'build' options object for all global scripts defined in the user provied
+ * build options.
+ * @param options The builder's user-provider normalized options.
+ * @returns An esbuild BuildOptions object.
+ */
+function createGlobalScriptsBundleOptions(options, initial, loadCache) {
+    const { globalScripts, optimizationOptions, outputNames, preserveSymlinks, sourcemapOptions, workspaceRoot, } = options;
+    const namespace = 'angular:script/global';
+    const entryPoints = {};
+    let found = false;
+    for (const script of globalScripts) {
+        if (script.initial === initial) {
+            found = true;
+            entryPoints[script.name] = `${namespace}:${script.name}`;
+        }
+    }
+    // Skip if there are no entry points for the style loading type
+    if (found === false) {
+        return;
+    }
+    return {
+        absWorkingDir: workspaceRoot,
+        bundle: false,
+        splitting: false,
+        entryPoints,
+        entryNames: initial ? outputNames.bundles : '[name]',
+        assetNames: outputNames.media,
+        mainFields: ['script', 'browser', 'main'],
+        conditions: ['script'],
+        resolveExtensions: ['.mjs', '.js'],
+        logLevel: options.verbose ? 'debug' : 'silent',
+        metafile: true,
+        minify: optimizationOptions.scripts,
+        outdir: workspaceRoot,
+        sourcemap: sourcemapOptions.scripts && (sourcemapOptions.hidden ? 'external' : true),
+        write: false,
+        platform: 'neutral',
+        preserveSymlinks,
+        plugins: [
+            (0, sourcemap_ignorelist_plugin_1.createSourcemapIngorelistPlugin)(),
+            (0, virtual_module_plugin_1.createVirtualModulePlugin)({
+                namespace,
+                external: true,
+                // Add the `js` extension here so that esbuild generates an output file with the extension
+                transformPath: (path) => path.slice(namespace.length + 1) + '.js',
+                loadContent: (args, build) => (0, load_result_cache_1.createCachedLoad)(loadCache, async (args) => {
+                    const files = globalScripts.find(({ name }) => name === args.path.slice(0, -3))?.files;
+                    (0, node_assert_1.default)(files, `Invalid operation: global scripts name not found [${args.path}]`);
+                    // Global scripts are concatenated using magic-string instead of bundled via esbuild.
+                    const bundleContent = new magic_string_1.Bundle();
+                    const watchFiles = [];
+                    for (const filename of files) {
+                        let fileContent;
+                        try {
+                            // Attempt to read as a relative path from the workspace root
+                            fileContent = await (0, promises_1.readFile)(node_path_1.default.join(workspaceRoot, filename), 'utf-8');
+                            watchFiles.push(filename);
+                        }
+                        catch (e) {
+                            (0, error_1.assertIsError)(e);
+                            if (e.code !== 'ENOENT') {
+                                throw e;
+                            }
+                            // If not found attempt to resolve as a module specifier
+                            const resolveResult = await build.resolve(filename, {
+                                kind: 'entry-point',
+                                resolveDir: workspaceRoot,
+                            });
+                            if (resolveResult.errors.length) {
+                                // Remove resolution failure notes about marking as external since it doesn't apply
+                                // to global scripts.
+                                resolveResult.errors.forEach((error) => (error.notes = []));
+                                return {
+                                    errors: resolveResult.errors,
+                                    warnings: resolveResult.warnings,
+                                };
+                            }
+                            watchFiles.push(node_path_1.default.relative(resolveResult.path, workspaceRoot));
+                            fileContent = await (0, promises_1.readFile)(resolveResult.path, 'utf-8');
+                        }
+                        bundleContent.addSource(new magic_string_1.default(fileContent, { filename }));
+                    }
+                    return {
+                        contents: bundleContent.toString(),
+                        loader: 'js',
+                        watchFiles,
+                    };
+                }).call(build, args),
+            }),
+        ],
+    };
+}
+exports.createGlobalScriptsBundleOptions = createGlobalScriptsBundleOptions;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"global-scripts.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/tools/esbuild/global-scripts.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport type { BuildOptions } from 'esbuild';\nimport MagicString, { Bundle } from 'magic-string';\nimport assert from 'node:assert';\nimport { readFile } from 'node:fs/promises';\nimport path from 'node:path';\nimport type { NormalizedBrowserOptions } from '../../builders/browser-esbuild/options';\nimport { assertIsError } from '../../utils/error';\nimport { LoadResultCache, createCachedLoad } from './load-result-cache';\nimport { createSourcemapIngorelistPlugin } from './sourcemap-ignorelist-plugin';\nimport { createVirtualModulePlugin } from './virtual-module-plugin';\n\n/**\n * Create an esbuild 'build' options object for all global scripts defined in the user provied\n * build options.\n * @param options The builder's user-provider normalized options.\n * @returns An esbuild BuildOptions object.\n */\nexport function createGlobalScriptsBundleOptions(\n  options: NormalizedBrowserOptions,\n  initial: boolean,\n  loadCache?: LoadResultCache,\n): BuildOptions | undefined {\n  const {\n    globalScripts,\n    optimizationOptions,\n    outputNames,\n    preserveSymlinks,\n    sourcemapOptions,\n    workspaceRoot,\n  } = options;\n\n  const namespace = 'angular:script/global';\n  const entryPoints: Record<string, string> = {};\n  let found = false;\n  for (const script of globalScripts) {\n    if (script.initial === initial) {\n      found = true;\n      entryPoints[script.name] = `${namespace}:${script.name}`;\n    }\n  }\n\n  // Skip if there are no entry points for the style loading type\n  if (found === false) {\n    return;\n  }\n\n  return {\n    absWorkingDir: workspaceRoot,\n    bundle: false,\n    splitting: false,\n    entryPoints,\n    entryNames: initial ? outputNames.bundles : '[name]',\n    assetNames: outputNames.media,\n    mainFields: ['script', 'browser', 'main'],\n    conditions: ['script'],\n    resolveExtensions: ['.mjs', '.js'],\n    logLevel: options.verbose ? 'debug' : 'silent',\n    metafile: true,\n    minify: optimizationOptions.scripts,\n    outdir: workspaceRoot,\n    sourcemap: sourcemapOptions.scripts && (sourcemapOptions.hidden ? 'external' : true),\n    write: false,\n    platform: 'neutral',\n    preserveSymlinks,\n    plugins: [\n      createSourcemapIngorelistPlugin(),\n      createVirtualModulePlugin({\n        namespace,\n        external: true,\n        // Add the `js` extension here so that esbuild generates an output file with the extension\n        transformPath: (path) => path.slice(namespace.length + 1) + '.js',\n        loadContent: (args, build) =>\n          createCachedLoad(loadCache, async (args) => {\n            const files = globalScripts.find(({ name }) => name === args.path.slice(0, -3))?.files;\n            assert(files, `Invalid operation: global scripts name not found [${args.path}]`);\n\n            // Global scripts are concatenated using magic-string instead of bundled via esbuild.\n            const bundleContent = new Bundle();\n            const watchFiles = [];\n            for (const filename of files) {\n              let fileContent;\n              try {\n                // Attempt to read as a relative path from the workspace root\n                fileContent = await readFile(path.join(workspaceRoot, filename), 'utf-8');\n                watchFiles.push(filename);\n              } catch (e) {\n                assertIsError(e);\n                if (e.code !== 'ENOENT') {\n                  throw e;\n                }\n\n                // If not found attempt to resolve as a module specifier\n                const resolveResult = await build.resolve(filename, {\n                  kind: 'entry-point',\n                  resolveDir: workspaceRoot,\n                });\n\n                if (resolveResult.errors.length) {\n                  // Remove resolution failure notes about marking as external since it doesn't apply\n                  // to global scripts.\n                  resolveResult.errors.forEach((error) => (error.notes = []));\n\n                  return {\n                    errors: resolveResult.errors,\n                    warnings: resolveResult.warnings,\n                  };\n                }\n\n                watchFiles.push(path.relative(resolveResult.path, workspaceRoot));\n                fileContent = await readFile(resolveResult.path, 'utf-8');\n              }\n\n              bundleContent.addSource(new MagicString(fileContent, { filename }));\n            }\n\n            return {\n              contents: bundleContent.toString(),\n              loader: 'js',\n              watchFiles,\n            };\n          }).call(build, args),\n      }),\n    ],\n  };\n}\n"]}

package/src/{builders/browser-esbuild → tools/esbuild}/global-styles.d.ts

@@ -6,6 +6,6 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import type { BuildOptions } from 'esbuild';
+import { NormalizedBrowserOptions } from '../../builders/browser-esbuild/options';
 import { LoadResultCache } from './load-result-cache';
-import { NormalizedBrowserOptions } from './options';
 export declare function createGlobalStylesBundleOptions(options: NormalizedBrowserOptions, target: string[], browsers: string[], initial: boolean, cache?: LoadResultCache): BuildOptions | undefined;

package/src/tools/esbuild/global-styles.js

@@ -0,0 +1,67 @@
+"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.createGlobalStylesBundleOptions = void 0;
+const node_assert_1 = __importDefault(require("node:assert"));
+const bundle_options_1 = require("./stylesheets/bundle-options");
+const virtual_module_plugin_1 = require("./virtual-module-plugin");
+function createGlobalStylesBundleOptions(options, target, browsers, initial, cache) {
+    const { workspaceRoot, optimizationOptions, sourcemapOptions, outputNames, globalStyles, preserveSymlinks, externalDependencies, stylePreprocessorOptions, tailwindConfiguration, } = options;
+    const namespace = 'angular:styles/global';
+    const entryPoints = {};
+    let found = false;
+    for (const style of globalStyles) {
+        if (style.initial === initial) {
+            found = true;
+            entryPoints[style.name] = `${namespace};${style.name}`;
+        }
+    }
+    // Skip if there are no entry points for the style loading type
+    if (found === false) {
+        return;
+    }
+    const buildOptions = (0, bundle_options_1.createStylesheetBundleOptions)({
+        workspaceRoot,
+        optimization: !!optimizationOptions.styles.minify,
+        sourcemap: !!sourcemapOptions.styles,
+        preserveSymlinks,
+        target,
+        externalDependencies,
+        outputNames: initial
+            ? outputNames
+            : {
+                ...outputNames,
+                bundles: '[name]',
+            },
+        includePaths: stylePreprocessorOptions?.includePaths,
+        browsers,
+        tailwindConfiguration,
+    }, cache);
+    buildOptions.legalComments = options.extractLicenses ? 'none' : 'eof';
+    buildOptions.entryPoints = entryPoints;
+    buildOptions.plugins.unshift((0, virtual_module_plugin_1.createVirtualModulePlugin)({
+        namespace,
+        transformPath: (path) => path.split(';', 2)[1],
+        loadContent: (args) => {
+            const files = globalStyles.find(({ name }) => name === args.path)?.files;
+            (0, node_assert_1.default)(files, `global style name should always be found [${args.path}]`);
+            return {
+                contents: files.map((file) => `@import '${file.replace(/\\/g, '/')}';`).join('\n'),
+                loader: 'css',
+                resolveDir: workspaceRoot,
+            };
+        },
+    }));
+    return buildOptions;
+}
+exports.createGlobalStylesBundleOptions = createGlobalStylesBundleOptions;
+//# sourceMappingURL=data:application/json;base64,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

package/src/tools/esbuild/index-html-generator.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @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 { NormalizedBrowserOptions } from '../../builders/browser-esbuild/options';
+import { IndexHtmlTransformResult } from '../../utils/index-file/index-html-generator';
+import { InitialFileRecord } from './bundler-context';
+import type { ExecutionResult } from './bundler-execution-result';
+export declare function generateIndexHtml(initialFiles: Map<string, InitialFileRecord>, executionResult: ExecutionResult, buildOptions: NormalizedBrowserOptions): Promise<IndexHtmlTransformResult>;

package/src/tools/esbuild/index-html-generator.js

@@ -0,0 +1,70 @@
+"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.generateIndexHtml = void 0;
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_path_1 = __importDefault(require("node:path"));
+const index_html_generator_1 = require("../../utils/index-file/index-html-generator");
+function generateIndexHtml(initialFiles, executionResult, buildOptions) {
+    // Analyze metafile for initial link-based hints.
+    // Skip if the internal externalPackages option is enabled since this option requires
+    // dev server cooperation to properly resolve and fetch imports.
+    const hints = [];
+    const { indexHtmlOptions, externalPackages, optimizationOptions, crossOrigin, subresourceIntegrity, baseHref, } = buildOptions;
+    (0, node_assert_1.default)(indexHtmlOptions, 'indexHtmlOptions cannot be undefined.');
+    if (!externalPackages) {
+        for (const [key, value] of initialFiles) {
+            if (value.entrypoint) {
+                // Entry points are already referenced in the HTML
+                continue;
+            }
+            if (value.type === 'script') {
+                hints.push({ url: key, mode: 'modulepreload' });
+            }
+            else if (value.type === 'style') {
+                hints.push({ url: key, mode: 'preload' });
+            }
+        }
+    }
+    // Create an index HTML generator that reads from the in-memory output files
+    const indexHtmlGenerator = new index_html_generator_1.IndexHtmlGenerator({
+        indexPath: indexHtmlOptions.input,
+        entrypoints: indexHtmlOptions.insertionOrder,
+        sri: subresourceIntegrity,
+        optimization: optimizationOptions,
+        crossOrigin: crossOrigin,
+    });
+    /** Virtual output path to support reading in-memory files. */
+    const virtualOutputPath = '/';
+    indexHtmlGenerator.readAsset = async function (filePath) {
+        // Remove leading directory separator
+        const relativefilePath = node_path_1.default.relative(virtualOutputPath, filePath);
+        const file = executionResult.outputFiles.find((file) => file.path === relativefilePath);
+        if (file) {
+            return file.text;
+        }
+        throw new Error(`Output file does not exist: ${node_path_1.default}`);
+    };
+    return indexHtmlGenerator.process({
+        baseHref,
+        lang: undefined,
+        outputPath: virtualOutputPath,
+        files: [...initialFiles].map(([file, record]) => ({
+            name: record.name ?? '',
+            file,
+            extension: node_path_1.default.extname(file),
+        })),
+        hints,
+    });
+}
+exports.generateIndexHtml = generateIndexHtml;
+//# sourceMappingURL=data:application/json;base64,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

package/src/tools/esbuild/javascript-transformer-worker.js

@@ -0,0 +1,76 @@
+"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 core_1 = require("@babel/core");
+const promises_1 = require("node:fs/promises");
+const application_1 = __importDefault(require("../../tools/babel/presets/application"));
+const webpack_loader_1 = require("../../tools/babel/webpack-loader");
+const load_esm_1 = require("../../utils/load-esm");
+async function transformJavaScript(request) {
+    request.data ?? (request.data = await (0, promises_1.readFile)(request.filename, 'utf-8'));
+    const transformedData = await transformWithBabel(request);
+    return Buffer.from(transformedData, 'utf-8');
+}
+exports.default = transformJavaScript;
+let linkerPluginCreator;
+async function transformWithBabel({ filename, data, ...options }) {
+    const forceAsyncTransformation = options.forceAsyncTransformation ??
+        (!/[\\/][_f]?esm2015[\\/]/.test(filename) && /async(?:\s+function)?\s*\*/.test(data));
+    const shouldLink = !options.skipLinker && (await (0, webpack_loader_1.requiresLinking)(filename, data));
+    const useInputSourcemap = options.sourcemap &&
+        (!!options.thirdPartySourcemaps || !/[\\/]node_modules[\\/]/.test(filename));
+    // If no additional transformations are needed, return the data directly
+    if (!forceAsyncTransformation && !options.advancedOptimizations && !shouldLink) {
+        // Strip sourcemaps if they should not be used
+        return useInputSourcemap ? data : data.replace(/^\/\/# sourceMappingURL=[^\r\n]*/gm, '');
+    }
+    // @angular/platform-server/init entry-point has side-effects.
+    const safeAngularPackage = /[\\/]node_modules[\\/]@angular[\\/]/.test(filename) &&
+        !/@angular[\\/]platform-server[\\/]f?esm2022[\\/]init/.test(filename);
+    // Lazy load the linker plugin only when linking is required
+    if (shouldLink) {
+        linkerPluginCreator ?? (linkerPluginCreator = (await (0, load_esm_1.loadEsmModule)('@angular/compiler-cli/linker/babel')).createEs2015LinkerPlugin);
+    }
+    const result = await (0, core_1.transformAsync)(data, {
+        filename,
+        inputSourceMap: (useInputSourcemap ? undefined : false),
+        sourceMaps: useInputSourcemap ? 'inline' : false,
+        compact: false,
+        configFile: false,
+        babelrc: false,
+        browserslistConfigFile: false,
+        plugins: [],
+        presets: [
+            [
+                application_1.default,
+                {
+                    angularLinker: linkerPluginCreator && {
+                        shouldLink,
+                        jitMode: options.jit,
+                        linkerPluginCreator,
+                    },
+                    forceAsyncTransformation,
+                    optimize: options.advancedOptimizations && {
+                        pureTopLevel: safeAngularPackage,
+                    },
+                },
+            ],
+        ],
+    });
+    const outputCode = result?.code ?? data;
+    // Strip sourcemaps if they should not be used.
+    // Babel will keep the original comments even if sourcemaps are disabled.
+    return useInputSourcemap
+        ? outputCode
+        : outputCode.replace(/^\/\/# sourceMappingURL=[^\r\n]*/gm, '');
+}
+//# sourceMappingURL=data:application/json;base64,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

package/src/tools/esbuild/javascript-transformer.js

@@ -0,0 +1,108 @@
+"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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _JavaScriptTransformer_workerPool, _JavaScriptTransformer_commonOptions;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JavaScriptTransformer = void 0;
+const piscina_1 = __importDefault(require("piscina"));
+/**
+ * A class that performs transformation of JavaScript files and raw data.
+ * A worker pool is used to distribute the transformation actions and allow
+ * parallel processing. Transformation behavior is based on the filename and
+ * data. Transformations may include: async downleveling, Angular linking,
+ * and advanced optimizations.
+ */
+class JavaScriptTransformer {
+    constructor(options, maxThreads) {
+        _JavaScriptTransformer_workerPool.set(this, void 0);
+        _JavaScriptTransformer_commonOptions.set(this, void 0);
+        __classPrivateFieldSet(this, _JavaScriptTransformer_workerPool, new piscina_1.default({
+            filename: require.resolve('./javascript-transformer-worker'),
+            maxThreads,
+        }), "f");
+        // Extract options to ensure only the named options are serialized and sent to the worker
+        const { sourcemap, thirdPartySourcemaps = false, advancedOptimizations = false, jit = false, } = options;
+        __classPrivateFieldSet(this, _JavaScriptTransformer_commonOptions, {
+            sourcemap,
+            thirdPartySourcemaps,
+            advancedOptimizations,
+            jit,
+        }, "f");
+    }
+    /**
+     * Performs JavaScript transformations on a file from the filesystem.
+     * If no transformations are required, the data for the original file will be returned.
+     * @param filename The full path to the file.
+     * @param skipLinker If true, bypass all Angular linker processing; if false, attempt linking.
+     * @returns A promise that resolves to a UTF-8 encoded Uint8Array containing the result.
+     */
+    transformFile(filename, skipLinker) {
+        // Always send the request to a worker. Files are almost always from node modules which measn
+        // they may need linking. The data is also not yet available to perform most transformation checks.
+        return __classPrivateFieldGet(this, _JavaScriptTransformer_workerPool, "f").run({
+            filename,
+            skipLinker,
+            ...__classPrivateFieldGet(this, _JavaScriptTransformer_commonOptions, "f"),
+        });
+    }
+    /**
+     * Performs JavaScript transformations on the provided data of a file. The file does not need
+     * to exist on the filesystem.
+     * @param filename The full path of the file represented by the data.
+     * @param data The data of the file that should be transformed.
+     * @param skipLinker If true, bypass all Angular linker processing; if false, attempt linking.
+     * @returns A promise that resolves to a UTF-8 encoded Uint8Array containing the result.
+     */
+    async transformData(filename, data, skipLinker) {
+        // Perform a quick test to determine if the data needs any transformations.
+        // This allows directly returning the data without the worker communication overhead.
+        let forceAsyncTransformation;
+        if (skipLinker && !__classPrivateFieldGet(this, _JavaScriptTransformer_commonOptions, "f").advancedOptimizations) {
+            // If the linker is being skipped and no optimizations are needed, only async transformation is left.
+            // This checks for async generator functions and class methods. All other async transformation is handled by esbuild.
+            forceAsyncTransformation = data.includes('async') && /async(?:\s+function)?\s*\*/.test(data);
+            if (!forceAsyncTransformation) {
+                const keepSourcemap = __classPrivateFieldGet(this, _JavaScriptTransformer_commonOptions, "f").sourcemap &&
+                    (!!__classPrivateFieldGet(this, _JavaScriptTransformer_commonOptions, "f").thirdPartySourcemaps || !/[\\/]node_modules[\\/]/.test(filename));
+                return Buffer.from(keepSourcemap ? data : data.replace(/^\/\/# sourceMappingURL=[^\r\n]*/gm, ''), 'utf-8');
+            }
+        }
+        return __classPrivateFieldGet(this, _JavaScriptTransformer_workerPool, "f").run({
+            filename,
+            data,
+            // Send the async check result if present to avoid rechecking in the worker
+            forceAsyncTransformation,
+            skipLinker,
+            ...__classPrivateFieldGet(this, _JavaScriptTransformer_commonOptions, "f"),
+        });
+    }
+    /**
+     * Stops all active transformation tasks and shuts down all workers.
+     * @returns A void promise that resolves when closing is complete.
+     */
+    close() {
+        return __classPrivateFieldGet(this, _JavaScriptTransformer_workerPool, "f").destroy();
+    }
+}
+exports.JavaScriptTransformer = JavaScriptTransformer;
+_JavaScriptTransformer_workerPool = new WeakMap(), _JavaScriptTransformer_commonOptions = new WeakMap();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"javascript-transformer.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/tools/esbuild/javascript-transformer.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;;;;;;;;;;;;;;;;AAEH,sDAA8B;AAY9B;;;;;;GAMG;AACH,MAAa,qBAAqB;IAIhC,YAAY,OAAqC,EAAE,UAAmB;QAHtE,oDAAqB;QACrB,uDAAuD;QAGrD,uBAAA,IAAI,qCAAe,IAAI,iBAAO,CAAC;YAC7B,QAAQ,EAAE,OAAO,CAAC,OAAO,CAAC,iCAAiC,CAAC;YAC5D,UAAU;SACX,CAAC,MAAA,CAAC;QAEH,yFAAyF;QACzF,MAAM,EACJ,SAAS,EACT,oBAAoB,GAAG,KAAK,EAC5B,qBAAqB,GAAG,KAAK,EAC7B,GAAG,GAAG,KAAK,GACZ,GAAG,OAAO,CAAC;QACZ,uBAAA,IAAI,wCAAkB;YACpB,SAAS;YACT,oBAAoB;YACpB,qBAAqB;YACrB,GAAG;SACJ,MAAA,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACH,aAAa,CAAC,QAAgB,EAAE,UAAoB;QAClD,6FAA6F;QAC7F,mGAAmG;QACnG,OAAO,uBAAA,IAAI,yCAAY,CAAC,GAAG,CAAC;YAC1B,QAAQ;YACR,UAAU;YACV,GAAG,uBAAA,IAAI,4CAAe;SACvB,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,aAAa,CAAC,QAAgB,EAAE,IAAY,EAAE,UAAmB;QACrE,2EAA2E;QAC3E,qFAAqF;QACrF,IAAI,wBAAwB,CAAC;QAC7B,IAAI,UAAU,IAAI,CAAC,uBAAA,IAAI,4CAAe,CAAC,qBAAqB,EAAE;YAC5D,qGAAqG;YACrG,qHAAqH;YACrH,wBAAwB,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,4BAA4B,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAE7F,IAAI,CAAC,wBAAwB,EAAE;gBAC7B,MAAM,aAAa,GACjB,uBAAA,IAAI,4CAAe,CAAC,SAAS;oBAC7B,CAAC,CAAC,CAAC,uBAAA,IAAI,4CAAe,CAAC,oBAAoB,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;gBAE3F,OAAO,MAAM,CAAC,IAAI,CAChB,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,oCAAoC,EAAE,EAAE,CAAC,EAC7E,OAAO,CACR,CAAC;aACH;SACF;QAED,OAAO,uBAAA,IAAI,yCAAY,CAAC,GAAG,CAAC;YAC1B,QAAQ;YACR,IAAI;YACJ,2EAA2E;YAC3E,wBAAwB;YACxB,UAAU;YACV,GAAG,uBAAA,IAAI,4CAAe;SACvB,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACH,KAAK;QACH,OAAO,uBAAA,IAAI,yCAAY,CAAC,OAAO,EAAE,CAAC;IACpC,CAAC;CACF;AAxFD,sDAwFC","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 Piscina from 'piscina';\n\n/**\n * Transformation options that should apply to all transformed files and data.\n */\nexport interface JavaScriptTransformerOptions {\n  sourcemap: boolean;\n  thirdPartySourcemaps?: boolean;\n  advancedOptimizations?: boolean;\n  jit?: boolean;\n}\n\n/**\n * A class that performs transformation of JavaScript files and raw data.\n * A worker pool is used to distribute the transformation actions and allow\n * parallel processing. Transformation behavior is based on the filename and\n * data. Transformations may include: async downleveling, Angular linking,\n * and advanced optimizations.\n */\nexport class JavaScriptTransformer {\n  #workerPool: Piscina;\n  #commonOptions: Required<JavaScriptTransformerOptions>;\n\n  constructor(options: JavaScriptTransformerOptions, maxThreads?: number) {\n    this.#workerPool = new Piscina({\n      filename: require.resolve('./javascript-transformer-worker'),\n      maxThreads,\n    });\n\n    // Extract options to ensure only the named options are serialized and sent to the worker\n    const {\n      sourcemap,\n      thirdPartySourcemaps = false,\n      advancedOptimizations = false,\n      jit = false,\n    } = options;\n    this.#commonOptions = {\n      sourcemap,\n      thirdPartySourcemaps,\n      advancedOptimizations,\n      jit,\n    };\n  }\n\n  /**\n   * Performs JavaScript transformations on a file from the filesystem.\n   * If no transformations are required, the data for the original file will be returned.\n   * @param filename The full path to the file.\n   * @param skipLinker If true, bypass all Angular linker processing; if false, attempt linking.\n   * @returns A promise that resolves to a UTF-8 encoded Uint8Array containing the result.\n   */\n  transformFile(filename: string, skipLinker?: boolean): Promise<Uint8Array> {\n    // Always send the request to a worker. Files are almost always from node modules which measn\n    // they may need linking. The data is also not yet available to perform most transformation checks.\n    return this.#workerPool.run({\n      filename,\n      skipLinker,\n      ...this.#commonOptions,\n    });\n  }\n\n  /**\n   * Performs JavaScript transformations on the provided data of a file. The file does not need\n   * to exist on the filesystem.\n   * @param filename The full path of the file represented by the data.\n   * @param data The data of the file that should be transformed.\n   * @param skipLinker If true, bypass all Angular linker processing; if false, attempt linking.\n   * @returns A promise that resolves to a UTF-8 encoded Uint8Array containing the result.\n   */\n  async transformData(filename: string, data: string, skipLinker: boolean): Promise<Uint8Array> {\n    // Perform a quick test to determine if the data needs any transformations.\n    // This allows directly returning the data without the worker communication overhead.\n    let forceAsyncTransformation;\n    if (skipLinker && !this.#commonOptions.advancedOptimizations) {\n      // If the linker is being skipped and no optimizations are needed, only async transformation is left.\n      // This checks for async generator functions and class methods. All other async transformation is handled by esbuild.\n      forceAsyncTransformation = data.includes('async') && /async(?:\\s+function)?\\s*\\*/.test(data);\n\n      if (!forceAsyncTransformation) {\n        const keepSourcemap =\n          this.#commonOptions.sourcemap &&\n          (!!this.#commonOptions.thirdPartySourcemaps || !/[\\\\/]node_modules[\\\\/]/.test(filename));\n\n        return Buffer.from(\n          keepSourcemap ? data : data.replace(/^\\/\\/# sourceMappingURL=[^\\r\\n]*/gm, ''),\n          'utf-8',\n        );\n      }\n    }\n\n    return this.#workerPool.run({\n      filename,\n      data,\n      // Send the async check result if present to avoid rechecking in the worker\n      forceAsyncTransformation,\n      skipLinker,\n      ...this.#commonOptions,\n    });\n  }\n\n  /**\n   * Stops all active transformation tasks and shuts down all workers.\n   * @returns A void promise that resolves when closing is complete.\n   */\n  close(): Promise<void> {\n    return this.#workerPool.destroy();\n  }\n}\n"]}