xhs-mp-pack 1.1.0-beta.0

package/dist/dependencies/DelegatedSourceDependency.d.ts

@@ -0,0 +1,7 @@
+import ModuleDependency from '@/dependencies/ModuleDependency';
+declare class DelegatedSourceDependency extends ModuleDependency {
+    constructor(request: string);
+    get type(): string;
+    get category(): string;
+}
+export default DelegatedSourceDependency;

package/dist/dependencies/DelegatedSourceDependency.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+const ModuleDependency_1 = __importDefault(require("@/dependencies/ModuleDependency"));
+class DelegatedSourceDependency extends ModuleDependency_1.default {
+    constructor(request) {
+        super(request);
+    }
+    get type() {
+        return 'delegated source';
+    }
+    get category() {
+        return 'esm';
+    }
+}
+(0, makeSerializable_1.default)(DelegatedSourceDependency, 'mp-compiler/core/dependencies/DelegatedSourceDependency');
+exports.default = DelegatedSourceDependency;

package/dist/dependencies/DependenciesBlock.d.ts

@@ -0,0 +1,29 @@
+import Dependency from './Dependency';
+import AsyncDependenciesBlock from './AsyncDependenciesBlock';
+/**
+ * DependenciesBlock is the base class for all Module classes in webpack. It describes a
+ * "block" of dependencies which are pointers to other DependenciesBlock instances. For example
+ * when a Module has a CommonJs require statement, the DependencyBlock for the CommonJs module
+ * would be added as a dependency to the Module. DependenciesBlock is inherited by two types of classes:
+ * Module subclasses and AsyncDependenciesBlock subclasses. The only difference between the two is that
+ * AsyncDependenciesBlock subclasses are used for code-splitting (async boundary) and Module subclasses are not.
+ */
+declare class DependenciesBlock {
+    dependencies: Dependency[];
+    blocks: AsyncDependenciesBlock[];
+    parent: DependenciesBlock | undefined;
+    constructor();
+    getRootBlock(): any;
+    addBlock(block: any): void;
+    addDependency(dependency: any): void;
+    removeDependency(dependency: any): void;
+    clearDependenciesAndBlocks(): void;
+    updateHash(hash: any, context: any): void;
+    serialize({ write }: {
+        write: any;
+    }): void;
+    deserialize({ read }: {
+        read: any;
+    }): void;
+}
+export default DependenciesBlock;

package/dist/dependencies/DependenciesBlock.js

@@ -0,0 +1,66 @@
+"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"));
+/**
+ * DependenciesBlock is the base class for all Module classes in webpack. It describes a
+ * "block" of dependencies which are pointers to other DependenciesBlock instances. For example
+ * when a Module has a CommonJs require statement, the DependencyBlock for the CommonJs module
+ * would be added as a dependency to the Module. DependenciesBlock is inherited by two types of classes:
+ * Module subclasses and AsyncDependenciesBlock subclasses. The only difference between the two is that
+ * AsyncDependenciesBlock subclasses are used for code-splitting (async boundary) and Module subclasses are not.
+ */
+class DependenciesBlock {
+    constructor() {
+        this.dependencies = [];
+        this.dependencies = [];
+        this.blocks = [];
+        this.parent = undefined;
+    }
+    getRootBlock() {
+        let current = this;
+        while (current.parent)
+            current = current.parent;
+        return current;
+    }
+    addBlock(block) {
+        this.blocks.push(block);
+        block.parent = this;
+    }
+    addDependency(dependency) {
+        this.dependencies.push(dependency);
+    }
+    removeDependency(dependency) {
+        const idx = this.dependencies.indexOf(dependency);
+        if (idx >= 0) {
+            this.dependencies.splice(idx, 1);
+        }
+    }
+    clearDependenciesAndBlocks() {
+        this.dependencies.length = 0;
+        this.blocks.length = 0;
+    }
+    updateHash(hash, context) {
+        for (const dep of this.dependencies) {
+            dep.updateHash(hash, context);
+        }
+        for (const block of this.blocks) {
+            block.updateHash(hash, context);
+        }
+    }
+    serialize({ write }) {
+        write(this.dependencies);
+        write(this.blocks);
+    }
+    deserialize({ read }) {
+        this.dependencies = read();
+        this.blocks = read();
+        for (const block of this.blocks) {
+            block.parent = this;
+        }
+    }
+}
+(0, makeSerializable_1.default)(DependenciesBlock, 'mp-compiler/core/dependencies/DependenciesBlock');
+exports.default = DependenciesBlock;

