xhs-mp-pack 1.1.0-beta.0

package/dist/dependencies/import/ImportMetaPlugin.js

@@ -0,0 +1,129 @@
+"use strict";
+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 ModuleDependencyWarning_1 = __importDefault(require("@/base/errors/ModuleDependencyWarning"));
+const ModuleTypeConstants_1 = require("@/module/ModuleTypeConstants");
+const Template_1 = require("@/template/Template");
+const BasicEvaluatedExpression_1 = __importDefault(require("@/module/javascript/BasicEvaluatedExpression"));
+const JavascriptParserHelpers_1 = require("@/module/javascript/JavascriptParserHelpers");
+const propertyAccess_1 = __importDefault(require("@/base/propertyAccess"));
+const ConstDependency_1 = __importDefault(require("@/dependencies/const/ConstDependency"));
+const CriticalDependencyWarning_1 = __importDefault(require("@/base/errors/CriticalDependencyWarning"));
+const PLUGIN_NAME = 'ImportMetaPlugin';
+const packageJson = require('../../../package.json');
+class ImportMetaPlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation, { normalModuleFactory }) => {
+            const getUrl = module => (0, url_1.pathToFileURL)(module.resource).toString();
+            const parserHandler = (parser, { importMeta }) => {
+                if (importMeta === false) {
+                    const { importMetaName } = compilation.outputOptions;
+                    if (importMetaName === 'import.meta')
+                        return;
+                    parser.hooks.expression.for('import.meta').tap(PLUGIN_NAME, metaProperty => {
+                        const dep = new ConstDependency_1.default(importMetaName, metaProperty.range);
+                        dep.loc = metaProperty.loc;
+                        parser.state.module.addPresentationalDependency(dep);
+                        return true;
+                    });
+                    return;
+                }
+                /// import.meta direct ///
+                const webpackVersion = parseInt(packageJson.version, 10);
+                const importMetaUrl = () => JSON.stringify(getUrl(parser.state.module));
+                const importMetaWebpackVersion = () => JSON.stringify(webpackVersion);
+                const importMetaUnknownProperty = members => `${Template_1.Template.toNormalComment(`unsupported import.meta.${members.join('.')}`)} undefined${(0, propertyAccess_1.default)(members, 1)}`;
+                parser.hooks.typeof
+                    .for('import.meta')
+                    .tap(PLUGIN_NAME, (0, JavascriptParserHelpers_1.toConstantDependency)(parser, JSON.stringify('object')));
+                parser.hooks.expression.for('import.meta').tap(PLUGIN_NAME, metaProperty => {
+                    const referencedPropertiesInDestructuring = parser.destructuringAssignmentPropertiesFor(metaProperty);
+                    if (!referencedPropertiesInDestructuring) {
+                        parser.state.module.addWarning(new ModuleDependencyWarning_1.default(parser.state.module, new CriticalDependencyWarning_1.default('Accessing import.meta directly is unsupported (only property access or destructuring is supported)'), metaProperty.loc));
+                        const dep = new ConstDependency_1.default(`${parser.isAsiPosition(metaProperty.range[0]) ? ';' : ''}({})`, metaProperty.range);
+                        dep.loc = metaProperty.loc;
+                        parser.state.module.addPresentationalDependency(dep);
+                        return true;
+                    }
+                    let str = '';
+                    for (const prop of referencedPropertiesInDestructuring) {
+                        switch (prop) {
+                            case 'url':
+                                str += `url: ${importMetaUrl()},`;
+                                break;
+                            case 'webpack':
+                                str += `webpack: ${importMetaWebpackVersion()},`;
+                                break;
+                            default:
+                                str += `[${JSON.stringify(prop)}]: ${importMetaUnknownProperty([prop])},`;
+                                break;
+                        }
+                    }
+                    const dep = new ConstDependency_1.default(`({${str}})`, metaProperty.range);
+                    dep.loc = metaProperty.loc;
+                    parser.state.module.addPresentationalDependency(dep);
+                    return true;
+                });
+                parser.hooks.evaluateTypeof.for('import.meta').tap(PLUGIN_NAME, (0, JavascriptParserHelpers_1.evaluateToString)('object'));
+                parser.hooks.evaluateIdentifier.for('import.meta').tap(PLUGIN_NAME, (0, JavascriptParserHelpers_1.evaluateToIdentifier)('import.meta', 'import.meta', () => [], true));
+                /// import.meta.url ///
+                parser.hooks.typeof
+                    .for('import.meta.url')
+                    .tap(PLUGIN_NAME, (0, JavascriptParserHelpers_1.toConstantDependency)(parser, JSON.stringify('string')));
+                parser.hooks.expression.for('import.meta.url').tap(PLUGIN_NAME, expr => {
+                    const dep = new ConstDependency_1.default(importMetaUrl(), expr.range);
+                    dep.loc = expr.loc;
+                    parser.state.module.addPresentationalDependency(dep);
+                    return true;
+                });
+                parser.hooks.evaluateTypeof
+                    .for('import.meta.url')
+                    .tap(PLUGIN_NAME, (0, JavascriptParserHelpers_1.evaluateToString)('string'));
+                parser.hooks.evaluateIdentifier.for('import.meta.url').tap(PLUGIN_NAME, expr => new BasicEvaluatedExpression_1.default()
+                    .setString(getUrl(parser.state.module))
+                    .setRange(expr.range));
+                /// import.meta.webpack ///
+                parser.hooks.typeof
+                    .for('import.meta.webpack')
+                    .tap(PLUGIN_NAME, (0, JavascriptParserHelpers_1.toConstantDependency)(parser, JSON.stringify('number')));
+                parser.hooks.expression
+                    .for('import.meta.webpack')
+                    .tap(PLUGIN_NAME, (0, JavascriptParserHelpers_1.toConstantDependency)(parser, importMetaWebpackVersion()));
+                parser.hooks.evaluateTypeof
+                    .for('import.meta.webpack')
+                    .tap(PLUGIN_NAME, (0, JavascriptParserHelpers_1.evaluateToString)('number'));
+                parser.hooks.evaluateIdentifier
+                    .for('import.meta.webpack')
+                    .tap(PLUGIN_NAME, (0, JavascriptParserHelpers_1.evaluateToNumber)(webpackVersion));
+                /// Unknown properties ///
+                parser.hooks.unhandledExpressionMemberChain
+                    .for('import.meta')
+                    .tap(PLUGIN_NAME, (expr, members) => {
+                    const dep = new ConstDependency_1.default(importMetaUnknownProperty(members), expr.range);
+                    dep.loc = expr.loc;
+                    parser.state.module.addPresentationalDependency(dep);
+                    return true;
+                });
+                parser.hooks.evaluate.for('MemberExpression').tap(PLUGIN_NAME, expression => {
+                    const expr = expression;
+                    if (expr.object.type === 'MetaProperty' &&
+                        expr.object.meta.name === 'import' &&
+                        expr.object.property.name === 'meta' &&
+                        expr.property.type === (expr.computed ? 'Literal' : 'Identifier')) {
+                        return new BasicEvaluatedExpression_1.default().setUndefined().setRange(expr.range);
+                    }
+                });
+            };
+            normalModuleFactory.hooks.parser
+                .for(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_AUTO)
+                .tap(PLUGIN_NAME, parserHandler);
+            normalModuleFactory.hooks.parser
+                .for(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_ESM)
+                .tap(PLUGIN_NAME, parserHandler);
+        });
+    }
+}
+exports.default = ImportMetaPlugin;

