xhs-mp-pack 1.1.0-beta.0

package/dist/module/asset/AssetGenerator.js

@@ -0,0 +1,364 @@
+"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 mime_types_1 = __importDefault(require("mime-types"));
+const path_1 = __importDefault(require("path"));
+const webpack_sources_1 = require("webpack-sources");
+const ConcatenationScope_1 = __importDefault(require("@/ConcatenationScope"));
+const ModuleTypeConstants_1 = require("@/module/ModuleTypeConstants");
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const createHash_1 = __importDefault(require("@/base/createHash"));
+const identifier_1 = require("@/base/identifier");
+const nonNumericOnlyHash_1 = __importDefault(require("@/base/nonNumericOnlyHash"));
+const Generator_1 = __importDefault(require("../Generator"));
+const mergeMaybeArrays = (a, b) => {
+    const set = new Set();
+    if (Array.isArray(a))
+        for (const item of a)
+            set.add(item);
+    else
+        set.add(a);
+    if (Array.isArray(b))
+        for (const item of b)
+            set.add(item);
+    else
+        set.add(b);
+    return Array.from(set);
+};
+const mergeAssetInfo = (a, b) => {
+    const result = Object.assign(Object.assign({}, a), b);
+    for (const key of Object.keys(a)) {
+        if (key in b) {
+            if (a[key] === b[key])
+                continue;
+            switch (key) {
+                case 'fullhash':
+                case 'chunkhash':
+                case 'modulehash':
+                case 'contenthash':
+                    result[key] = mergeMaybeArrays(a[key], b[key]);
+                    break;
+                case 'immutable':
+                case 'development':
+                case 'hotModuleReplacement':
+                case 'javascriptModule':
+                    result[key] = a[key] || b[key];
+                    break;
+                case 'related':
+                    result[key] = mergeRelatedInfo(a[key], b[key]);
+                    break;
+                default:
+                    throw new Error(`Can't handle conflicting asset info for ${key}`);
+            }
+        }
+    }
+    return result;
+};
+const mergeRelatedInfo = (a, b) => {
+    const result = Object.assign(Object.assign({}, a), b);
+    for (const key of Object.keys(a)) {
+        if (key in b) {
+            if (a[key] === b[key])
+                continue;
+            result[key] = mergeMaybeArrays(a[key], b[key]);
+        }
+    }
+    return result;
+};
+const encodeDataUri = (encoding, source) => {
+    let encodedContent;
+    switch (encoding) {
+        case 'base64': {
+            encodedContent = source.buffer().toString('base64');
+            break;
+        }
+        case false: {
+            const content = source.source();
+            if (typeof content !== 'string') {
+                encodedContent = content.toString('utf-8');
+            }
+            encodedContent = encodeURIComponent(encodedContent).replace(/[!'()*]/g, (character) => `%${character.codePointAt(0).toString(16)}`);
+            break;
+        }
+        default:
+            throw new Error(`Unsupported encoding '${encoding}'`);
+    }
+    return encodedContent;
+};
+const decodeDataUriContent = (encoding, content) => {
+    const isBase64 = encoding === 'base64';
+    if (isBase64) {
+        return Buffer.from(content, 'base64');
+    }
+    // If we can't decode return the original body
+    try {
+        return Buffer.from(decodeURIComponent(content), 'ascii');
+    }
+    catch (_) {
+        return Buffer.from(content, 'ascii');
+    }
+};
+const JS_TYPES = new Set(['javascript']);
+const JS_AND_ASSET_TYPES = new Set(['javascript', ModuleTypeConstants_1.ASSET_MODULE_TYPE]);
+const DEFAULT_ENCODING = 'base64';
+class AssetGenerator extends Generator_1.default {
+    constructor(dataUrlOptions, filename, publicPath, outputPath, emit) {
+        super();
+        this.dataUrlOptions = dataUrlOptions;
+        this.filename = filename;
+        this.publicPath = publicPath;
+        this.outputPath = outputPath;
+        this.emit = emit;
+    }
+    getSourceFileName(module, runtimeTemplate) {
+        return (0, identifier_1.makePathsRelative)(runtimeTemplate.compilation.compiler.context, module.matchResource || module.resource, runtimeTemplate.compilation.compiler.root).replace(/^\.\//, '');
+    }
+    getConcatenationBailoutReason(module, context) {
+        return undefined;
+    }
+    getMimeType(module) {
+        var _a;
+        if (typeof this.dataUrlOptions === 'function') {
+            throw new Error('This method must not be called when dataUrlOptions is a function');
+        }
+        let mimeType = this.dataUrlOptions.mimetype;
+        if (mimeType === undefined) {
+            const ext = path_1.default.extname(module.nameForCondition());
+            if (((_a = module.resourceResolveData) === null || _a === void 0 ? void 0 : _a.mimetype) !== undefined) {
+                mimeType = module.resourceResolveData.mimetype + module.resourceResolveData.parameters;
+            }
+            else if (ext) {
+                mimeType = mime_types_1.default.lookup(ext);
+                if (typeof mimeType !== 'string') {
+                    throw new Error("DataUrl can't be generated automatically, " +
+                        `because there is no mimetype for "${ext}" in mimetype database. ` +
+                        'Either pass a mimetype via "generator.mimetype" or ' +
+                        'use type: "asset/resource" to create a resource file instead of a DataUrl');
+                }
+            }
+        }
+        if (typeof mimeType !== 'string') {
+            throw new Error("DataUrl can't be generated automatically. " +
+                'Either pass a mimetype via "generator.mimetype" or ' +
+                'use type: "asset/resource" to create a resource file instead of a DataUrl');
+        }
+        return mimeType;
+    }
+    generate(module, { runtime, concatenationScope, chunkGraph, runtimeTemplate, runtimeRequirements, type, getData, }) {
+        var _a;
+        switch (type) {
+            case ModuleTypeConstants_1.ASSET_MODULE_TYPE:
+                return module.originalSource();
+            default: {
+                let content;
+                const originalSource = module.originalSource();
+                if (module.buildInfo.dataUrl) {
+                    let encodedSource;
+                    if (typeof this.dataUrlOptions === 'function') {
+                        encodedSource = this.dataUrlOptions.call(null, originalSource.source(), {
+                            filename: module.matchResource || module.resource,
+                            module,
+                        });
+                    }
+                    else {
+                        let encoding = this.dataUrlOptions.encoding;
+                        if (encoding === undefined) {
+                            if (((_a = module.resourceResolveData) === null || _a === void 0 ? void 0 : _a.encoding) !== undefined) {
+                                encoding = module.resourceResolveData.encoding;
+                            }
+                        }
+                        if (encoding === undefined) {
+                            encoding = DEFAULT_ENCODING;
+                        }
+                        const mimeType = this.getMimeType(module);
+                        let encodedContent;
+                        if (module.resourceResolveData &&
+                            module.resourceResolveData.encoding === encoding &&
+                            decodeDataUriContent(module.resourceResolveData.encoding, module.resourceResolveData.encodedContent).equals(originalSource.buffer())) {
+                            encodedContent = module.resourceResolveData.encodedContent;
+                        }
+                        else {
+                            encodedContent = encodeDataUri(encoding, originalSource);
+                        }
+                        encodedSource = `data:${mimeType}${encoding ? `;${encoding}` : ''},${encodedContent}`;
+                    }
+                    const data = getData();
+                    data.set('url', Buffer.from(encodedSource));
+                    content = JSON.stringify(encodedSource);
+                }
+                else {
+                    const assetModuleFilename = this.filename || runtimeTemplate.outputOptions.assetModuleFilename;
+                    const hash = (0, createHash_1.default)(runtimeTemplate.outputOptions.hashFunction);
+                    if (runtimeTemplate.outputOptions.hashSalt) {
+                        hash.update(runtimeTemplate.outputOptions.hashSalt);
+                    }
+                    hash.update(originalSource.buffer());
+                    const fullHash = hash.digest(runtimeTemplate.outputOptions.hashDigest);
+                    const contentHash = (0, nonNumericOnlyHash_1.default)(fullHash, runtimeTemplate.outputOptions.hashDigestLength);
+                    module.buildInfo.fullContentHash = fullHash;
+                    const sourceFilename = this.getSourceFileName(module, runtimeTemplate);
+                    let { path: filename, info: assetInfo } = runtimeTemplate.compilation.getAssetPathWithInfo(assetModuleFilename, {
+                        module,
+                        runtime,
+                        filename: sourceFilename,
+                        chunkGraph,
+                        contentHash,
+                    });
+                    let assetPath;
+                    if (this.publicPath !== undefined) {
+                        const { path, info } = runtimeTemplate.compilation.getAssetPathWithInfo(this.publicPath, {
+                            module,
+                            runtime,
+                            filename: sourceFilename,
+                            chunkGraph,
+                            contentHash,
+                        });
+                        assetInfo = mergeAssetInfo(assetInfo, info);
+                        assetPath = JSON.stringify(path + filename);
+                    }
+                    else {
+                        runtimeRequirements.add(RuntimeGlobals.publicPath); // add __webpack_require__.p
+                        assetPath = runtimeTemplate.concatenation({ expr: RuntimeGlobals.publicPath }, filename);
+                    }
+                    assetInfo = Object.assign({ sourceFilename }, assetInfo);
+                    if (this.outputPath) {
+                        const { path: outputPath, info } = runtimeTemplate.compilation.getAssetPathWithInfo(this.outputPath, {
+                            module,
+                            runtime,
+                            filename: sourceFilename,
+                            chunkGraph,
+                            contentHash,
+                        });
+                        assetInfo = mergeAssetInfo(assetInfo, info);
+                        filename = path_1.default.posix.join(outputPath, filename);
+                    }
+                    module.buildInfo.filename = filename;
+                    module.buildInfo.assetInfo = assetInfo;
+                    if (getData) {
+                        // Due to code generation caching module.buildInfo.XXX can't used to store such information
+                        // It need to be stored in the code generation results instead, where it's cached too
+                        // TODO webpack 6 For back-compat reasons we also store in on module.buildInfo
+                        const data = getData();
+                        data.set('fullContentHash', fullHash);
+                        data.set('filename', filename);
+                        data.set('assetInfo', assetInfo);
+                    }
+                    content = assetPath;
+                }
+                if (concatenationScope) {
+                    concatenationScope.registerNamespaceExport(ConcatenationScope_1.default.NAMESPACE_OBJECT_EXPORT);
+                    return new webpack_sources_1.RawSource(`${runtimeTemplate.supportsConst() ? 'const' : 'var'} ${ConcatenationScope_1.default.NAMESPACE_OBJECT_EXPORT} = ${content};`);
+                }
+                runtimeRequirements.add(RuntimeGlobals.module);
+                return new webpack_sources_1.RawSource(`${RuntimeGlobals.module}.exports = ${content};`);
+            }
+        }
+    }
+    getTypes(module) {
+        var _a;
+        if (((_a = module.buildInfo) === null || _a === void 0 ? void 0 : _a.dataUrl) || this.emit === false) {
+            return JS_TYPES;
+        }
+        return JS_AND_ASSET_TYPES;
+    }
+    getSize(module, type) {
+        var _a;
+        switch (type) {
+            case ModuleTypeConstants_1.ASSET_MODULE_TYPE: {
+                const originalSource = module.originalSource();
+                if (!originalSource) {
+                    return 0;
+                }
+                return originalSource.size();
+            }
+            default:
+                if ((_a = module.buildInfo) === null || _a === void 0 ? void 0 : _a.dataUrl) {
+                    const originalSource = module.originalSource();
+                    if (!originalSource) {
+                        return 0;
+                    }
+                    // roughly for data url
+                    // Example: m.exports="data:image/png;base64,ag82/f+2=="
+                    // 4/3 = base64 encoding
+                    // 34 = ~ data url header + footer + rounding
+                    return originalSource.size() * 1.34 + 36;
+                }
+                // it's only estimated so this number is probably fine
+                // Example: m.exports=r.p+"0123456789012345678901.ext"
+                return 42;
+        }
+    }
+    updateHash(hash, { module, runtime, runtimeTemplate, chunkGraph }) {
+        if (module.buildInfo.dataUrl) {
+            hash.update('data-url');
+            // this.dataUrlOptions as function should be pure and only depend on input source and filename
+            // therefore it doesn't need to be hashed
+            if (typeof this.dataUrlOptions === 'function') {
+                const ident = this.dataUrlOptions.ident;
+                if (ident)
+                    hash.update(ident);
+            }
+            else {
+                if (this.dataUrlOptions.encoding && this.dataUrlOptions.encoding !== DEFAULT_ENCODING) {
+                    hash.update(this.dataUrlOptions.encoding);
+                }
+                if (this.dataUrlOptions.mimetype)
+                    hash.update(this.dataUrlOptions.mimetype);
+                // computed mimetype depends only on module filename which is already part of the hash
+            }
+        }
+        else {
+            hash.update('resource');
+            const pathData = {
+                module,
+                runtime,
+                filename: this.getSourceFileName(module, runtimeTemplate),
+                chunkGraph,
+                contentHash: runtimeTemplate.contentHashReplacement,
+            };
+            if (typeof this.publicPath === 'function') {
+                hash.update('path');
+                const assetInfo = {};
+                hash.update(this.publicPath(pathData, assetInfo));
+                hash.update(JSON.stringify(assetInfo));
+            }
+            else if (this.publicPath) {
+                hash.update('path');
+                hash.update(this.publicPath);
+            }
+            else {
+                hash.update('no-path');
+            }
+            const assetModuleFilename = this.filename || runtimeTemplate.outputOptions.assetModuleFilename;
+            const { path: filename, info } = runtimeTemplate.compilation.getAssetPathWithInfo(assetModuleFilename, pathData);
+            hash.update(filename);
+            hash.update(JSON.stringify(info));
+        }
+    }
+}
+exports.default = AssetGenerator;

package/dist/module/asset/AssetModulesPlugin.d.ts

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

package/dist/module/asset/AssetModulesPlugin.js

@@ -0,0 +1,98 @@
+"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 cleverMerge_1 = require("@/base/cleverMerge");
+const comparators_1 = require("@/base/comparators");
+const AssetGenerator_1 = __importDefault(require("./AssetGenerator"));
+const AssetParser_1 = __importDefault(require("./AssetParser"));
+const AssetSourceParser_1 = __importDefault(require("./AssetSourceParser"));
+const AssetSourceGenerator_1 = __importDefault(require("./AssetSourceGenerator"));
+const type = ModuleTypeConstants_1.ASSET_MODULE_TYPE;
+const plugin = 'AssetModulesPlugin';
+class AssetModulesPlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap(plugin, (compilation, { normalModuleFactory }) => {
+            normalModuleFactory.hooks.createParser.for(ModuleTypeConstants_1.ASSET_MODULE_TYPE).tap(plugin, parserOptions => {
+                parserOptions = (0, cleverMerge_1.cleverMerge)(compiler.options.module.parser.asset, parserOptions);
+                let dataUrlCondition = parserOptions.dataUrlCondition;
+                if (!dataUrlCondition || typeof dataUrlCondition === 'object') {
+                    dataUrlCondition = Object.assign({ maxSize: 8096 }, dataUrlCondition);
+                }
+                return new AssetParser_1.default(dataUrlCondition);
+            });
+            normalModuleFactory.hooks.createParser
+                .for(ModuleTypeConstants_1.ASSET_MODULE_TYPE_INLINE)
+                .tap(plugin, parserOptions => new AssetParser_1.default(true));
+            normalModuleFactory.hooks.createParser
+                .for(ModuleTypeConstants_1.ASSET_MODULE_TYPE_RESOURCE)
+                .tap(plugin, parserOptions => new AssetParser_1.default(false));
+            normalModuleFactory.hooks.createParser
+                .for(ModuleTypeConstants_1.ASSET_MODULE_TYPE_SOURCE)
+                .tap(plugin, parserOptions => new AssetSourceParser_1.default());
+            for (const type of [
+                ModuleTypeConstants_1.ASSET_MODULE_TYPE,
+                ModuleTypeConstants_1.ASSET_MODULE_TYPE_INLINE,
+                ModuleTypeConstants_1.ASSET_MODULE_TYPE_RESOURCE,
+            ]) {
+                normalModuleFactory.hooks.createGenerator.for(type).tap(plugin, generatorOptions => {
+                    let dataUrl;
+                    if (type !== ModuleTypeConstants_1.ASSET_MODULE_TYPE_RESOURCE) {
+                        dataUrl = generatorOptions.dataUrl;
+                        if (!dataUrl || typeof dataUrl === 'object') {
+                            dataUrl = Object.assign({ encoding: undefined, mimetype: undefined }, dataUrl);
+                        }
+                    }
+                    let filename;
+                    let publicPath;
+                    let outputPath;
+                    if (type !== ModuleTypeConstants_1.ASSET_MODULE_TYPE_INLINE) {
+                        filename = generatorOptions.filename;
+                        publicPath = generatorOptions.publicPath;
+                        outputPath = generatorOptions.outputPath;
+                    }
+                    return new AssetGenerator_1.default(dataUrl, filename, publicPath, outputPath, generatorOptions.emit !== false);
+                });
+            }
+            normalModuleFactory.hooks.createGenerator.for(ModuleTypeConstants_1.ASSET_MODULE_TYPE_SOURCE).tap(plugin, () => new AssetSourceGenerator_1.default());
+            compilation.hooks.renderManifest.tap(plugin, (result, options) => {
+                const { chunkGraph } = compilation;
+                const { chunk, codeGenerationResults } = options;
+                const modules = chunkGraph.getOrderedChunkModulesIterableBySourceType(chunk, ModuleTypeConstants_1.ASSET_MODULE_TYPE, comparators_1.compareModulesByIdentifier);
+                if (modules) {
+                    for (const module of modules) {
+                        try {
+                            const codeGenResult = codeGenerationResults.get(module, chunk.runtime);
+                            result.push({
+                                render: () => codeGenResult.sources.get(type),
+                                filename: module.buildInfo.filename || codeGenResult.data.get('filename'),
+                                info: module.buildInfo.assetInfo || codeGenResult.data.get('assetInfo'),
+                                auxiliary: true,
+                                identifier: `assetModule${chunkGraph.getModuleId(module)}`,
+                                hash: module.buildInfo.fullContentHash || codeGenResult.data.get('fullContentHash'),
+                            });
+                        }
+                        catch (e) {
+                            e.message += `\nduring rendering of asset ${module.identifier()}`;
+                            throw e;
+                        }
+                    }
+                }
+                return result;
+            });
+            compilation.hooks.prepareModuleExecution.tap('AssetModulesPlugin', (options, context) => {
+                const { codeGenerationResult } = options;
+                const source = codeGenerationResult.sources.get(ModuleTypeConstants_1.ASSET_MODULE_TYPE);
+                if (source === undefined)
+                    return;
+                context.assets.set(codeGenerationResult.data.get('filename'), {
+                    source,
+                    info: codeGenerationResult.data.get('assetInfo'),
+                });
+            });
+        });
+    }
+}
+exports.default = AssetModulesPlugin;

package/dist/module/asset/AssetParser.d.ts

@@ -0,0 +1,12 @@
+import Parser from '../Parser';
+declare class AssetParser extends Parser {
+    dataUrlCondition: any;
+    constructor(dataUrlCondition?: any);
+    /**
+     * @param {string | Buffer | PreparsedAst} source the source to parse
+     * @param {ParserState} state the parser state
+     * @returns {ParserState} the parser state
+     */
+    parse(source: any, state: any): any;
+}
+export default AssetParser;

package/dist/module/asset/AssetParser.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Parser_1 = __importDefault(require("../Parser"));
+class AssetParser extends Parser_1.default {
+    constructor(dataUrlCondition) {
+        super();
+        this.dataUrlCondition = dataUrlCondition;
+    }
+    /**
+     * @param {string | Buffer | PreparsedAst} source the source to parse
+     * @param {ParserState} state the parser state
+     * @returns {ParserState} the parser state
+     */
+    parse(source, state) {
+        if (typeof source === 'object' && !Buffer.isBuffer(source)) {
+            throw new Error("AssetParser doesn't accept preparsed AST");
+        }
+        const buildInfo = state.module.buildInfo;
+        buildInfo.strict = true;
+        const buildMeta = state.module.buildMeta;
+        buildMeta.exportsType = 'default';
+        buildMeta.defaultObject = false;
+        if (typeof this.dataUrlCondition === 'function') {
+            buildInfo.dataUrl = this.dataUrlCondition(source, {
+                filename: state.module.matchResource || state.module.resource,
+                module: state.module,
+            });
+        }
+        else if (typeof this.dataUrlCondition === 'boolean') {
+            buildInfo.dataUrl = this.dataUrlCondition;
+        }
+        else if (this.dataUrlCondition && typeof this.dataUrlCondition === 'object') {
+            buildInfo.dataUrl = Buffer.byteLength(source) <= this.dataUrlCondition.maxSize;
+        }
+        else {
+            throw new Error('Unexpected dataUrlCondition type');
+        }
+        return state;
+    }
+}
+exports.default = AssetParser;

package/dist/module/asset/AssetSourceGenerator.d.ts

@@ -0,0 +1,14 @@
+import { RawSource } from 'webpack-sources';
+import Generator from '../Generator';
+declare class AssetSourceGenerator extends Generator {
+    generate(module: any, { concatenationScope, chunkGraph, runtimeTemplate, runtimeRequirements }: {
+        concatenationScope: any;
+        chunkGraph: any;
+        runtimeTemplate: any;
+        runtimeRequirements: any;
+    }): RawSource;
+    getConcatenationBailoutReason(module: any, context: any): undefined;
+    getTypes(module: any): Set<string>;
+    getSize(module: any, type?: any): any;
+}
+export default AssetSourceGenerator;

package/dist/module/asset/AssetSourceGenerator.js

@@ -0,0 +1,74 @@
+"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 webpack_sources_1 = require("webpack-sources");
+const ConcatenationScope_1 = __importDefault(require("@/ConcatenationScope"));
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const Generator_1 = __importDefault(require("../Generator"));
+const TYPES = new Set(['javascript']);
+class AssetSourceGenerator extends Generator_1.default {
+    generate(module, { concatenationScope, chunkGraph, runtimeTemplate, runtimeRequirements }) {
+        const originalSource = module.originalSource();
+        if (!originalSource) {
+            return new webpack_sources_1.RawSource('');
+        }
+        const content = originalSource.source();
+        let encodedSource;
+        if (typeof content === 'string') {
+            encodedSource = content;
+        }
+        else {
+            encodedSource = content.toString('utf-8');
+        }
+        let sourceContent;
+        if (concatenationScope) {
+            concatenationScope.registerNamespaceExport(ConcatenationScope_1.default.NAMESPACE_OBJECT_EXPORT);
+            sourceContent = `${runtimeTemplate.supportsConst() ? 'const' : 'var'} ${ConcatenationScope_1.default.NAMESPACE_OBJECT_EXPORT} = ${JSON.stringify(encodedSource)};`;
+        }
+        else {
+            runtimeRequirements.add(RuntimeGlobals.module);
+            sourceContent = `${RuntimeGlobals.module}.exports = ${JSON.stringify(encodedSource)};`;
+        }
+        return new webpack_sources_1.RawSource(sourceContent);
+    }
+    getConcatenationBailoutReason(module, context) {
+        return undefined;
+    }
+    getTypes(module) {
+        return TYPES;
+    }
+    getSize(module, type) {
+        const originalSource = module.originalSource();
+        if (!originalSource) {
+            return 0;
+        }
+        // Example: m.exports="abcd"
+        return originalSource.size() + 12;
+    }
+}
+exports.default = AssetSourceGenerator;

package/dist/module/asset/AssetSourceParser.d.ts

@@ -0,0 +1,5 @@
+import Parser from '../Parser';
+declare class AssetSourceParser extends Parser {
+    parse(source: any, state: any): any;
+}
+export default AssetSourceParser;

package/dist/module/asset/AssetSourceParser.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Parser_1 = __importDefault(require("../Parser"));
+class AssetSourceParser extends Parser_1.default {
+    parse(source, state) {
+        if (typeof source === 'object' && !Buffer.isBuffer(source)) {
+            throw new Error("AssetSourceParser doesn't accept preparsed AST");
+        }
+        const { module } = state;
+        module.buildInfo.strict = true;
+        module.buildMeta.exportsType = 'default';
+        state.module.buildMeta.defaultObject = false;
+        return state;
+    }
+}
+exports.default = AssetSourceParser;

package/dist/module/asset/RawDataUrlModule.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import Module from '../Module';
+declare class RawDataUrlModule extends Module {
+    url: any;
+    urlBuffer: Buffer;
+    identifierStr: any;
+    readableIdentifierStr: any;
+    constructor(url: any, identifier: any, readableIdentifier: any);
+    getSourceTypes(): Set<string>;
+    /**
+     * @returns {string} a unique identifier of the module
+     */
+    identifier(): any;
+    size(type?: string): number;
+    readableIdentifier(requestShortener: any): any;
+    needBuild(context: any, callback: any): any;
+    build(options: any, compilation: any, resolver: any, fs: any, callback: any): void;
+    codeGeneration(context: any): {
+        sources: Map<any, any>;
+        runtimeRequirements: Set<unknown>;
+        data: Map<any, any>;
+    };
+    updateHash(hash: any, context: any): void;
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default RawDataUrlModule;