xhs-mp-pack 1.1.0-beta.0

package/dist/module/javascript/JavascriptParserHelpers.d.ts

@@ -0,0 +1,10 @@
+import BasicEvaluatedExpression from './BasicEvaluatedExpression';
+declare const toConstantDependency: (parser: any, value: string, runtimeRequirements?: string[]) => (expr: any) => boolean;
+declare const evaluateToString: (value: string) => (expr: any) => BasicEvaluatedExpression;
+declare const evaluateToNumber: (value: number) => (expr: any) => BasicEvaluatedExpression;
+declare const evaluateToBoolean: (value: boolean) => (expr: any) => BasicEvaluatedExpression;
+declare const evaluateToIdentifier: (identifier: string, rootInfo: string, getMembers: any, truthy?: boolean | null) => (expr: any) => BasicEvaluatedExpression;
+declare const expressionIsUnsupported: (parser: any, message: any) => (expr: any) => true | undefined;
+declare const skipTraversal: () => boolean;
+declare const approve: () => boolean;
+export { toConstantDependency, evaluateToString, evaluateToNumber, evaluateToBoolean, evaluateToIdentifier, expressionIsUnsupported, skipTraversal, approve, };

package/dist/module/javascript/JavascriptParserHelpers.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.approve = exports.skipTraversal = exports.expressionIsUnsupported = exports.evaluateToIdentifier = exports.evaluateToBoolean = exports.evaluateToNumber = exports.evaluateToString = exports.toConstantDependency = void 0;
+const UnsupportedFeatureWarning_1 = __importDefault(require("@/base/errors/UnsupportedFeatureWarning"));
+const ConstDependency_1 = __importDefault(require("@/dependencies/const/ConstDependency"));
+const BasicEvaluatedExpression_1 = __importDefault(require("./BasicEvaluatedExpression"));
+const toConstantDependency = (parser, value, runtimeRequirements) => function constDependency(expr) {
+    const dep = new ConstDependency_1.default(value, expr.range, runtimeRequirements);
+    dep.loc = expr.loc;
+    parser.state.module.addPresentationalDependency(dep);
+    return true;
+};
+exports.toConstantDependency = toConstantDependency;
+const evaluateToString = (value) => function stringExpression(expr) {
+    return new BasicEvaluatedExpression_1.default().setString(value).setRange(expr.range);
+};
+exports.evaluateToString = evaluateToString;
+const evaluateToNumber = (value) => function stringExpression(expr) {
+    return new BasicEvaluatedExpression_1.default().setNumber(value).setRange(expr.range);
+};
+exports.evaluateToNumber = evaluateToNumber;
+const evaluateToBoolean = (value) => function booleanExpression(expr) {
+    return new BasicEvaluatedExpression_1.default().setBoolean(value).setRange(expr.range);
+};
+exports.evaluateToBoolean = evaluateToBoolean;
+const evaluateToIdentifier = (identifier, rootInfo, getMembers, truthy) => function identifierExpression(expr) {
+    const evaluatedExpression = new BasicEvaluatedExpression_1.default()
+        .setIdentifier(identifier, rootInfo, getMembers)
+        .setSideEffects(false)
+        .setRange(expr.range);
+    switch (truthy) {
+        case true:
+            evaluatedExpression.setTruthy();
+            break;
+        case null:
+            evaluatedExpression.setNullish(true);
+            break;
+        case false:
+            evaluatedExpression.setFalsy();
+            break;
+    }
+    return evaluatedExpression;
+};
+exports.evaluateToIdentifier = evaluateToIdentifier;
+const expressionIsUnsupported = (parser, message) => function unsupportedExpression(expr) {
+    const dep = new ConstDependency_1.default('(void 0)', expr.range, null);
+    dep.loc = expr.loc;
+    parser.state.module.addPresentationalDependency(dep);
+    if (!parser.state.module)
+        return;
+    parser.state.module.addWarning(new UnsupportedFeatureWarning_1.default(message, expr.loc));
+    return true;
+};
+exports.expressionIsUnsupported = expressionIsUnsupported;
+const skipTraversal = () => true;
+exports.skipTraversal = skipTraversal;
+const approve = () => true;
+exports.approve = approve;

