xhs-mp-pack 1.1.0-beta.0

package/dist/module/runtime/GetChunkFilenameRuntimeModule.js

@@ -0,0 +1,220 @@
+"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 SetHelpers_1 = require("@/base/SetHelpers");
+const RuntimeModule_1 = __importDefault(require("../RuntimeModule"));
+class GetChunkFilenameRuntimeModule extends RuntimeModule_1.default {
+    constructor(contentType, name, global, getFilenameForChunk, allChunks) {
+        super(`get ${name} chunk filename`);
+        this.contentType = contentType;
+        this.global = global;
+        this.getFilenameForChunk = getFilenameForChunk;
+        this.allChunks = allChunks;
+        this.dependentHash = true;
+    }
+    generate() {
+        const { global, contentType, getFilenameForChunk, allChunks } = this;
+        const compilation = this.compilation;
+        const chunkGraph = this.chunkGraph;
+        const chunk = this.chunk;
+        const { runtimeTemplate } = compilation;
+        const chunkFilenames = new Map();
+        let maxChunks = 0;
+        let dynamicFilename;
+        const addChunk = c => {
+            const chunkFilename = getFilenameForChunk(c);
+            if (chunkFilename) {
+                let set = chunkFilenames.get(chunkFilename);
+                if (set === undefined) {
+                    chunkFilenames.set(chunkFilename, (set = new Set()));
+                }
+                set.add(c);
+                if (typeof chunkFilename === 'string') {
+                    if (set.size < maxChunks)
+                        return;
+                    if (set.size === maxChunks) {
+                        if (chunkFilename.length < dynamicFilename.length) {
+                            return;
+                        }
+                        if (chunkFilename.length === dynamicFilename.length) {
+                            if (chunkFilename < dynamicFilename) {
+                                return;
+                            }
+                        }
+                    }
+                    maxChunks = set.size;
+                    dynamicFilename = chunkFilename;
+                }
+            }
+        };
+        const includedChunksMessages = [];
+        if (allChunks) {
+            includedChunksMessages.push('all chunks');
+            for (const c of chunk.getAllReferencedChunks()) {
+                addChunk(c);
+            }
+        }
+        else {
+            includedChunksMessages.push('async chunks');
+            for (const c of chunk.getAllAsyncChunks()) {
+                addChunk(c);
+            }
+            const includeEntries = chunkGraph
+                .getTreeRuntimeRequirements(chunk)
+                .has(RuntimeGlobals.ensureChunkIncludeEntries);
+            if (includeEntries) {
+                includedChunksMessages.push('sibling chunks for the entrypoint');
+                for (const c of chunkGraph.getChunkEntryDependentChunksIterable(chunk)) {
+                    addChunk(c);
+                }
+            }
+        }
+        for (const entrypoint of chunk.getAllReferencedAsyncEntrypoints()) {
+            addChunk(entrypoint.chunks[entrypoint.chunks.length - 1]);
+        }
+        const staticUrls = new Map();
+        const dynamicUrlChunks = new Set();
+        const addStaticUrl = (c, chunkFilename) => {
+            const unquotedStringify = value => {
+                const str = `${value}`;
+                if (str.length >= 5 && str === `${c.id}`) {
+                    // This is shorter and generates the same result
+                    return '" + chunkId + "';
+                }
+                const s = JSON.stringify(str);
+                return s.slice(1, s.length - 1);
+            };
+            const unquotedStringifyWithLength = value => length => unquotedStringify(`${value}`.slice(0, length));
+            const chunkFilenameValue = typeof chunkFilename === 'function'
+                ? JSON.stringify(chunkFilename({
+                    chunk: c,
+                    contentHashType: contentType,
+                }))
+                : JSON.stringify(chunkFilename);
+            const staticChunkFilename = compilation.getPath(chunkFilenameValue, {
+                hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
+                hashWithLength: length => `" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
+                chunk: {
+                    id: unquotedStringify(c.id),
+                    hash: unquotedStringify(c.renderedHash),
+                    hashWithLength: unquotedStringifyWithLength(c.renderedHash),
+                    name: unquotedStringify(c.name || c.id),
+                    contentHash: {
+                        [contentType]: unquotedStringify(c.contentHash[contentType]),
+                    },
+                    contentHashWithLength: {
+                        [contentType]: unquotedStringifyWithLength(c.contentHash[contentType]),
+                    },
+                },
+                contentHashType: contentType,
+            });
+            let set = staticUrls.get(staticChunkFilename);
+            if (set === undefined) {
+                staticUrls.set(staticChunkFilename, (set = new Set()));
+            }
+            set.add(c.id);
+        };
+        for (const [filename, chunks] of chunkFilenames) {
+            if (filename !== dynamicFilename) {
+                for (const c of chunks)
+                    addStaticUrl(c, filename);
+            }
+            else {
+                for (const c of chunks)
+                    dynamicUrlChunks.add(c);
+            }
+        }
+        const createMap = fn => {
+            const obj = {};
+            let useId = false;
+            let lastKey;
+            let entries = 0;
+            for (const c of dynamicUrlChunks) {
+                const value = fn(c);
+                if (value === c.id) {
+                    useId = true;
+                }
+                else {
+                    obj[c.id] = value;
+                    lastKey = c.id;
+                    entries++;
+                }
+            }
+            if (entries === 0)
+                return 'chunkId';
+            if (entries === 1) {
+                return useId
+                    ? `(chunkId === ${JSON.stringify(lastKey)} ? ${JSON.stringify(obj[lastKey])} : chunkId)`
+                    : JSON.stringify(obj[lastKey]);
+            }
+            return useId
+                ? `(${JSON.stringify(obj)}[chunkId] || chunkId)`
+                : `${JSON.stringify(obj)}[chunkId]`;
+        };
+        const mapExpr = fn => `" + ${createMap(fn)} + "`;
+        const mapExprWithLength = fn => length => `" + ${createMap(c => `${fn(c)}`.slice(0, length))} + "`;
+        const url = dynamicFilename &&
+            compilation.getPath(JSON.stringify(dynamicFilename), {
+                hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
+                hashWithLength: length => `" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
+                chunk: {
+                    id: `" + chunkId + "`,
+                    hash: mapExpr(c => c.renderedHash),
+                    hashWithLength: mapExprWithLength(c => c.renderedHash),
+                    name: mapExpr(c => c.name || c.id),
+                    contentHash: {
+                        [contentType]: mapExpr(c => c.contentHash[contentType]),
+                    },
+                    contentHashWithLength: {
+                        [contentType]: mapExprWithLength(c => c.contentHash[contentType]),
+                    },
+                },
+                contentHashType: contentType,
+            });
+        return Template_1.Template.asString([
+            `// This function allow to reference ${includedChunksMessages.join(' and ')}`,
+            `${global} = ${runtimeTemplate.basicFunction('chunkId', staticUrls.size > 0
+                ? [
+                    '// return url for filenames not based on template',
+                    // it minimizes to `x===1?"...":x===2?"...":"..."`
+                    Template_1.Template.asString(Array.from(staticUrls, ([url, ids]) => {
+                        const condition = ids.size === 1
+                            ? `chunkId === ${JSON.stringify((0, SetHelpers_1.first)(ids))}`
+                            : `{${Array.from(ids, id => `${JSON.stringify(id)}:1`).join(',')}}[chunkId]`;
+                        return `if (${condition}) return ${url};`;
+                    })),
+                    '// return url for filenames based on template',
+                    `return ${url};`,
+                ]
+                : ['// return url for filenames based on template', `return ${url};`])};`,
+        ]);
+    }
+}
+exports.default = GetChunkFilenameRuntimeModule;

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

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

package/dist/module/runtime/GetFullHashRuntimeModule.js

@@ -0,0 +1,42 @@
+"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 GetFullHashRuntimeModule extends RuntimeModule_1.default {
+    constructor() {
+        super('getFullHash');
+        this.fullHash = true;
+    }
+    generate() {
+        const compilation = this.compilation;
+        const { runtimeTemplate } = compilation;
+        return `${RuntimeGlobals.getFullHash} = ${runtimeTemplate.returningFunction(JSON.stringify(compilation.hash || 'XXXX'))}`;
+    }
+}
+exports.default = GetFullHashRuntimeModule;

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

