xhs-mp-pack 1.1.0-beta.0

package/dist/dependencies/harmony/HarmonyExportDependencyParserPlugin.js

@@ -0,0 +1,143 @@
+"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 InnerGraph = __importStar(require("@/plugins/optimize/InnerGraph"));
+const ConstDependency_1 = __importDefault(require("@/dependencies/const/ConstDependency"));
+const HarmonyExportExpressionDependency_1 = __importDefault(require("./HarmonyExportExpressionDependency"));
+const HarmonyExportHeaderDependency_1 = __importDefault(require("./HarmonyExportHeaderDependency"));
+const HarmonyExportImportedSpecifierDependency_1 = require("./HarmonyExportImportedSpecifierDependency");
+const HarmonyExportSpecifierDependency_1 = __importDefault(require("./HarmonyExportSpecifierDependency"));
+const HarmonyImportDependency_1 = require("./HarmonyImportDependency");
+const HarmonyImportDependencyParserPlugin_1 = require("./HarmonyImportDependencyParserPlugin");
+const HarmonyImportSideEffectDependency_1 = __importDefault(require("./HarmonyImportSideEffectDependency"));
+class HarmonyExportDependencyParserPlugin {
+    constructor(options) {
+        this.exportPresenceMode =
+            options.reexportExportsPresence !== undefined
+                ? HarmonyImportDependency_1.ExportPresenceModes.fromUserOption(options.reexportExportsPresence)
+                : options.exportsPresence !== undefined
+                    ? HarmonyImportDependency_1.ExportPresenceModes.fromUserOption(options.exportsPresence)
+                    : options.strictExportPresence
+                        ? HarmonyImportDependency_1.ExportPresenceModes.ERROR
+                        : HarmonyImportDependency_1.ExportPresenceModes.AUTO;
+    }
+    apply(parser) {
+        const { exportPresenceMode } = this;
+        parser.hooks.export.tap('HarmonyExportDependencyParserPlugin', statement => {
+            var _a;
+            const dep = new HarmonyExportHeaderDependency_1.default((_a = statement.declaration) === null || _a === void 0 ? void 0 : _a.range, statement.range);
+            dep.loc = Object.create(statement.loc);
+            dep.loc.index = -1;
+            parser.state.module.addPresentationalDependency(dep);
+            return true;
+        });
+        parser.hooks.exportImport.tap('HarmonyExportDependencyParserPlugin', (statement, source) => {
+            parser.state.lastHarmonyImportOrder = (parser.state.lastHarmonyImportOrder || 0) + 1;
+            const clearDep = new ConstDependency_1.default('', statement.range);
+            clearDep.loc = Object.create(statement.loc);
+            clearDep.loc.index = -1;
+            parser.state.module.addPresentationalDependency(clearDep);
+            const sideEffectDep = new HarmonyImportSideEffectDependency_1.default(source, parser.state.lastHarmonyImportOrder, (0, HarmonyImportDependencyParserPlugin_1.getAssertions)(statement));
+            sideEffectDep.loc = Object.create(statement.loc);
+            sideEffectDep.loc.index = -1;
+            parser.state.current.addDependency(sideEffectDep);
+            return true;
+        });
+        parser.hooks.exportExpression.tap('HarmonyExportDependencyParserPlugin', (statement, expr) => {
+            const isFunctionDeclaration = expr.type === 'FunctionDeclaration';
+            const comments = parser.getComments([statement.range[0], expr.range[0]]);
+            const dep = new HarmonyExportExpressionDependency_1.default(expr.range, statement.range, comments
+                .map(c => {
+                switch (c.type) {
+                    case 'Block':
+                        return `/*${c.value}*/`;
+                    case 'Line':
+                        return `//${c.value}\n`;
+                }
+                return '';
+            })
+                .join(''), expr.type.endsWith('Declaration') && expr.id
+                ? expr.id.name
+                : isFunctionDeclaration
+                    ? {
+                        id: expr.id ? expr.id.name : undefined,
+                        range: [
+                            expr.range[0],
+                            expr.params.length > 0 ? expr.params[0].range[0] : expr.body.range[0],
+                        ],
+                        prefix: `${expr.async ? 'async ' : ''}function${expr.generator ? '*' : ''} `,
+                        suffix: `(${expr.params.length > 0 ? '' : ') '}`,
+                    }
+                    : undefined);
+            dep.loc = Object.create(statement.loc);
+            dep.loc.index = -1;
+            parser.state.current.addDependency(dep);
+            InnerGraph.addVariableUsage(parser, expr.type.endsWith('Declaration') && expr.id ? expr.id.name : '*default*', 'default');
+            return true;
+        });
+        parser.hooks.exportSpecifier.tap('HarmonyExportDependencyParserPlugin', (statement, id, name, idx) => {
+            const settings = parser.getTagData(id, HarmonyImportDependencyParserPlugin_1.harmonySpecifierTag);
+            let dep;
+            const harmonyNamedExports = (parser.state.harmonyNamedExports =
+                parser.state.harmonyNamedExports || new Set());
+            harmonyNamedExports.add(name);
+            InnerGraph.addVariableUsage(parser, id, name);
+            if (settings) {
+                dep = new HarmonyExportImportedSpecifierDependency_1.HarmonyExportImportedSpecifierDependency(settings.source, settings.sourceOrder, settings.ids, name, harmonyNamedExports, null, exportPresenceMode, null, settings.assertions);
+            }
+            else {
+                dep = new HarmonyExportSpecifierDependency_1.default(id, name);
+            }
+            dep.loc = Object.create(statement.loc);
+            dep.loc.index = idx;
+            parser.state.current.addDependency(dep);
+            return true;
+        });
+        parser.hooks.exportImportSpecifier.tap('HarmonyExportDependencyParserPlugin', (statement, source, id, name, idx) => {
+            const harmonyNamedExports = (parser.state.harmonyNamedExports =
+                parser.state.harmonyNamedExports || new Set());
+            let harmonyStarExports = null;
+            if (name) {
+                harmonyNamedExports.add(name);
+            }
+            else {
+                harmonyStarExports = parser.state.harmonyStarExports =
+                    parser.state.harmonyStarExports || new HarmonyExportImportedSpecifierDependency_1.HarmonyStarExportsList();
+            }
+            const dep = new HarmonyExportImportedSpecifierDependency_1.HarmonyExportImportedSpecifierDependency(source, parser.state.lastHarmonyImportOrder, id ? [id] : [], name, harmonyNamedExports, harmonyStarExports === null || harmonyStarExports === void 0 ? void 0 : harmonyStarExports.slice(), exportPresenceMode, harmonyStarExports);
+            if (harmonyStarExports) {
+                harmonyStarExports.push(dep);
+            }
+            dep.loc = Object.create(statement.loc);
+            dep.loc.index = idx;
+            parser.state.current.addDependency(dep);
+            return true;
+        });
+    }
+}
+exports.default = HarmonyExportDependencyParserPlugin;

