@angular/build 18.0.0-next.3

package/src/utils/check-port.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export declare function checkPort(port: number, host: string): Promise<number>;

package/src/utils/check-port.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkPort = void 0;
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_net_1 = require("node:net");
+const load_esm_1 = require("./load-esm");
+const tty_1 = require("./tty");
+function createInUseError(port) {
+    return new Error(`Port ${port} is already in use. Use '--port' to specify a different port.`);
+}
+async function checkPort(port, host) {
+    // Disabled due to Vite not handling port 0 and instead always using the default value (5173)
+    // TODO: Enable this again once Vite is fixed
+    // if (port === 0) {
+    //   return 0;
+    // }
+    return new Promise((resolve, reject) => {
+        const server = (0, node_net_1.createServer)();
+        server
+            .once('error', (err) => {
+            if (err.code !== 'EADDRINUSE') {
+                reject(err);
+                return;
+            }
+            if (!tty_1.isTTY) {
+                reject(createInUseError(port));
+                return;
+            }
+            (0, load_esm_1.loadEsmModule)('inquirer')
+                .then(({ default: { prompt } }) => prompt({
+                type: 'confirm',
+                name: 'useDifferent',
+                message: `Port ${port} is already in use.\nWould you like to use a different port?`,
+                default: true,
+            }))
+                .then((answers) => answers.useDifferent ? resolve(checkPort(0, host)) : reject(createInUseError(port)), () => reject(createInUseError(port)));
+        })
+            .once('listening', () => {
+            // Get the actual address from the listening server instance
+            const address = server.address();
+            (0, node_assert_1.default)(address && typeof address !== 'string', 'Port check server address should always be an object.');
+            server.close();
+            resolve(address.port);
+        })
+            .listen(port, host);
+    });
+}
+exports.checkPort = checkPort;

package/src/utils/color.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import * as ansiColors from 'ansi-colors';
+declare const colors: typeof ansiColors;
+export { colors };

package/src/utils/color.js

@@ -0,0 +1,63 @@
+"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.colors = void 0;
+const ansiColors = __importStar(require("ansi-colors"));
+const node_tty_1 = require("node:tty");
+function supportColor() {
+    if (process.env.FORCE_COLOR !== undefined) {
+        // 2 colors: FORCE_COLOR = 0 (Disables colors), depth 1
+        // 16 colors: FORCE_COLOR = 1, depth 4
+        // 256 colors: FORCE_COLOR = 2, depth 8
+        // 16,777,216 colors: FORCE_COLOR = 3, depth 16
+        // See: https://nodejs.org/dist/latest-v12.x/docs/api/tty.html#tty_writestream_getcolordepth_env
+        // and https://github.com/nodejs/node/blob/b9f36062d7b5c5039498e98d2f2c180dca2a7065/lib/internal/tty.js#L106;
+        switch (process.env.FORCE_COLOR) {
+            case '':
+            case 'true':
+            case '1':
+            case '2':
+            case '3':
+                return true;
+            default:
+                return false;
+        }
+    }
+    if (process.stdout instanceof node_tty_1.WriteStream) {
+        return process.stdout.hasColors();
+    }
+    return false;
+}
+// Create a separate instance to prevent unintended global changes to the color configuration
+const colors = ansiColors.create();
+exports.colors = colors;
+colors.enabled = supportColor();

package/src/utils/delete-output-dir.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @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
+ */
+/**
+ * Delete an output directory, but error out if it's the root of the project.
+ */
+export declare function deleteOutputDir(root: string, outputPath: string, emptyOnlyDirectories?: string[]): Promise<void>;

package/src/utils/delete-output-dir.js

