xhs-mp-pack 1.1.0-beta.0

package/dist/dependencies/css/CssUrlDependency.js

@@ -0,0 +1,89 @@
+"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"));
+const RawDataUrlModule_1 = __importDefault(require("@/module/asset/RawDataUrlModule"));
+class CssUrlDependency extends ModuleDependency_1.default {
+    constructor(request, range, urlType) {
+        super(request);
+        this.range = range;
+        this.urlType = urlType;
+    }
+    get type() {
+        return 'css url()';
+    }
+    get category() {
+        return 'url';
+    }
+    createIgnoredModule(context) {
+        return new RawDataUrlModule_1.default('data:,', `ignored-asset`, `(ignored asset)`);
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.urlType);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.urlType = read();
+        super.deserialize(context);
+    }
+}
+const cssEscapeString = str => {
+    let countWhiteOrBracket = 0;
+    let countQuotation = 0;
+    let countApostrophe = 0;
+    for (let i = 0; i < str.length; i++) {
+        const cc = str.charCodeAt(i);
+        switch (cc) {
+            case 9: // tab
+            case 10: // nl
+            case 32: // space
+            case 40: // (
+            case 41: // )
+                countWhiteOrBracket++;
+                break;
+            case 34:
+                countQuotation++;
+                break;
+            case 39:
+                countApostrophe++;
+                break;
+        }
+    }
+    if (countWhiteOrBracket < 2) {
+        return str.replace(/[\n\t ()'"\\]/g, m => `\\${m}`);
+    }
+    if (countQuotation <= countApostrophe) {
+        return `"${str.replace(/[\n"\\]/g, m => `\\${m}`)}"`;
+    }
+    return `'${str.replace(/[\n'\\]/g, m => `\\${m}`)}'`;
+};
+CssUrlDependency.Template = class CssUrlDependencyTemplate extends ModuleDependency_1.default.Template {
+    apply(dependency, source, { moduleGraph, runtimeTemplate, codeGenerationResults }) {
+        const dep = dependency;
+        let newValue;
+        switch (dep.urlType) {
+            case 'string':
+                newValue = cssEscapeString(runtimeTemplate.assetUrl({
+                    publicPath: '',
+                    module: moduleGraph.getModule(dep),
+                    codeGenerationResults,
+                }));
+                break;
+            case 'url':
+                newValue = `url(${cssEscapeString(runtimeTemplate.assetUrl({
+                    publicPath: '',
+                    module: moduleGraph.getModule(dep),
+                    codeGenerationResults,
+                }))})`;
+                break;
+        }
+        source.replace(dep.range[0], dep.range[1] - 1, newValue);
+    }
+};
+(0, makeSerializable_1.default)(CssUrlDependency, 'mp-compiler/core/dependencies/CssUrlDependency');
+exports.default = CssUrlDependency;

package/dist/dependencies/entry/DynamicEntryPlugin.d.ts

@@ -0,0 +1,22 @@
+import EntryDependency from './EntryDependency';
+declare class DynamicEntryPlugin {
+    context: any;
+    entry: any;
+    constructor(context: any, entry: any);
+    apply(compiler: any): void;
+    static entryDescriptionToOptions(compiler: any, name: any, desc: any): {
+        name: any;
+        filename: any;
+        runtime: any;
+        layer: any;
+        dependOn: any;
+        baseUri: any;
+        publicPath: any;
+        chunkLoading: any;
+        asyncChunks: any;
+        wasmLoading: any;
+        library: any;
+    };
+    static createDependency(entry: any, options: any): EntryDependency;
+}
+export default DynamicEntryPlugin;

package/dist/dependencies/entry/DynamicEntryPlugin.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const EntryDependency_1 = __importDefault(require("./EntryDependency"));
+class DynamicEntryPlugin {
+    constructor(context, entry) {
+        this.context = context;
+        this.entry = entry;
+    }
+    apply(compiler) {
+        compiler.hooks.compilation.tap('DynamicEntryPlugin', (compilation, { normalModuleFactory }) => {
+            compilation.dependencyFactories.set(EntryDependency_1.default, normalModuleFactory);
+        });
+        compiler.hooks.make.tapPromise('DynamicEntryPlugin', (compilation, callback) => Promise.resolve(this.entry())
+            .then(entry => {
+            const promises = [];
+            for (const name of Object.keys(entry)) {
+                const desc = entry[name];
+                const options = DynamicEntryPlugin.entryDescriptionToOptions(compiler, name, desc);
+                for (const entry of desc.import) {
+                    promises.push(new Promise((resolve, reject) => {
+                        compilation.addEntry(this.context, DynamicEntryPlugin.createDependency(entry, options), options, err => {
+                            if (err)
+                                return reject(err);
+                            resolve(null);
+                        });
+                    }));
+                }
+            }
+            return Promise.all(promises);
+        })
+            .then(x => { }));
+    }
+    static entryDescriptionToOptions(compiler, name, desc) {
+        const options = {
+            name,
+            filename: desc.filename,
+            runtime: desc.runtime,
+            layer: desc.layer,
+            dependOn: desc.dependOn,
+            baseUri: desc.baseUri,
+            publicPath: desc.publicPath,
+            chunkLoading: desc.chunkLoading,
+            asyncChunks: desc.asyncChunks,
+            wasmLoading: desc.wasmLoading,
+            library: desc.library,
+        };
+        if (desc.library) {
+            const EnableLibraryPlugin = require('../../library/EnableLibraryPlugin').default;
+            EnableLibraryPlugin.checkEnabled(compiler, desc.library.type);
+        }
+        return options;
+    }
+    static createDependency(entry, options) {
+        const dep = new EntryDependency_1.default(entry);
+        dep.loc = { name: typeof options === 'object' ? options.name : options };
+        return dep;
+    }
+}
+exports.default = DynamicEntryPlugin;

package/dist/dependencies/entry/EntryDependency.d.ts

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

package/dist/dependencies/entry/EntryDependency.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 EntryDependency extends ModuleDependency_1.default {
+    constructor(request) {
+        super(request);
+    }
+    get type() {
+        return 'entry';
+    }
+    get category() {
+        return 'esm';
+    }
+}
+(0, makeSerializable_1.default)(EntryDependency, 'mp-compiler/core/dependencies/EntryDependency');
+exports.default = EntryDependency;

package/dist/dependencies/getFunctionExpression.d.ts

@@ -0,0 +1,10 @@
+declare const _default: (expr: any) => {
+    fn: any;
+    expressions: never[];
+    needThis: boolean;
+} | {
+    fn: any;
+    expressions: any[];
+    needThis: undefined;
+} | undefined;
+export default _default;

package/dist/dependencies/getFunctionExpression.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = expr => {
+    // <FunctionExpression>
+    if (expr.type === 'FunctionExpression' || expr.type === 'ArrowFunctionExpression') {
+        return {
+            fn: expr,
+            expressions: [],
+            needThis: false,
+        };
+    }
+    // <FunctionExpression>.bind(<Expression>)
+    if (expr.type === 'CallExpression' &&
+        expr.callee.type === 'MemberExpression' &&
+        expr.callee.object.type === 'FunctionExpression' &&
+        expr.callee.property.type === 'Identifier' &&
+        expr.callee.property.name === 'bind' &&
+        expr.arguments.length === 1) {
+        return {
+            fn: expr.callee.object,
+            expressions: [expr.arguments[0]],
+            needThis: undefined,
+        };
+    }
+    // (function(_this) {return <FunctionExpression>})(this) (Coffeescript)
+    if (expr.type === 'CallExpression' &&
+        expr.callee.type === 'FunctionExpression' &&
+        expr.callee.body.type === 'BlockStatement' &&
+        expr.arguments.length === 1 &&
+        expr.arguments[0].type === 'ThisExpression' &&
+        expr.callee.body.body &&
+        expr.callee.body.body.length === 1 &&
+        expr.callee.body.body[0].type === 'ReturnStatement' &&
+        expr.callee.body.body[0].argument &&
+        expr.callee.body.body[0].argument.type === 'FunctionExpression') {
+        return {
+            fn: expr.callee.body.body[0].argument,
+            expressions: [],
+            needThis: true,
+        };
+    }
+};

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

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

package/dist/dependencies/harmony/HarmonyAcceptDependency.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Template_1 = require("@/template/Template");
+const makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+const NullDependency_1 = __importDefault(require("@/dependencies/NullDependency"));
+const HarmonyImportDependency_1 = require("./HarmonyImportDependency");
+class HarmonyAcceptDependency extends NullDependency_1.default {
+    constructor(range, dependencies, hasCallback) {
+        super();
+        this.range = range;
+        this.dependencies = dependencies;
+        this.hasCallback = hasCallback;
+    }
+    get type() {
+        return 'accepted harmony modules';
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.range);
+        write(this.dependencies);
+        write(this.hasCallback);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.range = read();
+        this.dependencies = read();
+        this.hasCallback = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(HarmonyAcceptDependency, 'mp-compiler/core/dependencies/HarmonyAcceptDependency');
+HarmonyAcceptDependency.Template = class HarmonyAcceptDependencyTemplate extends (NullDependency_1.default.Template) {
+    apply(dependency, source, templateContext) {
+        const dep = dependency;
+        const { module, runtime, runtimeRequirements, runtimeTemplate, moduleGraph, chunkGraph } = templateContext;
+        const content = dep.dependencies
+            .map(dependency => {
+            const referencedModule = moduleGraph.getModule(dependency);
+            return {
+                dependency,
+                runtimeCondition: referencedModule
+                    ? HarmonyImportDependency_1.HarmonyImportDependency.Template.getImportEmittedRuntime(module, referencedModule)
+                    : false,
+            };
+        })
+            .filter(({ runtimeCondition }) => runtimeCondition !== false)
+            .map(({ dependency, runtimeCondition }) => {
+            const condition = runtimeTemplate.runtimeConditionExpression({
+                chunkGraph,
+                runtime,
+                runtimeCondition,
+                runtimeRequirements,
+            });
+            const s = dependency.getImportStatement(true, templateContext);
+            const code = s[0] + s[1];
+            if (condition !== 'true') {
+                return `if (${condition}) {\n${Template_1.Template.indent(code)}\n}\n`;
+            }
+            return code;
+        })
+            .join('');
+        if (dep.hasCallback) {
+            if (runtimeTemplate.supportsArrowFunction()) {
+                source.insert(dep.range[0], `__WEBPACK_OUTDATED_DEPENDENCIES__ => { ${content}(`);
+                source.insert(dep.range[1], ')(__WEBPACK_OUTDATED_DEPENDENCIES__); }');
+            }
+            else {
+                source.insert(dep.range[0], `function(__WEBPACK_OUTDATED_DEPENDENCIES__) { ${content}(`);
+                source.insert(dep.range[1], ')(__WEBPACK_OUTDATED_DEPENDENCIES__); }.bind(this)');
+            }
+            return;
+        }
+        const arrow = runtimeTemplate.supportsArrowFunction();
+        source.insert(dep.range[1] - 0.5, `, ${arrow ? '() =>' : 'function()'} { ${content} }`);
+    }
+};
+exports.default = HarmonyAcceptDependency;

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

@@ -0,0 +1,6 @@
+import { HarmonyImportDependency } from './HarmonyImportDependency';
+declare class HarmonyAcceptImportDependency extends HarmonyImportDependency {
+    constructor(request: any);
+    get type(): string;
+}
+export default HarmonyAcceptImportDependency;

package/dist/dependencies/harmony/HarmonyAcceptImportDependency.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 HarmonyImportDependency_1 = require("./HarmonyImportDependency");
+const NullDependency_1 = __importDefault(require("../NullDependency"));
+class HarmonyAcceptImportDependency extends HarmonyImportDependency_1.HarmonyImportDependency {
+    constructor(request) {
+        super(request, NaN);
+        this.weak = true;
+    }
+    get type() {
+        return 'harmony accept';
+    }
+}
+(0, makeSerializable_1.default)(HarmonyAcceptImportDependency, 'mp-compiler/core/dependencies/HarmonyAcceptImportDependency');
+HarmonyAcceptImportDependency.Template = NullDependency_1.default.Template;
+exports.default = HarmonyAcceptImportDependency;

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

@@ -0,0 +1,5 @@
+import NullDependency from '@/dependencies/NullDependency';
+declare class HarmonyCompatibilityDependency extends NullDependency {
+    get type(): string;
+}
+export default HarmonyCompatibilityDependency;

package/dist/dependencies/harmony/HarmonyCompatibilityDependency.js

@@ -0,0 +1,61 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ExportsInfo_1 = require("@/module/ExportsInfo");
+const InitFragment_1 = __importDefault(require("@/base/InitFragment"));
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+const NullDependency_1 = __importDefault(require("@/dependencies/NullDependency"));
+class HarmonyCompatibilityDependency extends NullDependency_1.default {
+    get type() {
+        return 'harmony export header';
+    }
+}
+(0, makeSerializable_1.default)(HarmonyCompatibilityDependency, 'mp-compiler/core/dependencies/HarmonyCompatibilityDependency');
+HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate extends (NullDependency_1.default.Template) {
+    apply(dependency, source, { module, runtimeTemplate, moduleGraph, initFragments, runtimeRequirements, runtime, concatenationScope, }) {
+        if (concatenationScope)
+            return;
+        const exportsInfo = moduleGraph.getExportsInfo(module);
+        if (exportsInfo.getReadOnlyExportInfo('__esModule').getUsed(runtime) !== ExportsInfo_1.UsageState.Unused) {
+            const content = runtimeTemplate.defineEsModuleFlagStatement({
+                exportsArgument: module.exportsArgument,
+                runtimeRequirements,
+            });
+            initFragments.push(new InitFragment_1.default(content, InitFragment_1.default.STAGE_HARMONY_EXPORTS, 0, 'harmony compatibility'));
+        }
+        if (moduleGraph.isAsync(module)) {
+            runtimeRequirements.add(RuntimeGlobals.module);
+            runtimeRequirements.add(RuntimeGlobals.asyncModule);
+            initFragments.push(new InitFragment_1.default(runtimeTemplate.supportsArrowFunction()
+                ? `${RuntimeGlobals.asyncModule}(${module.moduleArgument}, async (__webpack_handle_async_dependencies__, __webpack_async_result__) => { try {\n`
+                : `${RuntimeGlobals.asyncModule}(${module.moduleArgument}, async function (__webpack_handle_async_dependencies__, __webpack_async_result__) { try {\n`, InitFragment_1.default.STAGE_ASYNC_BOUNDARY, 0, undefined, `\n__webpack_async_result__();\n} catch(e) { __webpack_async_result__(e); } }${module.buildMeta.async ? ', 1' : ''});`));
+        }
+    }
+};
+exports.default = HarmonyCompatibilityDependency;

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

@@ -0,0 +1,5 @@
+export default class HarmonyDetectionParserPlugin {
+    topLevelAwait: any;
+    constructor(options: any);
+    apply(parser: any): void;
+}

package/dist/dependencies/harmony/HarmonyDetectionParserPlugin.js

@@ -0,0 +1,102 @@
+"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 ModuleTypeConstants_1 = require("@/module/ModuleTypeConstants");
+const DynamicExports = __importStar(require("@/dependencies/DynamicExports"));
+const HarmonyExports = __importStar(require("@/dependencies/harmony/HarmonyExports"));
+const HarmonyCompatibilityDependency_1 = __importDefault(require("./HarmonyCompatibilityDependency"));
+class HarmonyDetectionParserPlugin {
+    constructor(options) {
+        const { topLevelAwait = false } = options || {};
+        this.topLevelAwait = topLevelAwait;
+    }
+    apply(parser) {
+        parser.hooks.program.tap('HarmonyDetectionParserPlugin', ast => {
+            const isStrictHarmony = parser.state.module.type === ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_ESM;
+            const isHarmony = isStrictHarmony ||
+                ast.body.some(statement => statement.type === 'ImportDeclaration' ||
+                    statement.type === 'ExportDefaultDeclaration' ||
+                    statement.type === 'ExportNamedDeclaration' ||
+                    statement.type === 'ExportAllDeclaration');
+            if (isHarmony) {
+                const module = parser.state.module;
+                const compatDep = new HarmonyCompatibilityDependency_1.default();
+                compatDep.loc = {
+                    start: {
+                        line: -1,
+                        column: 0,
+                    },
+                    end: {
+                        line: -1,
+                        column: 0,
+                    },
+                    index: -3,
+                };
+                module.addPresentationalDependency(compatDep);
+                DynamicExports.bailout(parser.state);
+                HarmonyExports.enable(parser.state, isStrictHarmony);
+                parser.scope.isStrict = true;
+            }
+        });
+        parser.hooks.topLevelAwait.tap('HarmonyDetectionParserPlugin', () => {
+            const module = parser.state.module;
+            if (!this.topLevelAwait) {
+                throw new Error('The top-level-await experiment is not enabled (set experiments.topLevelAwait: true to enabled it)');
+            }
+            if (!HarmonyExports.isEnabled(parser.state)) {
+                throw new Error('Top-level-await is only supported in EcmaScript Modules');
+            }
+            module.buildMeta.async = true;
+        });
+        /**
+         * @returns {boolean | undefined} true if in harmony
+         */
+        const skipInHarmony = () => {
+            if (HarmonyExports.isEnabled(parser.state)) {
+                return true;
+            }
+        };
+        /**
+         * @returns {null | undefined} null if in harmony
+         */
+        const nullInHarmony = () => {
+            if (HarmonyExports.isEnabled(parser.state)) {
+                return null;
+            }
+        };
+        const nonHarmonyIdentifiers = ['define', 'exports'];
+        for (const identifier of nonHarmonyIdentifiers) {
+            parser.hooks.evaluateTypeof.for(identifier).tap('HarmonyDetectionParserPlugin', nullInHarmony);
+            parser.hooks.typeof.for(identifier).tap('HarmonyDetectionParserPlugin', skipInHarmony);
+            parser.hooks.evaluate.for(identifier).tap('HarmonyDetectionParserPlugin', nullInHarmony);
+            parser.hooks.expression.for(identifier).tap('HarmonyDetectionParserPlugin', skipInHarmony);
+            parser.hooks.call.for(identifier).tap('HarmonyDetectionParserPlugin', skipInHarmony);
+        }
+    }
+}
+exports.default = HarmonyDetectionParserPlugin;

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

@@ -0,0 +1,16 @@
+import HarmonyImportSpecifierDependency from './HarmonyImportSpecifierDependency';
+/**
+ * Dependency for static evaluating import specifier. e.g.
+ * @example
+ * import a from "a";
+ * "x" in a;
+ * a.x !== undefined; // if x value statically analyzable
+ */
+declare class HarmonyEvaluatedImportSpecifierDependency extends HarmonyImportSpecifierDependency {
+    operator: string;
+    constructor(request: string, sourceOrder: number, ids: any, name: any, range: any, assertions: any, operator: string);
+    get type(): string;
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default HarmonyEvaluatedImportSpecifierDependency;

package/dist/dependencies/harmony/HarmonyEvaluatedImportSpecifierDependency.js

@@ -0,0 +1,84 @@
+"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 HarmonyImportSpecifierDependency_1 = __importDefault(require("./HarmonyImportSpecifierDependency"));
+/**
+ * Dependency for static evaluating import specifier. e.g.
+ * @example
+ * import a from "a";
+ * "x" in a;
+ * a.x !== undefined; // if x value statically analyzable
+ */
+class HarmonyEvaluatedImportSpecifierDependency extends HarmonyImportSpecifierDependency_1.default {
+    constructor(request, sourceOrder, ids, name, range, assertions, operator) {
+        super(request, sourceOrder, ids, name, range, false, assertions, []);
+        this.operator = operator;
+    }
+    get type() {
+        return `evaluated X ${this.operator} harmony import specifier`;
+    }
+    serialize(context) {
+        super.serialize(context);
+        const { write } = context;
+        write(this.operator);
+    }
+    deserialize(context) {
+        super.deserialize(context);
+        const { read } = context;
+        this.operator = read();
+    }
+}
+(0, makeSerializable_1.default)(HarmonyEvaluatedImportSpecifierDependency, 'mp-compiler/core/dependencies/HarmonyEvaluatedImportSpecifierDependency');
+HarmonyEvaluatedImportSpecifierDependency.Template = class HarmonyEvaluatedImportSpecifierDependencyTemplate extends (HarmonyImportSpecifierDependency_1.default.Template) {
+    apply(dependency, source, templateContext) {
+        const dep = dependency;
+        const { module, moduleGraph, runtime } = templateContext;
+        const connection = moduleGraph.getConnection(dep);
+        // Skip rendering depending when dependency is conditional
+        if (connection && !connection.isTargetActive(runtime))
+            return;
+        const exportsInfo = moduleGraph.getExportsInfo(connection.module);
+        const ids = dep.getIds(moduleGraph);
+        let value;
+        const exportsType = connection.module.getExportsType(moduleGraph, module.buildMeta.strictHarmonyModule);
+        switch (exportsType) {
+            case 'default-with-named': {
+                if (ids[0] === 'default') {
+                    value = ids.length === 1 || exportsInfo.isExportProvided(ids.slice(1));
+                }
+                else {
+                    value = exportsInfo.isExportProvided(ids);
+                }
+                break;
+            }
+            case 'namespace': {
+                if (ids[0] === '__esModule') {
+                    value = ids.length === 1 || undefined;
+                }
+                else {
+                    value = exportsInfo.isExportProvided(ids);
+                }
+                break;
+            }
+            case 'dynamic': {
+                if (ids[0] !== 'default') {
+                    value = exportsInfo.isExportProvided(ids);
+                }
+                break;
+            }
+            // default-only could lead to runtime error, when default value is primitive
+        }
+        if (typeof value === 'boolean') {
+            source.replace(dep.range[0], dep.range[1] - 1, ` ${value}`);
+        }
+        else {
+            const usedName = exportsInfo.getUsedName(ids, runtime);
+            const code = this._getCodeForIds(dep, source, templateContext, ids.slice(0, -1));
+            source.replace(dep.range[0], dep.range[1] - 1, `${usedName ? JSON.stringify(usedName[usedName.length - 1]) : '""'} in ${code}`);
+        }
+    }
+};
+exports.default = HarmonyEvaluatedImportSpecifierDependency;

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

@@ -0,0 +1,5 @@
+export default class HarmonyExportDependencyParserPlugin {
+    exportPresenceMode: any;
+    constructor(options: any);
+    apply(parser: any): void;
+}