@shuvi/toolpack 0.0.1-rc.9 → 1.0.0-rc.10

package/lib/webpack/dynamic-dll/index.js

@@ -0,0 +1,198 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamicDll = void 0;
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+const mrmime_1 = require("mrmime");
+const webpack_virtual_modules_1 = __importDefault(require("webpack-virtual-modules"));
+const invariant_1 = __importDefault(require("@shuvi/utils/lib/invariant"));
+const constants_1 = require("./constants");
+const bundler_1 = require("./bundler");
+const dynamic_dll_plugin_1 = require("./plugin/dynamic-dll-plugin");
+const metadata_1 = require("./metadata");
+const utils_1 = require("./utils");
+const check_not_in_node_modules_1 = require("./helper/check-not-in-node-modules");
+function makeAsyncEntry(entry) {
+    const asyncEntry = {};
+    const virtualModules = {};
+    const entryObject = ((0, utils_1.isString)(entry) || (0, utils_1.isArray)(entry)
+        ? { main: [].concat(entry) }
+        : entry);
+    for (const key of Object.keys(entryObject)) {
+        const virtualPath = `./dynamic-dll-virtual-entry/${key}.js`;
+        const virtualContent = [];
+        const entryFiles = (0, utils_1.isArray)(entryObject[key])
+            ? entryObject[key]
+            : [entryObject[key]];
+        for (let entry of entryFiles) {
+            (0, invariant_1.default)((0, utils_1.isString)(entry), 'wepback entry must be a string');
+            virtualContent.push(`import('${entry}');`);
+        }
+        virtualModules[virtualPath] = virtualContent.join('\n');
+        asyncEntry[key] = virtualPath;
+    }
+    return {
+        asyncEntry,
+        virtualModules
+    };
+}
+class DynamicDll {
+    constructor(opts) {
+        this._hasBuilt = false;
+        this.handleSnapshot = (snapshot) => __awaiter(this, void 0, void 0, function* () {
+            if (this._hasBuilt) {
+                (0, metadata_1.writeUpdate)(this._cacheDir, snapshot);
+                return;
+            }
+            const originModules = (0, metadata_1.getMetadata)(this._cacheDir).modules;
+            const diffNames = this.getRemovedModules(snapshot, originModules);
+            const requiredSnapshot = Object.assign(Object.assign({}, originModules), snapshot);
+            diffNames.forEach(lib => {
+                delete requiredSnapshot[lib];
+            });
+            yield this._buildDLL(requiredSnapshot);
+            this._dllPlugin.disableDllReference();
+            this._hasBuilt = true;
+        });
+        this.middleware = (req, res, next) => __awaiter(this, void 0, void 0, function* () {
+            const url = req.url || '';
+            const shouldServe = url.startsWith(constants_1.DEFAULT_PUBLIC_PATH);
+            if (!shouldServe) {
+                return next();
+            }
+            this._bundler.onBuildComplete(() => {
+                const relativePath = url.replace(new RegExp(`^${constants_1.DEFAULT_PUBLIC_PATH}`), '/');
+                const filePath = (0, path_1.join)((0, utils_1.getDllDir)(this._cacheDir), relativePath);
+                const { mtime } = (0, fs_extra_1.statSync)(filePath);
+                // Get the last modification time of the file and convert the time into a world time string
+                let lastModified = mtime.toUTCString();
+                const ifModifiedSince = req.headers['if-modified-since'];
+                // Tell the browser what time to use the browser cache without asking the server directly, but it seems that it is not effective, and needs to learn why.
+                res.setHeader('cache-control', 'no-cache');
+                if (ifModifiedSince && lastModified <= ifModifiedSince) {
+                    // If the request header contains the request ifModifiedSince and the file is not modified, it returns 304
+                    res.writeHead(304, 'Not Modified');
+                    res.end();
+                    return;
+                }
+                // Return the header Last-Modified for the last modification time of the current request file
+                res.setHeader('Last-Modified', lastModified);
+                // Return file
+                res.setHeader('content-type', (0, mrmime_1.lookup)((0, path_1.extname)(url)) || 'text/plain');
+                const content = (0, fs_extra_1.readFileSync)(filePath);
+                res.statusCode = 200;
+                res.end(content);
+            });
+        });
+        this.modifyWebpackChain = (chain) => {
+            const webpack = this._resolveWebpackModule('webpack');
+            const entries = chain.entryPoints.entries();
+            const entry = Object.keys(entries).reduce((acc, name) => {
+                acc[name] = entries[name].values();
+                return acc;
+            }, {});
+            const { asyncEntry, virtualModules } = makeAsyncEntry(entry);
+            chain.entryPoints.clear();
+            chain.merge({
+                entry: asyncEntry
+            });
+            chain
+                .plugin('dynamic-virtual-modules')
+                .use(webpack_virtual_modules_1.default, [virtualModules]);
+            chain
+                .plugin('dynamic-dll-mf')
+                .use(webpack.container.ModuleFederationPlugin, [this._getMFconfig()]);
+            chain.plugin('dynamic-dll-plugin').use(this._dllPlugin);
+            return chain;
+        };
+        this.modifyWebpack = (config) => {
+            const { asyncEntry, virtualModules } = makeAsyncEntry(config.entry);
+            config.entry = asyncEntry;
+            const webpack = this._resolveWebpackModule('webpack');
+            if (!config.plugins) {
+                config.plugins = [];
+            }
+            config.plugins.push(new webpack_virtual_modules_1.default(virtualModules), new webpack.container.ModuleFederationPlugin(this._getMFconfig()), this._dllPlugin);
+            return config;
+        };
+        this._opts = opts;
+        this._cacheDir = opts.cacheDir;
+        this._rootDir = opts.rootDir;
+        this._resolveWebpackModule = opts.resolveWebpackModule || require;
+        this._bundler = new bundler_1.Bundler();
+        this._dllPlugin = new dynamic_dll_plugin_1.DynamicDLLPlugin({
+            include: opts.include,
+            exclude: opts.exclude,
+            dllName: constants_1.NAME,
+            resolveWebpackModule: this._resolveWebpackModule,
+            onSnapshot: this.handleSnapshot
+        });
+    }
+    getRemovedModules(snapshot, originModules) {
+        return Object.keys(originModules).filter(key => {
+            if (snapshot[key]) {
+                return false;
+            }
+            return (0, check_not_in_node_modules_1.checkNotInNodeModules)(key, this._rootDir);
+        });
+    }
+    _buildDLL(snapshot) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._bundler.build(snapshot, {
+                outputDir: this._cacheDir,
+                shared: this._opts.shared,
+                externals: this._opts.externals,
+                esmFullSpecific: this._opts.esmFullSpecific,
+                force: process.env.DLL_FORCE_BUILD === 'true'
+            });
+        });
+    }
+    _getMFconfig() {
+        return {
+            name: '__',
+            remotes: {
+                // [NAME]: `${NAME}@${DEFAULT_PUBLIC_PATH}${DLL_FILENAME}`,
+                // https://webpack.js.org/concepts/module-federation/#promise-based-dynamic-remotes
+                [constants_1.NAME]: `
+promise new Promise(resolve => {
+  const remoteUrl = '${constants_1.DEFAULT_PUBLIC_PATH}${constants_1.DLL_FILENAME}';
+  const script = document.createElement('script');
+  script.src = remoteUrl;
+  script.onload = () => {
+    // the injected script has loaded and is available on window
+    // we can now resolve this Promise
+    const proxy = {
+      get: (request) => {
+        const promise = window['${constants_1.NAME}'].get(request);
+        return promise;
+      },
+      init: (arg) => {
+        try {
+          return window['${constants_1.NAME}'].init(arg);
+        } catch(e) {
+          console.log('remote container already initialized');
+        }
+      }
+    }
+    resolve(proxy);
+  }
+  // inject this script with the src set to the versioned remoteEntry.js
+  document.head.appendChild(script);
+})`.trim()
+            }
+        };
+    }
+}
+exports.DynamicDll = DynamicDll;