@@ -0,0 +1,8 @@
+import RuntimeModule from '../RuntimeModule';
+declare class GetMainFilenameRuntimeModule extends RuntimeModule {
+    global: string;
+    filename: string;
+    constructor(name: any, global: any, filename: any);
+    generate(): string;
+}
+export default GetMainFilenameRuntimeModule;

package/dist/module/runtime/GetMainFilenameRuntimeModule.js

@@ -0,0 +1,52 @@
+"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 RuntimeModule_1 = __importDefault(require("../RuntimeModule"));
+class GetMainFilenameRuntimeModule extends RuntimeModule_1.default {
+    constructor(name, global, filename) {
+        super(`get ${name} filename`);
+        this.global = global;
+        this.filename = filename;
+    }
+    generate() {
+        const { global, filename } = this;
+        const compilation = this.compilation;
+        const chunk = this.chunk;
+        const { runtimeTemplate } = compilation;
+        const url = compilation.getPath(JSON.stringify(filename), {
+            hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
+            hashWithLength: length => `" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
+            chunk,
+            runtime: chunk.runtime,
+        });
+        return Template_1.Template.asString([`${global} = ${runtimeTemplate.returningFunction(url)};`]);
+    }
+}
+exports.default = GetMainFilenameRuntimeModule;

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

@@ -0,0 +1,7 @@
+import HelperRuntimeModule from './HelperRuntimeModule';
+declare class GetTrustedTypesPolicyRuntimeModule extends HelperRuntimeModule {
+    runtimeRequirements: ReadonlySet<string>;
+    constructor(runtimeRequirements: ReadonlySet<string>);
+    generate(): string;
+}
+export default GetTrustedTypesPolicyRuntimeModule;

package/dist/module/runtime/GetTrustedTypesPolicyRuntimeModule.js

@@ -0,0 +1,89 @@
+"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 GetTrustedTypesPolicyRuntimeModule extends HelperRuntimeModule_1.default {
+    constructor(runtimeRequirements) {
+        super('trusted types policy');
+        this.runtimeRequirements = runtimeRequirements;
+    }
+    generate() {
+        const compilation = this.compilation;
+        const { runtimeTemplate, outputOptions } = compilation;
+        const { trustedTypes } = outputOptions;
+        const fn = RuntimeGlobals.getTrustedTypesPolicy;
+        const wrapPolicyCreationInTryCatch = trustedTypes
+            ? trustedTypes.onPolicyCreationFailure === 'continue'
+            : false;
+        return Template_1.Template.asString([
+            'var policy;',
+            `${fn} = ${runtimeTemplate.basicFunction('', [
+                "// Create Trusted Type policy if Trusted Types are available and the policy doesn't exist yet.",
+                'if (policy === undefined) {',
+                Template_1.Template.indent([
+                    'policy = {',
+                    Template_1.Template.indent([
+                        ...(this.runtimeRequirements.has(RuntimeGlobals.createScript)
+                            ? [`createScript: ${runtimeTemplate.returningFunction('script', 'script')}`]
+                            : []),
+                        ...(this.runtimeRequirements.has(RuntimeGlobals.createScriptUrl)
+                            ? [`createScriptURL: ${runtimeTemplate.returningFunction('url', 'url')}`]
+                            : []),
+                    ].join(',\n')),
+                    '};',
+                    ...(trustedTypes
+                        ? [
+                            'if (typeof trustedTypes !== "undefined" && trustedTypes.createPolicy) {',
+                            Template_1.Template.indent([
+                                ...(wrapPolicyCreationInTryCatch ? ['try {'] : []),
+                                ...[
+                                    `policy = trustedTypes.createPolicy(${JSON.stringify(trustedTypes.policyName)}, policy);`,
+                                ].map(line => (wrapPolicyCreationInTryCatch ? Template_1.Template.indent(line) : line)),
+                                ...(wrapPolicyCreationInTryCatch
+                                    ? [
+                                        '} catch (e: any) {',
+                                        Template_1.Template.indent([
+                                            `console.warn('Could not create trusted-types policy ${JSON.stringify(trustedTypes.policyName)}');`,
+                                        ]),
+                                        '}',
+                                    ]
+                                    : []),
+                            ]),
+                            '}',
+                        ]
+                        : []),
+                ]),
+                '}',
+                'return policy;',
+            ])};`,
+        ]);
+    }
+}
+exports.default = GetTrustedTypesPolicyRuntimeModule;

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

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

package/dist/module/runtime/GlobalRuntimeModule.js

@@ -0,0 +1,61 @@
+"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 RuntimeModule_1 = __importDefault(require("../RuntimeModule"));
+class GlobalRuntimeModule extends RuntimeModule_1.default {
+    constructor() {
+        super('global');
+    }
+    generate() {
+        return Template_1.Template.asString([
+            `${RuntimeGlobals.global} = (function() {`,
+            Template_1.Template.indent([
+                "if (typeof globalThis === 'object') return globalThis;",
+                'try {',
+                Template_1.Template.indent(
+                // This works in non-strict mode
+                // or
+                // This works if eval is allowed (see CSP)
+                "return this || new Function('return this')();"),
+                '} catch (e) {',
+                Template_1.Template.indent(
+                // This works if the window reference is available
+                "if (typeof window === 'object') return window;"),
+                '}',
+                // It can still be `undefined`, but nothing to do about it...
+                // We return `undefined`, instead of nothing here, so it's
+                // easier to handle this case:
+                //   if (!global) { … }
+            ]),
+            '})();',
+        ]);
+    }
+}
+exports.default = GlobalRuntimeModule;

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

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

package/dist/module/runtime/HasOwnPropertyRuntimeModule.js

@@ -0,0 +1,44 @@
+"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 RuntimeModule_1 = __importDefault(require("../RuntimeModule"));
+class HasOwnPropertyRuntimeModule extends RuntimeModule_1.default {
+    constructor() {
+        super('hasOwnProperty shorthand');
+    }
+    generate() {
+        const compilation = this.compilation;
+        const { runtimeTemplate } = compilation;
+        return Template_1.Template.asString([
+            `${RuntimeGlobals.hasOwnProperty} = ${runtimeTemplate.returningFunction('Object.prototype.hasOwnProperty.call(obj, prop)', 'obj, prop')}`,
+        ]);
+    }
+}
+exports.default = HasOwnPropertyRuntimeModule;

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

@@ -0,0 +1,5 @@
+import RuntimeModule from '../RuntimeModule';
+declare class HelperRuntimeModule extends RuntimeModule {
+    constructor(name: any);
+}
+export default HelperRuntimeModule;

package/dist/module/runtime/HelperRuntimeModule.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const RuntimeModule_1 = __importDefault(require("../RuntimeModule"));
+class HelperRuntimeModule extends RuntimeModule_1.default {
+    constructor(name) {
+        super(name);
+    }
+}
+exports.default = HelperRuntimeModule;

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

@@ -0,0 +1,9 @@
+import HelperRuntimeModule from './HelperRuntimeModule';
+declare class LoadScriptRuntimeModule extends HelperRuntimeModule {
+    _withCreateScriptUrl: boolean | undefined;
+    _withFetchPriority: boolean | undefined;
+    static getCompilationHooks(compilation: any): any;
+    constructor(withCreateScriptUrl?: boolean, withFetchPriority?: boolean);
+    generate(): string;
+}
+export default LoadScriptRuntimeModule;