xhs-mp-pack 1.1.0-beta.0

package/dist/dependencies/context/ContextDependencyHelpers.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const identifier_1 = require("@/base/identifier");
+const quoteMeta = str => str.replace(/[-[\]\\/{}()*+?.^$|]/g, '\\$&');
+const splitContextFromPrefix = prefix => {
+    const idx = prefix.lastIndexOf('/');
+    let context = '.';
+    if (idx >= 0) {
+        context = prefix.slice(0, idx);
+        prefix = `.${prefix.slice(idx)}`;
+    }
+    return {
+        context,
+        prefix,
+    };
+};
+const create = (Dep, range, param, expr, options, contextOptions, parser, ...depArgs) => {
+    var _a, _b, _c, _d, _e, _f;
+    if (param.isTemplateString()) {
+        const prefixRaw = param.quasis[0].string;
+        const postfixRaw = param.quasis.length > 1 ? param.quasis[param.quasis.length - 1].string : '';
+        const valueRange = param.range;
+        const { context, prefix } = splitContextFromPrefix(prefixRaw);
+        const { path: postfix, query, fragment } = (0, identifier_1.parseResource)(postfixRaw, parser);
+        // When there are more than two quasis, the generated RegExp can be more precise
+        // We join the quasis with the expression regexp
+        const innerQuasis = param.quasis.slice(1, param.quasis.length - 1);
+        const innerRegExp = options.wrappedContextRegExp.source +
+            innerQuasis.map(q => quoteMeta(q.string) + options.wrappedContextRegExp.source).join('');
+        // Example: `./context/pre${e}inner${e}inner2${e}post?query#frag`
+        // context: "./context"
+        // prefix: "./pre"
+        // innerQuasis: [BEE("inner"), BEE("inner2")]
+        // (BEE = BasicEvaluatedExpression)
+        // postfix: "post"
+        // query: "?query"
+        // fragment: "#frag"
+        // regExp: /^\.\/pre.*inner.*inner2.*post$/
+        const regExp = new RegExp(`^${quoteMeta(prefix)}${innerRegExp}${quoteMeta(postfix)}$`);
+        const dep = new Dep(Object.assign({ request: context + query + fragment, recursive: options.wrappedContextRecursive, regExp, mode: 'sync' }, contextOptions), range, valueRange, ...depArgs);
+        dep.loc = expr.loc;
+        const replaces = [];
+        param.parts.forEach((part, i) => {
+            if (i % 2 === 0) {
+                // Quasis or merged quasi
+                let range = part.range;
+                let value = part.string;
+                if (param.templateStringKind === 'cooked') {
+                    value = JSON.stringify(value);
+                    value = value.slice(1, value.length - 1);
+                }
+                if (i === 0) {
+                    // prefix
+                    value = prefix;
+                    range = [param.range[0], part.range[1]];
+                    value = (param.templateStringKind === 'cooked' ? '`' : 'String.raw`') + value;
+                }
+                else if (i === param.parts.length - 1) {
+                    // postfix
+                    value = postfix;
+                    range = [part.range[0], param.range[1]];
+                    value += '`';
+                }
+                else if (part.expression &&
+                    part.expression.type === 'TemplateElement' &&
+                    part.expression.value.raw === value) {
+                    // Shortcut when it's a single quasi and doesn't need to be replaced
+                    return;
+                }
+                replaces.push({
+                    range,
+                    value,
+                });
+            }
+            else {
+                // Expression
+                parser.walkExpression(part.expression);
+            }
+        });
+        dep.replaces = replaces;
+        dep.critical =
+            options.wrappedContextCritical && 'a part of the request of a dependency is an expression';
+        return dep;
+    }
+    if (param.isWrapped() &&
+        (((_a = param.prefix) === null || _a === void 0 ? void 0 : _a.isString()) || ((_b = param.postfix) === null || _b === void 0 ? void 0 : _b.isString()))) {
+        const prefixRaw = ((_c = param.prefix) === null || _c === void 0 ? void 0 : _c.isString()) ? param.prefix.string : '';
+        const postfixRaw = ((_d = param.postfix) === null || _d === void 0 ? void 0 : _d.isString()) ? param.postfix.string : '';
+        const prefixRange = ((_e = param.prefix) === null || _e === void 0 ? void 0 : _e.isString()) ? param.prefix.range : null;
+        const postfixRange = ((_f = param.postfix) === null || _f === void 0 ? void 0 : _f.isString()) ? param.postfix.range : null;
+        const valueRange = param.range;
+        const { context, prefix } = splitContextFromPrefix(prefixRaw);
+        const { path: postfix, query, fragment } = (0, identifier_1.parseResource)(postfixRaw, parser);
+        const regExp = new RegExp(`^${quoteMeta(prefix)}${options.wrappedContextRegExp.source}${quoteMeta(postfix)}$`);
+        const dep = new Dep(Object.assign({ request: context + query + fragment, recursive: options.wrappedContextRecursive, regExp, mode: 'sync' }, contextOptions), range, valueRange, ...depArgs);
+        dep.loc = expr.loc;
+        const replaces = [];
+        if (prefixRange) {
+            replaces.push({
+                range: prefixRange,
+                value: JSON.stringify(prefix),
+            });
+        }
+        if (postfixRange) {
+            replaces.push({
+                range: postfixRange,
+                value: JSON.stringify(postfix),
+            });
+        }
+        dep.replaces = replaces;
+        dep.critical =
+            options.wrappedContextCritical && 'a part of the request of a dependency is an expression';
+        if (parser && param.wrappedInnerExpressions) {
+            for (const part of param.wrappedInnerExpressions) {
+                if (part.expression)
+                    parser.walkExpression(part.expression);
+            }
+        }
+        return dep;
+    }
+    const dep = new Dep(Object.assign({ request: options.exprContextRequest, recursive: options.exprContextRecursive, regExp: options.exprContextRegExp, mode: 'sync' }, contextOptions), range, param.range, ...depArgs);
+    dep.loc = expr.loc;
+    dep.critical = options.exprContextCritical && 'the request of a dependency is an expression';
+    parser.walkExpression(param.expression);
+    return dep;
+};
+exports.create = create;