package/lib/webpack/dynamic-dll/metadata.d.ts

@@ -0,0 +1,13 @@
+import { ModuleInfo } from './moduleCollector';
+export interface Metadata {
+    hash: string;
+    buildHash: string;
+    modules: Record<string, ModuleInfo>;
+}
+export interface Update {
+    discovered: Record<string, ModuleInfo>;
+}
+export declare function getMetadata(root: string): Metadata;
+export declare function writeMetadata(root: string, content: Metadata): void;
+export declare function getUpdate(root: string): Update;
+export declare function writeUpdate(root: string, updateModules: Record<string, ModuleInfo>): void;

package/lib/webpack/dynamic-dll/metadata.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeUpdate = exports.getUpdate = exports.writeMetadata = exports.getMetadata = void 0;
+const path_1 = require("path");
+const fs_extra_1 = require("fs-extra");
+const constants_1 = require("./constants");
+const utils_1 = require("./utils");
+let lastMetadata = null;
+function getNewModules(pre, next) {
+    const result = {};
+    for (const key of Object.keys(next)) {
+        let preItem = pre[key];
+        let item = next[key];
+        if (!preItem) {
+            result[key] = item;
+        }
+        else if (preItem.version != item.version) {
+            result[key] = item;
+        }
+    }
+    return result;
+}
+function getMetadata(root) {
+    const file = (0, path_1.join)((0, utils_1.getDllDir)(root), constants_1.METADATA_FILENAME);
+    if (!(0, fs_extra_1.existsSync)(file)) {
+        return {
+            hash: '',
+            buildHash: '',
+            modules: {}
+        };
+    }
+    return (0, fs_extra_1.readJSONSync)(file);
+}
+exports.getMetadata = getMetadata;
+function writeMetadata(root, content) {
+    (0, fs_extra_1.writeJSONSync)((0, path_1.join)(root, constants_1.METADATA_FILENAME), content, {
+        spaces: 2
+    });
+    lastMetadata = content;
+}
+exports.writeMetadata = writeMetadata;
+function getUpdate(root) {
+    const file = (0, path_1.join)((0, utils_1.getDllDir)(root), constants_1.UPDATE_FILENAME);
+    if (!(0, fs_extra_1.existsSync)(file)) {
+        return {
+            discovered: {}
+        };
+    }
+    return (0, fs_extra_1.readJSONSync)(file);
+}
+exports.getUpdate = getUpdate;
+function writeUpdate(root, updateModules) {
+    if (!lastMetadata) {
+        return;
+    }
+    (0, fs_extra_1.writeJSONSync)((0, path_1.join)((0, utils_1.getDllDir)(root), constants_1.UPDATE_FILENAME), {
+        discovered: getNewModules(lastMetadata.modules, updateModules)
+    }, {
+        spaces: 2
+    });
+}
+exports.writeUpdate = writeUpdate;