package/dist/dependencies/harmony/HarmonyExportExpressionDependency.d.ts

@@ -0,0 +1,23 @@
+import NullDependency from '@/dependencies/NullDependency';
+declare class HarmonyExportExpressionDependency extends NullDependency {
+    range: any;
+    rangeStatement: any;
+    prefix: any;
+    declarationId: any;
+    constructor(range: any, rangeStatement: any, prefix: string, declarationId: string | {
+        range: any;
+        prefix: string;
+        suffix: string;
+    });
+    get type(): string;
+    getExports(moduleGraph: any): {
+        exports: string[];
+        priority: number;
+        terminalBinding: boolean;
+        dependencies: undefined;
+    };
+    getModuleEvaluationSideEffectsState(moduleGraph: any): boolean;
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default HarmonyExportExpressionDependency;

package/dist/dependencies/harmony/HarmonyExportExpressionDependency.js

@@ -0,0 +1,148 @@
+"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 ConcatenationScope_1 = __importDefault(require("@/ConcatenationScope"));
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+const propertyAccess_1 = __importDefault(require("@/base/propertyAccess"));
+const NullDependency_1 = __importDefault(require("@/dependencies/NullDependency"));
+const HarmonyExportInitFragment_1 = __importDefault(require("./HarmonyExportInitFragment"));
+class HarmonyExportExpressionDependency extends NullDependency_1.default {
+    constructor(range, rangeStatement, prefix, declarationId) {
+        super();
+        this.range = range;
+        this.rangeStatement = rangeStatement;
+        this.prefix = prefix;
+        this.declarationId = declarationId;
+    }
+    get type() {
+        return 'harmony export expression';
+    }
+    getExports(moduleGraph) {
+        return {
+            exports: ['default'],
+            priority: 1,
+            terminalBinding: true,
+            dependencies: undefined,
+        };
+    }
+    getModuleEvaluationSideEffectsState(moduleGraph) {
+        // The expression/declaration is already covered by SideEffectsFlagPlugin
+        return false;
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.range);
+        write(this.rangeStatement);
+        write(this.prefix);
+        write(this.declarationId);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.range = read();
+        this.rangeStatement = read();
+        this.prefix = read();
+        this.declarationId = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(HarmonyExportExpressionDependency, 'mp-compiler/core/dependencies/HarmonyExportExpressionDependency');
+HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTemplate extends (NullDependency_1.default.Template) {
+    apply(dependency, source, { module, moduleGraph, runtimeTemplate, runtimeRequirements, initFragments, runtime, concatenationScope, }) {
+        const dep = dependency;
+        const { declarationId } = dep;
+        const exportsName = module.exportsArgument;
+        if (declarationId) {
+            let name;
+            if (typeof declarationId === 'string') {
+                name = declarationId;
+            }
+            else {
+                name = ConcatenationScope_1.default.DEFAULT_EXPORT;
+                source.replace(declarationId.range[0], declarationId.range[1] - 1, `${declarationId.prefix}${name}${declarationId.suffix}`);
+            }
+            if (concatenationScope) {
+                concatenationScope.registerExport('default', name);
+            }
+            else {
+                const used = moduleGraph.getExportsInfo(module).getUsedName('default', runtime);
+                if (used) {
+                    const map = new Map();
+                    map.set(used, `/* module.exports = binding */ ${name}`);
+                    initFragments.push(new HarmonyExportInitFragment_1.default(exportsName, map));
+                }
+            }
+            source.replace(dep.rangeStatement[0], dep.range[0] - 1, `/* harmony default export */ ${dep.prefix}`);
+        }
+        else {
+            let content;
+            const name = ConcatenationScope_1.default.DEFAULT_EXPORT;
+            if (runtimeTemplate.supportsConst()) {
+                content = `/* harmony default export */ const ${name} = `;
+                if (concatenationScope) {
+                    concatenationScope.registerExport('default', name);
+                }
+                else {
+                    const used = moduleGraph.getExportsInfo(module).getUsedName('default', runtime);
+                    if (used) {
+                        runtimeRequirements.add(RuntimeGlobals.exports);
+                        const map = new Map();
+                        map.set(used, name);
+                        initFragments.push(new HarmonyExportInitFragment_1.default(exportsName, map));
+                    }
+                    else {
+                        content = `/* unused harmony default export */ var ${name} = `;
+                    }
+                }
+            }
+            else if (concatenationScope) {
+                content = `/* harmony default export */ var ${name} = `;
+                concatenationScope.registerExport('default', name);
+            }
+            else {
+                const used = moduleGraph.getExportsInfo(module).getUsedName('default', runtime);
+                if (used) {
+                    runtimeRequirements.add(RuntimeGlobals.exports);
+                    // This is a little bit incorrect as TDZ is not correct, but we can't use const.
+                    content = `/* harmony default export */ ${exportsName}${(0, propertyAccess_1.default)(typeof used === 'string' ? [used] : used)} = `;
+                }
+                else {
+                    content = `/* unused harmony default export */ var ${name} = `;
+                }
+            }
+            if (dep.range) {
+                source.replace(dep.rangeStatement[0], dep.range[0] - 1, `${content}(${dep.prefix}`);
+                source.replace(dep.range[1], dep.rangeStatement[1] - 0.5, ');');
+                return;
+            }
+            source.replace(dep.rangeStatement[0], dep.rangeStatement[1] - 1, content);
+        }
+    }
+};
+exports.default = HarmonyExportExpressionDependency;

package/dist/dependencies/harmony/HarmonyExportHeaderDependency.d.ts

@@ -0,0 +1,10 @@
+import NullDependency from '@/dependencies/NullDependency';
+declare class HarmonyExportHeaderDependency extends NullDependency {
+    range: any;
+    rangeStatement: any;
+    constructor(range: any, rangeStatement: any);
+    get type(): string;
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default HarmonyExportHeaderDependency;

package/dist/dependencies/harmony/HarmonyExportHeaderDependency.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+const NullDependency_1 = __importDefault(require("@/dependencies/NullDependency"));
+class HarmonyExportHeaderDependency extends NullDependency_1.default {
+    constructor(range, rangeStatement) {
+        super();
+        this.range = range;
+        this.rangeStatement = rangeStatement;
+    }
+    get type() {
+        return 'harmony export header';
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.range);
+        write(this.rangeStatement);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.range = read();
+        this.rangeStatement = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(HarmonyExportHeaderDependency, 'mp-compiler/core/dependencies/HarmonyExportHeaderDependency');
+HarmonyExportHeaderDependency.Template = class HarmonyExportDependencyTemplate extends (NullDependency_1.default.Template) {
+    apply(dependency, source, templateContext) {
+        const dep = dependency;
+        const content = '';
+        const replaceUntil = dep.range ? dep.range[0] - 1 : dep.rangeStatement[1] - 1;
+        source.replace(dep.rangeStatement[0], replaceUntil, content);
+    }
+};
+exports.default = HarmonyExportHeaderDependency;

package/dist/dependencies/harmony/HarmonyExportImportedSpecifierDependency.d.ts

@@ -0,0 +1,140 @@
+import HarmonyLinkingError from '@/base/errors/HarmonyLinkingError';
+import { HarmonyImportDependency } from './HarmonyImportDependency';
+declare class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
+    ids: string[];
+    name: string | null;
+    activeExports: Set<string>;
+    otherStarExports: any;
+    exportPresenceMode: number;
+    allStarExports: HarmonyStarExportsList | null;
+    constructor(request: string, sourceOrder: number, ids: string[], name: string | null, activeExports: Set<string>, otherStarExports: readonly HarmonyExportImportedSpecifierDependency[] | Iterable<HarmonyExportImportedSpecifierDependency> | null, exportPresenceMode: number, allStarExports: HarmonyStarExportsList | null, assertions?: any);
+    couldAffectReferencingModule(): any;
+    get id(): void;
+    getId(): void;
+    setId(): void;
+    get type(): string;
+    getIds(moduleGraph: any): any;
+    setIds(moduleGraph: any, ids: string[]): void;
+    getMode(moduleGraph: any, runtime: any): any;
+    getStarReexports(moduleGraph: any, runtime: any, exportsInfo?: any, importedModule?: any): {
+        ignoredExports: Set<string>;
+        hidden: any;
+        exports?: undefined;
+        checked?: undefined;
+    } | {
+        ignoredExports: Set<string>;
+        exports: Set<unknown>;
+        checked: Set<unknown>;
+        hidden: any;
+    };
+    getCondition(moduleGraph: any): (connection: any, runtime: any) => boolean;
+    getModuleEvaluationSideEffectsState(moduleGraph: any): boolean;
+    getReferencedExports(moduleGraph: any, runtime: any): any;
+    _discoverActiveExportsFromOtherStarExports(moduleGraph: any): {
+        names: any;
+        namesSlice: any;
+        dependencyIndices: any;
+        dependencyIndex: any;
+    } | undefined;
+    getExports(moduleGraph: any): {
+        exports: boolean;
+        from: any;
+        canMangle: boolean;
+        excludeExports: any;
+        hideExports: any;
+        dependencies: any[];
+        priority?: undefined;
+    } | {
+        exports: never[];
+        hideExports: any;
+        dependencies: any[];
+        from?: undefined;
+        canMangle?: undefined;
+        excludeExports?: undefined;
+        priority?: undefined;
+    } | {
+        exports: {
+            name: any;
+            from: any;
+            export: any;
+            hidden: any;
+        }[];
+        priority: number;
+        dependencies: any[];
+        from?: undefined;
+        canMangle?: undefined;
+        excludeExports?: undefined;
+        hideExports?: undefined;
+    } | {
+        exports: {
+            name: any;
+            from: any;
+            export: string[];
+        }[];
+        priority: number;
+        dependencies: any[];
+        from?: undefined;
+        canMangle?: undefined;
+        excludeExports?: undefined;
+        hideExports?: undefined;
+    } | {
+        exports: any[];
+        dependencies: any[];
+        from?: undefined;
+        canMangle?: undefined;
+        excludeExports?: undefined;
+        hideExports?: undefined;
+        priority?: undefined;
+    } | {
+        exports: {
+            name: any;
+            from: any;
+            export: null;
+            exports: {
+                name: string;
+                canMangle: boolean;
+                from: any;
+                export: null;
+            }[];
+        }[];
+        priority: number;
+        dependencies: any[];
+        from?: undefined;
+        canMangle?: undefined;
+        excludeExports?: undefined;
+        hideExports?: undefined;
+    } | {
+        exports: {
+            name: any;
+            from: any;
+            export: null;
+        }[];
+        priority: number;
+        dependencies: any[];
+        from?: undefined;
+        canMangle?: undefined;
+        excludeExports?: undefined;
+        hideExports?: undefined;
+    } | undefined;
+    _getEffectiveExportPresenceLevel(moduleGraph: any): number;
+    getWarnings(moduleGraph: any): HarmonyLinkingError[] | null | undefined;
+    getErrors(moduleGraph: any): HarmonyLinkingError[] | null | undefined;
+    _getErrors(moduleGraph: any): HarmonyLinkingError[] | undefined;
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+declare class HarmonyStarExportsList {
+    dependencies: any[];
+    constructor();
+    push(dep: any): void;
+    slice(): any[];
+    serialize({ write, setCircularReference }: {
+        write: any;
+        setCircularReference: any;
+    }): void;
+    deserialize({ read, setCircularReference }: {
+        read: any;
+        setCircularReference: any;
+    }): void;
+}
+export { HarmonyExportImportedSpecifierDependency, HarmonyStarExportsList };