package/dist/dependencies/Dependency.d.ts

@@ -0,0 +1,44 @@
+declare class Dependency {
+    static EXPORTS_OBJECT_REFERENCED: any;
+    static NO_EXPORTS_REFERENCED: any;
+    static TRANSITIVE: any;
+    userRequest: any;
+    _parentModule: any;
+    _parentDependenciesBlock: any;
+    _parentDependenciesBlockIndex: number;
+    weak: boolean;
+    optional: boolean;
+    _locSL: number;
+    _locSC: number;
+    _locEL: number;
+    _locEC: number;
+    _locI: any;
+    _locN: any;
+    _loc: any;
+    constructor();
+    get type(): string;
+    get category(): string;
+    get loc(): any;
+    set loc(loc: any);
+    setLoc(startLine: number, startColumn: number, endLine: number, endColumn: number): void;
+    getContext(): any;
+    getResourceIdentifier(): string;
+    couldAffectReferencingModule(): any;
+    getReference(moduleGraph: any): void;
+    getReferencedExports(moduleGraph: any, runtime: any): any;
+    getCondition(moduleGraph: any): any;
+    getExports(moduleGraph: any): any;
+    getWarnings(moduleGraph: any): any;
+    getErrors(moduleGraph: any): any;
+    updateHash(hash: any, context: any): void;
+    getNumberOfIdOccurrences(): number;
+    getModuleEvaluationSideEffectsState(moduleGraph: any): any;
+    createIgnoredModule(context: any): any;
+    serialize({ write }: {
+        write: any;
+    }): void;
+    deserialize({ read }: {
+        read: any;
+    }): void;
+}
+export default Dependency;

package/dist/dependencies/Dependency.js