package/lib/webpack/dynamic-dll/moduleCollector.d.ts

@@ -0,0 +1,28 @@
+export interface ModuleInfo {
+    libraryPath: string;
+    version: string;
+}
+export interface ModuleCollectorOptions {
+    include?: RegExp[];
+    exclude?: RegExp[];
+}
+export interface ModuleSnapshot {
+    [key: string]: ModuleInfo;
+}
+declare class ModuleCollector {
+    private _include;
+    private _exclude;
+    private _modules;
+    private _changed;
+    constructor(options: ModuleCollectorOptions);
+    shouldCollect({ request, context, resource }: {
+        request: string;
+        context: string;
+        resource: string;
+    }): boolean;
+    hasChanged(): boolean;
+    add(id: string, { libraryPath, version }: ModuleInfo): void;
+    snapshot(): ModuleSnapshot;
+}
+export type { ModuleCollector };
+export declare function getModuleCollector(options: ModuleCollectorOptions): ModuleCollector;

package/lib/webpack/dynamic-dll/moduleCollector.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModuleCollector = void 0;
+const NODE_MODULES = /node_modules/;
+class ModuleCollector {
+    constructor(options) {
+        this._modules = {};
+        this._include = options.include || [];
+        this._exclude = options.exclude || [];
+        this._changed = false;
+    }
+    shouldCollect({ request, context, resource }) {
+        if (request.startsWith('.')) {
+            return false;
+        }
+        // only inlucde modules that user has referenced in his src/
+        if (NODE_MODULES.test(context)) {
+            return false;
+        }
+        if (this._exclude.some(p => p.test(request))) {
+            return false;
+        }
+        if (this._include.some(p => p.test(request))) {
+            return true;
+        }
+        return NODE_MODULES.test(resource);
+    }
+    hasChanged() {
+        return this._changed;
+    }
+    add(id, { libraryPath, version }) {
+        const modules = this._modules;
+        const mod = modules[id];
+        if (!mod) {
+            modules[id] = {
+                libraryPath,
+                version
+            };
+            this._changed = true;
+        }
+        else {
+            const { version: oldVersion } = mod;
+            if (oldVersion !== version) {
+                modules[id] = {
+                    libraryPath,
+                    version
+                };
+                this._changed = true;
+            }
+        }
+    }
+    snapshot() {
+        const snapshot = Object.assign({}, this._modules);
+        this._changed = false;
+        return snapshot;
+    }
+}
+function getModuleCollector(options) {
+    return new ModuleCollector({
+        include: options.include,
+        exclude: options.exclude
+    });
+}
+exports.getModuleCollector = getModuleCollector;

