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

package/src/tools/webpack/configs/styles.js

@@ -0,0 +1,396 @@
+"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.getStylesConfig = void 0;
+const mini_css_extract_plugin_1 = __importDefault(require("mini-css-extract-plugin"));
+const path = __importStar(require("node:path"));
+const node_url_1 = require("node:url");
+const environment_options_1 = require("../../../utils/environment-options");
+const tailwind_1 = require("../../../utils/tailwind");
+const sass_service_1 = require("../../sass/sass-service");
+const sass_service_legacy_1 = require("../../sass/sass-service-legacy");
+const plugins_1 = require("../plugins");
+const css_optimizer_plugin_1 = require("../plugins/css-optimizer-plugin");
+const styles_webpack_plugin_1 = require("../plugins/styles-webpack-plugin");
+const helpers_1 = require("../utils/helpers");
+// eslint-disable-next-line max-lines-per-function
+async function getStylesConfig(wco) {
+    const { root, buildOptions, logger, projectRoot } = wco;
+    const extraPlugins = [];
+    extraPlugins.push(new plugins_1.AnyComponentStyleBudgetChecker(buildOptions.budgets));
+    const cssSourceMap = buildOptions.sourceMap.styles;
+    // Determine hashing format.
+    const hashFormat = (0, helpers_1.getOutputHashFormat)(buildOptions.outputHashing);
+    // use includePaths from appConfig
+    const includePaths = buildOptions.stylePreprocessorOptions?.includePaths?.map((p) => path.resolve(root, p)) ?? [];
+    // Process global styles.
+    if (buildOptions.styles.length > 0) {
+        const { entryPoints, noInjectNames } = (0, helpers_1.normalizeGlobalStyles)(buildOptions.styles);
+        extraPlugins.push(new styles_webpack_plugin_1.StylesWebpackPlugin({
+            root,
+            entryPoints,
+            preserveSymlinks: buildOptions.preserveSymlinks,
+        }));
+        if (noInjectNames.length > 0) {
+            // Add plugin to remove hashes from lazy styles.
+            extraPlugins.push(new plugins_1.RemoveHashPlugin({ chunkNames: noInjectNames, hashFormat }));
+        }
+    }
+    const sassImplementation = environment_options_1.useLegacySass
+        ? new sass_service_legacy_1.SassLegacyWorkerImplementation()
+        : new sass_service_1.SassWorkerImplementation();
+    extraPlugins.push({
+        apply(compiler) {
+            compiler.hooks.shutdown.tap('sass-worker', () => {
+                sassImplementation.close();
+            });
+        },
+    });
+    const assetNameTemplate = (0, helpers_1.assetNameTemplateFactory)(hashFormat);
+    const extraPostcssPlugins = [];
+    // Attempt to setup Tailwind CSS
+    // Only load Tailwind CSS plugin if configuration file was found.
+    // This acts as a guard to ensure the project actually wants to use Tailwind CSS.
+    // The package may be unknowningly present due to a third-party transitive package dependency.
+    const tailwindConfigPath = await (0, tailwind_1.findTailwindConfigurationFile)(root, projectRoot);
+    if (tailwindConfigPath) {
+        let tailwindPackagePath;
+        try {
+            tailwindPackagePath = require.resolve('tailwindcss', { paths: [root] });
+        }
+        catch {
+            const relativeTailwindConfigPath = path.relative(root, tailwindConfigPath);
+            logger.warn(`Tailwind CSS configuration file found (${relativeTailwindConfigPath})` +
+                ` but the 'tailwindcss' package is not installed.` +
+                ` To enable Tailwind CSS, please install the 'tailwindcss' package.`);
+        }
+        if (tailwindPackagePath) {
+            extraPostcssPlugins.push(require(tailwindPackagePath)({ config: tailwindConfigPath }));
+        }
+    }
+    const autoprefixer = require('autoprefixer');
+    const postcssOptionsCreator = (inlineSourcemaps, extracted) => {
+        const optionGenerator = (loader) => ({
+            map: inlineSourcemaps
+                ? {
+                    inline: true,
+                    annotation: false,
+                }
+                : undefined,
+            plugins: [
+                (0, plugins_1.PostcssCliResources)({
+                    baseHref: buildOptions.baseHref,
+                    deployUrl: buildOptions.deployUrl,
+                    resourcesOutputPath: buildOptions.resourcesOutputPath,
+                    loader,
+                    filename: assetNameTemplate,
+                    emitFile: buildOptions.platform !== 'server',
+                    extracted,
+                }),
+                ...extraPostcssPlugins,
+                autoprefixer({
+                    ignoreUnknownVersions: true,
+                    overrideBrowserslist: buildOptions.supportedBrowsers,
+                }),
+            ],
+        });
+        // postcss-loader fails when trying to determine configuration files for data URIs
+        optionGenerator.config = false;
+        return optionGenerator;
+    };
+    let componentsSourceMap = !!cssSourceMap;
+    if (cssSourceMap) {
+        if (buildOptions.optimization.styles.minify) {
+            // Never use component css sourcemap when style optimizations are on.
+            // It will just increase bundle size without offering good debug experience.
+            logger.warn('Components styles sourcemaps are not generated when styles optimization is enabled.');
+            componentsSourceMap = false;
+        }
+        else if (buildOptions.sourceMap.hidden) {
+            // Inline all sourcemap types except hidden ones, which are the same as no sourcemaps
+            // for component css.
+            logger.warn('Components styles sourcemaps are not generated when sourcemaps are hidden.');
+            componentsSourceMap = false;
+        }
+    }
+    // extract global css from js files into own css file.
+    extraPlugins.push(new mini_css_extract_plugin_1.default({ filename: `[name]${hashFormat.extract}.css` }));
+    if (!buildOptions.hmr) {
+        // don't remove `.js` files for `.css` when we are using HMR these contain HMR accept codes.
+        // suppress empty .js files in css only entry points.
+        extraPlugins.push(new plugins_1.SuppressExtractedTextChunksWebpackPlugin());
+    }
+    const postCss = require('postcss');
+    const postCssLoaderPath = require.resolve('postcss-loader');
+    const componentStyleLoaders = [
+        {
+            loader: require.resolve('css-loader'),
+            options: {
+                url: false,
+                sourceMap: componentsSourceMap,
+                importLoaders: 1,
+                exportType: 'string',
+                esModule: false,
+            },
+        },
+        {
+            loader: postCssLoaderPath,
+            options: {
+                implementation: postCss,
+                postcssOptions: postcssOptionsCreator(componentsSourceMap, false),
+            },
+        },
+    ];
+    const globalStyleLoaders = [
+        {
+            loader: mini_css_extract_plugin_1.default.loader,
+        },
+        {
+            loader: require.resolve('css-loader'),
+            options: {
+                url: false,
+                sourceMap: !!cssSourceMap,
+                importLoaders: 1,
+            },
+        },
+        {
+            loader: postCssLoaderPath,
+            options: {
+                implementation: postCss,
+                postcssOptions: postcssOptionsCreator(false, true),
+                sourceMap: !!cssSourceMap,
+            },
+        },
+    ];
+    const styleLanguages = [
+        {
+            extensions: ['css'],
+            use: [],
+        },
+        {
+            extensions: ['scss'],
+            use: [
+                {
+                    loader: require.resolve('resolve-url-loader'),
+                    options: {
+                        sourceMap: cssSourceMap,
+                    },
+                },
+                {
+                    loader: require.resolve('sass-loader'),
+                    options: getSassLoaderOptions(root, sassImplementation, includePaths, false, !!buildOptions.verbose, !!buildOptions.preserveSymlinks),
+                },
+            ],
+        },
+        {
+            extensions: ['sass'],
+            use: [
+                {
+                    loader: require.resolve('resolve-url-loader'),
+                    options: {
+                        sourceMap: cssSourceMap,
+                    },
+                },
+                {
+                    loader: require.resolve('sass-loader'),
+                    options: getSassLoaderOptions(root, sassImplementation, includePaths, true, !!buildOptions.verbose, !!buildOptions.preserveSymlinks),
+                },
+            ],
+        },
+        {
+            extensions: ['less'],
+            use: [
+                {
+                    loader: require.resolve('less-loader'),
+                    options: {
+                        implementation: require('less'),
+                        sourceMap: cssSourceMap,
+                        lessOptions: {
+                            javascriptEnabled: true,
+                            paths: includePaths,
+                        },
+                    },
+                },
+            ],
+        },
+    ];
+    return {
+        module: {
+            rules: styleLanguages.map(({ extensions, use }) => ({
+                test: new RegExp(`\\.(?:${extensions.join('|')})$`, 'i'),
+                rules: [
+                    // Setup processing rules for global and component styles
+                    {
+                        oneOf: [
+                            // Global styles are only defined global styles
+                            {
+                                use: globalStyleLoaders,
+                                resourceQuery: /\?ngGlobalStyle/,
+                            },
+                            // Component styles are all styles except defined global styles
+                            {
+                                use: componentStyleLoaders,
+                                resourceQuery: /\?ngResource/,
+                            },
+                        ],
+                    },
+                    { use },
+                ],
+            })),
+        },
+        optimization: {
+            minimizer: buildOptions.optimization.styles.minify
+                ? [
+                    new css_optimizer_plugin_1.CssOptimizerPlugin({
+                        supportedBrowsers: buildOptions.supportedBrowsers,
+                    }),
+                ]
+                : undefined,
+        },
+        plugins: extraPlugins,
+    };
+}
+exports.getStylesConfig = getStylesConfig;
+function getSassLoaderOptions(root, implementation, includePaths, indentedSyntax, verbose, preserveSymlinks) {
+    return implementation instanceof sass_service_1.SassWorkerImplementation
+        ? {
+            sourceMap: true,
+            api: 'modern',
+            implementation,
+            // Webpack importer is only implemented in the legacy API and we have our own custom Webpack importer.
+            // See: https://github.com/webpack-contrib/sass-loader/blob/997f3eb41d86dd00d5fa49c395a1aeb41573108c/src/utils.js#L642-L651
+            webpackImporter: false,
+            sassOptions: (loaderContext) => ({
+                importers: [getSassResolutionImporter(loaderContext, root, preserveSymlinks)],
+                loadPaths: includePaths,
+                // Use expanded as otherwise sass will remove comments that are needed for autoprefixer
+                // Ex: /* autoprefixer grid: autoplace */
+                // See: https://github.com/webpack-contrib/sass-loader/blob/45ad0be17264ceada5f0b4fb87e9357abe85c4ff/src/getSassOptions.js#L68-L70
+                style: 'expanded',
+                // Silences compiler warnings from 3rd party stylesheets
+                quietDeps: !verbose,
+                verbose,
+                syntax: indentedSyntax ? 'indented' : 'scss',
+                sourceMapIncludeSources: true,
+            }),
+        }
+        : {
+            sourceMap: true,
+            api: 'legacy',
+            implementation,
+            sassOptions: {
+                importer: (url, from) => {
+                    if (url.charAt(0) === '~') {
+                        throw new Error(`'${from}' imports '${url}' with a tilde. Usage of '~' in imports is no longer supported.`);
+                    }
+                    return null;
+                },
+                // Prevent use of `fibers` package as it no longer works in newer Node.js versions
+                fiber: false,
+                indentedSyntax,
+                // bootstrap-sass requires a minimum precision of 8
+                precision: 8,
+                includePaths,
+                // Use expanded as otherwise sass will remove comments that are needed for autoprefixer
+                // Ex: /* autoprefixer grid: autoplace */
+                // See: https://github.com/webpack-contrib/sass-loader/blob/45ad0be17264ceada5f0b4fb87e9357abe85c4ff/src/getSassOptions.js#L68-L70
+                outputStyle: 'expanded',
+                // Silences compiler warnings from 3rd party stylesheets
+                quietDeps: !verbose,
+                verbose,
+            },
+        };
+}
+function getSassResolutionImporter(loaderContext, root, preserveSymlinks) {
+    const commonResolverOptions = {
+        conditionNames: ['sass', 'style'],
+        mainFields: ['sass', 'style', 'main', '...'],
+        extensions: ['.scss', '.sass', '.css'],
+        restrictions: [/\.((sa|sc|c)ss)$/i],
+        preferRelative: true,
+        symlinks: !preserveSymlinks,
+    };
+    // Sass also supports import-only files. If you name a file <name>.import.scss, it will only be loaded for imports, not for @uses.
+    // See: https://sass-lang.com/documentation/at-rules/import#import-only-files
+    const resolveImport = loaderContext.getResolve({
+        ...commonResolverOptions,
+        dependencyType: 'sass-import',
+        mainFiles: ['_index.import', '_index', 'index.import', 'index', '...'],
+    });
+    const resolveModule = loaderContext.getResolve({
+        ...commonResolverOptions,
+        dependencyType: 'sass-module',
+        mainFiles: ['_index', 'index', '...'],
+    });
+    return {
+        findFileUrl: async (url, { fromImport, previousResolvedModules }) => {
+            if (url.charAt(0) === '.') {
+                // Let Sass handle relative imports.
+                return null;
+            }
+            const resolve = fromImport ? resolveImport : resolveModule;
+            // Try to resolve from root of workspace
+            let result = await tryResolve(resolve, root, url);
+            // Try to resolve from previously resolved modules.
+            if (!result && previousResolvedModules) {
+                for (const path of previousResolvedModules) {
+                    result = await tryResolve(resolve, path, url);
+                    if (result) {
+                        break;
+                    }
+                }
+            }
+            return result ? (0, node_url_1.pathToFileURL)(result) : null;
+        },
+    };
+}
+async function tryResolve(resolve, root, url) {
+    try {
+        return await resolve(root, url);
+    }
+    catch {
+        // Try to resolve a partial file
+        // @use '@material/button/button' as mdc-button;
+        // `@material/button/button` -> `@material/button/_button`
+        const lastSlashIndex = url.lastIndexOf('/');
+        const underscoreIndex = lastSlashIndex + 1;
+        if (underscoreIndex > 0 && url.charAt(underscoreIndex) !== '_') {
+            const partialFileUrl = `${url.slice(0, underscoreIndex)}_${url.slice(underscoreIndex)}`;
+            return resolve(root, partialFileUrl).catch(() => undefined);
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"styles.js","sourceRoot":"","sources":["../../../../../../../../../../packages/angular_devkit/build_angular/src/tools/webpack/configs/styles.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 MiniCssExtractPlugin from 'mini-css-extract-plugin';\nimport * as path from 'node:path';\nimport { pathToFileURL } from 'node:url';\nimport type { FileImporter } from 'sass';\nimport type { Configuration, LoaderContext, RuleSetUseItem } from 'webpack';\nimport { WebpackConfigOptions } from '../../../utils/build-options';\nimport { useLegacySass } from '../../../utils/environment-options';\nimport { findTailwindConfigurationFile } from '../../../utils/tailwind';\nimport {\n  FileImporterWithRequestContextOptions,\n  SassWorkerImplementation,\n} from '../../sass/sass-service';\nimport { SassLegacyWorkerImplementation } from '../../sass/sass-service-legacy';\nimport {\n  AnyComponentStyleBudgetChecker,\n  PostcssCliResources,\n  RemoveHashPlugin,\n  SuppressExtractedTextChunksWebpackPlugin,\n} from '../plugins';\nimport { CssOptimizerPlugin } from '../plugins/css-optimizer-plugin';\nimport { StylesWebpackPlugin } from '../plugins/styles-webpack-plugin';\nimport {\n  assetNameTemplateFactory,\n  getOutputHashFormat,\n  normalizeGlobalStyles,\n} from '../utils/helpers';\n\n// eslint-disable-next-line max-lines-per-function\nexport async function getStylesConfig(wco: WebpackConfigOptions): Promise<Configuration> {\n  const { root, buildOptions, logger, projectRoot } = wco;\n  const extraPlugins: Configuration['plugins'] = [];\n\n  extraPlugins.push(new AnyComponentStyleBudgetChecker(buildOptions.budgets));\n\n  const cssSourceMap = buildOptions.sourceMap.styles;\n\n  // Determine hashing format.\n  const hashFormat = getOutputHashFormat(buildOptions.outputHashing);\n\n  // use includePaths from appConfig\n  const includePaths =\n    buildOptions.stylePreprocessorOptions?.includePaths?.map((p) => path.resolve(root, p)) ?? [];\n\n  // Process global styles.\n  if (buildOptions.styles.length > 0) {\n    const { entryPoints, noInjectNames } = normalizeGlobalStyles(buildOptions.styles);\n    extraPlugins.push(\n      new StylesWebpackPlugin({\n        root,\n        entryPoints,\n        preserveSymlinks: buildOptions.preserveSymlinks,\n      }),\n    );\n\n    if (noInjectNames.length > 0) {\n      // Add plugin to remove hashes from lazy styles.\n      extraPlugins.push(new RemoveHashPlugin({ chunkNames: noInjectNames, hashFormat }));\n    }\n  }\n\n  const sassImplementation = useLegacySass\n    ? new SassLegacyWorkerImplementation()\n    : new SassWorkerImplementation();\n\n  extraPlugins.push({\n    apply(compiler) {\n      compiler.hooks.shutdown.tap('sass-worker', () => {\n        sassImplementation.close();\n      });\n    },\n  });\n\n  const assetNameTemplate = assetNameTemplateFactory(hashFormat);\n\n  const extraPostcssPlugins: import('postcss').Plugin[] = [];\n\n  // Attempt to setup Tailwind CSS\n  // Only load Tailwind CSS plugin if configuration file was found.\n  // This acts as a guard to ensure the project actually wants to use Tailwind CSS.\n  // The package may be unknowningly present due to a third-party transitive package dependency.\n  const tailwindConfigPath = await findTailwindConfigurationFile(root, projectRoot);\n  if (tailwindConfigPath) {\n    let tailwindPackagePath;\n    try {\n      tailwindPackagePath = require.resolve('tailwindcss', { paths: [root] });\n    } catch {\n      const relativeTailwindConfigPath = path.relative(root, tailwindConfigPath);\n      logger.warn(\n        `Tailwind CSS configuration file found (${relativeTailwindConfigPath})` +\n          ` but the 'tailwindcss' package is not installed.` +\n          ` To enable Tailwind CSS, please install the 'tailwindcss' package.`,\n      );\n    }\n    if (tailwindPackagePath) {\n      extraPostcssPlugins.push(require(tailwindPackagePath)({ config: tailwindConfigPath }));\n    }\n  }\n\n  const autoprefixer: typeof import('autoprefixer') = require('autoprefixer');\n\n  const postcssOptionsCreator = (inlineSourcemaps: boolean, extracted: boolean) => {\n    const optionGenerator = (loader: LoaderContext<unknown>) => ({\n      map: inlineSourcemaps\n        ? {\n            inline: true,\n            annotation: false,\n          }\n        : undefined,\n      plugins: [\n        PostcssCliResources({\n          baseHref: buildOptions.baseHref,\n          deployUrl: buildOptions.deployUrl,\n          resourcesOutputPath: buildOptions.resourcesOutputPath,\n          loader,\n          filename: assetNameTemplate,\n          emitFile: buildOptions.platform !== 'server',\n          extracted,\n        }),\n        ...extraPostcssPlugins,\n        autoprefixer({\n          ignoreUnknownVersions: true,\n          overrideBrowserslist: buildOptions.supportedBrowsers,\n        }),\n      ],\n    });\n    // postcss-loader fails when trying to determine configuration files for data URIs\n    optionGenerator.config = false;\n\n    return optionGenerator;\n  };\n\n  let componentsSourceMap = !!cssSourceMap;\n  if (cssSourceMap) {\n    if (buildOptions.optimization.styles.minify) {\n      // Never use component css sourcemap when style optimizations are on.\n      // It will just increase bundle size without offering good debug experience.\n      logger.warn(\n        'Components styles sourcemaps are not generated when styles optimization is enabled.',\n      );\n      componentsSourceMap = false;\n    } else if (buildOptions.sourceMap.hidden) {\n      // Inline all sourcemap types except hidden ones, which are the same as no sourcemaps\n      // for component css.\n      logger.warn('Components styles sourcemaps are not generated when sourcemaps are hidden.');\n      componentsSourceMap = false;\n    }\n  }\n\n  // extract global css from js files into own css file.\n  extraPlugins.push(new MiniCssExtractPlugin({ filename: `[name]${hashFormat.extract}.css` }));\n\n  if (!buildOptions.hmr) {\n    // don't remove `.js` files for `.css` when we are using HMR these contain HMR accept codes.\n    // suppress empty .js files in css only entry points.\n    extraPlugins.push(new SuppressExtractedTextChunksWebpackPlugin());\n  }\n\n  const postCss = require('postcss');\n  const postCssLoaderPath = require.resolve('postcss-loader');\n\n  const componentStyleLoaders: RuleSetUseItem[] = [\n    {\n      loader: require.resolve('css-loader'),\n      options: {\n        url: false,\n        sourceMap: componentsSourceMap,\n        importLoaders: 1,\n        exportType: 'string',\n        esModule: false,\n      },\n    },\n    {\n      loader: postCssLoaderPath,\n      options: {\n        implementation: postCss,\n        postcssOptions: postcssOptionsCreator(componentsSourceMap, false),\n      },\n    },\n  ];\n\n  const globalStyleLoaders: RuleSetUseItem[] = [\n    {\n      loader: MiniCssExtractPlugin.loader,\n    },\n    {\n      loader: require.resolve('css-loader'),\n      options: {\n        url: false,\n        sourceMap: !!cssSourceMap,\n        importLoaders: 1,\n      },\n    },\n    {\n      loader: postCssLoaderPath,\n      options: {\n        implementation: postCss,\n        postcssOptions: postcssOptionsCreator(false, true),\n        sourceMap: !!cssSourceMap,\n      },\n    },\n  ];\n\n  const styleLanguages: {\n    extensions: string[];\n    use: RuleSetUseItem[];\n  }[] = [\n    {\n      extensions: ['css'],\n      use: [],\n    },\n    {\n      extensions: ['scss'],\n      use: [\n        {\n          loader: require.resolve('resolve-url-loader'),\n          options: {\n            sourceMap: cssSourceMap,\n          },\n        },\n        {\n          loader: require.resolve('sass-loader'),\n          options: getSassLoaderOptions(\n            root,\n            sassImplementation,\n            includePaths,\n            false,\n            !!buildOptions.verbose,\n            !!buildOptions.preserveSymlinks,\n          ),\n        },\n      ],\n    },\n    {\n      extensions: ['sass'],\n      use: [\n        {\n          loader: require.resolve('resolve-url-loader'),\n          options: {\n            sourceMap: cssSourceMap,\n          },\n        },\n        {\n          loader: require.resolve('sass-loader'),\n          options: getSassLoaderOptions(\n            root,\n            sassImplementation,\n            includePaths,\n            true,\n            !!buildOptions.verbose,\n            !!buildOptions.preserveSymlinks,\n          ),\n        },\n      ],\n    },\n    {\n      extensions: ['less'],\n      use: [\n        {\n          loader: require.resolve('less-loader'),\n          options: {\n            implementation: require('less'),\n            sourceMap: cssSourceMap,\n            lessOptions: {\n              javascriptEnabled: true,\n              paths: includePaths,\n            },\n          },\n        },\n      ],\n    },\n  ];\n\n  return {\n    module: {\n      rules: styleLanguages.map(({ extensions, use }) => ({\n        test: new RegExp(`\\\\.(?:${extensions.join('|')})$`, 'i'),\n        rules: [\n          // Setup processing rules for global and component styles\n          {\n            oneOf: [\n              // Global styles are only defined global styles\n              {\n                use: globalStyleLoaders,\n                resourceQuery: /\\?ngGlobalStyle/,\n              },\n              // Component styles are all styles except defined global styles\n              {\n                use: componentStyleLoaders,\n                resourceQuery: /\\?ngResource/,\n              },\n            ],\n          },\n          { use },\n        ],\n      })),\n    },\n    optimization: {\n      minimizer: buildOptions.optimization.styles.minify\n        ? [\n            new CssOptimizerPlugin({\n              supportedBrowsers: buildOptions.supportedBrowsers,\n            }),\n          ]\n        : undefined,\n    },\n    plugins: extraPlugins,\n  };\n}\n\nfunction getSassLoaderOptions(\n  root: string,\n  implementation: SassWorkerImplementation | SassLegacyWorkerImplementation,\n  includePaths: string[],\n  indentedSyntax: boolean,\n  verbose: boolean,\n  preserveSymlinks: boolean,\n): Record<string, unknown> {\n  return implementation instanceof SassWorkerImplementation\n    ? {\n        sourceMap: true,\n        api: 'modern',\n        implementation,\n        // Webpack importer is only implemented in the legacy API and we have our own custom Webpack importer.\n        // See: https://github.com/webpack-contrib/sass-loader/blob/997f3eb41d86dd00d5fa49c395a1aeb41573108c/src/utils.js#L642-L651\n        webpackImporter: false,\n        sassOptions: (loaderContext: LoaderContext<{}>) => ({\n          importers: [getSassResolutionImporter(loaderContext, root, preserveSymlinks)],\n          loadPaths: includePaths,\n          // Use expanded as otherwise sass will remove comments that are needed for autoprefixer\n          // Ex: /* autoprefixer grid: autoplace */\n          // See: https://github.com/webpack-contrib/sass-loader/blob/45ad0be17264ceada5f0b4fb87e9357abe85c4ff/src/getSassOptions.js#L68-L70\n          style: 'expanded',\n          // Silences compiler warnings from 3rd party stylesheets\n          quietDeps: !verbose,\n          verbose,\n          syntax: indentedSyntax ? 'indented' : 'scss',\n          sourceMapIncludeSources: true,\n        }),\n      }\n    : {\n        sourceMap: true,\n        api: 'legacy',\n        implementation,\n        sassOptions: {\n          importer: (url: string, from: string) => {\n            if (url.charAt(0) === '~') {\n              throw new Error(\n                `'${from}' imports '${url}' with a tilde. Usage of '~' in imports is no longer supported.`,\n              );\n            }\n\n            return null;\n          },\n          // Prevent use of `fibers` package as it no longer works in newer Node.js versions\n          fiber: false,\n          indentedSyntax,\n          // bootstrap-sass requires a minimum precision of 8\n          precision: 8,\n          includePaths,\n          // Use expanded as otherwise sass will remove comments that are needed for autoprefixer\n          // Ex: /* autoprefixer grid: autoplace */\n          // See: https://github.com/webpack-contrib/sass-loader/blob/45ad0be17264ceada5f0b4fb87e9357abe85c4ff/src/getSassOptions.js#L68-L70\n          outputStyle: 'expanded',\n          // Silences compiler warnings from 3rd party stylesheets\n          quietDeps: !verbose,\n          verbose,\n        },\n      };\n}\n\nfunction getSassResolutionImporter(\n  loaderContext: LoaderContext<{}>,\n  root: string,\n  preserveSymlinks: boolean,\n): FileImporter<'async'> {\n  const commonResolverOptions: Parameters<(typeof loaderContext)['getResolve']>[0] = {\n    conditionNames: ['sass', 'style'],\n    mainFields: ['sass', 'style', 'main', '...'],\n    extensions: ['.scss', '.sass', '.css'],\n    restrictions: [/\\.((sa|sc|c)ss)$/i],\n    preferRelative: true,\n    symlinks: !preserveSymlinks,\n  };\n\n  // Sass also supports import-only files. If you name a file <name>.import.scss, it will only be loaded for imports, not for @uses.\n  // See: https://sass-lang.com/documentation/at-rules/import#import-only-files\n  const resolveImport = loaderContext.getResolve({\n    ...commonResolverOptions,\n    dependencyType: 'sass-import',\n    mainFiles: ['_index.import', '_index', 'index.import', 'index', '...'],\n  });\n\n  const resolveModule = loaderContext.getResolve({\n    ...commonResolverOptions,\n    dependencyType: 'sass-module',\n    mainFiles: ['_index', 'index', '...'],\n  });\n\n  return {\n    findFileUrl: async (\n      url,\n      { fromImport, previousResolvedModules }: FileImporterWithRequestContextOptions,\n    ): Promise<URL | null> => {\n      if (url.charAt(0) === '.') {\n        // Let Sass handle relative imports.\n        return null;\n      }\n\n      const resolve = fromImport ? resolveImport : resolveModule;\n      // Try to resolve from root of workspace\n      let result = await tryResolve(resolve, root, url);\n\n      // Try to resolve from previously resolved modules.\n      if (!result && previousResolvedModules) {\n        for (const path of previousResolvedModules) {\n          result = await tryResolve(resolve, path, url);\n          if (result) {\n            break;\n          }\n        }\n      }\n\n      return result ? pathToFileURL(result) : null;\n    },\n  };\n}\n\nasync function tryResolve(\n  resolve: ReturnType<LoaderContext<{}>['getResolve']>,\n  root: string,\n  url: string,\n): Promise<string | undefined> {\n  try {\n    return await resolve(root, url);\n  } catch {\n    // Try to resolve a partial file\n    // @use '@material/button/button' as mdc-button;\n    // `@material/button/button` -> `@material/button/_button`\n    const lastSlashIndex = url.lastIndexOf('/');\n    const underscoreIndex = lastSlashIndex + 1;\n    if (underscoreIndex > 0 && url.charAt(underscoreIndex) !== '_') {\n      const partialFileUrl = `${url.slice(0, underscoreIndex)}_${url.slice(underscoreIndex)}`;\n\n      return resolve(root, partialFileUrl).catch(() => undefined);\n    }\n  }\n\n  return undefined;\n}\n"]}

package/src/{webpack → tools/webpack}/plugins/any-component-style-budget-checker.d.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { Compiler } from 'webpack';
-import { Budget } from '../../builders/browser/schema';
+import { Budget } from '../../../builders/browser/schema';
 /**
  * Check budget sizes for component styles by emitting a warning or error if a
  * budget is exceeded by a particular component's styles.

package/src/tools/webpack/plugins/any-component-style-budget-checker.js

@@ -0,0 +1,92 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnyComponentStyleBudgetChecker = void 0;
+const path = __importStar(require("path"));
+const webpack_1 = require("webpack");
+const schema_1 = require("../../../builders/browser/schema");
+const bundle_calculator_1 = require("../../../utils/bundle-calculator");
+const webpack_diagnostics_1 = require("../../../utils/webpack-diagnostics");
+const PLUGIN_NAME = 'AnyComponentStyleBudgetChecker';
+/**
+ * Check budget sizes for component styles by emitting a warning or error if a
+ * budget is exceeded by a particular component's styles.
+ */
+class AnyComponentStyleBudgetChecker {
+    constructor(budgets) {
+        this.budgets = budgets.filter((budget) => budget.type === schema_1.Type.AnyComponentStyle);
+    }
+    apply(compiler) {
+        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+            compilation.hooks.processAssets.tap({
+                name: PLUGIN_NAME,
+                stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_ANALYSE,
+            }, () => {
+                // No budgets.
+                if (this.budgets.length === 0) {
+                    return;
+                }
+                // In AOT compilations component styles get processed in child compilations.
+                if (!compilation.compiler.parentCompilation) {
+                    return;
+                }
+                const cssExtensions = ['.css', '.scss', '.less', '.sass'];
+                const componentStyles = Object.keys(compilation.assets)
+                    .filter((name) => cssExtensions.includes(path.extname(name)))
+                    .map((name) => ({
+                    size: compilation.assets[name].size(),
+                    label: name,
+                }));
+                const thresholds = this.budgets.flatMap((budget) => [...(0, bundle_calculator_1.calculateThresholds)(budget)]);
+                for (const { size, label } of componentStyles) {
+                    for (const { severity, message } of (0, bundle_calculator_1.checkThresholds)(thresholds[Symbol.iterator](), size, label)) {
+                        switch (severity) {
+                            case bundle_calculator_1.ThresholdSeverity.Warning:
+                                (0, webpack_diagnostics_1.addWarning)(compilation, message);
+                                break;
+                            case bundle_calculator_1.ThresholdSeverity.Error:
+                                (0, webpack_diagnostics_1.addError)(compilation, message);
+                                break;
+                            default:
+                                assertNever(severity);
+                        }
+                    }
+                }
+            });
+        });
+    }
+}
+exports.AnyComponentStyleBudgetChecker = AnyComponentStyleBudgetChecker;
+function assertNever(input) {
+    throw new Error(`Unexpected call to assertNever() with input: ${JSON.stringify(input, null /* replacer */, 4 /* tabSize */)}`);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW55LWNvbXBvbmVudC1zdHlsZS1idWRnZXQtY2hlY2tlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2FuZ3VsYXJfZGV2a2l0L2J1aWxkX2FuZ3VsYXIvc3JjL3Rvb2xzL3dlYnBhY2svcGx1Z2lucy9hbnktY29tcG9uZW50LXN0eWxlLWJ1ZGdldC1jaGVja2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7Ozs7O0dBTUc7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBRUgsMkNBQTZCO0FBQzdCLHFDQUFnRDtBQUNoRCw2REFBZ0U7QUFDaEUsd0VBSTBDO0FBQzFDLDRFQUEwRTtBQUUxRSxNQUFNLFdBQVcsR0FBRyxnQ0FBZ0MsQ0FBQztBQUVyRDs7O0dBR0c7QUFDSCxNQUFhLDhCQUE4QjtJQUd6QyxZQUFZLE9BQWlCO1FBQzNCLElBQUksQ0FBQyxPQUFPLEdBQUcsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUFDLE1BQU0sRUFBRSxFQUFFLENBQUMsTUFBTSxDQUFDLElBQUksS0FBSyxhQUFJLENBQUMsaUJBQWlCLENBQUMsQ0FBQztJQUNwRixDQUFDO0lBRUQsS0FBSyxDQUFDLFFBQWtCO1FBQ3RCLFFBQVEsQ0FBQyxLQUFLLENBQUMsV0FBVyxDQUFDLEdBQUcsQ0FBQyxXQUFXLEVBQUUsQ0FBQyxXQUFXLEVBQUUsRUFBRTtZQUMxRCxXQUFXLENBQUMsS0FBSyxDQUFDLGFBQWEsQ0FBQyxHQUFHLENBQ2pDO2dCQUNFLElBQUksRUFBRSxXQUFXO2dCQUNqQixLQUFLLEVBQUUscUJBQVcsQ0FBQyw0QkFBNEI7YUFDaEQsRUFDRCxHQUFHLEVBQUU7Z0JBQ0gsY0FBYztnQkFDZCxJQUFJLElBQUksQ0FBQyxPQUFPLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRTtvQkFDN0IsT0FBTztpQkFDUjtnQkFFRCw0RUFBNEU7Z0JBQzVFLElBQUksQ0FBQyxXQUFXLENBQUMsUUFBUSxDQUFDLGlCQUFpQixFQUFFO29CQUMzQyxPQUFPO2lCQUNSO2dCQUVELE1BQU0sYUFBYSxHQUFHLENBQUMsTUFBTSxFQUFFLE9BQU8sRUFBRSxPQUFPLEVBQUUsT0FBTyxDQUFDLENBQUM7Z0JBRTFELE1BQU0sZUFBZSxHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLE1BQU0sQ0FBQztxQkFDcEQsTUFBTSxDQUFDLENBQUMsSUFBSSxFQUFFLEVBQUUsQ0FBQyxhQUFhLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQztxQkFDNUQsR0FBRyxDQUFDLENBQUMsSUFBSSxFQUFFLEVBQUUsQ0FBQyxDQUFDO29CQUNkLElBQUksRUFBRSxXQUFXLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxDQUFDLElBQUksRUFBRTtvQkFDckMsS0FBSyxFQUFFLElBQUk7aUJBQ1osQ0FBQyxDQUFDLENBQUM7Z0JBRU4sTUFBTSxVQUFVLEdBQUcsSUFBSSxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FBQyxNQUFNLEVBQUUsRUFBRSxDQUFDLENBQUMsR0FBRyxJQUFBLHVDQUFtQixFQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQztnQkFDdEYsS0FBSyxNQUFNLEVBQUUsSUFBSSxFQUFFLEtBQUssRUFBRSxJQUFJLGVBQWUsRUFBRTtvQkFDN0MsS0FBSyxNQUFNLEVBQUUsUUFBUSxFQUFFLE9BQU8sRUFBRSxJQUFJLElBQUEsbUNBQWUsRUFDakQsVUFBVSxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsRUFBRSxFQUM3QixJQUFJLEVBQ0osS0FBSyxDQUNOLEVBQUU7d0JBQ0QsUUFBUSxRQUFRLEVBQUU7NEJBQ2hCLEtBQUsscUNBQWlCLENBQUMsT0FBTztnQ0FDNUIsSUFBQSxnQ0FBVSxFQUFDLFdBQVcsRUFBRSxPQUFPLENBQUMsQ0FBQztnQ0FDakMsTUFBTTs0QkFDUixLQUFLLHFDQUFpQixDQUFDLEtBQUs7Z0NBQzFCLElBQUEsOEJBQVEsRUFBQyxXQUFXLEVBQUUsT0FBTyxDQUFDLENBQUM7Z0NBQy9CLE1BQU07NEJBQ1I7Z0NBQ0UsV0FBVyxDQUFDLFFBQVEsQ0FBQyxDQUFDO3lCQUN6QjtxQkFDRjtpQkFDRjtZQUNILENBQUMsQ0FDRixDQUFDO1FBQ0osQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDO0NBQ0Y7QUF6REQsd0VBeURDO0FBRUQsU0FBUyxXQUFXLENBQUMsS0FBWTtJQUMvQixNQUFNLElBQUksS0FBSyxDQUNiLGdEQUFnRCxJQUFJLENBQUMsU0FBUyxDQUM1RCxLQUFLLEVBQ0wsSUFBSSxDQUFDLGNBQWMsRUFDbkIsQ0FBQyxDQUFDLGFBQWEsQ0FDaEIsRUFBRSxDQUNKLENBQUM7QUFDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmltcG9ydCAqIGFzIHBhdGggZnJvbSAncGF0aCc7XG5pbXBvcnQgeyBDb21waWxhdGlvbiwgQ29tcGlsZXIgfSBmcm9tICd3ZWJwYWNrJztcbmltcG9ydCB7IEJ1ZGdldCwgVHlwZSB9IGZyb20gJy4uLy4uLy4uL2J1aWxkZXJzL2Jyb3dzZXIvc2NoZW1hJztcbmltcG9ydCB7XG4gIFRocmVzaG9sZFNldmVyaXR5LFxuICBjYWxjdWxhdGVUaHJlc2hvbGRzLFxuICBjaGVja1RocmVzaG9sZHMsXG59IGZyb20gJy4uLy4uLy4uL3V0aWxzL2J1bmRsZS1jYWxjdWxhdG9yJztcbmltcG9ydCB7IGFkZEVycm9yLCBhZGRXYXJuaW5nIH0gZnJvbSAnLi4vLi4vLi4vdXRpbHMvd2VicGFjay1kaWFnbm9zdGljcyc7XG5cbmNvbnN0IFBMVUdJTl9OQU1FID0gJ0FueUNvbXBvbmVudFN0eWxlQnVkZ2V0Q2hlY2tlcic7XG5cbi8qKlxuICogQ2hlY2sgYnVkZ2V0IHNpemVzIGZvciBjb21wb25lbnQgc3R5bGVzIGJ5IGVtaXR0aW5nIGEgd2FybmluZyBvciBlcnJvciBpZiBhXG4gKiBidWRnZXQgaXMgZXhjZWVkZWQgYnkgYSBwYXJ0aWN1bGFyIGNvbXBvbmVudCdzIHN0eWxlcy5cbiAqL1xuZXhwb3J0IGNsYXNzIEFueUNvbXBvbmVudFN0eWxlQnVkZ2V0Q2hlY2tlciB7XG4gIHByaXZhdGUgcmVhZG9ubHkgYnVkZ2V0czogQnVkZ2V0W107XG5cbiAgY29uc3RydWN0b3IoYnVkZ2V0czogQnVkZ2V0W10pIHtcbiAgICB0aGlzLmJ1ZGdldHMgPSBidWRnZXRzLmZpbHRlcigoYnVkZ2V0KSA9PiBidWRnZXQudHlwZSA9PT0gVHlwZS5BbnlDb21wb25lbnRTdHlsZSk7XG4gIH1cblxuICBhcHBseShjb21waWxlcjogQ29tcGlsZXIpIHtcbiAgICBjb21waWxlci5ob29rcy5jb21waWxhdGlvbi50YXAoUExVR0lOX05BTUUsIChjb21waWxhdGlvbikgPT4ge1xuICAgICAgY29tcGlsYXRpb24uaG9va3MucHJvY2Vzc0Fzc2V0cy50YXAoXG4gICAgICAgIHtcbiAgICAgICAgICBuYW1lOiBQTFVHSU5fTkFNRSxcbiAgICAgICAgICBzdGFnZTogQ29tcGlsYXRpb24uUFJPQ0VTU19BU1NFVFNfU1RBR0VfQU5BTFlTRSxcbiAgICAgICAgfSxcbiAgICAgICAgKCkgPT4ge1xuICAgICAgICAgIC8vIE5vIGJ1ZGdldHMuXG4gICAgICAgICAgaWYgKHRoaXMuYnVkZ2V0cy5sZW5ndGggPT09IDApIHtcbiAgICAgICAgICAgIHJldHVybjtcbiAgICAgICAgICB9XG5cbiAgICAgICAgICAvLyBJbiBBT1QgY29tcGlsYXRpb25zIGNvbXBvbmVudCBzdHlsZXMgZ2V0IHByb2Nlc3NlZCBpbiBjaGlsZCBjb21waWxhdGlvbnMuXG4gICAgICAgICAgaWYgKCFjb21waWxhdGlvbi5jb21waWxlci5wYXJlbnRDb21waWxhdGlvbikge1xuICAgICAgICAgICAgcmV0dXJuO1xuICAgICAgICAgIH1cblxuICAgICAgICAgIGNvbnN0IGNzc0V4dGVuc2lvbnMgPSBbJy5jc3MnLCAnLnNjc3MnLCAnLmxlc3MnLCAnLnNhc3MnXTtcblxuICAgICAgICAgIGNvbnN0IGNvbXBvbmVudFN0eWxlcyA9IE9iamVjdC5rZXlzKGNvbXBpbGF0aW9uLmFzc2V0cylcbiAgICAgICAgICAgIC5maWx0ZXIoKG5hbWUpID0+IGNzc0V4dGVuc2lvbnMuaW5jbHVkZXMocGF0aC5leHRuYW1lKG5hbWUpKSlcbiAgICAgICAgICAgIC5tYXAoKG5hbWUpID0+ICh7XG4gICAgICAgICAgICAgIHNpemU6IGNvbXBpbGF0aW9uLmFzc2V0c1tuYW1lXS5zaXplKCksXG4gICAgICAgICAgICAgIGxhYmVsOiBuYW1lLFxuICAgICAgICAgICAgfSkpO1xuXG4gICAgICAgICAgY29uc3QgdGhyZXNob2xkcyA9IHRoaXMuYnVkZ2V0cy5mbGF0TWFwKChidWRnZXQpID0+IFsuLi5jYWxjdWxhdGVUaHJlc2hvbGRzKGJ1ZGdldCldKTtcbiAgICAgICAgICBmb3IgKGNvbnN0IHsgc2l6ZSwgbGFiZWwgfSBvZiBjb21wb25lbnRTdHlsZXMpIHtcbiAgICAgICAgICAgIGZvciAoY29uc3QgeyBzZXZlcml0eSwgbWVzc2FnZSB9IG9mIGNoZWNrVGhyZXNob2xkcyhcbiAgICAgICAgICAgICAgdGhyZXNob2xkc1tTeW1ib2wuaXRlcmF0b3JdKCksXG4gICAgICAgICAgICAgIHNpemUsXG4gICAgICAgICAgICAgIGxhYmVsLFxuICAgICAgICAgICAgKSkge1xuICAgICAgICAgICAgICBzd2l0Y2ggKHNldmVyaXR5KSB7XG4gICAgICAgICAgICAgICAgY2FzZSBUaHJlc2hvbGRTZXZlcml0eS5XYXJuaW5nOlxuICAgICAgICAgICAgICAgICAgYWRkV2FybmluZyhjb21waWxhdGlvbiwgbWVzc2FnZSk7XG4gICAgICAgICAgICAgICAgICBicmVhaztcbiAgICAgICAgICAgICAgICBjYXNlIFRocmVzaG9sZFNldmVyaXR5LkVycm9yOlxuICAgICAgICAgICAgICAgICAgYWRkRXJyb3IoY29tcGlsYXRpb24sIG1lc3NhZ2UpO1xuICAgICAgICAgICAgICAgICAgYnJlYWs7XG4gICAgICAgICAgICAgICAgZGVmYXVsdDpcbiAgICAgICAgICAgICAgICAgIGFzc2VydE5ldmVyKHNldmVyaXR5KTtcbiAgICAgICAgICAgICAgfVxuICAgICAgICAgICAgfVxuICAgICAgICAgIH1cbiAgICAgICAgfSxcbiAgICAgICk7XG4gICAgfSk7XG4gIH1cbn1cblxuZnVuY3Rpb24gYXNzZXJ0TmV2ZXIoaW5wdXQ6IG5ldmVyKTogbmV2ZXIge1xuICB0aHJvdyBuZXcgRXJyb3IoXG4gICAgYFVuZXhwZWN0ZWQgY2FsbCB0byBhc3NlcnROZXZlcigpIHdpdGggaW5wdXQ6ICR7SlNPTi5zdHJpbmdpZnkoXG4gICAgICBpbnB1dCxcbiAgICAgIG51bGwgLyogcmVwbGFjZXIgKi8sXG4gICAgICA0IC8qIHRhYlNpemUgKi8sXG4gICAgKX1gLFxuICApO1xufVxuIl19