@@ -0,0 +1,171 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const memoize_1 = __importDefault(require("@/base/memoize"));
+const RawModule_1 = __importDefault(require("../module/RawModule"));
+const TRANSITIVE = Symbol('transitive');
+const getIgnoredModule = (0, memoize_1.default)(() => new RawModule_1.default('/* (ignored) */', `ignored`, `(ignored)`));
+class Dependency {
+    constructor() {
+        this._parentModule = undefined;
+        this._parentDependenciesBlock = undefined;
+        this._parentDependenciesBlockIndex = -1;
+        // TODO check if this can be moved into ModuleDependency
+        this.weak = false;
+        // TODO check if this can be moved into ModuleDependency
+        this.optional = false;
+        this._locSL = 0;
+        this._locSC = 0;
+        this._locEL = 0;
+        this._locEC = 0;
+        this._locI = undefined;
+        this._locN = undefined;
+        this._loc = undefined;
+    }
+    get type() {
+        return 'unknown';
+    }
+    get category() {
+        return 'unknown';
+    }
+    get loc() {
+        if (this._loc !== undefined)
+            return this._loc;
+        const loc = {};
+        if (this._locSL > 0) {
+            loc.start = { line: this._locSL, column: this._locSC };
+        }
+        if (this._locEL > 0) {
+            loc.end = { line: this._locEL, column: this._locEC };
+        }
+        if (this._locN !== undefined) {
+            loc.name = this._locN;
+        }
+        if (this._locI !== undefined) {
+            loc.index = this._locI;
+        }
+        this._loc = loc;
+        return this._loc;
+    }
+    set loc(loc) {
+        if ('start' in loc && typeof loc.start === 'object') {
+            this._locSL = loc.start.line || 0;
+            this._locSC = loc.start.column || 0;
+        }
+        else {
+            this._locSL = 0;
+            this._locSC = 0;
+        }
+        if ('end' in loc && typeof loc.end === 'object') {
+            this._locEL = loc.end.line || 0;
+            this._locEC = loc.end.column || 0;
+        }
+        else {
+            this._locEL = 0;
+            this._locEC = 0;
+        }
+        if ('index' in loc) {
+            this._locI = loc.index;
+        }
+        else {
+            this._locI = undefined;
+        }
+        if ('name' in loc) {
+            this._locN = loc.name;
+        }
+        else {
+            this._locN = undefined;
+        }
+        this._loc = loc;
+    }
+    setLoc(startLine, startColumn, endLine, endColumn) {
+        this._locSL = startLine;
+        this._locSC = startColumn;
+        this._locEL = endLine;
+        this._locEC = endColumn;
+        this._locI = undefined;
+        this._locN = undefined;
+        this._loc = undefined;
+    }
+    getContext() {
+        return undefined;
+    }
+    getResourceIdentifier() {
+        // @ts-ignore
+        return null;
+    }
+    couldAffectReferencingModule() {
+        return TRANSITIVE;
+    }
+    getReference(moduleGraph) {
+        throw new Error('Dependency.getReference was removed in favor of Dependency.getReferencedExports, ModuleGraph.getModule and ModuleGraph.getConnection().active');
+    }
+    getReferencedExports(moduleGraph, runtime) {
+        return Dependency.EXPORTS_OBJECT_REFERENCED;
+    }
+    getCondition(moduleGraph) {
+        return null;
+    }
+    getExports(moduleGraph) {
+        return undefined;
+    }
+    getWarnings(moduleGraph) {
+        return null;
+    }
+    getErrors(moduleGraph) {
+        return null;
+    }
+    updateHash(hash, context) { }
+    getNumberOfIdOccurrences() {
+        return 1;
+    }
+    getModuleEvaluationSideEffectsState(moduleGraph) {
+        return true;
+    }
+    createIgnoredModule(context) {
+        return getIgnoredModule();
+    }
+    serialize({ write }) {
+        write(this.weak);
+        write(this.optional);
+        write(this._locSL);
+        write(this._locSC);
+        write(this._locEL);
+        write(this._locEC);
+        write(this._locI);
+        write(this._locN);
+    }
+    deserialize({ read }) {
+        this.weak = read();
+        this.optional = read();
+        this._locSL = read();
+        this._locSC = read();
+        this._locEL = read();
+        this._locEC = read();
+        this._locI = read();
+        this._locN = read();
+    }
+}
+Dependency.NO_EXPORTS_REFERENCED = [];
+Dependency.EXPORTS_OBJECT_REFERENCED = [[]];
+Object.defineProperty(Dependency.prototype, 'module', {
+    get() {
+        throw new Error('module property was removed from Dependency (use compilation.moduleGraph.getModule(dependency) instead)');
+    },
+    /**
+     * @deprecated
+     * @returns {never} throws
+     */
+    set() {
+        throw new Error('module property was removed from Dependency (use compilation.moduleGraph.updateModule(dependency, module) instead)');
+    },
+});
+Object.defineProperty(Dependency.prototype, 'disconnect', {
+    get() {
+        throw new Error('disconnect was removed from Dependency (Dependency no longer carries graph specific information)');
+    },
+});
+Dependency.TRANSITIVE = TRANSITIVE;
+exports.default = Dependency;

package/dist/dependencies/DependencyTemplate.d.ts

@@ -0,0 +1,4 @@
+declare class DependencyTemplate {
+    apply(dependency: any, source: any, templateContext: any): void;
+}
+export default DependencyTemplate;

package/dist/dependencies/DependencyTemplate.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class DependencyTemplate {
+    apply(dependency, source, templateContext) {
+        const AbstractMethodError = require('@/base/errors/AbstractMethodError').default;
+        throw new AbstractMethodError();
+    }
+}
+exports.default = DependencyTemplate;

package/dist/dependencies/DependencyTemplates.d.ts

@@ -0,0 +1,12 @@
+declare class DependencyTemplates {
+    _map: Map<any, any>;
+    _hash: string;
+    _hashFunction: string;
+    constructor(hashFunction?: string);
+    get(dependency: any): any;
+    set(dependency: any, dependencyTemplate: any): void;
+    updateHash(part: string): void;
+    getHash(): string;
+    clone(): DependencyTemplates;
+}
+export default DependencyTemplates;

package/dist/dependencies/DependencyTemplates.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const createHash_1 = __importDefault(require("@/base/createHash"));
+class DependencyTemplates {
+    constructor(hashFunction = 'md4') {
+        this._map = new Map();
+        this._hash = '31d6cfe0d16ae931b73c59d7e0c089c0';
+        this._hashFunction = hashFunction;
+    }
+    get(dependency) {
+        return this._map.get(dependency);
+    }
+    set(dependency, dependencyTemplate) {
+        this._map.set(dependency, dependencyTemplate);
+    }
+    updateHash(part) {
+        const hash = (0, createHash_1.default)(this._hashFunction);
+        hash.update(`${this._hash}${part}`);
+        this._hash = hash.digest('hex');
+    }
+    getHash() {
+        return this._hash;
+    }
+    clone() {
+        const newInstance = new DependencyTemplates(this._hashFunction);
+        newInstance._map = new Map(this._map);
+        newInstance._hash = this._hash;
+        return newInstance;
+    }
+}
+exports.default = DependencyTemplates;

