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

package/src/tools/babel/plugins/pure-toplevel-functions.js

@@ -0,0 +1,91 @@
+"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 });
+const core_1 = require("@babel/core");
+const helper_annotate_as_pure_1 = __importDefault(require("@babel/helper-annotate-as-pure"));
+const tslib = __importStar(require("tslib"));
+/**
+ * A cached set of TypeScript helper function names used by the helper name matcher utility function.
+ */
+const tslibHelpers = new Set(Object.keys(tslib).filter((h) => h.startsWith('__')));
+/**
+ * Determinates whether an identifier name matches one of the TypeScript helper function names.
+ *
+ * @param name The identifier name to check.
+ * @returns True, if the name matches a TypeScript helper name; otherwise, false.
+ */
+function isTslibHelperName(name) {
+    const nameParts = name.split('$');
+    const originalName = nameParts[0];
+    if (nameParts.length > 2 || (nameParts.length === 2 && isNaN(+nameParts[1]))) {
+        return false;
+    }
+    return tslibHelpers.has(originalName);
+}
+/**
+ * A babel plugin factory function for adding the PURE annotation to top-level new and call expressions.
+ *
+ * @returns A babel plugin object instance.
+ */
+function default_1() {
+    return {
+        visitor: {
+            CallExpression(path) {
+                // If the expression has a function parent, it is not top-level
+                if (path.getFunctionParent()) {
+                    return;
+                }
+                const callee = path.node.callee;
+                if (core_1.types.isFunctionExpression(callee) && path.node.arguments.length !== 0) {
+                    return;
+                }
+                // Do not annotate TypeScript helpers emitted by the TypeScript compiler.
+                // TypeScript helpers are intended to cause side effects.
+                if (core_1.types.isIdentifier(callee) && isTslibHelperName(callee.name)) {
+                    return;
+                }
+                (0, helper_annotate_as_pure_1.default)(path);
+            },
+            NewExpression(path) {
+                // If the expression has a function parent, it is not top-level
+                if (!path.getFunctionParent()) {
+                    (0, helper_annotate_as_pure_1.default)(path);
+                }
+            },
+        },
+    };
+}
+exports.default = default_1;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVyZS10b3BsZXZlbC1mdW5jdGlvbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9hbmd1bGFyX2RldmtpdC9idWlsZF9hbmd1bGFyL3NyYy90b29scy9iYWJlbC9wbHVnaW5zL3B1cmUtdG9wbGV2ZWwtZnVuY3Rpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7Ozs7O0dBTUc7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFFSCxzQ0FBeUQ7QUFDekQsNkZBQTREO0FBQzVELDZDQUErQjtBQUUvQjs7R0FFRztBQUNILE1BQU0sWUFBWSxHQUFHLElBQUksR0FBRyxDQUFTLE1BQU0sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQztBQUUzRjs7Ozs7R0FLRztBQUNILFNBQVMsaUJBQWlCLENBQUMsSUFBWTtJQUNyQyxNQUFNLFNBQVMsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ2xDLE1BQU0sWUFBWSxHQUFHLFNBQVMsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUVsQyxJQUFJLFNBQVMsQ0FBQyxNQUFNLEdBQUcsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLE1BQU0sS0FBSyxDQUFDLElBQUksS0FBSyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsRUFBRTtRQUM1RSxPQUFPLEtBQUssQ0FBQztLQUNkO0lBRUQsT0FBTyxZQUFZLENBQUMsR0FBRyxDQUFDLFlBQVksQ0FBQyxDQUFDO0FBQ3hDLENBQUM7QUFFRDs7OztHQUlHO0FBQ0g7SUFDRSxPQUFPO1FBQ0wsT0FBTyxFQUFFO1lBQ1AsY0FBYyxDQUFDLElBQW9DO2dCQUNqRCwrREFBK0Q7Z0JBQy9ELElBQUksSUFBSSxDQUFDLGlCQUFpQixFQUFFLEVBQUU7b0JBQzVCLE9BQU87aUJBQ1I7Z0JBRUQsTUFBTSxNQUFNLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUM7Z0JBQ2hDLElBQUksWUFBSyxDQUFDLG9CQUFvQixDQUFDLE1BQU0sQ0FBQyxJQUFJLElBQUksQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLE1BQU0sS0FBSyxDQUFDLEVBQUU7b0JBQzFFLE9BQU87aUJBQ1I7Z0JBQ0QseUVBQXlFO2dCQUN6RSx5REFBeUQ7Z0JBQ3pELElBQUksWUFBSyxDQUFDLFlBQVksQ0FBQyxNQUFNLENBQUMsSUFBSSxpQkFBaUIsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEVBQUU7b0JBQ2hFLE9BQU87aUJBQ1I7Z0JBRUQsSUFBQSxpQ0FBYyxFQUFDLElBQUksQ0FBQyxDQUFDO1lBQ3ZCLENBQUM7WUFDRCxhQUFhLENBQUMsSUFBbUM7Z0JBQy9DLCtEQUErRDtnQkFDL0QsSUFBSSxDQUFDLElBQUksQ0FBQyxpQkFBaUIsRUFBRSxFQUFFO29CQUM3QixJQUFBLGlDQUFjLEVBQUMsSUFBSSxDQUFDLENBQUM7aUJBQ3RCO1lBQ0gsQ0FBQztTQUNGO0tBQ0YsQ0FBQztBQUNKLENBQUM7QUE3QkQsNEJBNkJDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmltcG9ydCB7IE5vZGVQYXRoLCBQbHVnaW5PYmosIHR5cGVzIH0gZnJvbSAnQGJhYmVsL2NvcmUnO1xuaW1wb3J0IGFubm90YXRlQXNQdXJlIGZyb20gJ0BiYWJlbC9oZWxwZXItYW5ub3RhdGUtYXMtcHVyZSc7XG5pbXBvcnQgKiBhcyB0c2xpYiBmcm9tICd0c2xpYic7XG5cbi8qKlxuICogQSBjYWNoZWQgc2V0IG9mIFR5cGVTY3JpcHQgaGVscGVyIGZ1bmN0aW9uIG5hbWVzIHVzZWQgYnkgdGhlIGhlbHBlciBuYW1lIG1hdGNoZXIgdXRpbGl0eSBmdW5jdGlvbi5cbiAqL1xuY29uc3QgdHNsaWJIZWxwZXJzID0gbmV3IFNldDxzdHJpbmc+KE9iamVjdC5rZXlzKHRzbGliKS5maWx0ZXIoKGgpID0+IGguc3RhcnRzV2l0aCgnX18nKSkpO1xuXG4vKipcbiAqIERldGVybWluYXRlcyB3aGV0aGVyIGFuIGlkZW50aWZpZXIgbmFtZSBtYXRjaGVzIG9uZSBvZiB0aGUgVHlwZVNjcmlwdCBoZWxwZXIgZnVuY3Rpb24gbmFtZXMuXG4gKlxuICogQHBhcmFtIG5hbWUgVGhlIGlkZW50aWZpZXIgbmFtZSB0byBjaGVjay5cbiAqIEByZXR1cm5zIFRydWUsIGlmIHRoZSBuYW1lIG1hdGNoZXMgYSBUeXBlU2NyaXB0IGhlbHBlciBuYW1lOyBvdGhlcndpc2UsIGZhbHNlLlxuICovXG5mdW5jdGlvbiBpc1RzbGliSGVscGVyTmFtZShuYW1lOiBzdHJpbmcpOiBib29sZWFuIHtcbiAgY29uc3QgbmFtZVBhcnRzID0gbmFtZS5zcGxpdCgnJCcpO1xuICBjb25zdCBvcmlnaW5hbE5hbWUgPSBuYW1lUGFydHNbMF07XG5cbiAgaWYgKG5hbWVQYXJ0cy5sZW5ndGggPiAyIHx8IChuYW1lUGFydHMubGVuZ3RoID09PSAyICYmIGlzTmFOKCtuYW1lUGFydHNbMV0pKSkge1xuICAgIHJldHVybiBmYWxzZTtcbiAgfVxuXG4gIHJldHVybiB0c2xpYkhlbHBlcnMuaGFzKG9yaWdpbmFsTmFtZSk7XG59XG5cbi8qKlxuICogQSBiYWJlbCBwbHVnaW4gZmFjdG9yeSBmdW5jdGlvbiBmb3IgYWRkaW5nIHRoZSBQVVJFIGFubm90YXRpb24gdG8gdG9wLWxldmVsIG5ldyBhbmQgY2FsbCBleHByZXNzaW9ucy5cbiAqXG4gKiBAcmV0dXJucyBBIGJhYmVsIHBsdWdpbiBvYmplY3QgaW5zdGFuY2UuXG4gKi9cbmV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uICgpOiBQbHVnaW5PYmoge1xuICByZXR1cm4ge1xuICAgIHZpc2l0b3I6IHtcbiAgICAgIENhbGxFeHByZXNzaW9uKHBhdGg6IE5vZGVQYXRoPHR5cGVzLkNhbGxFeHByZXNzaW9uPikge1xuICAgICAgICAvLyBJZiB0aGUgZXhwcmVzc2lvbiBoYXMgYSBmdW5jdGlvbiBwYXJlbnQsIGl0IGlzIG5vdCB0b3AtbGV2ZWxcbiAgICAgICAgaWYgKHBhdGguZ2V0RnVuY3Rpb25QYXJlbnQoKSkge1xuICAgICAgICAgIHJldHVybjtcbiAgICAgICAgfVxuXG4gICAgICAgIGNvbnN0IGNhbGxlZSA9IHBhdGgubm9kZS5jYWxsZWU7XG4gICAgICAgIGlmICh0eXBlcy5pc0Z1bmN0aW9uRXhwcmVzc2lvbihjYWxsZWUpICYmIHBhdGgubm9kZS5hcmd1bWVudHMubGVuZ3RoICE9PSAwKSB7XG4gICAgICAgICAgcmV0dXJuO1xuICAgICAgICB9XG4gICAgICAgIC8vIERvIG5vdCBhbm5vdGF0ZSBUeXBlU2NyaXB0IGhlbHBlcnMgZW1pdHRlZCBieSB0aGUgVHlwZVNjcmlwdCBjb21waWxlci5cbiAgICAgICAgLy8gVHlwZVNjcmlwdCBoZWxwZXJzIGFyZSBpbnRlbmRlZCB0byBjYXVzZSBzaWRlIGVmZmVjdHMuXG4gICAgICAgIGlmICh0eXBlcy5pc0lkZW50aWZpZXIoY2FsbGVlKSAmJiBpc1RzbGliSGVscGVyTmFtZShjYWxsZWUubmFtZSkpIHtcbiAgICAgICAgICByZXR1cm47XG4gICAgICAgIH1cblxuICAgICAgICBhbm5vdGF0ZUFzUHVyZShwYXRoKTtcbiAgICAgIH0sXG4gICAgICBOZXdFeHByZXNzaW9uKHBhdGg6IE5vZGVQYXRoPHR5cGVzLk5ld0V4cHJlc3Npb24+KSB7XG4gICAgICAgIC8vIElmIHRoZSBleHByZXNzaW9uIGhhcyBhIGZ1bmN0aW9uIHBhcmVudCwgaXQgaXMgbm90IHRvcC1sZXZlbFxuICAgICAgICBpZiAoIXBhdGguZ2V0RnVuY3Rpb25QYXJlbnQoKSkge1xuICAgICAgICAgIGFubm90YXRlQXNQdXJlKHBhdGgpO1xuICAgICAgICB9XG4gICAgICB9LFxuICAgIH0sXG4gIH07XG59XG4iXX0=