package/dist/dependencies/context/ContextDependencyTemplateAsId.d.ts

@@ -0,0 +1,10 @@
+import ContextDependency from './ContextDependency';
+declare class ContextDependencyTemplateAsId extends ContextDependency.Template {
+    apply(dependency: any, source: any, { runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }: {
+        runtimeTemplate: any;
+        moduleGraph: any;
+        chunkGraph: any;
+        runtimeRequirements: any;
+    }): void;
+}
+export default ContextDependencyTemplateAsId;

package/dist/dependencies/context/ContextDependencyTemplateAsId.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ContextDependency_1 = __importDefault(require("./ContextDependency"));
+class ContextDependencyTemplateAsId extends ContextDependency_1.default.Template {
+    apply(dependency, source, { runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }) {
+        const dep = dependency;
+        const moduleExports = runtimeTemplate.moduleExports({
+            module: moduleGraph.getModule(dep),
+            chunkGraph,
+            request: dep.request,
+            weak: dep.weak,
+            runtimeRequirements,
+        });
+        if (moduleGraph.getModule(dep)) {
+            if (dep.valueRange) {
+                if (Array.isArray(dep.replaces)) {
+                    for (let i = 0; i < dep.replaces.length; i++) {
+                        const rep = dep.replaces[i];
+                        source.replace(rep.range[0], rep.range[1] - 1, rep.value);
+                    }
+                }
+                source.replace(dep.valueRange[1], dep.range[1] - 1, ')');
+                source.replace(dep.range[0], dep.valueRange[0] - 1, `${moduleExports}.resolve(`);
+            }
+            else {
+                source.replace(dep.range[0], dep.range[1] - 1, `${moduleExports}.resolve`);
+            }
+        }
+        else {
+            source.replace(dep.range[0], dep.range[1] - 1, moduleExports);
+        }
+    }
+}
+exports.default = ContextDependencyTemplateAsId;

package/dist/dependencies/context/ContextDependencyTemplateAsRequireCall.d.ts

@@ -0,0 +1,10 @@
+import ContextDependency from './ContextDependency';
+declare class ContextDependencyTemplateAsRequireCall extends ContextDependency.Template {
+    apply(dependency: any, source: any, { runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }: {
+        runtimeTemplate: any;
+        moduleGraph: any;
+        chunkGraph: any;
+        runtimeRequirements: any;
+    }): void;
+}
+export default ContextDependencyTemplateAsRequireCall;