package/lib/webpack/dynamic-dll/plugin/dynamic-dll-plugin.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+/// <reference types="webpack-env" />
+import type { Compiler } from 'webpack';
+import { ModuleCollectorOptions, ModuleSnapshot } from '../moduleCollector';
+export declare type SnapshotListener = (snapshot: ModuleSnapshot) => void;
+export interface DynamicDLLPluginOptions {
+    resolveWebpackModule: (s: string) => ReturnType<typeof require>;
+    dllName: string;
+    onSnapshot: SnapshotListener;
+    shareScope?: string;
+}
+export declare class DynamicDLLPlugin {
+    private _collector;
+    private _resolveWebpackModule;
+    private _dllName;
+    private _shareScope?;
+    private _timer;
+    private _matchCache;
+    private _onSnapshot;
+    private _disabled;
+    constructor(opts: DynamicDLLPluginOptions & ModuleCollectorOptions);
+    disableDllReference(): void;
+    apply(compiler: Compiler): void;
+}

package/lib/webpack/dynamic-dll/plugin/dynamic-dll-plugin.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamicDLLPlugin = void 0;
+const moduleCollector_1 = require("../moduleCollector");
+const PLUGIN_NAME = 'DLLBuildDeps';
+class DynamicDLLPlugin {
+    constructor(opts) {
+        this._resolveWebpackModule = opts.resolveWebpackModule;
+        this._dllName = opts.dllName;
+        this._shareScope = opts.shareScope;
+        this._onSnapshot = opts.onSnapshot;
+        this._collector = (0, moduleCollector_1.getModuleCollector)({
+            include: opts.include,
+            exclude: opts.exclude
+        });
+        this._matchCache = new Map();
+        this._timer = null;
+        this._disabled = false;
+    }
+    disableDllReference() {
+        this._disabled = true;
+    }
+    apply(compiler) {
+        compiler.hooks.normalModuleFactory.tap(PLUGIN_NAME, nmf => {
+            nmf.hooks.beforeResolve.tap(PLUGIN_NAME, resolveData => {
+                const { request } = resolveData;
+                const replaceValue = this._matchCache.get(request);
+                if (replaceValue) {
+                    resolveData.request = replaceValue;
+                }
+            });
+            nmf.hooks.createModule.tap(PLUGIN_NAME, (_createData, resolveData) => {
+                const { createData = {}, request } = resolveData;
+                const { resource = '' } = createData;
+                if (!this._collector.shouldCollect({
+                    request,
+                    context: resolveData.context,
+                    resource
+                })) {
+                    return;
+                }
+                const { resourceResolveData: { descriptionFileData: { version = null } } = {} } = createData;
+                this._collector.add(request, {
+                    libraryPath: resource,
+                    version
+                });
+                if (this._disabled) {
+                    return;
+                }
+                const name = this._dllName;
+                const replaceValue = `${name}/${request}`;
+                resolveData.request = replaceValue;
+                this._matchCache.set(request, replaceValue);
+                const RemoteModule = this._resolveWebpackModule(`webpack/lib/container/RemoteModule`);
+                return new RemoteModule(resolveData.request, [`webpack/container/reference/${name}`], `.${resolveData.request.slice(name.length)}`, this._shareScope || 'default');
+            });
+        });
+        compiler.hooks.done.tap(PLUGIN_NAME, (stats) => {
+            if (!stats.hasErrors()) {
+                if (this._timer) {
+                    clearTimeout(this._timer);
+                }
+                this._timer = setTimeout(() => {
+                    this._onSnapshot(this._collector.snapshot());
+                }, 500);
+            }
+        });
+    }
+}
+exports.DynamicDLLPlugin = DynamicDLLPlugin;

package/lib/webpack/dynamic-dll/utils.d.ts

@@ -0,0 +1,6 @@
+export declare const version: any;
+export declare function isString(val: unknown): val is string;
+export declare function isArray(val: unknown): val is any[];
+export declare function getDepsDir(dir: string): string;
+export declare function getDllDir(dir: string): string;
+export declare function getDllPendingDir(dir: string): string;

package/lib/webpack/dynamic-dll/utils.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDllPendingDir = exports.getDllDir = exports.getDepsDir = exports.isArray = exports.isString = exports.version = void 0;
+const path_1 = __importDefault(require("path"));
+const pkg = require(path_1.default.resolve(__dirname, '../../..', 'package.json'));
+exports.version = pkg.version;
+function isString(val) {
+    return typeof val === 'string';
+}
+exports.isString = isString;
+function isArray(val) {
+    return Array.isArray(val);
+}
+exports.isArray = isArray;
+function getDepsDir(dir) {
+    return path_1.default.join(dir, 'deps');
+}
+exports.getDepsDir = getDepsDir;
+function getDllDir(dir) {
+    return path_1.default.join(dir, 'current');
+}
+exports.getDllDir = getDllDir;
+function getDllPendingDir(dir) {
+    return path_1.default.join(dir, 'pending');
+}
+exports.getDllPendingDir = getDllPendingDir;