package/dist/module/json/JsonData.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+declare class JsonData {
+    _buffer: Buffer | string | undefined;
+    _data: any;
+    constructor(data: any);
+    get(): any;
+    updateHash(hash: any): void;
+}
+export default JsonData;

package/dist/module/json/JsonData.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Serialization_1 = __importDefault(require("@/serialization/Serialization"));
+class JsonData {
+    constructor(data) {
+        this._buffer = undefined;
+        this._data = undefined;
+        if (Buffer.isBuffer(data)) {
+            this._buffer = data;
+        }
+        else {
+            this._data = data;
+        }
+    }
+    get() {
+        if (this._data === undefined && this._buffer !== undefined) {
+            this._data = JSON.parse(this._buffer.toString());
+        }
+        return this._data;
+    }
+    updateHash(hash) {
+        if (this._buffer === undefined && this._data !== undefined) {
+            this._buffer = Buffer.from(JSON.stringify(this._data));
+        }
+        if (this._buffer)
+            hash.update(this._buffer);
+    }
+}
+Serialization_1.default.register(JsonData, 'mp-compiler/core/module/json/JsonData', null, {
+    serialize(obj, { write }) {
+        if (obj._buffer === undefined && obj._data !== undefined) {
+            obj._buffer = Buffer.from(JSON.stringify(obj._data));
+        }
+        write(obj._buffer);
+    },
+    deserialize({ read }) {
+        return new JsonData(read());
+    },
+});
+exports.default = JsonData;

package/dist/module/json/JsonGenerator.d.ts

@@ -0,0 +1,15 @@
+import { RawSource } from 'webpack-sources';
+import Generator from '../Generator';
+declare class JsonGenerator extends Generator {
+    getTypes(module: any): Set<string>;
+    getSize(module: any, type?: any): number;
+    getConcatenationBailoutReason(module: any, context: any): undefined;
+    generate(module: any, { moduleGraph, runtimeTemplate, runtimeRequirements, runtime, concatenationScope }: {
+        moduleGraph: any;
+        runtimeTemplate: any;
+        runtimeRequirements: any;
+        runtime: any;
+        concatenationScope: any;
+    }): RawSource;
+}
+export default JsonGenerator;

package/dist/module/json/JsonGenerator.js

