xhs-mp-pack 1.1.0-beta.0

package/dist/dependencies/StaticExportsDependency.d.ts

@@ -0,0 +1,15 @@
+import NullDependency from '@/dependencies/NullDependency';
+declare class StaticExportsDependency extends NullDependency {
+    exports: boolean | string[];
+    canMangle: boolean;
+    constructor(exports: string[] | boolean, canMangle: boolean);
+    get type(): string;
+    getExports(moduleGraph: any): {
+        exports: boolean | string[];
+        canMangle: boolean;
+        dependencies: undefined;
+    };
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default StaticExportsDependency;

package/dist/dependencies/StaticExportsDependency.js

@@ -0,0 +1,38 @@
+"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 StaticExportsDependency extends NullDependency_1.default {
+    constructor(exports, canMangle) {
+        super();
+        this.exports = exports;
+        this.canMangle = canMangle;
+    }
+    get type() {
+        return 'static exports';
+    }
+    getExports(moduleGraph) {
+        return {
+            exports: this.exports,
+            canMangle: this.canMangle,
+            dependencies: undefined,
+        };
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.exports);
+        write(this.canMangle);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.exports = read();
+        this.canMangle = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(StaticExportsDependency, 'mp-compiler/core/dependencies/StaticExportsDependency');
+exports.default = StaticExportsDependency;

package/dist/dependencies/URLDependency.d.ts

@@ -0,0 +1,16 @@
+import ModuleDependency from '@/dependencies/ModuleDependency';
+import RawDataUrlModule from '@/module/asset/RawDataUrlModule';
+declare class URLDependency extends ModuleDependency {
+    range: any;
+    outerRange: any;
+    relative: any;
+    usedByExports: any;
+    constructor(request: any, range: any, outerRange: any, relative?: any);
+    get type(): string;
+    get category(): string;
+    getCondition(moduleGraph: any): false | ((connections: any, runtime: any) => boolean) | null;
+    createIgnoredModule(context: any): RawDataUrlModule;
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default URLDependency;

package/dist/dependencies/URLDependency.js

@@ -0,0 +1,103 @@
+"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 InnerGraph_1 = require("@/plugins/optimize/InnerGraph");
+const makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+const ModuleDependency_1 = __importDefault(require("@/dependencies/ModuleDependency"));
+const RawDataUrlModule_1 = __importDefault(require("@/module/asset/RawDataUrlModule"));
+class URLDependency extends ModuleDependency_1.default {
+    constructor(request, range, outerRange, relative) {
+        super(request);
+        this.range = range;
+        this.outerRange = outerRange;
+        this.relative = relative || false;
+        this.usedByExports = undefined;
+    }
+    get type() {
+        return 'new URL()';
+    }
+    get category() {
+        return 'url';
+    }
+    getCondition(moduleGraph) {
+        return (0, InnerGraph_1.getDependencyUsedByExportsCondition)(this, this.usedByExports, moduleGraph);
+    }
+    createIgnoredModule(context) {
+        return new RawDataUrlModule_1.default('data:,', `ignored-asset`, `(ignored asset)`);
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.outerRange);
+        write(this.relative);
+        write(this.usedByExports);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.outerRange = read();
+        this.relative = read();
+        this.usedByExports = read();
+        super.deserialize(context);
+    }
+}
+URLDependency.Template = class URLDependencyTemplate extends ModuleDependency_1.default.Template {
+    apply(dependency, source, templateContext) {
+        const { chunkGraph, moduleGraph, runtimeRequirements, runtimeTemplate, runtime } = templateContext;
+        const dep = dependency;
+        const connection = moduleGraph.getConnection(dep);
+        // Skip rendering depending when dependency is conditional
+        if (connection && !connection.isTargetActive(runtime)) {
+            source.replace(dep.outerRange[0], dep.outerRange[1] - 1, '/* unused asset import */ undefined');
+            return;
+        }
+        runtimeRequirements.add(RuntimeGlobals.require);
+        if (dep.relative) {
+            runtimeRequirements.add(RuntimeGlobals.relativeUrl);
+            source.replace(dep.outerRange[0], dep.outerRange[1] - 1, `/* asset import */ new ${RuntimeGlobals.relativeUrl}(${runtimeTemplate.moduleRaw({
+                chunkGraph,
+                module: moduleGraph.getModule(dep),
+                request: dep.request,
+                runtimeRequirements,
+                weak: false,
+            })})`);
+        }
+        else {
+            runtimeRequirements.add(RuntimeGlobals.baseURI);
+            source.replace(dep.range[0], dep.range[1] - 1, `/* asset import */ ${runtimeTemplate.moduleRaw({
+                chunkGraph,
+                module: moduleGraph.getModule(dep),
+                request: dep.request,
+                runtimeRequirements,
+                weak: false,
+            })}, ${RuntimeGlobals.baseURI}`);
+        }
+    }
+};
+(0, makeSerializable_1.default)(URLDependency, 'mp-compiler/core/dependencies/URLDependency');
+exports.default = URLDependency;

package/dist/dependencies/URLPlugin.d.ts

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

package/dist/dependencies/URLPlugin.js

@@ -0,0 +1,107 @@
+"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 url_1 = require("url");
+const ModuleTypeConstants_1 = require("@/module/ModuleTypeConstants");
+const BasicEvaluatedExpression_1 = __importDefault(require("@/module/javascript/BasicEvaluatedExpression"));
+const JavascriptParserHelpers_1 = require("@/module/javascript/JavascriptParserHelpers");
+const InnerGraph = __importStar(require("@/plugins/optimize/InnerGraph"));
+const URLDependency_1 = __importDefault(require("./URLDependency"));
+const PLUGIN_NAME = 'URLPlugin';
+class URLPlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation, { normalModuleFactory }) => {
+            compilation.dependencyFactories.set(URLDependency_1.default, normalModuleFactory);
+            compilation.dependencyTemplates.set(URLDependency_1.default, new URLDependency_1.default.Template());
+            const getUrl = module => (0, url_1.pathToFileURL)(module.resource);
+            const parserCallback = (parser, parserOptions) => {
+                if (parserOptions.url === false)
+                    return;
+                const relative = parserOptions.url === 'relative';
+                const getUrlRequest = expr => {
+                    if (expr.arguments.length !== 2)
+                        return;
+                    const [arg1, arg2] = expr.arguments;
+                    if (arg2.type !== 'MemberExpression' || arg1.type === 'SpreadElement')
+                        return;
+                    const chain = parser.extractMemberExpressionChain(arg2);
+                    if (chain.members.length !== 1 ||
+                        chain.object.type !== 'MetaProperty' ||
+                        chain.object.meta.name !== 'import' ||
+                        chain.object.property.name !== 'meta' ||
+                        chain.members[0] !== 'url')
+                        return;
+                    return parser.evaluateExpression(arg1).asString();
+                };
+                parser.hooks.canRename.for('URL').tap(PLUGIN_NAME, JavascriptParserHelpers_1.approve);
+                parser.hooks.evaluateNewExpression.for('URL').tap(PLUGIN_NAME, expr => {
+                    const request = getUrlRequest(expr);
+                    if (!request)
+                        return;
+                    // @ts-ignore
+                    const url = new URL(request, getUrl(parser.state.module));
+                    return new BasicEvaluatedExpression_1.default().setString(url.toString()).setRange(expr.range);
+                });
+                parser.hooks.new.for('URL').tap(PLUGIN_NAME, _expr => {
+                    const expr = _expr;
+                    const request = getUrlRequest(expr);
+                    if (!request)
+                        return;
+                    const [arg1, arg2] = expr.arguments;
+                    const dep = new URLDependency_1.default(request, [arg2.range[1]], expr.range, relative);
+                    dep.loc = expr.loc;
+                    parser.state.current.addDependency(dep);
+                    InnerGraph.onUsage(parser.state, e => {
+                        dep.usedByExports = e;
+                        return dep.usedByExports;
+                    });
+                    return true;
+                });
+                parser.hooks.isPure.for('NewExpression').tap(PLUGIN_NAME, _expr => {
+                    const expr = _expr;
+                    const { callee } = expr;
+                    if (callee.type !== 'Identifier')
+                        return;
+                    const calleeInfo = parser.getFreeInfoFromVariable(callee.name);
+                    if (!calleeInfo || calleeInfo.name !== 'URL')
+                        return;
+                    const request = getUrlRequest(expr);
+                    if (request)
+                        return true;
+                });
+            };
+            normalModuleFactory.hooks.parser
+                .for(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_AUTO)
+                .tap(PLUGIN_NAME, parserCallback);
+            normalModuleFactory.hooks.parser
+                .for(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_ESM)
+                .tap(PLUGIN_NAME, parserCallback);
+        });
+    }
+}
+exports.default = URLPlugin;