package/lib/webpack/index.d.ts

@@ -0,0 +1,15 @@
+import webpack from 'webpack';
+export { webpack as default };
+export { WebpackChain } from './config';
+export { DynamicDll } from './dynamic-dll';
+/**
+ * re-export for shuvi plugin
+ */
+export { webpack, validate, validateSchema, version, cli, ModuleFilenameHelpers, RuntimeGlobals, UsageState, WebpackOptionsValidationError, ValidationError, cache, config, dependencies, ids, javascript, optimize, runtime, prefetch, web, webworker, node, electron, wasm, library, container, sharing, debug, util, sources, experiments, WebpackPluginFunction, 
+/** export */
+AutomaticPrefetchPlugin, AsyncDependenciesBlock, BannerPlugin, Cache, Chunk, ChunkGraph, CleanPlugin, Compilation, Compiler, ConcatenationScope, ContextExclusionPlugin, ContextReplacementPlugin, DefinePlugin, DelegatedPlugin, Dependency, DllPlugin, DllReferencePlugin, DynamicEntryPlugin, EntryOptionPlugin, EntryPlugin, EnvironmentPlugin, EvalDevToolModulePlugin, EvalSourceMapDevToolPlugin, ExternalModule, ExternalsPlugin, Generator, HotUpdateChunk, HotModuleReplacementPlugin, IgnorePlugin, JavascriptModulesPlugin, LibManifestPlugin, LibraryTemplatePlugin, LoaderOptionsPlugin, LoaderTargetPlugin, Module, ModuleGraph, ModuleGraphConnection, NoEmitOnErrorsPlugin, NormalModule, NormalModuleReplacementPlugin, MultiCompiler, Parser, Plugin, PrefetchPlugin, ProgressPlugin, ProvidePlugin, RuntimeModule, EntryPlugin as SingleEntryPlugin, SourceMapDevToolPlugin, Stats, Template, WatchIgnorePlugin, WebpackError, WebpackOptionsApply, WebpackOptionsDefaulter, Entry, EntryNormalized, EntryObject, LibraryOptions, ModuleOptions, ResolveOptions, RuleSetCondition, RuleSetConditionAbsolute, RuleSetRule, RuleSetUse, RuleSetUseItem, Configuration, WebpackOptionsNormalized, WebpackPluginInstance, Asset, AssetInfo, MultiStats, ParserState, Watching, StatsAsset, StatsChunk, StatsChunkGroup, StatsChunkOrigin, StatsCompilation, StatsError, StatsLogging, StatsLoggingEntry, StatsModule, StatsModuleIssuer, StatsModuleReason, StatsModuleTraceDependency, StatsModuleTraceItem, StatsProfile } from 'webpack';
+/**
+ * resolve webpack module for not shuvi plugin
+ */
+declare const webpackResolveContext: string;
+export { webpackResolveContext };

