xhs-mp-pack 1.1.0-beta.0

package/dist/serialization/registerExternalSerializer.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ValidationError_1 = __importDefault(require("schema-utils/dist/ValidationError"));
+const webpack_sources_1 = require("webpack-sources");
+const Serialization_1 = __importDefault(require("./Serialization"));
+const CURRENT_MODULE = 'mp-compiler/core/serialization/registerExternalSerializer';
+const Position = require('acorn').Position;
+const SourceLocation = require('acorn').SourceLocation;
+Serialization_1.default.register(webpack_sources_1.CachedSource, CURRENT_MODULE, 'webpack-sources/CachedSource', new (class CachedSourceSerializer {
+    serialize(source, { write, writeLazy }) {
+        if (writeLazy) {
+            writeLazy(source.originalLazy());
+        }
+        else {
+            write(source.original());
+        }
+        write(source.getCachedData());
+    }
+    deserialize({ read }) {
+        const source = read();
+        const cachedData = read();
+        return new webpack_sources_1.CachedSource(source, cachedData);
+    }
+})());
+Serialization_1.default.register(webpack_sources_1.RawSource, CURRENT_MODULE, 'webpack-sources/RawSource', new (class RawSourceSerializer {
+    serialize(source, { write }) {
+        write(source.buffer());
+        write(!source.isBuffer());
+    }
+    deserialize({ read }) {
+        const source = read();
+        const convertToString = read();
+        // @ts-ignore
+        return new webpack_sources_1.RawSource(source, convertToString);
+    }
+})());
+Serialization_1.default.register(webpack_sources_1.ConcatSource, CURRENT_MODULE, 'webpack-sources/ConcatSource', new (class ConcatSourceSerializer {
+    serialize(source, { write }) {
+        write(source.getChildren());
+    }
+    deserialize({ read }) {
+        const source = new webpack_sources_1.ConcatSource();
+        // @ts-ignore
+        source.addAllSkipOptimizing(read());
+        return source;
+    }
+})());
+Serialization_1.default.register(webpack_sources_1.PrefixSource, CURRENT_MODULE, 'webpack-sources/PrefixSource', new (class PrefixSourceSerializer {
+    serialize(source, { write }) {
+        write(source.getPrefix());
+        write(source.original());
+    }
+    deserialize({ read }) {
+        return new webpack_sources_1.PrefixSource(read(), read());
+    }
+})());
+Serialization_1.default.register(webpack_sources_1.ReplaceSource, CURRENT_MODULE, 'webpack-sources/ReplaceSource', new (class ReplaceSourceSerializer {
+    serialize(source, { write }) {
+        write(source.original());
+        write(source.getName());
+        const replacements = source.getReplacements();
+        write(replacements.length);
+        for (const repl of replacements) {
+            write(repl.start);
+            write(repl.end);
+        }
+        for (const repl of replacements) {
+            write(repl.content);
+            write(repl.name);
+        }
+    }
+    deserialize({ read }) {
+        const source = new webpack_sources_1.ReplaceSource(read(), read());
+        const len = read();
+        const startEndBuffer = [];
+        for (let i = 0; i < len; i++) {
+            startEndBuffer.push(read(), read());
+        }
+        let j = 0;
+        for (let i = 0; i < len; i++) {
+            source.replace(startEndBuffer[j++], startEndBuffer[j++], read(), read());
+        }
+        return source;
+    }
+})());
+Serialization_1.default.register(webpack_sources_1.OriginalSource, CURRENT_MODULE, 'webpack-sources/OriginalSource', new (class OriginalSourceSerializer {
+    serialize(source, { write }) {
+        write(source.buffer());
+        write(source.getName());
+    }
+    deserialize({ read }) {
+        const buffer = read();
+        const name = read();
+        return new webpack_sources_1.OriginalSource(buffer, name);
+    }
+})());
+Serialization_1.default.register(SourceLocation, CURRENT_MODULE, 'acorn/SourceLocation', new (class SourceLocationSerializer {
+    serialize(loc, { write }) {
+        write(loc.start.line);
+        write(loc.start.column);
+        write(loc.end.line);
+        write(loc.end.column);
+    }
+    deserialize({ read }) {
+        return {
+            start: {
+                line: read(),
+                column: read(),
+            },
+            end: {
+                line: read(),
+                column: read(),
+            },
+        };
+    }
+})());
+Serialization_1.default.register(Position, CURRENT_MODULE, 'acorn/Position', new (class PositionSerializer {
+    serialize(pos, { write }) {
+        write(pos.line);
+        write(pos.column);
+    }
+    deserialize({ read }) {
+        return {
+            line: read(),
+            column: read(),
+        };
+    }
+})());
+Serialization_1.default.register(webpack_sources_1.SourceMapSource, CURRENT_MODULE, 'webpack-sources/SourceMapSource', new (class SourceMapSourceSerializer {
+    serialize(source, { write }) {
+        write(source.getArgsAsBuffers());
+    }
+    deserialize({ read }) {
+        // @ts-expect-error
+        return new webpack_sources_1.SourceMapSource(...read());
+    }
+})());
+Serialization_1.default.register(ValidationError_1.default, CURRENT_MODULE, 'schema-utils/ValidationError', new (class ValidationErrorSerializer {
+    serialize(error, { write }) {
+        write(error.errors);
+        write(error.schema);
+        write({
+            name: error.headerName,
+            baseDataPath: error.baseDataPath,
+            postFormatter: error.postFormatter,
+        });
+    }
+    deserialize({ read }) {
+        return new ValidationError_1.default(read(), read(), read());
+    }
+})());