package/dist/dependencies/UnsupportedDependency.d.ts

@@ -0,0 +1,9 @@
+import NullDependency from '@/dependencies/NullDependency';
+declare class UnsupportedDependency extends NullDependency {
+    request: string;
+    range: any;
+    constructor(request: any, range: any);
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default UnsupportedDependency;

package/dist/dependencies/UnsupportedDependency.js

@@ -0,0 +1,36 @@
+"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 UnsupportedDependency extends NullDependency_1.default {
+    constructor(request, range) {
+        super();
+        this.request = request;
+        this.range = range;
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.request);
+        write(this.range);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.request = read();
+        this.range = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(UnsupportedDependency, 'mp-compiler/core/dependencies/UnsupportedDependency');
+UnsupportedDependency.Template = class UnsupportedDependencyTemplate extends (NullDependency_1.default.Template) {
+    apply(dependency, source, { runtimeTemplate }) {
+        const dep = dependency;
+        source.replace(dep.range[0], dep.range[1], runtimeTemplate.missingModule({
+            request: dep.request,
+        }));
+    }
+};
+exports.default = UnsupportedDependency;

package/dist/dependencies/commonjs/CommonJsDependencyHelpers.d.ts

@@ -0,0 +1,2 @@
+declare const handleDependencyBase: (depBase: any, module: any, runtimeRequirements: Set<string>) => any[];
+export { handleDependencyBase };

package/dist/dependencies/commonjs/CommonJsDependencyHelpers.js

@@ -0,0 +1,67 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleDependencyBase = void 0;
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const handleDependencyBase = (depBase, module, runtimeRequirements) => {
+    let base;
+    let type;
+    switch (depBase) {
+        case 'exports':
+            runtimeRequirements.add(RuntimeGlobals.exports);
+            base = module.exportsArgument;
+            type = 'expression';
+            break;
+        case 'module.exports':
+            runtimeRequirements.add(RuntimeGlobals.module);
+            base = `${module.moduleArgument}.exports`;
+            type = 'expression';
+            break;
+        case 'this':
+            runtimeRequirements.add(RuntimeGlobals.thisAsExports);
+            base = 'this';
+            type = 'expression';
+            break;
+        case 'Object.defineProperty(exports)':
+            runtimeRequirements.add(RuntimeGlobals.exports);
+            base = module.exportsArgument;
+            type = 'Object.defineProperty';
+            break;
+        case 'Object.defineProperty(module.exports)':
+            runtimeRequirements.add(RuntimeGlobals.module);
+            base = `${module.moduleArgument}.exports`;
+            type = 'Object.defineProperty';
+            break;
+        case 'Object.defineProperty(this)':
+            runtimeRequirements.add(RuntimeGlobals.thisAsExports);
+            base = 'this';
+            type = 'Object.defineProperty';
+            break;
+        default:
+            throw new Error(`Unsupported base ${depBase}`);
+    }
+    return [type, base];
+};
+exports.handleDependencyBase = handleDependencyBase;

package/dist/dependencies/commonjs/CommonJsExportRequireDependency.d.ts

@@ -0,0 +1,46 @@
+import ModuleDependency from '@/dependencies/ModuleDependency';
+declare class CommonJsExportRequireDependency extends ModuleDependency {
+    valueRange: any;
+    base: any;
+    names: any;
+    ids: any;
+    resultUsed: any;
+    asiSafe: undefined;
+    constructor(range: any, valueRange: any, base: any, names: string[], request: string, ids: string[], resultUsed: boolean);
+    get type(): string;
+    couldAffectReferencingModule(): any;
+    getIds(moduleGraph: any): any;
+    setIds(moduleGraph: any, ids: any): void;
+    getReferencedExports(moduleGraph: any, runtime: any): any;
+    getExports(moduleGraph: any): {
+        exports: {
+            name: any;
+            from: any;
+            export: any;
+            canMangle: false;
+        }[];
+        dependencies: any[];
+        from?: undefined;
+        canMangle?: undefined;
+    } | {
+        exports: {
+            name: any;
+            canMangle: false;
+        }[];
+        dependencies: undefined;
+        from?: undefined;
+        canMangle?: undefined;
+    } | {
+        exports: boolean;
+        from: any;
+        canMangle: boolean;
+        dependencies: any[];
+    } | undefined;
+    getStarReexports(moduleGraph: any, runtime: any, importedModule?: any): {
+        exports: Set<unknown>;
+        checked: Set<unknown>;
+    } | undefined;
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default CommonJsExportRequireDependency;