@@ -0,0 +1,46 @@
+"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.deleteOutputDir = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+/**
+ * Delete an output directory, but error out if it's the root of the project.
+ */
+async function deleteOutputDir(root, outputPath, emptyOnlyDirectories) {
+    const resolvedOutputPath = (0, node_path_1.resolve)(root, outputPath);
+    if (resolvedOutputPath === root) {
+        throw new Error('Output path MUST not be project root directory!');
+    }
+    const directoriesToEmpty = emptyOnlyDirectories
+        ? new Set(emptyOnlyDirectories.map((directory) => (0, node_path_1.join)(resolvedOutputPath, directory)))
+        : undefined;
+    // Avoid removing the actual directory to avoid errors in cases where the output
+    // directory is mounted or symlinked. Instead the contents are removed.
+    let entries;
+    try {
+        entries = await (0, promises_1.readdir)(resolvedOutputPath);
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+            return;
+        }
+        throw error;
+    }
+    for (const entry of entries) {
+        const fullEntry = (0, node_path_1.join)(resolvedOutputPath, entry);
+        // Leave requested directories. This allows symlinks to continue to function.
+        if (directoriesToEmpty?.has(fullEntry)) {
+            await deleteOutputDir(resolvedOutputPath, fullEntry);
+            continue;
+        }
+        await (0, promises_1.rm)(fullEntry, { force: true, recursive: true, maxRetries: 3 });
+    }
+}
+exports.deleteOutputDir = deleteOutputDir;

package/src/utils/environment-options.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export declare const allowMangle: boolean;
+export declare const shouldBeautify: boolean;
+export declare const allowMinify: boolean;
+export declare const maxWorkers: number;
+export declare const useParallelTs: boolean;
+export declare const debugPerformance: boolean;
+export declare const shouldWatchRoot: boolean;
+export declare const useTypeChecking: boolean;
+export declare const useJSONBuildLogs: boolean;

package/src/utils/environment-options.js

@@ -0,0 +1,79 @@
+"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.useJSONBuildLogs = exports.useTypeChecking = exports.shouldWatchRoot = exports.debugPerformance = exports.useParallelTs = exports.maxWorkers = exports.allowMinify = exports.shouldBeautify = exports.allowMangle = void 0;
+function isDisabled(variable) {
+    return variable === '0' || variable.toLowerCase() === 'false';
+}
+function isEnabled(variable) {
+    return variable === '1' || variable.toLowerCase() === 'true';
+}
+function isPresent(variable) {
+    return typeof variable === 'string' && variable !== '';
+}
+// Optimization and mangling
+const debugOptimizeVariable = process.env['NG_BUILD_DEBUG_OPTIMIZE'];
+const debugOptimize = (() => {
+    if (!isPresent(debugOptimizeVariable) || isDisabled(debugOptimizeVariable)) {
+        return {
+            mangle: true,
+            minify: true,
+            beautify: false,
+        };
+    }
+    const debugValue = {
+        mangle: false,
+        minify: false,
+        beautify: true,
+    };
+    if (isEnabled(debugOptimizeVariable)) {
+        return debugValue;
+    }
+    for (const part of debugOptimizeVariable.split(',')) {
+        switch (part.trim().toLowerCase()) {
+            case 'mangle':
+                debugValue.mangle = true;
+                break;
+            case 'minify':
+                debugValue.minify = true;
+                break;
+            case 'beautify':
+                debugValue.beautify = true;
+                break;
+        }
+    }
+    return debugValue;
+})();
+const mangleVariable = process.env['NG_BUILD_MANGLE'];
+exports.allowMangle = isPresent(mangleVariable)
+    ? !isDisabled(mangleVariable)
+    : debugOptimize.mangle;
+exports.shouldBeautify = debugOptimize.beautify;
+exports.allowMinify = debugOptimize.minify;
+/**
+ * Some environments, like CircleCI which use Docker report a number of CPUs by the host and not the count of available.
+ * This cause `Error: Call retries were exceeded` errors when trying to use them.
+ *
+ * @see https://github.com/nodejs/node/issues/28762
+ * @see https://github.com/webpack-contrib/terser-webpack-plugin/issues/143
+ * @see https://ithub.com/angular/angular-cli/issues/16860#issuecomment-588828079
+ *
+ */
+const maxWorkersVariable = process.env['NG_BUILD_MAX_WORKERS'];
+exports.maxWorkers = isPresent(maxWorkersVariable) ? +maxWorkersVariable : 4;
+const parallelTsVariable = process.env['NG_BUILD_PARALLEL_TS'];
+exports.useParallelTs = !isPresent(parallelTsVariable) || !isDisabled(parallelTsVariable);
+const debugPerfVariable = process.env['NG_BUILD_DEBUG_PERF'];
+exports.debugPerformance = isPresent(debugPerfVariable) && isEnabled(debugPerfVariable);
+const watchRootVariable = process.env['NG_BUILD_WATCH_ROOT'];
+exports.shouldWatchRoot = isPresent(watchRootVariable) && isEnabled(watchRootVariable);
+const typeCheckingVariable = process.env['NG_BUILD_TYPE_CHECK'];
+exports.useTypeChecking = !isPresent(typeCheckingVariable) || !isDisabled(typeCheckingVariable);
+const buildLogsJsonVariable = process.env['NG_BUILD_LOGS_JSON'];
+exports.useJSONBuildLogs = isPresent(buildLogsJsonVariable) && isEnabled(buildLogsJsonVariable);