package/dist/dependencies/DynamicExports.d.ts

@@ -0,0 +1,6 @@
+declare const bailout: (parserState: any) => void;
+declare const enable: (parserState: any) => void;
+declare const setFlagged: (parserState: any) => void;
+declare const setDynamic: (parserState: any) => void;
+declare const isEnabled: (parserState: any) => boolean;
+export { bailout, enable, setFlagged, setDynamic, isEnabled };

package/dist/dependencies/DynamicExports.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEnabled = exports.setDynamic = exports.setFlagged = exports.enable = exports.bailout = void 0;
+const parserStateExportsState = new WeakMap();
+const bailout = parserState => {
+    const value = parserStateExportsState.get(parserState);
+    parserStateExportsState.set(parserState, false);
+    if (value === true) {
+        const buildMeta = parserState.module.buildMeta;
+        buildMeta.exportsType = undefined;
+        buildMeta.defaultObject = false;
+    }
+};
+exports.bailout = bailout;
+const enable = parserState => {
+    const value = parserStateExportsState.get(parserState);
+    if (value === false)
+        return;
+    parserStateExportsState.set(parserState, true);
+    if (value !== true) {
+        const buildMeta = parserState.module.buildMeta;
+        buildMeta.exportsType = 'default';
+        buildMeta.defaultObject = 'redirect';
+    }
+};
+exports.enable = enable;
+const setFlagged = parserState => {
+    const value = parserStateExportsState.get(parserState);
+    if (value !== true)
+        return;
+    const buildMeta = parserState.module.buildMeta;
+    if (buildMeta.exportsType === 'dynamic')
+        return;
+    buildMeta.exportsType = 'flagged';
+};
+exports.setFlagged = setFlagged;
+const setDynamic = parserState => {
+    const value = parserStateExportsState.get(parserState);
+    if (value !== true)
+        return;
+    parserState.module.buildMeta.exportsType = 'dynamic';
+};
+exports.setDynamic = setDynamic;
+const isEnabled = parserState => {
+    const value = parserStateExportsState.get(parserState);
+    return value === true;
+};
+exports.isEnabled = isEnabled;

package/dist/dependencies/ExportsInfoDependency.d.ts

@@ -0,0 +1,10 @@
+import NullDependency from '@/dependencies/NullDependency';
+declare class ExportsInfoDependency extends NullDependency {
+    range: any;
+    exportName: any;
+    property: any;
+    constructor(range: any, exportName: any, property: any);
+    serialize(context: any): void;
+    static deserialize(context: any): ExportsInfoDependency;
+}
+export default ExportsInfoDependency;