package/dist/dependencies/import/ImportParserPlugin.d.ts

@@ -0,0 +1,6 @@
+declare class ImportParserPlugin {
+    options: any;
+    constructor(options: any);
+    apply(parser: any): void;
+}
+export default ImportParserPlugin;

package/dist/dependencies/import/ImportParserPlugin.js

@@ -0,0 +1,207 @@
+"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 CommentCompilationWarning_1 = __importDefault(require("@/base/errors/CommentCompilationWarning"));
+const UnsupportedFeatureWarning_1 = __importDefault(require("@/base/errors/UnsupportedFeatureWarning"));
+const ContextDependencyHelpers = __importStar(require("@/dependencies/context/ContextDependencyHelpers"));
+const AsyncDependenciesBlock_1 = __importDefault(require("../AsyncDependenciesBlock"));
+const ImportContextDependency_1 = __importDefault(require("./ImportContextDependency"));
+const ImportDependency_1 = __importDefault(require("./ImportDependency"));
+const ImportEagerDependency_1 = __importDefault(require("./ImportEagerDependency"));
+const ImportWeakDependency_1 = __importDefault(require("./ImportWeakDependency"));
+class ImportParserPlugin {
+    constructor(options) {
+        this.options = options;
+    }
+    apply(parser) {
+        const exportsFromEnumerable = enumerable => Array.from(enumerable, e => [e]);
+        parser.hooks.importCall.tap('ImportParserPlugin', expr => {
+            const param = parser.evaluateExpression(expr.source);
+            let chunkName = null;
+            let mode = this.options.dynamicImportMode;
+            let include = null;
+            let exclude = null;
+            let exports = null;
+            const groupOptions = {};
+            const { dynamicImportPreload, dynamicImportPrefetch, dynamicImportFetchPriority } = this.options;
+            if (dynamicImportPreload !== undefined && dynamicImportPreload !== false)
+                groupOptions.preloadOrder = dynamicImportPreload === true ? 0 : dynamicImportPreload;
+            if (dynamicImportPrefetch !== undefined && dynamicImportPrefetch !== false)
+                groupOptions.prefetchOrder = dynamicImportPrefetch === true ? 0 : dynamicImportPrefetch;
+            if (dynamicImportFetchPriority !== undefined && dynamicImportFetchPriority !== false)
+                groupOptions.fetchPriority = dynamicImportFetchPriority;
+            const { options: importOptions, errors: commentErrors } = parser.parseCommentOptions(expr.range);
+            if (commentErrors) {
+                for (const e of commentErrors) {
+                    const { comment } = e;
+                    parser.state.module.addWarning(new CommentCompilationWarning_1.default(`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`, comment.loc));
+                }
+            }
+            if (importOptions) {
+                if (importOptions.webpackIgnore !== undefined) {
+                    if (typeof importOptions.webpackIgnore !== 'boolean') {
+                        parser.state.module.addWarning(new UnsupportedFeatureWarning_1.default(`\`webpackIgnore\` expected a boolean, but received: ${importOptions.webpackIgnore}.`, expr.loc));
+                    }
+                    else {
+                        // Do not instrument `import()` if `webpackIgnore` is `true`
+                        // eslint-disable-next-line no-lonely-if
+                        if (importOptions.webpackIgnore) {
+                            return false;
+                        }
+                    }
+                }
+                if (importOptions.webpackChunkName !== undefined) {
+                    if (typeof importOptions.webpackChunkName !== 'string') {
+                        parser.state.module.addWarning(new UnsupportedFeatureWarning_1.default(`\`webpackChunkName\` expected a string, but received: ${importOptions.webpackChunkName}.`, expr.loc));
+                    }
+                    else {
+                        chunkName = importOptions.webpackChunkName;
+                    }
+                }
+                if (importOptions.webpackMode !== undefined) {
+                    if (typeof importOptions.webpackMode !== 'string') {
+                        parser.state.module.addWarning(new UnsupportedFeatureWarning_1.default(`\`webpackMode\` expected a string, but received: ${importOptions.webpackMode}.`, expr.loc));
+                    }
+                    else {
+                        mode = importOptions.webpackMode;
+                    }
+                }
+                if (importOptions.webpackPrefetch !== undefined) {
+                    if (importOptions.webpackPrefetch === true) {
+                        groupOptions.prefetchOrder = 0;
+                    }
+                    else if (typeof importOptions.webpackPrefetch === 'number') {
+                        groupOptions.prefetchOrder = importOptions.webpackPrefetch;
+                    }
+                    else {
+                        parser.state.module.addWarning(new UnsupportedFeatureWarning_1.default(`\`webpackPrefetch\` expected true or a number, but received: ${importOptions.webpackPrefetch}.`, expr.loc));
+                    }
+                }
+                if (importOptions.webpackPreload !== undefined) {
+                    if (importOptions.webpackPreload === true) {
+                        groupOptions.preloadOrder = 0;
+                    }
+                    else if (typeof importOptions.webpackPreload === 'number') {
+                        groupOptions.preloadOrder = importOptions.webpackPreload;
+                    }
+                    else {
+                        parser.state.module.addWarning(new UnsupportedFeatureWarning_1.default(`\`webpackPreload\` expected true or a number, but received: ${importOptions.webpackPreload}.`, expr.loc));
+                    }
+                }
+                if (importOptions.webpackFetchPriority !== undefined) {
+                    if (typeof importOptions.webpackFetchPriority === 'string' &&
+                        ['high', 'low', 'auto'].includes(importOptions.webpackFetchPriority)) {
+                        groupOptions.fetchPriority = importOptions.webpackFetchPriority;
+                    }
+                    else {
+                        parser.state.module.addWarning(new UnsupportedFeatureWarning_1.default(`\`webpackFetchPriority\` expected true or "low", "high" or "auto", but received: ${importOptions.webpackFetchPriority}.`, expr.loc));
+                    }
+                }
+                if (importOptions.webpackInclude !== undefined) {
+                    if (!importOptions.webpackInclude || !(importOptions.webpackInclude instanceof RegExp)) {
+                        parser.state.module.addWarning(new UnsupportedFeatureWarning_1.default(`\`webpackInclude\` expected a regular expression, but received: ${importOptions.webpackInclude}.`, expr.loc));
+                    }
+                    else {
+                        include = importOptions.webpackInclude;
+                    }
+                }
+                if (importOptions.webpackExclude !== undefined) {
+                    if (!importOptions.webpackExclude || !(importOptions.webpackExclude instanceof RegExp)) {
+                        parser.state.module.addWarning(new UnsupportedFeatureWarning_1.default(`\`webpackExclude\` expected a regular expression, but received: ${importOptions.webpackExclude}.`, expr.loc));
+                    }
+                    else {
+                        exclude = importOptions.webpackExclude;
+                    }
+                }
+                if (importOptions.webpackExports !== undefined) {
+                    if (!(typeof importOptions.webpackExports === 'string' ||
+                        (Array.isArray(importOptions.webpackExports) &&
+                            importOptions.webpackExports.every(item => typeof item === 'string')))) {
+                        parser.state.module.addWarning(new UnsupportedFeatureWarning_1.default(`\`webpackExports\` expected a string or an array of strings, but received: ${importOptions.webpackExports}.`, expr.loc));
+                    }
+                    else if (typeof importOptions.webpackExports === 'string') {
+                        exports = [[importOptions.webpackExports]];
+                    }
+                    else {
+                        exports = exportsFromEnumerable(importOptions.webpackExports);
+                    }
+                }
+            }
+            if (mode !== 'lazy' && mode !== 'lazy-once' && mode !== 'eager' && mode !== 'weak') {
+                parser.state.module.addWarning(new UnsupportedFeatureWarning_1.default(`\`webpackMode\` expected 'lazy', 'lazy-once', 'eager' or 'weak', but received: ${mode}.`, expr.loc));
+                mode = 'lazy';
+            }
+            const referencedPropertiesInDestructuring = parser.destructuringAssignmentPropertiesFor(expr);
+            if (referencedPropertiesInDestructuring) {
+                if (exports) {
+                    parser.state.module.addWarning(new UnsupportedFeatureWarning_1.default(`\`webpackExports\` could not be used with destructuring assignment.`, expr.loc));
+                }
+                exports = exportsFromEnumerable(referencedPropertiesInDestructuring);
+            }
+            if (param.isString()) {
+                if (mode === 'eager') {
+                    const dep = new ImportEagerDependency_1.default(param.string, expr.range, exports);
+                    parser.state.current.addDependency(dep);
+                }
+                else if (mode === 'weak') {
+                    const dep = new ImportWeakDependency_1.default(param.string, expr.range, exports);
+                    parser.state.current.addDependency(dep);
+                }
+                else {
+                    const depBlock = new AsyncDependenciesBlock_1.default(Object.assign(Object.assign({}, groupOptions), { name: chunkName }), expr.loc, param.string);
+                    const dep = new ImportDependency_1.default(param.string, expr.range, exports);
+                    dep.loc = expr.loc;
+                    depBlock.addDependency(dep);
+                    parser.state.current.addBlock(depBlock);
+                }
+                return true;
+            }
+            if (mode === 'weak') {
+                mode = 'async-weak';
+            }
+            const dep = ContextDependencyHelpers.create(ImportContextDependency_1.default, expr.range, param, expr, this.options, {
+                chunkName,
+                groupOptions,
+                include,
+                exclude,
+                mode,
+                namespaceObject: parser.state.module.buildMeta.strictHarmonyModule ? 'strict' : true,
+                typePrefix: 'import()',
+                category: 'esm',
+                referencedExports: exports,
+            }, parser);
+            if (!dep)
+                return;
+            dep.loc = expr.loc;
+            dep.optional = !!parser.scope.inTry;
+            parser.state.current.addDependency(dep);
+            return true;
+        });
+    }
+}
+exports.default = ImportParserPlugin;