package/src/utils/error.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export declare function assertIsError(value: unknown): asserts value is Error & {
+    code?: string;
+};

package/src/utils/error.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertIsError = void 0;
+const assert_1 = __importDefault(require("assert"));
+function assertIsError(value) {
+    const isError = value instanceof Error ||
+        // The following is needing to identify errors coming from RxJs.
+        (typeof value === 'object' && value && 'name' in value && 'message' in value);
+    (0, assert_1.default)(isError, 'catch clause variable is not an Error instance');
+}
+exports.assertIsError = assertIsError;

package/src/utils/format-bytes.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export declare function formatSize(size: number): string;

package/src/utils/format-bytes.js

@@ -0,0 +1,22 @@
+"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.formatSize = void 0;
+function formatSize(size) {
+    if (size <= 0) {
+        return '0 bytes';
+    }
+    const abbreviations = ['bytes', 'kB', 'MB', 'GB'];
+    const index = Math.floor(Math.log(size) / Math.log(1024));
+    const roundedSize = size / Math.pow(1024, index);
+    // bytes don't have a fraction
+    const fractionDigits = index === 0 ? 0 : 2;
+    return `${roundedSize.toFixed(fractionDigits)} ${abbreviations[index]}`;
+}
+exports.formatSize = formatSize;

package/src/utils/i18n-options.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import type { TranslationLoader } from './load-translations';
+export interface LocaleDescription {
+    files: {
+        path: string;
+        integrity?: string;
+        format?: string;
+    }[];
+    translation?: Record<string, unknown>;
+    dataPath?: string;
+    baseHref?: string;
+}
+export interface I18nOptions {
+    inlineLocales: Set<string>;
+    sourceLocale: string;
+    locales: Record<string, LocaleDescription>;
+    flatOutput?: boolean;
+    readonly shouldInline: boolean;
+    hasDefinedSourceLocale?: boolean;
+}
+export declare function createI18nOptions(projectMetadata: {
+    i18n?: unknown;
+}, inline?: boolean | string[]): I18nOptions;
+export declare function loadTranslations(locale: string, desc: LocaleDescription, workspaceRoot: string, loader: TranslationLoader, logger: {
+    warn: (message: string) => void;
+    error: (message: string) => void;
+}, usedFormats?: Set<string>, duplicateTranslation?: 'ignore' | 'error' | 'warning'): void;

package/src/utils/i18n-options.js