package/dist/dependencies/context/ContextDependencyTemplateAsRequireCall.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 ContextDependency_1 = __importDefault(require("./ContextDependency"));
+class ContextDependencyTemplateAsRequireCall extends ContextDependency_1.default.Template {
+    apply(dependency, source, { runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }) {
+        const dep = dependency;
+        let moduleExports = runtimeTemplate.moduleExports({
+            module: moduleGraph.getModule(dep),
+            chunkGraph,
+            request: dep.request,
+            runtimeRequirements,
+        });
+        if (dep.inShorthand) {
+            moduleExports = `${dep.inShorthand}: ${moduleExports}`;
+        }
+        if (moduleGraph.getModule(dep)) {
+            if (dep.valueRange) {
+                if (Array.isArray(dep.replaces)) {
+                    for (let i = 0; i < dep.replaces.length; i++) {
+                        const rep = dep.replaces[i];
+                        source.replace(rep.range[0], rep.range[1] - 1, rep.value);
+                    }
+                }
+                source.replace(dep.valueRange[1], dep.range[1] - 1, ')');
+                source.replace(dep.range[0], dep.valueRange[0] - 1, `${moduleExports}(`);
+            }
+            else {
+                source.replace(dep.range[0], dep.range[1] - 1, moduleExports);
+            }
+        }
+        else {
+            source.replace(dep.range[0], dep.range[1] - 1, moduleExports);
+        }
+    }
+}
+exports.default = ContextDependencyTemplateAsRequireCall;

package/dist/dependencies/context/ContextElementDependency.d.ts

@@ -0,0 +1,13 @@
+import ModuleDependency from '@/dependencies/ModuleDependency';
+declare class ContextElementDependency extends ModuleDependency {
+    referencedExports: string[][] | undefined;
+    _typePrefix: string;
+    _category: string;
+    constructor(request: string, userRequest: string | undefined, typePrefix: string, category: string, referencedExports?: string[][], context?: string);
+    get type(): string;
+    get category(): string;
+    getReferencedExports(moduleGraph: any, runtime: any): any;
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default ContextElementDependency;

package/dist/dependencies/context/ContextElementDependency.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Dependency_1 = __importDefault(require("@/dependencies/Dependency"));
+const makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+const ModuleDependency_1 = __importDefault(require("@/dependencies/ModuleDependency"));
+class ContextElementDependency extends ModuleDependency_1.default {
+    constructor(request, userRequest, typePrefix, category, referencedExports, context) {
+        super(request);
+        this.referencedExports = referencedExports;
+        this._typePrefix = typePrefix;
+        this._category = category;
+        this._context = context || undefined;
+        if (userRequest) {
+            this.userRequest = userRequest;
+        }
+    }
+    get type() {
+        if (this._typePrefix) {
+            return `${this._typePrefix} context element`;
+        }
+        return 'context element';
+    }
+    get category() {
+        return this._category;
+    }
+    getReferencedExports(moduleGraph, runtime) {
+        return this.referencedExports
+            ? this.referencedExports.map(e => ({
+                name: e,
+                canMangle: false,
+            }))
+            : Dependency_1.default.EXPORTS_OBJECT_REFERENCED;
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this._typePrefix);
+        write(this._category);
+        write(this.referencedExports);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this._typePrefix = read();
+        this._category = read();
+        this.referencedExports = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(ContextElementDependency, 'mp-compiler/core/dependencies/ContextElementDependency');
+exports.default = ContextElementDependency;

package/dist/dependencies/css/CssExportDependency.d.ts

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

package/dist/dependencies/css/CssExportDependency.js

@@ -0,0 +1,49 @@
+"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 CssExportDependency extends NullDependency_1.default {
+    constructor(name, value) {
+        super();
+        this.name = name;
+        this.value = value;
+    }
+    get type() {
+        return 'css :export';
+    }
+    getExports(moduleGraph) {
+        const name = this.name;
+        return {
+            exports: [
+                {
+                    name,
+                    canMangle: true,
+                },
+            ],
+            dependencies: undefined,
+        };
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.name);
+        write(this.value);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.name = read();
+        this.value = read();
+        super.deserialize(context);
+    }
+}
+CssExportDependency.Template = class CssExportDependencyTemplate extends NullDependency_1.default.Template {
+    apply(dependency, source, { cssExports }) {
+        const dep = dependency;
+        cssExports.set(dep.name, dep.value);
+    }
+};
+(0, makeSerializable_1.default)(CssExportDependency, 'mp-compiler/core/dependencies/CssExportDependency');
+exports.default = CssExportDependency;