@@ -0,0 +1,137 @@
+"use strict";
+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 webpack_sources_1 = require("webpack-sources");
+const ConcatenationScope_1 = __importDefault(require("@/ConcatenationScope"));
+const ExportsInfo_1 = require("@/module/ExportsInfo");
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const Generator_1 = __importDefault(require("../Generator"));
+const stringifySafe = data => {
+    const stringified = JSON.stringify(data);
+    if (!stringified) {
+        return undefined; // Invalid JSON
+    }
+    return stringified.replace(/\u2028|\u2029/g, str => (str === '\u2029' ? '\\u2029' : '\\u2028')); // invalid in JavaScript but valid JSON
+};
+const createObjectForExportsInfo = (data, exportsInfo, runtime) => {
+    if (exportsInfo.otherExportsInfo.getUsed(runtime) !== ExportsInfo_1.UsageState.Unused)
+        return data;
+    const isArray = Array.isArray(data);
+    const reducedData = isArray ? [] : {};
+    for (const key of Object.keys(data)) {
+        const exportInfo = exportsInfo.getReadOnlyExportInfo(key);
+        const used = exportInfo.getUsed(runtime);
+        if (used === ExportsInfo_1.UsageState.Unused)
+            continue;
+        let value;
+        if (used === ExportsInfo_1.UsageState.OnlyPropertiesUsed && exportInfo.exportsInfo) {
+            value = createObjectForExportsInfo(data[key], exportInfo.exportsInfo, runtime);
+        }
+        else {
+            value = data[key];
+        }
+        const name = exportInfo.getUsedName(key, runtime);
+        reducedData[name] = value;
+    }
+    if (isArray) {
+        const arrayLengthWhenUsed = exportsInfo.getReadOnlyExportInfo('length').getUsed(runtime) !== ExportsInfo_1.UsageState.Unused
+            ? data.length
+            : undefined;
+        let sizeObjectMinusArray = 0;
+        for (let i = 0; i < reducedData.length; i++) {
+            if (reducedData[i] === undefined) {
+                sizeObjectMinusArray -= 2;
+            }
+            else {
+                sizeObjectMinusArray += `${i}`.length + 3;
+            }
+        }
+        if (arrayLengthWhenUsed !== undefined) {
+            sizeObjectMinusArray +=
+                `${arrayLengthWhenUsed}`.length + 8 - (arrayLengthWhenUsed - reducedData.length) * 2;
+        }
+        if (sizeObjectMinusArray < 0)
+            return Object.assign(arrayLengthWhenUsed === undefined ? {} : { length: arrayLengthWhenUsed }, reducedData);
+        const generatedLength = arrayLengthWhenUsed !== undefined
+            ? Math.max(arrayLengthWhenUsed, reducedData.length)
+            : reducedData.length;
+        for (let i = 0; i < generatedLength; i++) {
+            if (reducedData[i] === undefined) {
+                reducedData[i] = 0;
+            }
+        }
+    }
+    return reducedData;
+};
+const TYPES = new Set(['javascript']);
+class JsonGenerator extends Generator_1.default {
+    getTypes(module) {
+        return TYPES;
+    }
+    getSize(module, type) {
+        var _a, _b;
+        const data = (_b = (_a = module.buildInfo) === null || _a === void 0 ? void 0 : _a.jsonData) === null || _b === void 0 ? void 0 : _b.get();
+        if (!data)
+            return 0;
+        return stringifySafe(data).length + 10;
+    }
+    getConcatenationBailoutReason(module, context) {
+        return undefined;
+    }
+    generate(module, { moduleGraph, runtimeTemplate, runtimeRequirements, runtime, concatenationScope }) {
+        var _a, _b;
+        const data = (_b = (_a = module.buildInfo) === null || _a === void 0 ? void 0 : _a.jsonData) === null || _b === void 0 ? void 0 : _b.get();
+        if (data === undefined) {
+            return new webpack_sources_1.RawSource(runtimeTemplate.missingModuleStatement({
+                request: module.rawRequest,
+            }));
+        }
+        const exportsInfo = moduleGraph.getExportsInfo(module);
+        const finalJson = typeof data === 'object' &&
+            data &&
+            exportsInfo.otherExportsInfo.getUsed(runtime) === ExportsInfo_1.UsageState.Unused
+            ? createObjectForExportsInfo(data, exportsInfo, runtime)
+            : data;
+        // Use JSON because JSON.parse() is much faster than JavaScript evaluation
+        const jsonStr = stringifySafe(finalJson);
+        const jsonExpr = jsonStr.length > 20 && typeof finalJson === 'object'
+            ? `JSON.parse('${jsonStr.replace(/[\\']/g, '\\$&')}')`
+            : jsonStr;
+        let content;
+        if (concatenationScope) {
+            content = `${runtimeTemplate.supportsConst() ? 'const' : 'var'} ${ConcatenationScope_1.default.NAMESPACE_OBJECT_EXPORT} = ${jsonExpr};`;
+            concatenationScope.registerNamespaceExport(ConcatenationScope_1.default.NAMESPACE_OBJECT_EXPORT);
+        }
+        else {
+            runtimeRequirements.add(RuntimeGlobals.module);
+            content = `${module.moduleArgument}.exports = ${jsonExpr};`;
+        }
+        return new webpack_sources_1.RawSource(content);
+    }
+}
+exports.default = JsonGenerator;

package/dist/module/json/JsonModulesPlugin.d.ts

@@ -0,0 +1,4 @@
+declare class JsonModulesPlugin {
+    apply(compiler: any): void;
+}
+export default JsonModulesPlugin;