package/src/tools/babel/presets/application.js

@@ -0,0 +1,197 @@
+"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 });
+const assert_1 = require("assert");
+const browserslist_1 = __importDefault(require("browserslist"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * List of browsers which are affected by a WebKit bug where class field
+ * initializers might have incorrect variable scopes.
+ *
+ * See: https://github.com/angular/angular-cli/issues/24355#issuecomment-1333477033
+ * See: https://github.com/WebKit/WebKit/commit/e8788a34b3d5f5b4edd7ff6450b80936bff396f2
+ */
+const safariClassFieldScopeBugBrowsers = new Set((0, browserslist_1.default)([
+    // Safari <15 is technically not supported via https://angular.io/guide/browser-support,
+    // but we apply the workaround if forcibly selected.
+    'Safari <=15',
+    'iOS <=15',
+]));
+function createI18nDiagnostics(reporter) {
+    const diagnostics = new (class {
+        constructor() {
+            this.messages = [];
+            this.hasErrors = false;
+        }
+        add(type, message) {
+            if (type === 'ignore') {
+                return;
+            }
+            this.messages.push({ type, message });
+            this.hasErrors || (this.hasErrors = type === 'error');
+            reporter?.(type, message);
+        }
+        error(message) {
+            this.add('error', message);
+        }
+        warn(message) {
+            this.add('warning', message);
+        }
+        merge(other) {
+            for (const diagnostic of other.messages) {
+                this.add(diagnostic.type, diagnostic.message);
+            }
+        }
+        formatDiagnostics() {
+            assert_1.strict.fail('@angular/localize Diagnostics formatDiagnostics should not be called from within babel.');
+        }
+    })();
+    return diagnostics;
+}
+function createI18nPlugins(locale, translation, missingTranslationBehavior, diagnosticReporter, pluginCreators) {
+    const diagnostics = createI18nDiagnostics(diagnosticReporter);
+    const plugins = [];
+    const { makeEs2015TranslatePlugin, makeLocalePlugin } = pluginCreators;
+    if (translation) {
+        plugins.push(makeEs2015TranslatePlugin(diagnostics, translation, {
+            missingTranslation: missingTranslationBehavior,
+        }));
+    }
+    plugins.push(makeLocalePlugin(locale));
+    return plugins;
+}
+function createNgtscLogger(reporter) {
+    return {
+        level: 1,
+        debug(...args) { },
+        info(...args) {
+            reporter?.('info', args.join());
+        },
+        warn(...args) {
+            reporter?.('warning', args.join());
+        },
+        error(...args) {
+            reporter?.('error', args.join());
+        },
+    };
+}
+function default_1(api, options) {
+    const presets = [];
+    const plugins = [];
+    let needRuntimeTransform = false;
+    if (options.angularLinker?.shouldLink) {
+        plugins.push(options.angularLinker.linkerPluginCreator({
+            linkerJitMode: options.angularLinker.jitMode,
+            // This is a workaround until https://github.com/angular/angular/issues/42769 is fixed.
+            sourceMapping: false,
+            logger: createNgtscLogger(options.diagnosticReporter),
+            fileSystem: {
+                resolve: path.resolve,
+                exists: fs.existsSync,
+                dirname: path.dirname,
+                relative: path.relative,
+                readFile: fs.readFileSync,
+                // Node.JS types don't overlap the Compiler types.
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            },
+        }));
+    }
+    // Applications code ES version can be controlled using TypeScript's `target` option.
+    // However, this doesn't effect libraries and hence we use preset-env to downlevel ES features
+    // based on the supported browsers in browserslist.
+    if (options.supportedBrowsers) {
+        const includePlugins = [];
+        // If a Safari browser affected by the class field scope bug is selected, we
+        // downlevel class properties by ensuring the class properties Babel plugin
+        // is always included- regardless of the preset-env targets.
+        if (options.supportedBrowsers.some((b) => safariClassFieldScopeBugBrowsers.has(b))) {
+            includePlugins.push('@babel/plugin-proposal-class-properties', '@babel/plugin-proposal-private-methods');
+        }
+        presets.push([
+            require('@babel/preset-env').default,
+            {
+                bugfixes: true,
+                modules: false,
+                targets: options.supportedBrowsers,
+                include: includePlugins,
+                exclude: ['transform-typeof-symbol'],
+            },
+        ]);
+        needRuntimeTransform = true;
+    }
+    if (options.i18n) {
+        const { locale, missingTranslationBehavior, pluginCreators, translation } = options.i18n;
+        const i18nPlugins = createI18nPlugins(locale, translation, missingTranslationBehavior || 'ignore', options.diagnosticReporter, pluginCreators);
+        plugins.push(...i18nPlugins);
+    }
+    if (options.forceAsyncTransformation) {
+        // Always transform async/await to support Zone.js
+        plugins.push(require('@babel/plugin-transform-async-to-generator').default, require('@babel/plugin-proposal-async-generator-functions').default);
+        needRuntimeTransform = true;
+    }
+    if (options.optimize) {
+        if (options.optimize.pureTopLevel) {
+            plugins.push(require('../plugins/pure-toplevel-functions').default);
+        }
+        plugins.push(require('../plugins/elide-angular-metadata').default, [require('../plugins/adjust-typescript-enums').default, { loose: true }], [
+            require('../plugins/adjust-static-class-members').default,
+            { wrapDecorators: options.optimize.wrapDecorators },
+        ]);
+    }
+    if (options.instrumentCode) {
+        plugins.push([
+            require('babel-plugin-istanbul').default,
+            {
+                inputSourceMap: options.instrumentCode.inputSourceMap ?? false,
+                cwd: options.instrumentCode.includedBasePath,
+            },
+        ]);
+    }
+    if (needRuntimeTransform) {
+        // Babel equivalent to TypeScript's `importHelpers` option
+        plugins.push([
+            require('@babel/plugin-transform-runtime').default,
+            {
+                useESModules: true,
+                version: require('@babel/runtime/package.json').version,
+                absoluteRuntime: path.dirname(require.resolve('@babel/runtime/package.json')),
+            },
+        ]);
+    }
+    return { presets, plugins };
+}
+exports.default = default_1;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"application.js","sourceRoot":"","sources":["../../../../../../../../../../packages/angular_devkit/build_angular/src/tools/babel/presets/application.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASH,mCAA0C;AAC1C,gEAAwC;AACxC,uCAAyB;AACzB,2CAA6B;AAE7B;;;;;;GAMG;AACH,MAAM,gCAAgC,GAAG,IAAI,GAAG,CAC9C,IAAA,sBAAY,EAAC;IACX,wFAAwF;IACxF,oDAAoD;IACpD,aAAa;IACb,UAAU;CACX,CAAC,CACH,CAAC;AAiDF,SAAS,qBAAqB,CAAC,QAAwC;IACrE,MAAM,WAAW,GAAgB,IAAI,CAAC;QAAA;YAC3B,aAAQ,GAA4B,EAAE,CAAC;YAChD,cAAS,GAAG,KAAK,CAAC;QA+BpB,CAAC;QA7BC,GAAG,CAAC,IAAgC,EAAE,OAAe;YACnD,IAAI,IAAI,KAAK,QAAQ,EAAE;gBACrB,OAAO;aACR;YAED,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;YACtC,IAAI,CAAC,SAAS,KAAd,IAAI,CAAC,SAAS,GAAK,IAAI,KAAK,OAAO,EAAC;YACpC,QAAQ,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QAC5B,CAAC;QAED,KAAK,CAAC,OAAe;YACnB,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QAC7B,CAAC;QAED,IAAI,CAAC,OAAe;YAClB,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;QAC/B,CAAC;QAED,KAAK,CAAC,KAAkB;YACtB,KAAK,MAAM,UAAU,IAAI,KAAK,CAAC,QAAQ,EAAE;gBACvC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC;aAC/C;QACH,CAAC;QAED,iBAAiB;YACf,eAAM,CAAC,IAAI,CACT,yFAAyF,CAC1F,CAAC;QACJ,CAAC;KACF,CAAC,EAAE,CAAC;IAEL,OAAO,WAAW,CAAC;AACrB,CAAC;AAED,SAAS,iBAAiB,CACxB,MAAc,EACd,WAA2D,EAC3D,0BAA0D,EAC1D,kBAAkD,EAClD,cAAkC;IAElC,MAAM,WAAW,GAAG,qBAAqB,CAAC,kBAAkB,CAAC,CAAC;IAC9D,MAAM,OAAO,GAAG,EAAE,CAAC;IAEnB,MAAM,EAAE,yBAAyB,EAAE,gBAAgB,EAAE,GAAG,cAAc,CAAC;IAEvE,IAAI,WAAW,EAAE;QACf,OAAO,CAAC,IAAI,CACV,yBAAyB,CAAC,WAAW,EAAE,WAAW,EAAE;YAClD,kBAAkB,EAAE,0BAA0B;SAC/C,CAAC,CACH,CAAC;KACH;IAED,OAAO,CAAC,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC;IAEvC,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,SAAS,iBAAiB,CAAC,QAAwC;IACjE,OAAO;QACL,KAAK,EAAE,CAAC;QACR,KAAK,CAAC,GAAG,IAAc,IAAG,CAAC;QAC3B,IAAI,CAAC,GAAG,IAAc;YACpB,QAAQ,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;QAClC,CAAC;QACD,IAAI,CAAC,GAAG,IAAc;YACpB,QAAQ,EAAE,CAAC,SAAS,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;QACrC,CAAC;QACD,KAAK,CAAC,GAAG,IAAc;YACrB,QAAQ,EAAE,CAAC,OAAO,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;QACnC,CAAC;KACF,CAAC;AACJ,CAAC;AAED,mBAAyB,GAAY,EAAE,OAAiC;IACtE,MAAM,OAAO,GAAG,EAAE,CAAC;IACnB,MAAM,OAAO,GAAG,EAAE,CAAC;IACnB,IAAI,oBAAoB,GAAG,KAAK,CAAC;IAEjC,IAAI,OAAO,CAAC,aAAa,EAAE,UAAU,EAAE;QACrC,OAAO,CAAC,IAAI,CACV,OAAO,CAAC,aAAa,CAAC,mBAAmB,CAAC;YACxC,aAAa,EAAE,OAAO,CAAC,aAAa,CAAC,OAAO;YAC5C,uFAAuF;YACvF,aAAa,EAAE,KAAK;YACpB,MAAM,EAAE,iBAAiB,CAAC,OAAO,CAAC,kBAAkB,CAAC;YACrD,UAAU,EAAE;gBACV,OAAO,EAAE,IAAI,CAAC,OAAO;gBACrB,MAAM,EAAE,EAAE,CAAC,UAAU;gBACrB,OAAO,EAAE,IAAI,CAAC,OAAO;gBACrB,QAAQ,EAAE,IAAI,CAAC,QAAQ;gBACvB,QAAQ,EAAE,EAAE,CAAC,YAAY;gBACzB,kDAAkD;gBAClD,8DAA8D;aACxD;SACT,CAAC,CACH,CAAC;KACH;IAED,qFAAqF;IACrF,8FAA8F;IAC9F,mDAAmD;IACnD,IAAI,OAAO,CAAC,iBAAiB,EAAE;QAC7B,MAAM,cAAc,GAAa,EAAE,CAAC;QAEpC,4EAA4E;QAC5E,2EAA2E;QAC3E,4DAA4D;QAC5D,IAAI,OAAO,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,gCAAgC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE;YAClF,cAAc,CAAC,IAAI,CACjB,yCAAyC,EACzC,wCAAwC,CACzC,CAAC;SACH;QAED,OAAO,CAAC,IAAI,CAAC;YACX,OAAO,CAAC,mBAAmB,CAAC,CAAC,OAAO;YACpC;gBACE,QAAQ,EAAE,IAAI;gBACd,OAAO,EAAE,KAAK;gBACd,OAAO,EAAE,OAAO,CAAC,iBAAiB;gBAClC,OAAO,EAAE,cAAc;gBACvB,OAAO,EAAE,CAAC,yBAAyB,CAAC;aACrC;SACF,CAAC,CAAC;QACH,oBAAoB,GAAG,IAAI,CAAC;KAC7B;IAED,IAAI,OAAO,CAAC,IAAI,EAAE;QAChB,MAAM,EAAE,MAAM,EAAE,0BAA0B,EAAE,cAAc,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;QACzF,MAAM,WAAW,GAAG,iBAAiB,CACnC,MAAM,EACN,WAAW,EACX,0BAA0B,IAAI,QAAQ,EACtC,OAAO,CAAC,kBAAkB,EAC1B,cAAc,CACf,CAAC;QAEF,OAAO,CAAC,IAAI,CAAC,GAAG,WAAW,CAAC,CAAC;KAC9B;IAED,IAAI,OAAO,CAAC,wBAAwB,EAAE;QACpC,kDAAkD;QAClD,OAAO,CAAC,IAAI,CACV,OAAO,CAAC,4CAA4C,CAAC,CAAC,OAAO,EAC7D,OAAO,CAAC,kDAAkD,CAAC,CAAC,OAAO,CACpE,CAAC;QACF,oBAAoB,GAAG,IAAI,CAAC;KAC7B;IAED,IAAI,OAAO,CAAC,QAAQ,EAAE;QACpB,IAAI,OAAO,CAAC,QAAQ,CAAC,YAAY,EAAE;YACjC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,oCAAoC,CAAC,CAAC,OAAO,CAAC,CAAC;SACrE;QAED,OAAO,CAAC,IAAI,CACV,OAAO,CAAC,mCAAmC,CAAC,CAAC,OAAO,EACpD,CAAC,OAAO,CAAC,oCAAoC,CAAC,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,EACxE;YACE,OAAO,CAAC,wCAAwC,CAAC,CAAC,OAAO;YACzD,EAAE,cAAc,EAAE,OAAO,CAAC,QAAQ,CAAC,cAAc,EAAE;SACpD,CACF,CAAC;KACH;IAED,IAAI,OAAO,CAAC,cAAc,EAAE;QAC1B,OAAO,CAAC,IAAI,CAAC;YACX,OAAO,CAAC,uBAAuB,CAAC,CAAC,OAAO;YACxC;gBACE,cAAc,EAAE,OAAO,CAAC,cAAc,CAAC,cAAc,IAAI,KAAK;gBAC9D,GAAG,EAAE,OAAO,CAAC,cAAc,CAAC,gBAAgB;aAC7C;SACF,CAAC,CAAC;KACJ;IAED,IAAI,oBAAoB,EAAE;QACxB,0DAA0D;QAC1D,OAAO,CAAC,IAAI,CAAC;YACX,OAAO,CAAC,iCAAiC,CAAC,CAAC,OAAO;YAClD;gBACE,YAAY,EAAE,IAAI;gBAClB,OAAO,EAAE,OAAO,CAAC,6BAA6B,CAAC,CAAC,OAAO;gBACvD,eAAe,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,6BAA6B,CAAC,CAAC;aAC9E;SACF,CAAC,CAAC;KACJ;IAED,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC;AAC9B,CAAC;AAlHD,4BAkHC","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 { ɵParsedTranslation } from '@angular/localize';\nimport type {\n  DiagnosticHandlingStrategy,\n  Diagnostics,\n  makeEs2015TranslatePlugin,\n  makeLocalePlugin,\n} from '@angular/localize/tools';\nimport { strict as assert } from 'assert';\nimport browserslist from 'browserslist';\nimport * as fs from 'fs';\nimport * as path from 'path';\n\n/**\n * List of browsers which are affected by a WebKit bug where class field\n * initializers might have incorrect variable scopes.\n *\n * See: https://github.com/angular/angular-cli/issues/24355#issuecomment-1333477033\n * See: https://github.com/WebKit/WebKit/commit/e8788a34b3d5f5b4edd7ff6450b80936bff396f2\n */\nconst safariClassFieldScopeBugBrowsers = new Set(\n  browserslist([\n    // Safari <15 is technically not supported via https://angular.io/guide/browser-support,\n    // but we apply the workaround if forcibly selected.\n    'Safari <=15',\n    'iOS <=15',\n  ]),\n);\n\nexport type DiagnosticReporter = (type: 'error' | 'warning' | 'info', message: string) => void;\n\n/**\n * An interface representing the factory functions for the `@angular/localize` translation Babel plugins.\n * This must be provided for the ESM imports since dynamic imports are required to be asynchronous and\n * Babel presets currently can only be synchronous.\n *\n */\nexport interface I18nPluginCreators {\n  makeEs2015TranslatePlugin: typeof makeEs2015TranslatePlugin;\n  makeLocalePlugin: typeof makeLocalePlugin;\n}\n\nexport interface ApplicationPresetOptions {\n  i18n?: {\n    locale: string;\n    missingTranslationBehavior?: 'error' | 'warning' | 'ignore';\n    translation?: Record<string, ɵParsedTranslation>;\n    translationFiles?: string[];\n    pluginCreators: I18nPluginCreators;\n  };\n\n  angularLinker?: {\n    shouldLink: boolean;\n    jitMode: boolean;\n    linkerPluginCreator: typeof import('@angular/compiler-cli/linker/babel').createEs2015LinkerPlugin;\n  };\n\n  forceAsyncTransformation?: boolean;\n  instrumentCode?: {\n    includedBasePath: string;\n    inputSourceMap: unknown;\n  };\n  optimize?: {\n    pureTopLevel: boolean;\n    wrapDecorators: boolean;\n  };\n\n  supportedBrowsers?: string[];\n  diagnosticReporter?: DiagnosticReporter;\n}\n\n// Extract Logger type from the linker function to avoid deep importing to access the type\ntype NgtscLogger = Parameters<\n  typeof import('@angular/compiler-cli/linker/babel').createEs2015LinkerPlugin\n>[0]['logger'];\n\nfunction createI18nDiagnostics(reporter: DiagnosticReporter | undefined): Diagnostics {\n  const diagnostics: Diagnostics = new (class {\n    readonly messages: Diagnostics['messages'] = [];\n    hasErrors = false;\n\n    add(type: DiagnosticHandlingStrategy, message: string): void {\n      if (type === 'ignore') {\n        return;\n      }\n\n      this.messages.push({ type, message });\n      this.hasErrors ||= type === 'error';\n      reporter?.(type, message);\n    }\n\n    error(message: string): void {\n      this.add('error', message);\n    }\n\n    warn(message: string): void {\n      this.add('warning', message);\n    }\n\n    merge(other: Diagnostics): void {\n      for (const diagnostic of other.messages) {\n        this.add(diagnostic.type, diagnostic.message);\n      }\n    }\n\n    formatDiagnostics(): never {\n      assert.fail(\n        '@angular/localize Diagnostics formatDiagnostics should not be called from within babel.',\n      );\n    }\n  })();\n\n  return diagnostics;\n}\n\nfunction createI18nPlugins(\n  locale: string,\n  translation: Record<string, ɵParsedTranslation> | undefined,\n  missingTranslationBehavior: 'error' | 'warning' | 'ignore',\n  diagnosticReporter: DiagnosticReporter | undefined,\n  pluginCreators: I18nPluginCreators,\n) {\n  const diagnostics = createI18nDiagnostics(diagnosticReporter);\n  const plugins = [];\n\n  const { makeEs2015TranslatePlugin, makeLocalePlugin } = pluginCreators;\n\n  if (translation) {\n    plugins.push(\n      makeEs2015TranslatePlugin(diagnostics, translation, {\n        missingTranslation: missingTranslationBehavior,\n      }),\n    );\n  }\n\n  plugins.push(makeLocalePlugin(locale));\n\n  return plugins;\n}\n\nfunction createNgtscLogger(reporter: DiagnosticReporter | undefined): NgtscLogger {\n  return {\n    level: 1, // Info level\n    debug(...args: string[]) {},\n    info(...args: string[]) {\n      reporter?.('info', args.join());\n    },\n    warn(...args: string[]) {\n      reporter?.('warning', args.join());\n    },\n    error(...args: string[]) {\n      reporter?.('error', args.join());\n    },\n  };\n}\n\nexport default function (api: unknown, options: ApplicationPresetOptions) {\n  const presets = [];\n  const plugins = [];\n  let needRuntimeTransform = false;\n\n  if (options.angularLinker?.shouldLink) {\n    plugins.push(\n      options.angularLinker.linkerPluginCreator({\n        linkerJitMode: options.angularLinker.jitMode,\n        // This is a workaround until https://github.com/angular/angular/issues/42769 is fixed.\n        sourceMapping: false,\n        logger: createNgtscLogger(options.diagnosticReporter),\n        fileSystem: {\n          resolve: path.resolve,\n          exists: fs.existsSync,\n          dirname: path.dirname,\n          relative: path.relative,\n          readFile: fs.readFileSync,\n          // Node.JS types don't overlap the Compiler types.\n          // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        } as any,\n      }),\n    );\n  }\n\n  // Applications code ES version can be controlled using TypeScript's `target` option.\n  // However, this doesn't effect libraries and hence we use preset-env to downlevel ES features\n  // based on the supported browsers in browserslist.\n  if (options.supportedBrowsers) {\n    const includePlugins: string[] = [];\n\n    // If a Safari browser affected by the class field scope bug is selected, we\n    // downlevel class properties by ensuring the class properties Babel plugin\n    // is always included- regardless of the preset-env targets.\n    if (options.supportedBrowsers.some((b) => safariClassFieldScopeBugBrowsers.has(b))) {\n      includePlugins.push(\n        '@babel/plugin-proposal-class-properties',\n        '@babel/plugin-proposal-private-methods',\n      );\n    }\n\n    presets.push([\n      require('@babel/preset-env').default,\n      {\n        bugfixes: true,\n        modules: false,\n        targets: options.supportedBrowsers,\n        include: includePlugins,\n        exclude: ['transform-typeof-symbol'],\n      },\n    ]);\n    needRuntimeTransform = true;\n  }\n\n  if (options.i18n) {\n    const { locale, missingTranslationBehavior, pluginCreators, translation } = options.i18n;\n    const i18nPlugins = createI18nPlugins(\n      locale,\n      translation,\n      missingTranslationBehavior || 'ignore',\n      options.diagnosticReporter,\n      pluginCreators,\n    );\n\n    plugins.push(...i18nPlugins);\n  }\n\n  if (options.forceAsyncTransformation) {\n    // Always transform async/await to support Zone.js\n    plugins.push(\n      require('@babel/plugin-transform-async-to-generator').default,\n      require('@babel/plugin-proposal-async-generator-functions').default,\n    );\n    needRuntimeTransform = true;\n  }\n\n  if (options.optimize) {\n    if (options.optimize.pureTopLevel) {\n      plugins.push(require('../plugins/pure-toplevel-functions').default);\n    }\n\n    plugins.push(\n      require('../plugins/elide-angular-metadata').default,\n      [require('../plugins/adjust-typescript-enums').default, { loose: true }],\n      [\n        require('../plugins/adjust-static-class-members').default,\n        { wrapDecorators: options.optimize.wrapDecorators },\n      ],\n    );\n  }\n\n  if (options.instrumentCode) {\n    plugins.push([\n      require('babel-plugin-istanbul').default,\n      {\n        inputSourceMap: options.instrumentCode.inputSourceMap ?? false,\n        cwd: options.instrumentCode.includedBasePath,\n      },\n    ]);\n  }\n\n  if (needRuntimeTransform) {\n    // Babel equivalent to TypeScript's `importHelpers` option\n    plugins.push([\n      require('@babel/plugin-transform-runtime').default,\n      {\n        useESModules: true,\n        version: require('@babel/runtime/package.json').version,\n        absoluteRuntime: path.dirname(require.resolve('@babel/runtime/package.json')),\n      },\n    ]);\n  }\n\n  return { presets, plugins };\n}\n"]}

package/src/{babel → tools/babel}/webpack-loader.d.ts

@@ -9,7 +9,7 @@ import { ApplicationPresetOptions } from './presets/application';
 interface AngularCustomOptions extends Omit<ApplicationPresetOptions, 'instrumentCode'> {
     instrumentCode?: {
         /** node_modules and test files are always excluded. */
-        excludedPaths: Set<String>;
+        excludedPaths: Set<string>;
         includedBasePath: string;
     };
 }

package/src/tools/babel/webpack-loader.js

@@ -0,0 +1,189 @@
+"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.requiresLinking = void 0;
+const babel_loader_1 = require("babel-loader");
+const load_esm_1 = require("../../utils/load-esm");
+const package_version_1 = require("../../utils/package-version");
+/**
+ * Cached instance of the compiler-cli linker's needsLinking function.
+ */
+let needsLinking;
+/**
+ * Cached instance of the compiler-cli linker's Babel plugin factory function.
+ */
+let linkerPluginCreator;
+/**
+ * Cached instance of the localize Babel plugins factory functions.
+ */
+let i18nPluginCreators;
+async function requiresLinking(path, source) {
+    // @angular/core and @angular/compiler will cause false positives
+    // Also, TypeScript files do not require linking
+    if (/[\\/]@angular[\\/](?:compiler|core)|\.tsx?$/.test(path)) {
+        return false;
+    }
+    if (!needsLinking) {
+        // Load ESM `@angular/compiler-cli/linker` using the TypeScript dynamic import workaround.
+        // Once TypeScript provides support for keeping the dynamic import this workaround can be
+        // changed to a direct dynamic import.
+        const linkerModule = await (0, load_esm_1.loadEsmModule)('@angular/compiler-cli/linker');
+        needsLinking = linkerModule.needsLinking;
+    }
+    return needsLinking(path, source);
+}
+exports.requiresLinking = requiresLinking;
+// eslint-disable-next-line max-lines-per-function
+exports.default = (0, babel_loader_1.custom)(() => {
+    const baseOptions = Object.freeze({
+        babelrc: false,
+        configFile: false,
+        compact: false,
+        cacheCompression: false,
+        sourceType: 'unambiguous',
+        inputSourceMap: false,
+    });
+    return {
+        async customOptions(options, { source, map }) {
+            const { i18n, aot, optimize, instrumentCode, supportedBrowsers, ...rawOptions } = options;
+            // Must process file if plugins are added
+            let shouldProcess = Array.isArray(rawOptions.plugins) && rawOptions.plugins.length > 0;
+            const customOptions = {
+                forceAsyncTransformation: false,
+                angularLinker: undefined,
+                i18n: undefined,
+                instrumentCode: undefined,
+                supportedBrowsers,
+            };
+            // Analyze file for linking
+            if (await requiresLinking(this.resourcePath, source)) {
+                // Load ESM `@angular/compiler-cli/linker/babel` using the TypeScript dynamic import workaround.
+                // Once TypeScript provides support for keeping the dynamic import this workaround can be
+                // changed to a direct dynamic import.
+                linkerPluginCreator ?? (linkerPluginCreator = (await (0, load_esm_1.loadEsmModule)('@angular/compiler-cli/linker/babel')).createEs2015LinkerPlugin);
+                customOptions.angularLinker = {
+                    shouldLink: true,
+                    jitMode: aot !== true,
+                    linkerPluginCreator,
+                };
+                shouldProcess = true;
+            }
+            // Application code (TS files) will only contain native async if target is ES2017+.
+            // However, third-party libraries can regardless of the target option.
+            // APF packages with code in [f]esm2015 directories is downlevelled to ES2015 and
+            // will not have native async.
+            customOptions.forceAsyncTransformation =
+                !/[\\/][_f]?esm2015[\\/]/.test(this.resourcePath) && source.includes('async');
+            shouldProcess || (shouldProcess = customOptions.forceAsyncTransformation ||
+                customOptions.supportedBrowsers !== undefined ||
+                false);
+            // Analyze for i18n inlining
+            if (i18n &&
+                !/[\\/]@angular[\\/](?:compiler|localize)/.test(this.resourcePath) &&
+                source.includes('$localize')) {
+                // Load the i18n plugin creators from the new `@angular/localize/tools` entry point.
+                // This may fail during the transition to ESM due to the entry point not yet existing.
+                // During the transition, this will always attempt to load the entry point for each file.
+                // This will only occur during prerelease and will be automatically corrected once the new
+                // entry point exists.
+                if (i18nPluginCreators === undefined) {
+                    // Load ESM `@angular/localize/tools` using the TypeScript dynamic import workaround.
+                    // Once TypeScript provides support for keeping the dynamic import this workaround can be
+                    // changed to a direct dynamic import.
+                    i18nPluginCreators = await (0, load_esm_1.loadEsmModule)('@angular/localize/tools');
+                }
+                customOptions.i18n = {
+                    ...i18n,
+                    pluginCreators: i18nPluginCreators,
+                };
+                // Add translation files as dependencies of the file to support rebuilds
+                // Except for `@angular/core` which needs locale injection but has no translations
+                if (customOptions.i18n.translationFiles &&
+                    !/[\\/]@angular[\\/]core/.test(this.resourcePath)) {
+                    for (const file of customOptions.i18n.translationFiles) {
+                        this.addDependency(file);
+                    }
+                }
+                shouldProcess = true;
+            }
+            if (optimize) {
+                const AngularPackage = /[\\/]node_modules[\\/]@angular[\\/]/.test(this.resourcePath);
+                const sideEffectFree = !!this._module?.factoryMeta?.sideEffectFree;
+                customOptions.optimize = {
+                    // Angular packages provide additional tested side effects guarantees and can use
+                    // otherwise unsafe optimizations. (@angular/platform-server/init) however has side-effects.
+                    pureTopLevel: AngularPackage && sideEffectFree,
+                    // JavaScript modules that are marked as side effect free are considered to have
+                    // no decorators that contain non-local effects.
+                    wrapDecorators: sideEffectFree,
+                };
+                shouldProcess = true;
+            }
+            if (instrumentCode &&
+                !instrumentCode.excludedPaths.has(this.resourcePath) &&
+                !/\.(e2e|spec)\.tsx?$|[\\/]node_modules[\\/]/.test(this.resourcePath) &&
+                this.resourcePath.startsWith(instrumentCode.includedBasePath)) {
+                // `babel-plugin-istanbul` has it's own includes but we do the below so that we avoid running the the loader.
+                customOptions.instrumentCode = {
+                    includedBasePath: instrumentCode.includedBasePath,
+                    inputSourceMap: map,
+                };
+                shouldProcess = true;
+            }
+            // Add provided loader options to default base options
+            const loaderOptions = {
+                ...baseOptions,
+                ...rawOptions,
+                cacheIdentifier: JSON.stringify({
+                    buildAngular: package_version_1.VERSION,
+                    customOptions,
+                    baseOptions,
+                    rawOptions,
+                }),
+            };
+            // Skip babel processing if no actions are needed
+            if (!shouldProcess) {
+                // Force the current file to be ignored
+                loaderOptions.ignore = [() => true];
+            }
+            return { custom: customOptions, loader: loaderOptions };
+        },
+        config(configuration, { customOptions }) {
+            return {
+                ...configuration.options,
+                // Using `false` disables babel from attempting to locate sourcemaps or process any inline maps.
+                // The babel types do not include the false option even though it is valid
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                inputSourceMap: configuration.options.inputSourceMap ?? false,
+                presets: [
+                    ...(configuration.options.presets || []),
+                    [
+                        require('./presets/application').default,
+                        {
+                            ...customOptions,
+                            diagnosticReporter: (type, message) => {
+                                switch (type) {
+                                    case 'error':
+                                        this.emitError(message);
+                                        break;
+                                    case 'info':
+                                    // Webpack does not currently have an informational diagnostic
+                                    case 'warning':
+                                        this.emitWarning(message);
+                                        break;
+                                }
+                            },
+                        },
+                    ],
+                ],
+            };
+        },
+    };
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"webpack-loader.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/tools/babel/webpack-loader.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;AAEH,+CAAsC;AACtC,mDAAqD;AACrD,iEAAsD;AAatD;;GAEG;AACH,IAAI,YAAoF,CAAC;AAEzF;;GAEG;AACH,IAAI,mBAES,CAAC;AAEd;;GAEG;AACH,IAAI,kBAAkD,CAAC;AAEhD,KAAK,UAAU,eAAe,CAAC,IAAY,EAAE,MAAc;IAChE,iEAAiE;IACjE,gDAAgD;IAChD,IAAI,6CAA6C,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;QAC5D,OAAO,KAAK,CAAC;KACd;IAED,IAAI,CAAC,YAAY,EAAE;QACjB,0FAA0F;QAC1F,yFAAyF;QACzF,sCAAsC;QACtC,MAAM,YAAY,GAAG,MAAM,IAAA,wBAAa,EACtC,8BAA8B,CAC/B,CAAC;QACF,YAAY,GAAG,YAAY,CAAC,YAAY,CAAC;KAC1C;IAED,OAAO,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;AACpC,CAAC;AAlBD,0CAkBC;AAED,kDAAkD;AAClD,kBAAe,IAAA,qBAAM,EAA2B,GAAG,EAAE;IACnD,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC;QAChC,OAAO,EAAE,KAAK;QACd,UAAU,EAAE,KAAK;QACjB,OAAO,EAAE,KAAK;QACd,gBAAgB,EAAE,KAAK;QACvB,UAAU,EAAE,aAAa;QACzB,cAAc,EAAE,KAAK;KACtB,CAAC,CAAC;IAEH,OAAO;QACL,KAAK,CAAC,aAAa,CAAC,OAAO,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE;YAC1C,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,QAAQ,EAAE,cAAc,EAAE,iBAAiB,EAAE,GAAG,UAAU,EAAE,GAC7E,OAAoC,CAAC;YAEvC,yCAAyC;YACzC,IAAI,aAAa,GAAG,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,UAAU,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC;YAEvF,MAAM,aAAa,GAA6B;gBAC9C,wBAAwB,EAAE,KAAK;gBAC/B,aAAa,EAAE,SAAS;gBACxB,IAAI,EAAE,SAAS;gBACf,cAAc,EAAE,SAAS;gBACzB,iBAAiB;aAClB,CAAC;YAEF,2BAA2B;YAC3B,IAAI,MAAM,eAAe,CAAC,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,EAAE;gBACpD,gGAAgG;gBAChG,yFAAyF;gBACzF,sCAAsC;gBACtC,mBAAmB,KAAnB,mBAAmB,GAAK,CACtB,MAAM,IAAA,wBAAa,EACjB,oCAAoC,CACrC,CACF,CAAC,wBAAwB,EAAC;gBAE3B,aAAa,CAAC,aAAa,GAAG;oBAC5B,UAAU,EAAE,IAAI;oBAChB,OAAO,EAAE,GAAG,KAAK,IAAI;oBACrB,mBAAmB;iBACpB,CAAC;gBACF,aAAa,GAAG,IAAI,CAAC;aACtB;YAED,mFAAmF;YACnF,sEAAsE;YACtE,iFAAiF;YACjF,8BAA8B;YAC9B,aAAa,CAAC,wBAAwB;gBACpC,CAAC,wBAAwB,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;YAEhF,aAAa,KAAb,aAAa,GACX,aAAa,CAAC,wBAAwB;gBACtC,aAAa,CAAC,iBAAiB,KAAK,SAAS;gBAC7C,KAAK,EAAC;YAER,4BAA4B;YAC5B,IACE,IAAI;gBACJ,CAAC,yCAAyC,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC;gBAClE,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC,EAC5B;gBACA,oFAAoF;gBACpF,sFAAsF;gBACtF,yFAAyF;gBACzF,0FAA0F;gBAC1F,sBAAsB;gBACtB,IAAI,kBAAkB,KAAK,SAAS,EAAE;oBACpC,qFAAqF;oBACrF,yFAAyF;oBACzF,sCAAsC;oBACtC,kBAAkB,GAAG,MAAM,IAAA,wBAAa,EAAqB,yBAAyB,CAAC,CAAC;iBACzF;gBAED,aAAa,CAAC,IAAI,GAAG;oBACnB,GAAI,IAAsD;oBAC1D,cAAc,EAAE,kBAAkB;iBACnC,CAAC;gBAEF,wEAAwE;gBACxE,kFAAkF;gBAClF,IACE,aAAa,CAAC,IAAI,CAAC,gBAAgB;oBACnC,CAAC,wBAAwB,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,EACjD;oBACA,KAAK,MAAM,IAAI,IAAI,aAAa,CAAC,IAAI,CAAC,gBAAgB,EAAE;wBACtD,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;qBAC1B;iBACF;gBAED,aAAa,GAAG,IAAI,CAAC;aACtB;YAED,IAAI,QAAQ,EAAE;gBACZ,MAAM,cAAc,GAAG,qCAAqC,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;gBACrF,MAAM,cAAc,GAAG,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,WAAW,EAAE,cAAc,CAAC;gBACnE,aAAa,CAAC,QAAQ,GAAG;oBACvB,iFAAiF;oBACjF,4FAA4F;oBAC5F,YAAY,EAAE,cAAc,IAAI,cAAc;oBAC9C,gFAAgF;oBAChF,gDAAgD;oBAChD,cAAc,EAAE,cAAc;iBAC/B,CAAC;gBAEF,aAAa,GAAG,IAAI,CAAC;aACtB;YAED,IACE,cAAc;gBACd,CAAC,cAAc,CAAC,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC;gBACpD,CAAC,4CAA4C,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC;gBACrE,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,cAAc,CAAC,gBAAgB,CAAC,EAC7D;gBACA,6GAA6G;gBAC7G,aAAa,CAAC,cAAc,GAAG;oBAC7B,gBAAgB,EAAE,cAAc,CAAC,gBAAgB;oBACjD,cAAc,EAAE,GAAG;iBACpB,CAAC;gBAEF,aAAa,GAAG,IAAI,CAAC;aACtB;YAED,sDAAsD;YACtD,MAAM,aAAa,GAA4B;gBAC7C,GAAG,WAAW;gBACd,GAAG,UAAU;gBACb,eAAe,EAAE,IAAI,CAAC,SAAS,CAAC;oBAC9B,YAAY,EAAE,yBAAO;oBACrB,aAAa;oBACb,WAAW;oBACX,UAAU;iBACX,CAAC;aACH,CAAC;YAEF,iDAAiD;YACjD,IAAI,CAAC,aAAa,EAAE;gBAClB,uCAAuC;gBACvC,aAAa,CAAC,MAAM,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC;aACrC;YAED,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE,CAAC;QAC1D,CAAC;QACD,MAAM,CAAC,aAAa,EAAE,EAAE,aAAa,EAAE;YACrC,OAAO;gBACL,GAAG,aAAa,CAAC,OAAO;gBACxB,gGAAgG;gBAChG,0EAA0E;gBAC1E,8DAA8D;gBAC9D,cAAc,EAAE,aAAa,CAAC,OAAO,CAAC,cAAc,IAAK,KAAa;gBACtE,OAAO,EAAE;oBACP,GAAG,CAAC,aAAa,CAAC,OAAO,CAAC,OAAO,IAAI,EAAE,CAAC;oBACxC;wBACE,OAAO,CAAC,uBAAuB,CAAC,CAAC,OAAO;wBACxC;4BACE,GAAG,aAAa;4BAChB,kBAAkB,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE;gCACpC,QAAQ,IAAI,EAAE;oCACZ,KAAK,OAAO;wCACV,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;wCACxB,MAAM;oCACR,KAAK,MAAM,CAAC;oCACZ,8DAA8D;oCAC9D,KAAK,SAAS;wCACZ,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;wCAC1B,MAAM;iCACT;4BACH,CAAC;yBAC0B;qBAC9B;iBACF;aACF,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC,CAAC,CAAC","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 { custom } from 'babel-loader';\nimport { loadEsmModule } from '../../utils/load-esm';\nimport { VERSION } from '../../utils/package-version';\nimport { ApplicationPresetOptions, I18nPluginCreators } from './presets/application';\n\ninterface AngularCustomOptions extends Omit<ApplicationPresetOptions, 'instrumentCode'> {\n  instrumentCode?: {\n    /** node_modules and test files are always excluded. */\n    excludedPaths: Set<string>;\n    includedBasePath: string;\n  };\n}\n\nexport type AngularBabelLoaderOptions = AngularCustomOptions & Record<string, unknown>;\n\n/**\n * Cached instance of the compiler-cli linker's needsLinking function.\n */\nlet needsLinking: typeof import('@angular/compiler-cli/linker').needsLinking | undefined;\n\n/**\n * Cached instance of the compiler-cli linker's Babel plugin factory function.\n */\nlet linkerPluginCreator:\n  | typeof import('@angular/compiler-cli/linker/babel').createEs2015LinkerPlugin\n  | undefined;\n\n/**\n * Cached instance of the localize Babel plugins factory functions.\n */\nlet i18nPluginCreators: I18nPluginCreators | undefined;\n\nexport async function requiresLinking(path: string, source: string): Promise<boolean> {\n  // @angular/core and @angular/compiler will cause false positives\n  // Also, TypeScript files do not require linking\n  if (/[\\\\/]@angular[\\\\/](?:compiler|core)|\\.tsx?$/.test(path)) {\n    return false;\n  }\n\n  if (!needsLinking) {\n    // Load ESM `@angular/compiler-cli/linker` using the TypeScript dynamic import workaround.\n    // Once TypeScript provides support for keeping the dynamic import this workaround can be\n    // changed to a direct dynamic import.\n    const linkerModule = await loadEsmModule<typeof import('@angular/compiler-cli/linker')>(\n      '@angular/compiler-cli/linker',\n    );\n    needsLinking = linkerModule.needsLinking;\n  }\n\n  return needsLinking(path, source);\n}\n\n// eslint-disable-next-line max-lines-per-function\nexport default custom<ApplicationPresetOptions>(() => {\n  const baseOptions = Object.freeze({\n    babelrc: false,\n    configFile: false,\n    compact: false,\n    cacheCompression: false,\n    sourceType: 'unambiguous',\n    inputSourceMap: false,\n  });\n\n  return {\n    async customOptions(options, { source, map }) {\n      const { i18n, aot, optimize, instrumentCode, supportedBrowsers, ...rawOptions } =\n        options as AngularBabelLoaderOptions;\n\n      // Must process file if plugins are added\n      let shouldProcess = Array.isArray(rawOptions.plugins) && rawOptions.plugins.length > 0;\n\n      const customOptions: ApplicationPresetOptions = {\n        forceAsyncTransformation: false,\n        angularLinker: undefined,\n        i18n: undefined,\n        instrumentCode: undefined,\n        supportedBrowsers,\n      };\n\n      // Analyze file for linking\n      if (await requiresLinking(this.resourcePath, source)) {\n        // Load ESM `@angular/compiler-cli/linker/babel` using the TypeScript dynamic import workaround.\n        // Once TypeScript provides support for keeping the dynamic import this workaround can be\n        // changed to a direct dynamic import.\n        linkerPluginCreator ??= (\n          await loadEsmModule<typeof import('@angular/compiler-cli/linker/babel')>(\n            '@angular/compiler-cli/linker/babel',\n          )\n        ).createEs2015LinkerPlugin;\n\n        customOptions.angularLinker = {\n          shouldLink: true,\n          jitMode: aot !== true,\n          linkerPluginCreator,\n        };\n        shouldProcess = true;\n      }\n\n      // Application code (TS files) will only contain native async if target is ES2017+.\n      // However, third-party libraries can regardless of the target option.\n      // APF packages with code in [f]esm2015 directories is downlevelled to ES2015 and\n      // will not have native async.\n      customOptions.forceAsyncTransformation =\n        !/[\\\\/][_f]?esm2015[\\\\/]/.test(this.resourcePath) && source.includes('async');\n\n      shouldProcess ||=\n        customOptions.forceAsyncTransformation ||\n        customOptions.supportedBrowsers !== undefined ||\n        false;\n\n      // Analyze for i18n inlining\n      if (\n        i18n &&\n        !/[\\\\/]@angular[\\\\/](?:compiler|localize)/.test(this.resourcePath) &&\n        source.includes('$localize')\n      ) {\n        // Load the i18n plugin creators from the new `@angular/localize/tools` entry point.\n        // This may fail during the transition to ESM due to the entry point not yet existing.\n        // During the transition, this will always attempt to load the entry point for each file.\n        // This will only occur during prerelease and will be automatically corrected once the new\n        // entry point exists.\n        if (i18nPluginCreators === undefined) {\n          // Load ESM `@angular/localize/tools` using the TypeScript dynamic import workaround.\n          // Once TypeScript provides support for keeping the dynamic import this workaround can be\n          // changed to a direct dynamic import.\n          i18nPluginCreators = await loadEsmModule<I18nPluginCreators>('@angular/localize/tools');\n        }\n\n        customOptions.i18n = {\n          ...(i18n as NonNullable<ApplicationPresetOptions['i18n']>),\n          pluginCreators: i18nPluginCreators,\n        };\n\n        // Add translation files as dependencies of the file to support rebuilds\n        // Except for `@angular/core` which needs locale injection but has no translations\n        if (\n          customOptions.i18n.translationFiles &&\n          !/[\\\\/]@angular[\\\\/]core/.test(this.resourcePath)\n        ) {\n          for (const file of customOptions.i18n.translationFiles) {\n            this.addDependency(file);\n          }\n        }\n\n        shouldProcess = true;\n      }\n\n      if (optimize) {\n        const AngularPackage = /[\\\\/]node_modules[\\\\/]@angular[\\\\/]/.test(this.resourcePath);\n        const sideEffectFree = !!this._module?.factoryMeta?.sideEffectFree;\n        customOptions.optimize = {\n          // Angular packages provide additional tested side effects guarantees and can use\n          // otherwise unsafe optimizations. (@angular/platform-server/init) however has side-effects.\n          pureTopLevel: AngularPackage && sideEffectFree,\n          // JavaScript modules that are marked as side effect free are considered to have\n          // no decorators that contain non-local effects.\n          wrapDecorators: sideEffectFree,\n        };\n\n        shouldProcess = true;\n      }\n\n      if (\n        instrumentCode &&\n        !instrumentCode.excludedPaths.has(this.resourcePath) &&\n        !/\\.(e2e|spec)\\.tsx?$|[\\\\/]node_modules[\\\\/]/.test(this.resourcePath) &&\n        this.resourcePath.startsWith(instrumentCode.includedBasePath)\n      ) {\n        // `babel-plugin-istanbul` has it's own includes but we do the below so that we avoid running the the loader.\n        customOptions.instrumentCode = {\n          includedBasePath: instrumentCode.includedBasePath,\n          inputSourceMap: map,\n        };\n\n        shouldProcess = true;\n      }\n\n      // Add provided loader options to default base options\n      const loaderOptions: Record<string, unknown> = {\n        ...baseOptions,\n        ...rawOptions,\n        cacheIdentifier: JSON.stringify({\n          buildAngular: VERSION,\n          customOptions,\n          baseOptions,\n          rawOptions,\n        }),\n      };\n\n      // Skip babel processing if no actions are needed\n      if (!shouldProcess) {\n        // Force the current file to be ignored\n        loaderOptions.ignore = [() => true];\n      }\n\n      return { custom: customOptions, loader: loaderOptions };\n    },\n    config(configuration, { customOptions }) {\n      return {\n        ...configuration.options,\n        // Using `false` disables babel from attempting to locate sourcemaps or process any inline maps.\n        // The babel types do not include the false option even though it is valid\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        inputSourceMap: configuration.options.inputSourceMap ?? (false as any),\n        presets: [\n          ...(configuration.options.presets || []),\n          [\n            require('./presets/application').default,\n            {\n              ...customOptions,\n              diagnosticReporter: (type, message) => {\n                switch (type) {\n                  case 'error':\n                    this.emitError(message);\n                    break;\n                  case 'info':\n                  // Webpack does not currently have an informational diagnostic\n                  case 'warning':\n                    this.emitWarning(message);\n                    break;\n                }\n              },\n            } as ApplicationPresetOptions,\n          ],\n        ],\n      };\n    },\n  };\n});\n"]}

package/src/tools/esbuild/angular/angular-compilation.js

@@ -0,0 +1,51 @@
+"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 __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 __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 _a, _AngularCompilation_angularCompilerCliModule;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AngularCompilation = void 0;
+const load_esm_1 = require("../../../utils/load-esm");
+const profiling_1 = require("../profiling");
+class AngularCompilation {
+    static async loadCompilerCli() {
+        var _b;
+        // This uses a wrapped dynamic import to load `@angular/compiler-cli` which is ESM.
+        // Once TypeScript provides support for retaining dynamic imports this workaround can be dropped.
+        __classPrivateFieldSet(_b = AngularCompilation, _a, __classPrivateFieldGet(_b, _a, "f", _AngularCompilation_angularCompilerCliModule) ?? await (0, load_esm_1.loadEsmModule)('@angular/compiler-cli'), "f", _AngularCompilation_angularCompilerCliModule);
+        return __classPrivateFieldGet(AngularCompilation, _a, "f", _AngularCompilation_angularCompilerCliModule);
+    }
+    async loadConfiguration(tsconfig) {
+        const { readConfiguration } = await AngularCompilation.loadCompilerCli();
+        return (0, profiling_1.profileSync)('NG_READ_CONFIG', () => readConfiguration(tsconfig, {
+            // Angular specific configuration defaults and overrides to ensure a functioning compilation.
+            suppressOutputPathCheck: true,
+            outDir: undefined,
+            sourceMap: false,
+            declaration: false,
+            declarationMap: false,
+            allowEmptyCodegenFiles: false,
+            annotationsAs: 'decorators',
+            enableResourceInlining: false,
+        }));
+    }
+}
+exports.AngularCompilation = AngularCompilation;
+_a = AngularCompilation;
+_AngularCompilation_angularCompilerCliModule = { value: void 0 };
+//# sourceMappingURL=data:application/json;base64,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