package/lib/webpack/index.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DllReferencePlugin = exports.DllPlugin = exports.Dependency = exports.DelegatedPlugin = exports.DefinePlugin = exports.ContextReplacementPlugin = exports.ContextExclusionPlugin = exports.ConcatenationScope = exports.Compiler = exports.Compilation = exports.CleanPlugin = exports.ChunkGraph = exports.Chunk = exports.Cache = exports.BannerPlugin = exports.AsyncDependenciesBlock = exports.AutomaticPrefetchPlugin = exports.experiments = exports.sources = exports.util = exports.debug = exports.sharing = exports.container = exports.library = exports.wasm = exports.electron = exports.node = exports.webworker = exports.web = exports.prefetch = exports.runtime = exports.optimize = exports.javascript = exports.ids = exports.dependencies = exports.config = exports.cache = exports.ValidationError = exports.WebpackOptionsValidationError = exports.UsageState = exports.RuntimeGlobals = exports.ModuleFilenameHelpers = exports.cli = exports.version = exports.validateSchema = exports.validate = exports.webpack = exports.DynamicDll = exports.WebpackChain = exports.default = void 0;
+exports.webpackResolveContext = exports.Watching = exports.MultiStats = exports.WebpackOptionsDefaulter = exports.WebpackOptionsApply = exports.WebpackError = exports.WatchIgnorePlugin = exports.Template = exports.Stats = exports.SourceMapDevToolPlugin = exports.SingleEntryPlugin = exports.RuntimeModule = exports.ProvidePlugin = exports.ProgressPlugin = exports.PrefetchPlugin = exports.Parser = exports.MultiCompiler = exports.NormalModuleReplacementPlugin = exports.NormalModule = exports.NoEmitOnErrorsPlugin = exports.ModuleGraphConnection = exports.ModuleGraph = exports.Module = exports.LoaderTargetPlugin = exports.LoaderOptionsPlugin = exports.LibraryTemplatePlugin = exports.LibManifestPlugin = exports.JavascriptModulesPlugin = exports.IgnorePlugin = exports.HotModuleReplacementPlugin = exports.HotUpdateChunk = exports.Generator = exports.ExternalsPlugin = exports.ExternalModule = exports.EvalSourceMapDevToolPlugin = exports.EvalDevToolModulePlugin = exports.EnvironmentPlugin = exports.EntryPlugin = exports.EntryOptionPlugin = exports.DynamicEntryPlugin = void 0;
+const path_1 = require("path");
+const webpack_1 = __importDefault(require("webpack"));
+exports.default = webpack_1.default;
+var config_1 = require("./config");
+Object.defineProperty(exports, "WebpackChain", { enumerable: true, get: function () { return config_1.WebpackChain; } });
+var dynamic_dll_1 = require("./dynamic-dll");
+Object.defineProperty(exports, "DynamicDll", { enumerable: true, get: function () { return dynamic_dll_1.DynamicDll; } });
+/**
+ * re-export for shuvi plugin
+ */
+var webpack_2 = require("webpack");
+Object.defineProperty(exports, "webpack", { enumerable: true, get: function () { return webpack_2.webpack; } });
+Object.defineProperty(exports, "validate", { enumerable: true, get: function () { return webpack_2.validate; } });
+Object.defineProperty(exports, "validateSchema", { enumerable: true, get: function () { return webpack_2.validateSchema; } });
+Object.defineProperty(exports, "version", { enumerable: true, get: function () { return webpack_2.version; } });
+Object.defineProperty(exports, "cli", { enumerable: true, get: function () { return webpack_2.cli; } });
+Object.defineProperty(exports, "ModuleFilenameHelpers", { enumerable: true, get: function () { return webpack_2.ModuleFilenameHelpers; } });
+Object.defineProperty(exports, "RuntimeGlobals", { enumerable: true, get: function () { return webpack_2.RuntimeGlobals; } });
+Object.defineProperty(exports, "UsageState", { enumerable: true, get: function () { return webpack_2.UsageState; } });
+Object.defineProperty(exports, "WebpackOptionsValidationError", { enumerable: true, get: function () { return webpack_2.WebpackOptionsValidationError; } });
+Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return webpack_2.ValidationError; } });
+Object.defineProperty(exports, "cache", { enumerable: true, get: function () { return webpack_2.cache; } });
+Object.defineProperty(exports, "config", { enumerable: true, get: function () { return webpack_2.config; } });
+Object.defineProperty(exports, "dependencies", { enumerable: true, get: function () { return webpack_2.dependencies; } });
+Object.defineProperty(exports, "ids", { enumerable: true, get: function () { return webpack_2.ids; } });
+Object.defineProperty(exports, "javascript", { enumerable: true, get: function () { return webpack_2.javascript; } });
+Object.defineProperty(exports, "optimize", { enumerable: true, get: function () { return webpack_2.optimize; } });
+Object.defineProperty(exports, "runtime", { enumerable: true, get: function () { return webpack_2.runtime; } });
+Object.defineProperty(exports, "prefetch", { enumerable: true, get: function () { return webpack_2.prefetch; } });
+Object.defineProperty(exports, "web", { enumerable: true, get: function () { return webpack_2.web; } });
+Object.defineProperty(exports, "webworker", { enumerable: true, get: function () { return webpack_2.webworker; } });
+Object.defineProperty(exports, "node", { enumerable: true, get: function () { return webpack_2.node; } });
+Object.defineProperty(exports, "electron", { enumerable: true, get: function () { return webpack_2.electron; } });
+Object.defineProperty(exports, "wasm", { enumerable: true, get: function () { return webpack_2.wasm; } });
+Object.defineProperty(exports, "library", { enumerable: true, get: function () { return webpack_2.library; } });
+Object.defineProperty(exports, "container", { enumerable: true, get: function () { return webpack_2.container; } });
+Object.defineProperty(exports, "sharing", { enumerable: true, get: function () { return webpack_2.sharing; } });
+Object.defineProperty(exports, "debug", { enumerable: true, get: function () { return webpack_2.debug; } });
+Object.defineProperty(exports, "util", { enumerable: true, get: function () { return webpack_2.util; } });
+Object.defineProperty(exports, "sources", { enumerable: true, get: function () { return webpack_2.sources; } });
+Object.defineProperty(exports, "experiments", { enumerable: true, get: function () { return webpack_2.experiments; } });
+/** export */
+Object.defineProperty(exports, "AutomaticPrefetchPlugin", { enumerable: true, get: function () { return webpack_2.AutomaticPrefetchPlugin; } });
+Object.defineProperty(exports, "AsyncDependenciesBlock", { enumerable: true, get: function () { return webpack_2.AsyncDependenciesBlock; } });
+Object.defineProperty(exports, "BannerPlugin", { enumerable: true, get: function () { return webpack_2.BannerPlugin; } });
+Object.defineProperty(exports, "Cache", { enumerable: true, get: function () { return webpack_2.Cache; } });
+Object.defineProperty(exports, "Chunk", { enumerable: true, get: function () { return webpack_2.Chunk; } });
+Object.defineProperty(exports, "ChunkGraph", { enumerable: true, get: function () { return webpack_2.ChunkGraph; } });
+Object.defineProperty(exports, "CleanPlugin", { enumerable: true, get: function () { return webpack_2.CleanPlugin; } });
+Object.defineProperty(exports, "Compilation", { enumerable: true, get: function () { return webpack_2.Compilation; } });
+Object.defineProperty(exports, "Compiler", { enumerable: true, get: function () { return webpack_2.Compiler; } });
+Object.defineProperty(exports, "ConcatenationScope", { enumerable: true, get: function () { return webpack_2.ConcatenationScope; } });
+Object.defineProperty(exports, "ContextExclusionPlugin", { enumerable: true, get: function () { return webpack_2.ContextExclusionPlugin; } });
+Object.defineProperty(exports, "ContextReplacementPlugin", { enumerable: true, get: function () { return webpack_2.ContextReplacementPlugin; } });
+Object.defineProperty(exports, "DefinePlugin", { enumerable: true, get: function () { return webpack_2.DefinePlugin; } });
+Object.defineProperty(exports, "DelegatedPlugin", { enumerable: true, get: function () { return webpack_2.DelegatedPlugin; } });
+Object.defineProperty(exports, "Dependency", { enumerable: true, get: function () { return webpack_2.Dependency; } });
+Object.defineProperty(exports, "DllPlugin", { enumerable: true, get: function () { return webpack_2.DllPlugin; } });
+Object.defineProperty(exports, "DllReferencePlugin", { enumerable: true, get: function () { return webpack_2.DllReferencePlugin; } });
+Object.defineProperty(exports, "DynamicEntryPlugin", { enumerable: true, get: function () { return webpack_2.DynamicEntryPlugin; } });
+Object.defineProperty(exports, "EntryOptionPlugin", { enumerable: true, get: function () { return webpack_2.EntryOptionPlugin; } });
+Object.defineProperty(exports, "EntryPlugin", { enumerable: true, get: function () { return webpack_2.EntryPlugin; } });
+Object.defineProperty(exports, "EnvironmentPlugin", { enumerable: true, get: function () { return webpack_2.EnvironmentPlugin; } });
+Object.defineProperty(exports, "EvalDevToolModulePlugin", { enumerable: true, get: function () { return webpack_2.EvalDevToolModulePlugin; } });
+Object.defineProperty(exports, "EvalSourceMapDevToolPlugin", { enumerable: true, get: function () { return webpack_2.EvalSourceMapDevToolPlugin; } });
+Object.defineProperty(exports, "ExternalModule", { enumerable: true, get: function () { return webpack_2.ExternalModule; } });
+Object.defineProperty(exports, "ExternalsPlugin", { enumerable: true, get: function () { return webpack_2.ExternalsPlugin; } });
+Object.defineProperty(exports, "Generator", { enumerable: true, get: function () { return webpack_2.Generator; } });
+Object.defineProperty(exports, "HotUpdateChunk", { enumerable: true, get: function () { return webpack_2.HotUpdateChunk; } });
+Object.defineProperty(exports, "HotModuleReplacementPlugin", { enumerable: true, get: function () { return webpack_2.HotModuleReplacementPlugin; } });
+Object.defineProperty(exports, "IgnorePlugin", { enumerable: true, get: function () { return webpack_2.IgnorePlugin; } });
+Object.defineProperty(exports, "JavascriptModulesPlugin", { enumerable: true, get: function () { return webpack_2.JavascriptModulesPlugin; } });
+Object.defineProperty(exports, "LibManifestPlugin", { enumerable: true, get: function () { return webpack_2.LibManifestPlugin; } });
+Object.defineProperty(exports, "LibraryTemplatePlugin", { enumerable: true, get: function () { return webpack_2.LibraryTemplatePlugin; } });
+Object.defineProperty(exports, "LoaderOptionsPlugin", { enumerable: true, get: function () { return webpack_2.LoaderOptionsPlugin; } });
+Object.defineProperty(exports, "LoaderTargetPlugin", { enumerable: true, get: function () { return webpack_2.LoaderTargetPlugin; } });
+Object.defineProperty(exports, "Module", { enumerable: true, get: function () { return webpack_2.Module; } });
+Object.defineProperty(exports, "ModuleGraph", { enumerable: true, get: function () { return webpack_2.ModuleGraph; } });
+Object.defineProperty(exports, "ModuleGraphConnection", { enumerable: true, get: function () { return webpack_2.ModuleGraphConnection; } });
+Object.defineProperty(exports, "NoEmitOnErrorsPlugin", { enumerable: true, get: function () { return webpack_2.NoEmitOnErrorsPlugin; } });
+Object.defineProperty(exports, "NormalModule", { enumerable: true, get: function () { return webpack_2.NormalModule; } });
+Object.defineProperty(exports, "NormalModuleReplacementPlugin", { enumerable: true, get: function () { return webpack_2.NormalModuleReplacementPlugin; } });
+Object.defineProperty(exports, "MultiCompiler", { enumerable: true, get: function () { return webpack_2.MultiCompiler; } });
+Object.defineProperty(exports, "Parser", { enumerable: true, get: function () { return webpack_2.Parser; } });
+Object.defineProperty(exports, "PrefetchPlugin", { enumerable: true, get: function () { return webpack_2.PrefetchPlugin; } });
+Object.defineProperty(exports, "ProgressPlugin", { enumerable: true, get: function () { return webpack_2.ProgressPlugin; } });
+Object.defineProperty(exports, "ProvidePlugin", { enumerable: true, get: function () { return webpack_2.ProvidePlugin; } });
+Object.defineProperty(exports, "RuntimeModule", { enumerable: true, get: function () { return webpack_2.RuntimeModule; } });
+Object.defineProperty(exports, "SingleEntryPlugin", { enumerable: true, get: function () { return webpack_2.EntryPlugin; } });
+Object.defineProperty(exports, "SourceMapDevToolPlugin", { enumerable: true, get: function () { return webpack_2.SourceMapDevToolPlugin; } });
+Object.defineProperty(exports, "Stats", { enumerable: true, get: function () { return webpack_2.Stats; } });
+Object.defineProperty(exports, "Template", { enumerable: true, get: function () { return webpack_2.Template; } });
+Object.defineProperty(exports, "WatchIgnorePlugin", { enumerable: true, get: function () { return webpack_2.WatchIgnorePlugin; } });
+Object.defineProperty(exports, "WebpackError", { enumerable: true, get: function () { return webpack_2.WebpackError; } });
+Object.defineProperty(exports, "WebpackOptionsApply", { enumerable: true, get: function () { return webpack_2.WebpackOptionsApply; } });
+Object.defineProperty(exports, "WebpackOptionsDefaulter", { enumerable: true, get: function () { return webpack_2.WebpackOptionsDefaulter; } });
+Object.defineProperty(exports, "MultiStats", { enumerable: true, get: function () { return webpack_2.MultiStats; } });
+Object.defineProperty(exports, "Watching", { enumerable: true, get: function () { return webpack_2.Watching; } });
+/**
+ * resolve webpack module for not shuvi plugin
+ */
+const webpackResolveContext = (0, path_1.join)((0, path_1.dirname)(require.resolve('webpack/package.json')), '../');
+exports.webpackResolveContext = webpackResolveContext;

package/lib/webpack/loaders/parcel-css-loader/CssSyntaxError.d.ts

@@ -0,0 +1,11 @@
+export interface ICssSyntaxError {
+    source: string;
+    fileName: string;
+    loc: {
+        line: number;
+        column: number;
+    };
+}
+export default class CssSyntaxError extends Error {
+    constructor(error: ICssSyntaxError);
+}