package/dist/module/json/JsonModulesPlugin.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ModuleTypeConstants_1 = require("@/module/ModuleTypeConstants");
+const JsonGenerator_1 = __importDefault(require("./JsonGenerator"));
+const JsonParser_1 = __importDefault(require("./JsonParser"));
+const PLUGIN_NAME = 'JsonModulesPlugin';
+class JsonModulesPlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation, { normalModuleFactory }) => {
+            normalModuleFactory.hooks.createParser
+                .for(ModuleTypeConstants_1.JSON_MODULE_TYPE)
+                .tap(PLUGIN_NAME, parserOptions => new JsonParser_1.default(parserOptions));
+            normalModuleFactory.hooks.createGenerator.for(ModuleTypeConstants_1.JSON_MODULE_TYPE).tap(PLUGIN_NAME, () => new JsonGenerator_1.default());
+        });
+    }
+}
+exports.default = JsonModulesPlugin;

package/dist/module/json/JsonParser.d.ts

@@ -0,0 +1,7 @@
+import Parser from '../Parser';
+declare class JsonParser extends Parser {
+    options: any;
+    constructor(options: any);
+    parse(source: any, state: any): any;
+}
+export default JsonParser;

package/dist/module/json/JsonParser.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const JsonExportsDependency_1 = __importDefault(require("@/dependencies/json/JsonExportsDependency"));
+const Parser_1 = __importDefault(require("../Parser"));
+const JsonData_1 = __importDefault(require("./JsonData"));
+const parseJson = require('json-parse-even-better-errors');
+class JsonParser extends Parser_1.default {
+    constructor(options) {
+        super();
+        this.options = options || {};
+    }
+    parse(source, state) {
+        if (Buffer.isBuffer(source)) {
+            source = source.toString('utf-8');
+        }
+        const parseFn = typeof this.options.parse === 'function' ? this.options.parse : parseJson;
+        let data;
+        try {
+            data =
+                typeof source === 'object'
+                    ? source
+                    : parseFn(source[0] === '\ufeff' ? source.slice(1) : source);
+        }
+        catch (e) {
+            throw new Error(`Cannot parse JSON: ${e.message}`);
+        }
+        const jsonData = new JsonData_1.default(data);
+        const buildInfo = state.module.buildInfo;
+        buildInfo.jsonData = jsonData;
+        buildInfo.strict = true;
+        const buildMeta = state.module.buildMeta;
+        buildMeta.exportsType = 'default';
+        buildMeta.defaultObject = typeof data === 'object' ? 'redirect-warn' : false;
+        state.module.addDependency(new JsonExportsDependency_1.default(jsonData));
+        return state;
+    }
+}
+exports.default = JsonParser;

package/dist/module/runtime/AsyncModuleRuntimeModule.d.ts

@@ -0,0 +1,6 @@
+import HelperRuntimeModule from './HelperRuntimeModule';
+declare class AsyncModuleRuntimeModule extends HelperRuntimeModule {
+    constructor();
+    generate(): string;
+}
+export default AsyncModuleRuntimeModule;

package/dist/module/runtime/AsyncModuleRuntimeModule.js