package/dist/dependencies/import/ImportPlugin.d.ts

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

package/dist/dependencies/import/ImportPlugin.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 ModuleTypeConstants_1 = require("@/module/ModuleTypeConstants");
+const ImportContextDependency_1 = __importDefault(require("./ImportContextDependency"));
+const ImportDependency_1 = __importDefault(require("./ImportDependency"));
+const ImportEagerDependency_1 = __importDefault(require("./ImportEagerDependency"));
+const ImportParserPlugin_1 = __importDefault(require("./ImportParserPlugin"));
+const ImportWeakDependency_1 = __importDefault(require("./ImportWeakDependency"));
+const PLUGIN_NAME = 'ImportPlugin';
+class ImportPlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation, { contextModuleFactory, normalModuleFactory }) => {
+            compilation.dependencyFactories.set(ImportDependency_1.default, normalModuleFactory);
+            compilation.dependencyTemplates.set(ImportDependency_1.default, new ImportDependency_1.default.Template());
+            compilation.dependencyFactories.set(ImportEagerDependency_1.default, normalModuleFactory);
+            compilation.dependencyTemplates.set(ImportEagerDependency_1.default, new ImportEagerDependency_1.default.Template());
+            compilation.dependencyFactories.set(ImportWeakDependency_1.default, normalModuleFactory);
+            compilation.dependencyTemplates.set(ImportWeakDependency_1.default, new ImportWeakDependency_1.default.Template());
+            compilation.dependencyFactories.set(ImportContextDependency_1.default, contextModuleFactory);
+            compilation.dependencyTemplates.set(ImportContextDependency_1.default, new ImportContextDependency_1.default.Template());
+            const handler = (parser, parserOptions) => {
+                if (parserOptions.import !== undefined && !parserOptions.import)
+                    return;
+                new ImportParserPlugin_1.default(parserOptions).apply(parser);
+            };
+            normalModuleFactory.hooks.parser.for(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_AUTO).tap(PLUGIN_NAME, handler);
+            normalModuleFactory.hooks.parser
+                .for(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_DYNAMIC)
+                .tap(PLUGIN_NAME, handler);
+            normalModuleFactory.hooks.parser.for(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_ESM).tap(PLUGIN_NAME, handler);
+        });
+    }
+}
+exports.default = ImportPlugin;