package/dist/dependencies/css/CssImportDependency.d.ts

@@ -0,0 +1,14 @@
+import ModuleDependency from '@/dependencies/ModuleDependency';
+declare class CssImportDependency extends ModuleDependency {
+    layer: string | undefined;
+    supports: string | undefined;
+    media: string | undefined;
+    constructor(request: string, range: any, layer?: string, supports?: string, media?: string);
+    get type(): string;
+    get category(): string;
+    getResourceIdentifier(): string;
+    createIgnoredModule(context: any): null;
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default CssImportDependency;

package/dist/dependencies/css/CssImportDependency.js

@@ -0,0 +1,60 @@
+"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 ModuleDependency_1 = __importDefault(require("@/dependencies/ModuleDependency"));
+class CssImportDependency extends ModuleDependency_1.default {
+    constructor(request, range, layer, supports, media) {
+        super(request);
+        this.range = range;
+        this.layer = layer;
+        this.supports = supports;
+        this.media = media;
+    }
+    get type() {
+        return 'css @import';
+    }
+    get category() {
+        return 'css-import';
+    }
+    getResourceIdentifier() {
+        let str = `context${this._context || ''}|module${this.request}`;
+        if (this.layer) {
+            str += `|layer${this.layer}`;
+        }
+        if (this.supports) {
+            str += `|supports${this.supports}`;
+        }
+        if (this.media) {
+            str += `|media${this.media}`;
+        }
+        return str;
+    }
+    createIgnoredModule(context) {
+        return null;
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.layer);
+        write(this.supports);
+        write(this.media);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.layer = read();
+        this.supports = read();
+        this.media = read();
+        super.deserialize(context);
+    }
+}
+CssImportDependency.Template = class CssImportDependencyTemplate extends ModuleDependency_1.default.Template {
+    apply(dependency, source, templateContext) {
+        const dep = dependency;
+        source.replace(dep.range[0], dep.range[1] - 1, '');
+    }
+};
+(0, makeSerializable_1.default)(CssImportDependency, 'mp-compiler/core/dependencies/CssImportDependency');
+exports.default = CssImportDependency;

package/dist/dependencies/css/CssLocalIdentifierDependency.d.ts

@@ -0,0 +1,12 @@
+import NullDependency from '@/dependencies/NullDependency';
+declare class CssLocalIdentifierDependency extends NullDependency {
+    name: any;
+    range: any;
+    prefix: string;
+    constructor(name: any, range: any, prefix?: string);
+    get type(): string;
+    getExports(moduleGraph: any): any;
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default CssLocalIdentifierDependency;

package/dist/dependencies/css/CssLocalIdentifierDependency.js

@@ -0,0 +1,69 @@
+"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 CssLocalIdentifierDependency extends NullDependency_1.default {
+    constructor(name, range, prefix = '') {
+        super();
+        this.name = name;
+        this.range = range;
+        this.prefix = prefix;
+    }
+    get type() {
+        return 'css local identifier';
+    }
+    getExports(moduleGraph) {
+        const name = this.name;
+        return {
+            exports: [
+                {
+                    name,
+                    canMangle: true,
+                },
+            ],
+            dependencies: undefined,
+        };
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.name);
+        write(this.range);
+        write(this.prefix);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.name = read();
+        this.range = read();
+        this.prefix = read();
+        super.deserialize(context);
+    }
+}
+const escapeCssIdentifier = (str, omitUnderscore) => {
+    const escaped = `${str}`.replace(
+    // cspell:word uffff
+    /[^a-zA-Z0-9_\u0081-\uffff-]/g, s => `\\${s}`);
+    return !omitUnderscore && /^(?!--)[0-9-]/.test(escaped) ? `_${escaped}` : escaped;
+};
+CssLocalIdentifierDependency.Template = class CssLocalIdentifierDependencyTemplate extends (NullDependency_1.default.Template) {
+    apply(dependency, source, { module, moduleGraph, chunkGraph, runtime, runtimeTemplate, cssExports }) {
+        const dep = dependency;
+        const used = moduleGraph.getExportInfo(module, dep.name).getUsedName(dep.name, runtime);
+        if (!used)
+            return;
+        const moduleId = chunkGraph.getModuleId(module);
+        const identifier = dep.prefix +
+            (runtimeTemplate.outputOptions.uniqueName
+                ? `${runtimeTemplate.outputOptions.uniqueName}-`
+                : '') +
+            (used ? `${moduleId}-${used}` : '-');
+        source.replace(dep.range[0], dep.range[1] - 1, escapeCssIdentifier(identifier, dep.prefix));
+        if (used)
+            cssExports.set(used, identifier);
+    }
+};
+(0, makeSerializable_1.default)(CssLocalIdentifierDependency, 'mp-compiler/core/dependencies/CssLocalIdentifierDependency');
+exports.default = CssLocalIdentifierDependency;