@@ -0,0 +1,115 @@
+"use strict";
+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 RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const Template_1 = require("@/template/Template");
+const HelperRuntimeModule_1 = __importDefault(require("./HelperRuntimeModule"));
+class AsyncModuleRuntimeModule extends HelperRuntimeModule_1.default {
+    constructor() {
+        super('async module');
+    }
+    generate() {
+        const compilation = this.compilation;
+        const { runtimeTemplate } = compilation;
+        const fn = RuntimeGlobals.asyncModule;
+        return Template_1.Template.asString([
+            'var webpackQueues = typeof Symbol === "function" ? Symbol("webpack queues") : "__webpack_queues__";',
+            `var webpackExports = typeof Symbol === "function" ? Symbol("webpack exports") : "${RuntimeGlobals.exports}";`,
+            'var webpackError = typeof Symbol === "function" ? Symbol("webpack error") : "__webpack_error__";',
+            `var resolveQueue = ${runtimeTemplate.basicFunction('queue', [
+                'if(queue && queue.d < 1) {',
+                Template_1.Template.indent([
+                    'queue.d = 1;',
+                    `queue.forEach(${runtimeTemplate.expressionFunction('fn.r--', 'fn')});`,
+                    `queue.forEach(${runtimeTemplate.expressionFunction('fn.r-- ? fn.r++ : fn()', 'fn')});`,
+                ]),
+                '}',
+            ])}`,
+            `var wrapDeps = ${runtimeTemplate.returningFunction(`deps.map(${runtimeTemplate.basicFunction('dep', [
+                'if(dep !== null && typeof dep === "object") {',
+                Template_1.Template.indent([
+                    'if(dep[webpackQueues]) return dep;',
+                    'if(dep.then) {',
+                    Template_1.Template.indent([
+                        'var queue = [];',
+                        'queue.d = 0;',
+                        `dep.then(${runtimeTemplate.basicFunction('r', [
+                            'obj[webpackExports] = r;',
+                            'resolveQueue(queue);',
+                        ])}, ${runtimeTemplate.basicFunction('e', [
+                            'obj[webpackError] = e;',
+                            'resolveQueue(queue);',
+                        ])});`,
+                        'var obj = {};',
+                        `obj[webpackQueues] = ${runtimeTemplate.expressionFunction(`fn(queue)`, 'fn')};`,
+                        'return obj;',
+                    ]),
+                    '}',
+                ]),
+                '}',
+                'var ret = {};',
+                `ret[webpackQueues] = ${runtimeTemplate.emptyFunction()};`,
+                'ret[webpackExports] = dep;',
+                'return ret;',
+            ])})`, 'deps')};`,
+            `${fn} = ${runtimeTemplate.basicFunction('module, body, hasAwait', [
+                'var queue;',
+                'hasAwait && ((queue = []).d = -1);',
+                'var depQueues = new Set();',
+                'var exports = module.exports;',
+                'var currentDeps;',
+                'var outerResolve;',
+                'var reject;',
+                `var promise = new Promise(${runtimeTemplate.basicFunction('resolve, rej', [
+                    'reject = rej;',
+                    'outerResolve = resolve;',
+                ])});`,
+                'promise[webpackExports] = exports;',
+                `promise[webpackQueues] = ${runtimeTemplate.expressionFunction(`queue && fn(queue), depQueues.forEach(fn), promise["catch"](${runtimeTemplate.emptyFunction()})`, 'fn')};`,
+                'module.exports = promise;',
+                `body(${runtimeTemplate.basicFunction('deps', [
+                    'currentDeps = wrapDeps(deps);',
+                    'var fn;',
+                    `var getResult = ${runtimeTemplate.returningFunction(`currentDeps.map(${runtimeTemplate.basicFunction('d', [
+                        'if(d[webpackError]) throw d[webpackError];',
+                        'return d[webpackExports];',
+                    ])})`)}`,
+                    `var promise = new Promise(${runtimeTemplate.basicFunction('resolve', [
+                        `fn = ${runtimeTemplate.expressionFunction('resolve(getResult)', '')};`,
+                        'fn.r = 0;',
+                        `var fnQueue = ${runtimeTemplate.expressionFunction('q !== queue && !depQueues.has(q) && (depQueues.add(q), q && !q.d && (fn.r++, q.push(fn)))', 'q')};`,
+                        `currentDeps.map(${runtimeTemplate.expressionFunction('dep[webpackQueues](fnQueue)', 'dep')});`,
+                    ])});`,
+                    'return fn.r ? promise : getResult();',
+                ])}, ${runtimeTemplate.expressionFunction('(err ? reject(promise[webpackError] = err) : outerResolve(exports)), resolveQueue(queue)', 'err')});`,
+                'queue && queue.d < 0 && (queue.d = 0);',
+            ])};`,
+        ]);
+    }
+}
+exports.default = AsyncModuleRuntimeModule;

package/dist/module/runtime/AutoPublicPathRuntimeModule.d.ts

@@ -0,0 +1,6 @@
+import RuntimeModule from '../RuntimeModule';
+declare class AutoPublicPathRuntimeModule extends RuntimeModule {
+    constructor();
+    generate(): string;
+}
+export default AutoPublicPathRuntimeModule;

package/dist/module/runtime/AutoPublicPathRuntimeModule.js

