xhs-mp-pack 1.1.0-beta.0

package/dist/module/Parser.d.ts

@@ -0,0 +1,4 @@
+declare class Parser {
+    parse(source: any, state: any): void;
+}
+export default Parser;

package/dist/module/Parser.js

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

package/dist/module/RawModule.d.ts

@@ -0,0 +1,29 @@
+import RequestShortener from '@/base/RequestShortener';
+import Module from './Module';
+declare class RawModule extends Module {
+    sourceStr: string;
+    identifierStr: any;
+    readableIdentifierStr: any;
+    runtimeRequirements: ReadonlySet<string> | null;
+    buildMeta: any;
+    buildInfo: {
+        cacheable?: boolean;
+    };
+    useSourceMap: any;
+    useSimpleSourceMap: any;
+    constructor(source: string, identifier: string, readableIdentifier?: string, runtimeRequirements?: ReadonlySet<string>);
+    getSourceTypes(): Set<string>;
+    identifier(): any;
+    size(type?: string): number;
+    readableIdentifier(requestShortener: RequestShortener): 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: ReadonlySet<string> | null;
+    };
+    updateHash(hash: any, context: any): void;
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default RawModule;

package/dist/module/RawModule.js

@@ -0,0 +1,74 @@
+"use strict";
+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 makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+const Module_1 = __importDefault(require("./Module"));
+const ModuleTypeConstants_1 = require("./ModuleTypeConstants");
+const TYPES = new Set(['javascript']);
+class RawModule extends Module_1.default {
+    constructor(source, identifier, readableIdentifier, runtimeRequirements) {
+        super(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_DYNAMIC, null);
+        this.buildInfo = {};
+        this.sourceStr = source;
+        this.identifierStr = identifier || this.sourceStr;
+        this.readableIdentifierStr = readableIdentifier || this.identifierStr;
+        this.runtimeRequirements = runtimeRequirements || null;
+    }
+    getSourceTypes() {
+        return TYPES;
+    }
+    identifier() {
+        return this.identifierStr;
+    }
+    size(type) {
+        return Math.max(1, this.sourceStr.length);
+    }
+    readableIdentifier(requestShortener) {
+        return requestShortener.shorten(this.readableIdentifierStr);
+    }
+    needBuild(context, callback) {
+        return callback(null, !this.buildMeta);
+    }
+    build(options, compilation, resolver, fs, callback) {
+        this.buildMeta = {};
+        this.buildInfo = {
+            cacheable: true,
+        };
+        callback();
+    }
+    codeGeneration(context) {
+        const sources = new Map();
+        if (this.useSourceMap || this.useSimpleSourceMap) {
+            sources.set('javascript', new webpack_sources_1.OriginalSource(this.sourceStr, this.identifier()));
+        }
+        else {
+            sources.set('javascript', new webpack_sources_1.RawSource(this.sourceStr));
+        }
+        return { sources, runtimeRequirements: this.runtimeRequirements };
+    }
+    updateHash(hash, context) {
+        hash.update(this.sourceStr);
+        super.updateHash(hash, context);
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.sourceStr);
+        write(this.identifierStr);
+        write(this.readableIdentifierStr);
+        write(this.runtimeRequirements);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.sourceStr = read();
+        this.identifierStr = read();
+        this.readableIdentifierStr = read();
+        this.runtimeRequirements = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(RawModule, 'mp-compiler/core/module/RawModule');
+exports.default = RawModule;

package/dist/module/RuntimeGlobals.d.ts

@@ -0,0 +1,310 @@
+/**
+ * the internal require function
+ */
+export declare const require = "__webpack_require__";
+/**
+ * access to properties of the internal require function/object
+ */
+export declare const requireScope = "__webpack_require__.*";
+/**
+ * the internal exports object
+ */
+export declare const exports = "__webpack_exports__";
+/**
+ * top-level this need to be the exports object
+ */
+export declare const thisAsExports = "top-level-this-exports";
+/**
+ * runtime need to return the exports of the last entry module
+ */
+export declare const returnExportsFromRuntime = "return-exports-from-runtime";
+/**
+ * the internal module object
+ */
+export declare const module = "module";
+/**
+ * the internal module object
+ */
+export declare const moduleId = "module.id";
+/**
+ * the internal module object
+ */
+export declare const moduleLoaded = "module.loaded";
+/**
+ * the bundle public path
+ */
+export declare const publicPath = "__webpack_require__.p";
+/**
+ * the module id of the entry point
+ */
+export declare const entryModuleId = "__webpack_require__.s";
+/**
+ * the module cache
+ */
+export declare const moduleCache = "__webpack_require__.c";
+/**
+ * the module functions
+ */
+export declare const moduleFactories = "__webpack_require__.m";
+/**
+ * the module functions, with only write access
+ */
+export declare const moduleFactoriesAddOnly = "__webpack_require__.m (add only)";
+/**
+ * the chunk ensure function
+ */
+export declare const ensureChunk = "__webpack_require__.e";
+/**
+ * an object with handlers to ensure a chunk
+ */
+export declare const ensureChunkHandlers = "__webpack_require__.f";
+/**
+ * a runtime requirement if ensureChunkHandlers should include loading of chunk needed for entries
+ */
+export declare const ensureChunkIncludeEntries = "__webpack_require__.f (include entries)";
+/**
+ * the chunk prefetch function
+ */
+export declare const prefetchChunk = "__webpack_require__.E";
+/**
+ * an object with handlers to prefetch a chunk
+ */
+export declare const prefetchChunkHandlers = "__webpack_require__.F";
+/**
+ * the chunk preload function
+ */
+export declare const preloadChunk = "__webpack_require__.G";
+/**
+ * an object with handlers to preload a chunk
+ */
+export declare const preloadChunkHandlers = "__webpack_require__.H";
+/**
+ * the exported property define getters function
+ */
+export declare const definePropertyGetters = "__webpack_require__.d";
+/**
+ * define compatibility on export
+ */
+export declare const makeNamespaceObject = "__webpack_require__.r";
+/**
+ * create a fake namespace object
+ */
+export declare const createFakeNamespaceObject = "__webpack_require__.t";
+/**
+ * compatibility get default export
+ */
+export declare const compatGetDefaultExport = "__webpack_require__.n";
+/**
+ * harmony module decorator
+ */
+export declare const harmonyModuleDecorator = "__webpack_require__.hmd";
+/**
+ * node.js module decorator
+ */
+export declare const nodeModuleDecorator = "__webpack_require__.nmd";
+/**
+ * the webpack hash
+ */
+export declare const getFullHash = "__webpack_require__.h";
+/**
+ * an object containing all installed WebAssembly.Instance export objects keyed by module id
+ */
+export declare const wasmInstances = "__webpack_require__.w";
+/**
+ * instantiate a wasm instance from module exports object, id, hash and importsObject
+ */
+export declare const instantiateWasm = "__webpack_require__.v";
+/**
+ * the uncaught error handler for the webpack runtime
+ */
+export declare const uncaughtErrorHandler = "__webpack_require__.oe";
+/**
+ * the script nonce
+ */
+export declare const scriptNonce = "__webpack_require__.nc";
+/**
+ * function to load a script tag.
+ * Arguments: (url: string, done: (event) => void), key?: string | number, chunkId?: string | number) => void
+ * done function is called when loading has finished or timeout occurred.
+ * It will attach to existing script tags with data-webpack == uniqueName + ":" + key or src == url.
+ */
+export declare const loadScript = "__webpack_require__.l";
+/**
+ * function to promote a string to a TrustedScript using webpack's Trusted
+ * Types policy
+ * Arguments: (script: string) => TrustedScript
+ */
+export declare const createScript = "__webpack_require__.ts";
+/**
+ * function to promote a string to a TrustedScriptURL using webpack's Trusted
+ * Types policy
+ * Arguments: (url: string) => TrustedScriptURL
+ */
+export declare const createScriptUrl = "__webpack_require__.tu";
+/**
+ * function to return webpack's Trusted Types policy
+ * Arguments: () => TrustedTypePolicy
+ */
+export declare const getTrustedTypesPolicy = "__webpack_require__.tt";
+/**
+ * a flag when a chunk has a fetch priority
+ */
+export declare const hasFetchPriority = "has fetch priority";
+/**
+ * the chunk name of the chunk with the runtime
+ */
+export declare const chunkName = "__webpack_require__.cn";
+/**
+ * the runtime id of the current runtime
+ */
+export declare const runtimeId = "__webpack_require__.j";
+/**
+ * the filename of the script part of the chunk
+ */
+export declare const getChunkScriptFilename = "__webpack_require__.u";
+/**
+ * the filename of the css part of the chunk
+ */
+export declare const getChunkCssFilename = "__webpack_require__.k";
+/**
+ * a flag when a module/chunk/tree has css modules
+ */
+export declare const hasCssModules = "has css modules";
+/**
+ * the filename of the script part of the hot update chunk
+ */
+export declare const getChunkUpdateScriptFilename = "__webpack_require__.hu";
+/**
+ * the filename of the css part of the hot update chunk
+ */
+export declare const getChunkUpdateCssFilename = "__webpack_require__.hk";
+/**
+ * startup signal from runtime
+ * This will be called when the runtime chunk has been loaded.
+ */
+export declare const startup = "__webpack_require__.x";
+/**
+ * @deprecated
+ * creating a default startup function with the entry modules
+ */
+export declare const startupNoDefault = "__webpack_require__.x (no default handler)";
+/**
+ * startup signal from runtime but only used to add logic after the startup
+ */
+export declare const startupOnlyAfter = "__webpack_require__.x (only after)";
+/**
+ * startup signal from runtime but only used to add sync logic before the startup
+ */
+export declare const startupOnlyBefore = "__webpack_require__.x (only before)";
+/**
+ * global callback functions for installing chunks
+ */
+export declare const chunkCallback = "webpackChunk";
+/**
+ * method to startup an entrypoint with needed chunks.
+ * Signature: (moduleId: Id, chunkIds: Id[]) => any.
+ * Returns the exports of the module or a Promise
+ */
+export declare const startupEntrypoint = "__webpack_require__.X";
+/**
+ * register deferred code, which will run when certain
+ * chunks are loaded.
+ * Signature: (chunkIds: Id[], fn: () => any, priority: int >= 0 = 0) => any
+ * Returned value will be returned directly when all chunks are already loaded
+ * When (priority & 1) it will wait for all other handlers with lower priority to
+ * be executed before itself is executed
+ */
+export declare const onChunksLoaded = "__webpack_require__.O";
+/**
+ * method to install a chunk that was loaded somehow
+ * Signature: ({ id, ids, modules, runtime }) => void
+ */
+export declare const externalInstallChunk = "__webpack_require__.C";
+/**
+ * interceptor for module executions
+ */
+export declare const interceptModuleExecution = "__webpack_require__.i";
+/**
+ * the global object
+ */
+export declare const global = "__webpack_require__.g";
+/**
+ * an object with all share scopes
+ */
+export declare const shareScopeMap = "__webpack_require__.S";
+/**
+ * The sharing init sequence function (only runs once per share scope).
+ * Has one argument, the name of the share scope.
+ * Creates a share scope if not existing
+ */
+export declare const initializeSharing = "__webpack_require__.I";
+/**
+ * The current scope when getting a module from a remote
+ */
+export declare const currentRemoteGetScope = "__webpack_require__.R";
+/**
+ * the filename of the HMR manifest
+ */
+export declare const getUpdateManifestFilename = "__webpack_require__.hmrF";
+/**
+ * function downloading the update manifest
+ */
+export declare const hmrDownloadManifest = "__webpack_require__.hmrM";
+/**
+ * array with handler functions to download chunk updates
+ */
+export declare const hmrDownloadUpdateHandlers = "__webpack_require__.hmrC";
+/**
+ * object with all hmr module data for all modules
+ */
+export declare const hmrModuleData = "__webpack_require__.hmrD";
+/**
+ * array with handler functions when a module should be invalidated
+ */
+export declare const hmrInvalidateModuleHandlers = "__webpack_require__.hmrI";
+/**
+ * the prefix for storing state of runtime modules when hmr is enabled
+ */
+export declare const hmrRuntimeStatePrefix = "__webpack_require__.hmrS";
+/**
+ * the AMD define function
+ */
+export declare const amdDefine = "__webpack_require__.amdD";
+/**
+ * the AMD options
+ */
+export declare const amdOptions = "__webpack_require__.amdO";
+/**
+ * the System polyfill object
+ */
+export declare const system = "__webpack_require__.System";
+/**
+ * the shorthand for Object.prototype.hasOwnProperty
+ * using of it decreases the compiled bundle size
+ */
+export declare const hasOwnProperty = "__webpack_require__.o";
+/**
+ * the System.register context object
+ */
+export declare const systemContext = "__webpack_require__.y";
+/**
+ * the baseURI of current document
+ */
+export declare const baseURI = "__webpack_require__.b";
+/**
+ * a RelativeURL class when relative URLs are used
+ */
+export declare const relativeUrl = "__webpack_require__.U";
+/**
+ * Creates an async module. The body function must be a async function.
+ * "module.exports" will be decorated with an AsyncModulePromise.
+ * The body function will be called.
+ * To handle async dependencies correctly do this: "([a, b, c] = await handleDependencies([a, b, c]));".
+ * If "hasAwaitAfterDependencies" is truthy, "handleDependencies()" must be called at the end of the body function.
+ * Signature: function(
+ * module: Module,
+ * body: (handleDependencies: (deps: AsyncModulePromise[]) => Promise<any[]> & () => void,
+ * hasAwaitAfterDependencies?: boolean
+ * ) => void
+ */
+export declare const asyncModule = "__webpack_require__.a";