package/dist/serialization/serializers/ArraySerializer.d.ts

@@ -0,0 +1,5 @@
+declare class ArraySerializer {
+    serialize(array: any, context: any): void;
+    deserialize(context: any): any[];
+}
+export default ArraySerializer;

package/dist/serialization/serializers/ArraySerializer.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ArraySerializer {
+    serialize(array, context) {
+        context.write(array.length);
+        for (const item of array)
+            context.write(item);
+    }
+    deserialize(context) {
+        const length = context.read();
+        const array = [];
+        for (let i = 0; i < length; i++) {
+            array.push(context.read());
+        }
+        return array;
+    }
+}
+exports.default = ArraySerializer;

package/dist/serialization/serializers/DateObjectSerializer.d.ts

@@ -0,0 +1,5 @@
+declare class DateObjectSerializer {
+    serialize(obj: any, context: any): void;
+    deserialize(context: any): Date;
+}
+export default DateObjectSerializer;

package/dist/serialization/serializers/DateObjectSerializer.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class DateObjectSerializer {
+    serialize(obj, context) {
+        context.write(obj.getTime());
+    }
+    deserialize(context) {
+        return new Date(context.read());
+    }
+}
+exports.default = DateObjectSerializer;

package/dist/serialization/serializers/ErrorObjectSerializer.d.ts

@@ -0,0 +1,7 @@
+declare class ErrorObjectSerializer {
+    Type: any;
+    constructor(Type: any);
+    serialize(obj: any, context: any): void;
+    deserialize(context: any): any;
+}
+export default ErrorObjectSerializer;

package/dist/serialization/serializers/ErrorObjectSerializer.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ErrorObjectSerializer {
+    constructor(Type) {
+        this.Type = Type;
+    }
+    serialize(obj, context) {
+        context.write(obj.message);
+        context.write(obj.stack);
+        context.write(obj.cause);
+    }
+    deserialize(context) {
+        const err = new this.Type();
+        err.message = context.read();
+        err.stack = context.read();
+        err.cause = context.read();
+        return err;
+    }
+}
+exports.default = ErrorObjectSerializer;

package/dist/serialization/serializers/MapObjectSerializer.d.ts

@@ -0,0 +1,5 @@
+declare class MapObjectSerializer {
+    serialize(obj: any, context: any): void;
+    deserialize(context: any): Map<any, any>;
+}
+export default MapObjectSerializer;

package/dist/serialization/serializers/MapObjectSerializer.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class MapObjectSerializer {
+    serialize(obj, context) {
+        context.write(obj.size);
+        for (const key of obj.keys()) {
+            context.write(key);
+        }
+        for (const value of obj.values()) {
+            context.write(value);
+        }
+    }
+    deserialize(context) {
+        const size = context.read();
+        const map = new Map();
+        const keys = [];
+        for (let i = 0; i < size; i++) {
+            keys.push(context.read());
+        }
+        for (let i = 0; i < size; i++) {
+            map.set(keys[i], context.read());
+        }
+        return map;
+    }
+}
+exports.default = MapObjectSerializer;

package/dist/serialization/serializers/NullPrototypeObjectSerializer.d.ts

@@ -0,0 +1,5 @@
+declare class NullPrototypeObjectSerializer {
+    serialize(obj: any, context: any): void;
+    deserialize(context: any): any;
+}
+export default NullPrototypeObjectSerializer;