package/dist/dependencies/css/CssSelfLocalIdentifierDependency.d.ts

@@ -0,0 +1,13 @@
+import CssLocalIdentifierDependency from './CssLocalIdentifierDependency';
+declare class CssSelfLocalIdentifierDependency extends CssLocalIdentifierDependency {
+    declaredSet: any;
+    constructor(name: any, range: any, prefix?: string, declaredSet?: undefined);
+    get type(): string;
+    get category(): string;
+    getResourceIdentifier(): string;
+    getExports(moduleGraph: any): any;
+    getReferencedExports(moduleGraph: any, runtime: any): any;
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default CssSelfLocalIdentifierDependency;

package/dist/dependencies/css/CssSelfLocalIdentifierDependency.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Dependency_1 = __importDefault(require("@/dependencies/Dependency"));
+const makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+const CssLocalIdentifierDependency_1 = __importDefault(require("./CssLocalIdentifierDependency"));
+class CssSelfLocalIdentifierDependency extends CssLocalIdentifierDependency_1.default {
+    constructor(name, range, prefix = '', declaredSet = undefined) {
+        super(name, range, prefix);
+        this.declaredSet = declaredSet;
+    }
+    get type() {
+        return 'css self local identifier';
+    }
+    get category() {
+        return 'self';
+    }
+    getResourceIdentifier() {
+        return `self`;
+    }
+    getExports(moduleGraph) {
+        if (this.declaredSet && !this.declaredSet.has(this.name))
+            return;
+        return super.getExports(moduleGraph);
+    }
+    getReferencedExports(moduleGraph, runtime) {
+        if (this.declaredSet && !this.declaredSet.has(this.name))
+            return Dependency_1.default.NO_EXPORTS_REFERENCED;
+        return [[this.name]];
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.declaredSet);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.declaredSet = read();
+        super.deserialize(context);
+    }
+}
+CssSelfLocalIdentifierDependency.Template = class CssSelfLocalIdentifierDependencyTemplate extends (CssLocalIdentifierDependency_1.default.Template) {
+    apply(dependency, source, templateContext) {
+        const dep = dependency;
+        if (dep.declaredSet && !dep.declaredSet.has(dep.name))
+            return;
+        super.apply(dependency, source, templateContext);
+    }
+};
+(0, makeSerializable_1.default)(CssSelfLocalIdentifierDependency, 'mp-compiler/core/dependencies/CssSelfLocalIdentifierDependency');
+exports.default = CssSelfLocalIdentifierDependency;

package/dist/dependencies/css/CssUrlDependency.d.ts

@@ -0,0 +1,12 @@
+import ModuleDependency from '@/dependencies/ModuleDependency';
+import RawDataUrlModule from '@/module/asset/RawDataUrlModule';
+declare class CssUrlDependency extends ModuleDependency {
+    urlType: 'string' | 'url';
+    constructor(request: any, range: any, urlType: any);
+    get type(): string;
+    get category(): string;
+    createIgnoredModule(context: any): RawDataUrlModule;
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default CssUrlDependency;