package/dist/dependencies/import/ImportWeakDependency.d.ts

@@ -0,0 +1,6 @@
+import ImportDependency from './ImportDependency';
+declare class ImportWeakDependency extends ImportDependency {
+    constructor(request: any, range: any, referencedExports?: string[][] | null);
+    get type(): string;
+}
+export default ImportWeakDependency;

package/dist/dependencies/import/ImportWeakDependency.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"));
+const ImportDependency_1 = __importDefault(require("./ImportDependency"));
+class ImportWeakDependency extends ImportDependency_1.default {
+    constructor(request, range, referencedExports) {
+        super(request, range, referencedExports);
+        this.weak = true;
+    }
+    get type() {
+        return 'import() weak';
+    }
+}
+(0, makeSerializable_1.default)(ImportWeakDependency, 'mp-compiler/core/dependencies/ImportWeakDependency');
+ImportWeakDependency.Template = class ImportDependencyTemplate extends ImportDependency_1.default.Template {
+    apply(dependency, source, { runtimeTemplate, module, moduleGraph, chunkGraph, runtimeRequirements }) {
+        const dep = dependency;
+        const content = runtimeTemplate.moduleNamespacePromise({
+            chunkGraph,
+            module: moduleGraph.getModule(dep),
+            request: dep.request,
+            strict: module.buildMeta.strictHarmonyModule,
+            message: 'import() weak',
+            weak: true,
+            runtimeRequirements,
+        });
+        source.replace(dep.range[0], dep.range[1] - 1, content);
+    }
+};
+exports.default = ImportWeakDependency;