package/dist/dependencies/ExportsInfoDependency.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ExportsInfo_1 = require("@/module/ExportsInfo");
+const makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+const NullDependency_1 = __importDefault(require("@/dependencies/NullDependency"));
+const getProperty = (moduleGraph, module, exportName, property, runtime) => {
+    if (!exportName) {
+        switch (property) {
+            case 'usedExports': {
+                const usedExports = moduleGraph.getExportsInfo(module).getUsedExports(runtime);
+                if (typeof usedExports === 'boolean' || usedExports === undefined || usedExports === null) {
+                    return usedExports;
+                }
+                return Array.from(usedExports).sort();
+            }
+        }
+    }
+    switch (property) {
+        case 'canMangle': {
+            const exportsInfo = moduleGraph.getExportsInfo(module);
+            const exportInfo = exportsInfo.getExportInfo(exportName);
+            if (exportInfo)
+                return exportInfo.canMangle;
+            return exportsInfo.otherExportsInfo.canMangle;
+        }
+        case 'used':
+            return moduleGraph.getExportsInfo(module).getUsed(exportName, runtime) !== ExportsInfo_1.UsageState.Unused;
+        case 'useInfo': {
+            const state = moduleGraph.getExportsInfo(module).getUsed(exportName, runtime);
+            switch (state) {
+                case ExportsInfo_1.UsageState.Used:
+                case ExportsInfo_1.UsageState.OnlyPropertiesUsed:
+                    return true;
+                case ExportsInfo_1.UsageState.Unused:
+                    return false;
+                case ExportsInfo_1.UsageState.NoInfo:
+                    return undefined;
+                case ExportsInfo_1.UsageState.Unknown:
+                    return null;
+                default:
+                    throw new Error(`Unexpected UsageState ${state}`);
+            }
+        }
+        case 'provideInfo':
+            return moduleGraph.getExportsInfo(module).isExportProvided(exportName);
+    }
+    return undefined;
+};
+class ExportsInfoDependency extends NullDependency_1.default {
+    constructor(range, exportName, property) {
+        super();
+        this.range = range;
+        this.exportName = exportName;
+        this.property = property;
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.range);
+        write(this.exportName);
+        write(this.property);
+        super.serialize(context);
+    }
+    static deserialize(context) {
+        const obj = new ExportsInfoDependency(context.read(), context.read(), context.read());
+        obj.deserialize(context);
+        return obj;
+    }
+}
+(0, makeSerializable_1.default)(ExportsInfoDependency, 'mp-compiler/core/dependencies/ExportsInfoDependency');
+ExportsInfoDependency.Template = class ExportsInfoDependencyTemplate extends (NullDependency_1.default.Template) {
+    apply(dependency, source, { module, moduleGraph, runtime }) {
+        const dep = dependency;
+        const value = getProperty(moduleGraph, module, dep.exportName, dep.property, runtime);
+        source.replace(dep.range[0], dep.range[1] - 1, value === undefined ? 'undefined' : JSON.stringify(value));
+    }
+};
+exports.default = ExportsInfoDependency;

package/dist/dependencies/LocalModule.d.ts

@@ -0,0 +1,11 @@
+declare class LocalModule {
+    name: string;
+    idx: number;
+    used: boolean;
+    constructor(name: string, idx: number);
+    flagUsed(): void;
+    variableName(): string;
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default LocalModule;

package/dist/dependencies/LocalModule.js

@@ -0,0 +1,33 @@
+"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"));
+class LocalModule {
+    constructor(name, idx) {
+        this.name = name;
+        this.idx = idx;
+        this.used = false;
+    }
+    flagUsed() {
+        this.used = true;
+    }
+    variableName() {
+        return `__WEBPACK_LOCAL_MODULE_${this.idx}__`;
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.name);
+        write(this.idx);
+        write(this.used);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.name = read();
+        this.idx = read();
+        this.used = read();
+    }
+}
+(0, makeSerializable_1.default)(LocalModule, 'mp-compiler/core/dependencies/LocalModule');
+exports.default = LocalModule;

package/dist/dependencies/LocalModuleDependency.d.ts

@@ -0,0 +1,10 @@
+import NullDependency from '@/dependencies/NullDependency';
+declare class LocalModuleDependency extends NullDependency {
+    localModule: any;
+    range: any;
+    callNew: boolean;
+    constructor(localModule: any, range: any, callNew: boolean);
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default LocalModuleDependency;

package/dist/dependencies/LocalModuleDependency.js

@@ -0,0 +1,42 @@
+"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 LocalModuleDependency extends NullDependency_1.default {
+    constructor(localModule, range, callNew) {
+        super();
+        this.localModule = localModule;
+        this.range = range;
+        this.callNew = callNew;
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.localModule);
+        write(this.range);
+        write(this.callNew);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.localModule = read();
+        this.range = read();
+        this.callNew = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(LocalModuleDependency, 'mp-compiler/core/dependencies/LocalModuleDependency');
+LocalModuleDependency.Template = class LocalModuleDependencyTemplate extends (NullDependency_1.default.Template) {
+    apply(dependency, source, templateContext) {
+        const dep = dependency;
+        if (!dep.range)
+            return;
+        const moduleInstance = dep.callNew
+            ? `new (function () { return ${dep.localModule.variableName()}; })()`
+            : dep.localModule.variableName();
+        source.replace(dep.range[0], dep.range[1] - 1, moduleInstance);
+    }
+};
+exports.default = LocalModuleDependency;

package/dist/dependencies/LocalModulesHelpers.d.ts

@@ -0,0 +1,4 @@
+import LocalModule from './LocalModule';
+declare const addLocalModule: (state: any, name: any) => LocalModule;
+declare const getLocalModule: (state: any, name: string, namedModule?: string) => any;
+export { addLocalModule, getLocalModule };