source: frontend/node_modules/webpack/lib/ConcatenationScope.js

/*
        MIT License http://www.opensource.org/licenses/mit-license.php
        Author Tobias Koppers @sokra
*/

"use strict";

const {
        DEFAULT_EXPORT,
        NAMESPACE_OBJECT_EXPORT
} = require("./util/concatenate");

/** @typedef {import("./Chunk")} Chunk */
/** @typedef {import("./Module")} Module */
/** @typedef {import("./optimize/ConcatenatedModule").ConcatenatedModuleInfo} ConcatenatedModuleInfo */
/** @typedef {import("./optimize/ConcatenatedModule").ModuleInfo} ModuleInfo */
/** @typedef {import("./optimize/ConcatenatedModule").ExportName} Ids */

const MODULE_REFERENCE_REGEXP =
        /^__WEBPACK_MODULE_REFERENCE__(\d+)_([\da-f]+|ns)(_call)?(_directImport)?(_deferredImport)?(?:_asiSafe(\d))?__$/;

/**
 * Encodes how a concatenated module reference should be interpreted when it is
 * later reconstructed from its placeholder identifier.
 * @typedef {object} ModuleReferenceOptions
 * @property {Ids} ids the properties or exports selected from the referenced module
 * @property {boolean} call true, when this referenced export is called
 * @property {boolean} directImport true, when this referenced export is directly imported (not via property access)
 * @property {boolean} deferredImport true, when this referenced export is deferred
 * @property {boolean | undefined} asiSafe if the position is ASI safe or unknown
 */

/**
 * Tracks the symbols and cross-module references needed while rendering a
 * concatenated module.
 */
class ConcatenationScope {
        /**
         * Creates the mutable scope object used while rendering a concatenated
         * module and its cross-module references.
         * @param {ModuleInfo[] | Map<Module, ModuleInfo>} modulesMap all module info by module
         * @param {ConcatenatedModuleInfo} currentModule the current module info
         * @param {Set<string>} usedNames all used names
         */
        constructor(modulesMap, currentModule, usedNames) {
                this._currentModule = currentModule;
                if (Array.isArray(modulesMap)) {
                        /** @type {Map<Module, ConcatenatedModuleInfo>} */
                        const map = new Map();
                        for (const info of modulesMap) {
                                map.set(info.module, /** @type {ConcatenatedModuleInfo} */ (info));
                        }
                        modulesMap = map;
                }
                this.usedNames = usedNames;
                this._modulesMap = modulesMap;
        }

        /**
         * Checks whether a module participates in the current concatenation scope.
         * @param {Module} module the referenced module
         * @returns {boolean} true, when it's in the scope
         */
        isModuleInScope(module) {
                return this._modulesMap.has(module);
        }

        /**
         * Records the symbol that should be used when the current module exports a
         * named binding.
         * @param {string} exportName name of the export
         * @param {string} symbol identifier of the export in source code
         */
        registerExport(exportName, symbol) {
                if (!this._currentModule.exportMap) {
                        this._currentModule.exportMap = new Map();
                }
                if (!this._currentModule.exportMap.has(exportName)) {
                        this._currentModule.exportMap.set(exportName, symbol);
                }
        }

        /**
         * Records a raw expression that can be used to reference an export without
         * going through the normal symbol map.
         * @param {string} exportName name of the export
         * @param {string} expression expression to be used
         */
        registerRawExport(exportName, expression) {
                if (!this._currentModule.rawExportMap) {
                        this._currentModule.rawExportMap = new Map();
                }
                if (!this._currentModule.rawExportMap.has(exportName)) {
                        this._currentModule.rawExportMap.set(exportName, expression);
                }
        }

        /**
         * Returns the raw expression registered for an export, if one exists.
         * @param {string} exportName name of the export
         * @returns {string | undefined} the expression of the export
         */
        getRawExport(exportName) {
                if (!this._currentModule.rawExportMap) {
                        return undefined;
                }
                return this._currentModule.rawExportMap.get(exportName);
        }

        /**
         * Replaces the raw expression for an export only when that export already
         * has an entry in the raw export map.
         * @param {string} exportName name of the export
         * @param {string} expression expression to be used
         */
        setRawExportMap(exportName, expression) {
                if (!this._currentModule.rawExportMap) {
                        this._currentModule.rawExportMap = new Map();
                }
                if (this._currentModule.rawExportMap.has(exportName)) {
                        this._currentModule.rawExportMap.set(exportName, expression);
                }
        }

        /**
         * Records the symbol that should be used for the synthetic namespace export.
         * @param {string} symbol identifier of the export in source code
         */
        registerNamespaceExport(symbol) {
                this._currentModule.namespaceExportSymbol = symbol;
        }

        /**
         * Encodes a reference to another concatenated module as a placeholder
         * identifier that can be parsed later during code generation.
         * @param {Module} module the referenced module
         * @param {Partial<ModuleReferenceOptions>} options options
         * @returns {string} the reference as identifier
         */
        createModuleReference(
                module,
                {
                        ids = undefined,
                        call = false,
                        directImport = false,
                        deferredImport = false,
                        asiSafe = false
                }
        ) {
                const info = /** @type {ModuleInfo} */ (this._modulesMap.get(module));
                const callFlag = call ? "_call" : "";
                const directImportFlag = directImport ? "_directImport" : "";
                const deferredImportFlag = deferredImport ? "_deferredImport" : "";
                const asiSafeFlag = asiSafe
                        ? "_asiSafe1"
                        : asiSafe === false
                                ? "_asiSafe0"
                                : "";
                const exportData = ids
                        ? Buffer.from(JSON.stringify(ids), "utf8").toString("hex")
                        : "ns";
                // a "._" is appended to allow "delete ...", which would cause a SyntaxError in strict mode
                return `__WEBPACK_MODULE_REFERENCE__${info.index}_${exportData}${callFlag}${directImportFlag}${deferredImportFlag}${asiSafeFlag}__._`;
        }

        /**
         * Checks whether an identifier is one of webpack's encoded concatenation
         * module references.
         * @param {string} name the identifier
         * @returns {boolean} true, when it's an module reference
         */
        static isModuleReference(name) {
                return MODULE_REFERENCE_REGEXP.test(name);
        }

        /**
         * Parses an encoded module reference back into its module index and
         * reference flags.
         * @param {string} name the identifier
         * @returns {ModuleReferenceOptions & { index: number } | null} parsed options and index
         */
        static matchModuleReference(name) {
                const match = MODULE_REFERENCE_REGEXP.exec(name);
                if (!match) return null;
                const index = Number(match[1]);
                const asiSafe = match[6];
                return {
                        index,
                        ids:
                                match[2] === "ns"
                                        ? []
                                        : JSON.parse(Buffer.from(match[2], "hex").toString("utf8")),
                        call: Boolean(match[3]),
                        directImport: Boolean(match[4]),
                        deferredImport: Boolean(match[5]),
                        asiSafe: asiSafe ? asiSafe === "1" : undefined
                };
        }
}

ConcatenationScope.DEFAULT_EXPORT = DEFAULT_EXPORT;
ConcatenationScope.NAMESPACE_OBJECT_EXPORT = NAMESPACE_OBJECT_EXPORT;

module.exports = ConcatenationScope;