package/dist/dependencies/json/JsonExportsDependency.d.ts

@@ -0,0 +1,14 @@
+import NullDependency from '@/dependencies/NullDependency';
+declare class JsonExportsDependency extends NullDependency {
+    data: any;
+    constructor(data: any);
+    get type(): string;
+    getExports(moduleGraph: any): {
+        exports: any;
+        dependencies: undefined;
+    };
+    updateHash(hash: any, context: any): void;
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default JsonExportsDependency;

package/dist/dependencies/json/JsonExportsDependency.js

@@ -0,0 +1,61 @@
+"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"));
+const getExportsFromData = data => {
+    if (data && typeof data === 'object') {
+        if (Array.isArray(data)) {
+            return data.length < 100
+                ? data.map((item, idx) => ({
+                    name: `${idx}`,
+                    canMangle: true,
+                    exports: getExportsFromData(item),
+                }))
+                : undefined;
+        }
+        const exports = [];
+        for (const key of Object.keys(data)) {
+            exports.push({
+                name: key,
+                canMangle: true,
+                exports: getExportsFromData(data[key]),
+            });
+        }
+        return exports;
+    }
+    return undefined;
+};
+class JsonExportsDependency extends NullDependency_1.default {
+    constructor(data) {
+        super();
+        this.data = data;
+    }
+    get type() {
+        return 'json exports';
+    }
+    getExports(moduleGraph) {
+        var _a;
+        return {
+            exports: getExportsFromData((_a = this.data) === null || _a === void 0 ? void 0 : _a.get()),
+            dependencies: undefined,
+        };
+    }
+    updateHash(hash, context) {
+        this.data.updateHash(hash);
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.data);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.data = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(JsonExportsDependency, 'mp-compiler/core/dependencies/JsonExportsDependency');
+exports.default = JsonExportsDependency;

package/dist/dependencies/loader/LoaderDependency.d.ts

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

package/dist/dependencies/loader/LoaderDependency.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ModuleDependency_1 = __importDefault(require("@/dependencies/ModuleDependency"));
+class LoaderDependency extends ModuleDependency_1.default {
+    constructor(request) {
+        super(request);
+    }
+    get type() {
+        return 'loader';
+    }
+    get category() {
+        return 'loader';
+    }
+    getCondition(moduleGraph) {
+        return false;
+    }
+}
+exports.default = LoaderDependency;

package/dist/dependencies/loader/LoaderImportDependency.d.ts

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

package/dist/dependencies/loader/LoaderImportDependency.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ModuleDependency_1 = __importDefault(require("@/dependencies/ModuleDependency"));
+class LoaderImportDependency extends ModuleDependency_1.default {
+    constructor(request) {
+        super(request);
+        this.weak = true;
+    }
+    get type() {
+        return 'loader import';
+    }
+    get category() {
+        return 'loaderImport';
+    }
+    getCondition(moduleGraph) {
+        return false;
+    }
+}
+exports.default = LoaderImportDependency;

package/dist/dependencies/loader/LoaderPlugin.d.ts

@@ -0,0 +1,5 @@
+declare class LoaderPlugin {
+    constructor(options?: {});
+    apply(compiler: any): void;
+}
+export default LoaderPlugin;