@@ -0,0 +1,161 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTranslations = exports.createI18nOptions = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+function normalizeTranslationFileOption(option, locale, expectObjectInError) {
+    if (typeof option === 'string') {
+        return [option];
+    }
+    if (Array.isArray(option) && option.every((element) => typeof element === 'string')) {
+        return option;
+    }
+    let errorMessage = `Project i18n locales translation field value for '${locale}' is malformed. `;
+    if (expectObjectInError) {
+        errorMessage += 'Expected a string, array of strings, or object.';
+    }
+    else {
+        errorMessage += 'Expected a string or array of strings.';
+    }
+    throw new Error(errorMessage);
+}
+function ensureObject(value, name) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`Project ${name} field is malformed. Expected an object.`);
+    }
+}
+function ensureString(value, name) {
+    if (typeof value !== 'string') {
+        throw new Error(`Project ${name} field is malformed. Expected a string.`);
+    }
+}
+function createI18nOptions(projectMetadata, inline) {
+    const { i18n: metadata = {} } = projectMetadata;
+    ensureObject(metadata, 'i18n');
+    const i18n = {
+        inlineLocales: new Set(),
+        // en-US is the default locale added to Angular applications (https://angular.io/guide/i18n#i18n-pipes)
+        sourceLocale: 'en-US',
+        locales: {},
+        get shouldInline() {
+            return this.inlineLocales.size > 0;
+        },
+    };
+    let rawSourceLocale;
+    let rawSourceLocaleBaseHref;
+    if (typeof metadata.sourceLocale === 'string') {
+        rawSourceLocale = metadata.sourceLocale;
+    }
+    else if (metadata.sourceLocale !== undefined) {
+        ensureObject(metadata.sourceLocale, 'i18n sourceLocale');
+        if (metadata.sourceLocale.code !== undefined) {
+            ensureString(metadata.sourceLocale.code, 'i18n sourceLocale code');
+            rawSourceLocale = metadata.sourceLocale.code;
+        }
+        if (metadata.sourceLocale.baseHref !== undefined) {
+            ensureString(metadata.sourceLocale.baseHref, 'i18n sourceLocale baseHref');
+            rawSourceLocaleBaseHref = metadata.sourceLocale.baseHref;
+        }
+    }
+    if (rawSourceLocale !== undefined) {
+        i18n.sourceLocale = rawSourceLocale;
+        i18n.hasDefinedSourceLocale = true;
+    }
+    i18n.locales[i18n.sourceLocale] = {
+        files: [],
+        baseHref: rawSourceLocaleBaseHref,
+    };
+    if (metadata.locales !== undefined) {
+        ensureObject(metadata.locales, 'i18n locales');
+        for (const [locale, options] of Object.entries(metadata.locales)) {
+            let translationFiles;
+            let baseHref;
+            if (options && typeof options === 'object' && 'translation' in options) {
+                translationFiles = normalizeTranslationFileOption(options.translation, locale, false);
+                if ('baseHref' in options) {
+                    ensureString(options.baseHref, `i18n locales ${locale} baseHref`);
+                    baseHref = options.baseHref;
+                }
+            }
+            else {
+                translationFiles = normalizeTranslationFileOption(options, locale, true);
+            }
+            if (locale === i18n.sourceLocale) {
+                throw new Error(`An i18n locale ('${locale}') cannot both be a source locale and provide a translation.`);
+            }
+            i18n.locales[locale] = {
+                files: translationFiles.map((file) => ({ path: file })),
+                baseHref,
+            };
+        }
+    }
+    if (inline === true) {
+        i18n.inlineLocales.add(i18n.sourceLocale);
+        Object.keys(i18n.locales).forEach((locale) => i18n.inlineLocales.add(locale));
+    }
+    else if (inline) {
+        for (const locale of inline) {
+            if (!i18n.locales[locale] && i18n.sourceLocale !== locale) {
+                throw new Error(`Requested locale '${locale}' is not defined for the project.`);
+            }
+            i18n.inlineLocales.add(locale);
+        }
+    }
+    return i18n;
+}
+exports.createI18nOptions = createI18nOptions;
+function loadTranslations(locale, desc, workspaceRoot, loader, logger, usedFormats, duplicateTranslation) {
+    let translations = undefined;
+    for (const file of desc.files) {
+        const loadResult = loader(node_path_1.default.join(workspaceRoot, file.path));
+        for (const diagnostics of loadResult.diagnostics.messages) {
+            if (diagnostics.type === 'error') {
+                logger.error(`Error parsing translation file '${file.path}': ${diagnostics.message}`);
+            }
+            else {
+                logger.warn(`WARNING [${file.path}]: ${diagnostics.message}`);
+            }
+        }
+        if (loadResult.locale !== undefined && loadResult.locale !== locale) {
+            logger.warn(`WARNING [${file.path}]: File target locale ('${loadResult.locale}') does not match configured locale ('${locale}')`);
+        }
+        usedFormats?.add(loadResult.format);
+        file.format = loadResult.format;
+        file.integrity = loadResult.integrity;
+        if (translations) {
+            // Merge translations
+            for (const [id, message] of Object.entries(loadResult.translations)) {
+                if (translations[id] !== undefined) {
+                    const duplicateTranslationMessage = `[${file.path}]: Duplicate translations for message '${id}' when merging.`;
+                    switch (duplicateTranslation) {
+                        case 'ignore':
+                            break;
+                        case 'error':
+                            logger.error(`ERROR ${duplicateTranslationMessage}`);
+                            break;
+                        case 'warning':
+                        default:
+                            logger.warn(`WARNING ${duplicateTranslationMessage}`);
+                            break;
+                    }
+                }
+                translations[id] = message;
+            }
+        }
+        else {
+            // First or only translation file
+            translations = loadResult.translations;
+        }
+    }
+    desc.translation = translations;
+}
+exports.loadTranslations = loadTranslations;