package/dist/serialization/serializers/NullPrototypeObjectSerializer.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class NullPrototypeObjectSerializer {
+    serialize(obj, context) {
+        const keys = Object.keys(obj);
+        for (const key of keys) {
+            context.write(key);
+        }
+        context.write(null);
+        for (const key of keys) {
+            context.write(obj[key]);
+        }
+    }
+    deserialize(context) {
+        const obj = Object.create(null);
+        const keys = [];
+        let key = context.read();
+        while (key !== null) {
+            keys.push(key);
+            key = context.read();
+        }
+        for (const key of keys) {
+            obj[key] = context.read();
+        }
+        return obj;
+    }
+}
+exports.default = NullPrototypeObjectSerializer;

package/dist/serialization/serializers/PlainObjectSerializer.d.ts

@@ -0,0 +1,5 @@
+declare class PlainObjectSerializer {
+    serialize(obj: any, context: any): void;
+    deserialize(context: any): {};
+}
+export default PlainObjectSerializer;

package/dist/serialization/serializers/PlainObjectSerializer.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cache = new WeakMap();
+class ObjectStructure {
+    constructor() {
+        this.keys = undefined;
+        this.children = undefined;
+    }
+    getKeys(keys) {
+        if (this.keys === undefined)
+            this.keys = keys;
+        return this.keys;
+    }
+    key(key) {
+        if (this.children === undefined)
+            this.children = new Map();
+        const child = this.children.get(key);
+        if (child !== undefined)
+            return child;
+        const newChild = new ObjectStructure();
+        this.children.set(key, newChild);
+        return newChild;
+    }
+}
+const getCachedKeys = (keys, cacheAssoc) => {
+    let root = cache.get(cacheAssoc);
+    if (root === undefined) {
+        root = new ObjectStructure();
+        cache.set(cacheAssoc, root);
+    }
+    let current = root;
+    for (const key of keys) {
+        current = current.key(key);
+    }
+    return current.getKeys(keys);
+};
+class PlainObjectSerializer {
+    serialize(obj, context) {
+        const keys = Object.keys(obj);
+        if (keys.length > 128) {
+            // Objects with so many keys are unlikely to share structure
+            // with other objects
+            context.write(keys);
+            for (const key of keys) {
+                context.write(obj[key]);
+            }
+        }
+        else if (keys.length > 1) {
+            context.write(getCachedKeys(keys, context.write));
+            for (const key of keys) {
+                context.write(obj[key]);
+            }
+        }
+        else if (keys.length === 1) {
+            const key = keys[0];
+            context.write(key);
+            context.write(obj[key]);
+        }
+        else {
+            context.write(null);
+        }
+    }
+    deserialize(context) {
+        const keys = context.read();
+        const obj = {};
+        if (Array.isArray(keys)) {
+            for (const key of keys) {
+                obj[key] = context.read();
+            }
+        }
+        else if (keys !== null) {
+            obj[keys] = context.read();
+        }
+        return obj;
+    }
+}
+exports.default = PlainObjectSerializer;

package/dist/serialization/serializers/RegExpObjectSerializer.d.ts

@@ -0,0 +1,5 @@
+declare class RegExpObjectSerializer {
+    serialize(obj: any, context: any): void;
+    deserialize(context: any): RegExp;
+}
+export default RegExpObjectSerializer;

package/dist/serialization/serializers/RegExpObjectSerializer.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class RegExpObjectSerializer {
+    serialize(obj, context) {
+        context.write(obj.source);
+        context.write(obj.flags);
+    }
+    deserialize(context) {
+        return new RegExp(context.read(), context.read());
+    }
+}
+exports.default = RegExpObjectSerializer;

package/dist/serialization/serializers/SetObjectSerializer.d.ts

@@ -0,0 +1,5 @@
+declare class SetObjectSerializer {
+    serialize(obj: any, context: any): void;
+    deserialize(context: any): Set<unknown>;
+}
+export default SetObjectSerializer;

package/dist/serialization/serializers/SetObjectSerializer.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class SetObjectSerializer {
+    serialize(obj, context) {
+        context.write(obj.size);
+        for (const value of obj) {
+            context.write(value);
+        }
+    }
+    deserialize(context) {
+        const size = context.read();
+        const set = new Set();
+        for (let i = 0; i < size; i++) {
+            set.add(context.read());
+        }
+        return set;
+    }
+}
+exports.default = SetObjectSerializer;

package/dist/sourcemap/EvalDevToolModulePlugin.d.ts