@@ -0,0 +1,81 @@
+"use strict";
+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 RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const Template_1 = require("@/template/Template");
+const identifier_1 = require("@/base/identifier");
+const RuntimeModule_1 = __importDefault(require("../RuntimeModule"));
+const JavascriptModulesPlugin_1 = require("../javascript/JavascriptModulesPlugin");
+class AutoPublicPathRuntimeModule extends RuntimeModule_1.default {
+    constructor() {
+        super('publicPath', RuntimeModule_1.default.STAGE_BASIC);
+    }
+    generate() {
+        const compilation = this.compilation;
+        const { scriptType, importMetaName, path } = compilation.outputOptions;
+        const chunkName = compilation.getPath(JavascriptModulesPlugin_1.JavascriptModulesPlugin.getChunkFilenameTemplate(this.chunk, compilation.outputOptions), {
+            chunk: this.chunk,
+            contentHashType: 'javascript',
+        });
+        const undoPath = (0, identifier_1.getUndoPath)(chunkName, path, false);
+        return Template_1.Template.asString([
+            'var scriptUrl;',
+            scriptType === 'module'
+                ? `if (typeof ${importMetaName}.url === "string") scriptUrl = ${importMetaName}.url`
+                : Template_1.Template.asString([
+                    `if (${RuntimeGlobals.global}.importScripts) scriptUrl = ${RuntimeGlobals.global}.location + "";`,
+                    `var document = ${RuntimeGlobals.global}.document;`,
+                    'if (!scriptUrl && document) {',
+                    Template_1.Template.indent([
+                        `if (document.currentScript)`,
+                        Template_1.Template.indent(`scriptUrl = document.currentScript.src;`),
+                        'if (!scriptUrl) {',
+                        Template_1.Template.indent([
+                            'var scripts = document.getElementsByTagName("script");',
+                            'if(scripts.length) {',
+                            Template_1.Template.indent([
+                                'var i = scripts.length - 1;',
+                                'while (i > -1 && !scriptUrl) scriptUrl = scripts[i--].src;',
+                            ]),
+                            '}',
+                        ]),
+                        '}',
+                    ]),
+                    '}',
+                ]),
+            '// When supporting browsers where an automatic publicPath is not supported you must specify an output.publicPath manually via configuration',
+            '// or pass an empty string ("") and set the __webpack_public_path__ variable from your code to use your own logic.',
+            'if (!scriptUrl) throw new Error("Automatic publicPath is not supported in this browser");',
+            'scriptUrl = scriptUrl.replace(/#.*$/, "").replace(/\\?.*$/, "").replace(/\\/[^\\/]+$/, "/");',
+            !undoPath
+                ? `${RuntimeGlobals.publicPath} = scriptUrl;`
+                : `${RuntimeGlobals.publicPath} = scriptUrl + ${JSON.stringify(undoPath)};`,
+        ]);
+    }
+}
+exports.default = AutoPublicPathRuntimeModule;

package/dist/module/runtime/BaseUriRuntimeModule.d.ts

@@ -0,0 +1,6 @@
+import RuntimeModule from '../RuntimeModule';
+declare class BaseUriRuntimeModule extends RuntimeModule {
+    constructor();
+    generate(): string;
+}
+export default BaseUriRuntimeModule;

package/dist/module/runtime/BaseUriRuntimeModule.js

@@ -0,0 +1,41 @@
+"use strict";
+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 RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const RuntimeModule_1 = __importDefault(require("../RuntimeModule"));
+class BaseUriRuntimeModule extends RuntimeModule_1.default {
+    constructor() {
+        super('base uri', RuntimeModule_1.default.STAGE_ATTACH);
+    }
+    generate() {
+        const chunk = this.chunk;
+        const options = chunk.getEntryOptions();
+        return `${RuntimeGlobals.baseURI} = ${options.baseUri === undefined ? 'undefined' : JSON.stringify(options.baseUri)};`;
+    }
+}
+exports.default = BaseUriRuntimeModule;

package/dist/module/runtime/ChunkNameRuntimeModule.d.ts

@@ -0,0 +1,7 @@
+import RuntimeModule from '../RuntimeModule';
+declare class ChunkNameRuntimeModule extends RuntimeModule {
+    chunkName: string;
+    constructor(chunkName: string);
+    generate(): string;
+}
+export default ChunkNameRuntimeModule;