package/src/utils/index-file/add-event-dispatch-contract.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export declare function addEventDispatchContract(html: string): Promise<string>;

package/src/utils/index-file/add-event-dispatch-contract.js

@@ -0,0 +1,28 @@
+"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.addEventDispatchContract = void 0;
+const promises_1 = require("node:fs/promises");
+const html_rewriting_stream_1 = require("./html-rewriting-stream");
+let jsActionContractScript;
+async function addEventDispatchContract(html) {
+    const { rewriter, transformedContent } = await (0, html_rewriting_stream_1.htmlRewritingStream)(html);
+    jsActionContractScript ??=
+        '<script type="text/javascript" id="ng-event-dispatch-contract">' +
+            (await (0, promises_1.readFile)(require.resolve('@angular/core/event-dispatch-contract.min.js'), 'utf-8')) +
+            '</script>';
+    rewriter.on('startTag', (tag) => {
+        rewriter.emitStartTag(tag);
+        if (tag.tagName === 'body') {
+            rewriter.emitRaw(jsActionContractScript);
+        }
+    });
+    return transformedContent();
+}
+exports.addEventDispatchContract = addEventDispatchContract;

package/src/utils/index-file/augment-index-html.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export type LoadOutputFileFunctionType = (file: string) => Promise<string>;
+export type CrossOriginValue = 'none' | 'anonymous' | 'use-credentials';
+export type Entrypoint = [name: string, isModule: boolean];
+export interface AugmentIndexHtmlOptions {
+    html: string;
+    baseHref?: string;
+    deployUrl?: string;
+    sri: boolean;
+    /** crossorigin attribute setting of elements that provide CORS support */
+    crossOrigin?: CrossOriginValue;
+    files: FileInfo[];
+    loadOutputFile: LoadOutputFileFunctionType;
+    /** Used to sort the inseration of files in the HTML file */
+    entrypoints: Entrypoint[];
+    /** Used to set the document default locale */
+    lang?: string;
+    hints?: {
+        url: string;
+        mode: string;
+        as?: string;
+    }[];
+    imageDomains?: string[];
+}
+export interface FileInfo {
+    file: string;
+    name?: string;
+    extension: string;
+}
+export declare function augmentIndexHtml(params: AugmentIndexHtmlOptions): Promise<{
+    content: string;
+    warnings: string[];
+    errors: string[];
+}>;