@@ -0,0 +1,8 @@
+declare class EvalDevToolModulePlugin {
+    namespace: any;
+    sourceUrlComment: any;
+    moduleFilenameTemplate: any;
+    constructor(options: any);
+    apply(compiler: any): void;
+}
+export default EvalDevToolModulePlugin;

package/dist/sourcemap/EvalDevToolModulePlugin.js

@@ -0,0 +1,97 @@
+"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 ExternalModule_1 = __importDefault(require("@/module/ExternalModule"));
+const ModuleFilenameHelpers = __importStar(require("@/base/ModuleFilenameHelpers"));
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const JavascriptModulesPlugin_1 = require("@/module/javascript/JavascriptModulesPlugin");
+const cache = new WeakMap();
+const devtoolWarning = new webpack_sources_1.RawSource(`/*
+ * ATTENTION: The "eval" devtool has been used (maybe by default in mode: "development").
+ * This devtool is neither made for production nor for readable output files.
+ * It uses "eval()" calls to create a separate source file in the browser devtools.
+ * If you are trying to read the output file, select a different devtool (https://webpack.js.org/configuration/devtool/)
+ * or disable the default devtool with "devtool: false".
+ * If you are looking for production-ready output files, see mode: "production" (https://webpack.js.org/configuration/mode/).
+ */
+`);
+class EvalDevToolModulePlugin {
+    constructor(options) {
+        this.namespace = options.namespace || '';
+        this.sourceUrlComment = options.sourceUrlComment || '\n//# sourceURL=[url]';
+        this.moduleFilenameTemplate =
+            options.moduleFilenameTemplate || 'webpack://[namespace]/[resourcePath]?[loaders]';
+    }
+    apply(compiler) {
+        compiler.hooks.compilation.tap('EvalDevToolModulePlugin', compilation => {
+            const hooks = JavascriptModulesPlugin_1.JavascriptModulesPlugin.getCompilationHooks(compilation);
+            hooks.renderModuleContent.tap('EvalDevToolModulePlugin', (source, module, { runtimeTemplate, chunkGraph }) => {
+                const cacheEntry = cache.get(source);
+                if (cacheEntry !== undefined)
+                    return cacheEntry;
+                if (module instanceof ExternalModule_1.default) {
+                    cache.set(source, source);
+                    return source;
+                }
+                const content = source.source();
+                const str = ModuleFilenameHelpers.createFilename(module, {
+                    moduleFilenameTemplate: this.moduleFilenameTemplate,
+                    namespace: this.namespace,
+                }, {
+                    requestShortener: runtimeTemplate.requestShortener,
+                    chunkGraph,
+                    hashFunction: compilation.outputOptions.hashFunction,
+                });
+                const footer = `\n${this.sourceUrlComment.replace(/\[url\]/g, encodeURI(str)
+                    .replace(/%2F/g, '/')
+                    .replace(/%20/g, '_')
+                    .replace(/%5E/g, '^')
+                    .replace(/%5C/g, '\\')
+                    .replace(/^\//, ''))}`;
+                const result = new webpack_sources_1.RawSource(`eval(${compilation.outputOptions.trustedTypes
+                    ? `${RuntimeGlobals.createScript}(${JSON.stringify(content + footer)})`
+                    : JSON.stringify(content + footer)});`);
+                cache.set(source, result);
+                return result;
+            });
+            hooks.inlineInRuntimeBailout.tap('EvalDevToolModulePlugin', () => 'the eval devtool is used.');
+            hooks.render.tap('EvalDevToolModulePlugin', source => new webpack_sources_1.ConcatSource(devtoolWarning, source));
+            hooks.chunkHash.tap('EvalDevToolModulePlugin', (chunk, hash) => {
+                hash.update('EvalDevToolModulePlugin');
+                hash.update('2');
+            });
+            if (compilation.outputOptions.trustedTypes) {
+                compilation.hooks.additionalModuleRuntimeRequirements.tap('EvalDevToolModulePlugin', (module, set, context) => {
+                    set.add(RuntimeGlobals.createScript);
+                });
+            }
+        });
+    }
+}
+exports.default = EvalDevToolModulePlugin;

package/dist/sourcemap/EvalSourceMapDevToolPlugin.d.ts

@@ -0,0 +1,9 @@
+declare class EvalSourceMapDevToolPlugin {
+    sourceMapComment: any;
+    moduleFilenameTemplate: any;
+    namespace: any;
+    options: any;
+    constructor(inputOptions: any);
+    apply(compiler: any): void;
+}
+export default EvalSourceMapDevToolPlugin;