@modern-js/utils
Version:
A Progressive React Framework for modern web development.
1,181 lines • 61 kB
JavaScript
(()=>{
var e = {
256: function(e) {
(function(t, s) {
e.exports = s();
})(0, function() {
"use strict";
var e = function(e) {
return isNonNullObject(e) && !isSpecial(e);
};
function isNonNullObject(e) {
return !!e && "object" == typeof e;
}
function isSpecial(e) {
var t = Object.prototype.toString.call(e);
return "[object RegExp]" === t || "[object Date]" === t || isReactElement(e);
}
var t = "function" == typeof Symbol && Symbol.for;
var s = t ? Symbol.for("react.element") : 60103;
function isReactElement(e) {
return e.$$typeof === s;
}
function emptyTarget(e) {
return Array.isArray(e) ? [] : {};
}
function cloneIfNecessary(t, s) {
var n = s && true === s.clone;
return n && e(t) ? deepmerge(emptyTarget(t), t, s) : t;
}
function defaultArrayMerge(t, s, n) {
var i = t.slice();
s.forEach(function(s, r) {
if (void 0 === i[r]) i[r] = cloneIfNecessary(s, n);
else if (e(s)) i[r] = deepmerge(t[r], s, n);
else if (-1 === t.indexOf(s)) i.push(cloneIfNecessary(s, n));
});
return i;
}
function mergeObject(t, s, n) {
var i = {};
if (e(t)) Object.keys(t).forEach(function(e) {
i[e] = cloneIfNecessary(t[e], n);
});
Object.keys(s).forEach(function(r) {
if (e(s[r]) && t[r]) i[r] = deepmerge(t[r], s[r], n);
else i[r] = cloneIfNecessary(s[r], n);
});
return i;
}
function deepmerge(e, t, s) {
var n = Array.isArray(t);
var i = Array.isArray(e);
var r = s || {
arrayMerge: defaultArrayMerge
};
var o = n === i;
if (!o) return cloneIfNecessary(t, s);
if (!n) return mergeObject(e, t, s);
var u = r.arrayMerge || defaultArrayMerge;
return u(e, t, s);
}
deepmerge.all = function(e, t) {
if (!Array.isArray(e) || e.length < 2) throw new Error("first argument should be an array with at least two elements");
return e.reduce(function(e, s) {
return deepmerge(e, s, t);
});
};
var n = deepmerge;
return n;
});
},
210: (e, t)=>{
"use strict";
Object.defineProperty(t, "__esModule", {
value: true
});
t.arrayToString = void 0;
const arrayToString = (e, t, s)=>{
const n = e.map(function(e, n) {
const i = s(e, n);
if (void 0 === i) return String(i);
return t + i.split("\n").join(`\n${t}`);
}).join(t ? ",\n" : ",");
const i = t && n ? "\n" : "";
return `[${i}${n}${i}]`;
};
t.arrayToString = arrayToString;
},
262: (e, t, s)=>{
"use strict";
Object.defineProperty(t, "__esModule", {
value: true
});
t.FunctionParser = t.dedentFunction = t.functionToString = t.USED_METHOD_KEY = void 0;
const n = s(893);
const i = '"' === ({
" " () {}
})[" "].toString().charAt(0);
const r = {
Function: "function ",
GeneratorFunction: "function* ",
AsyncFunction: "async function ",
AsyncGeneratorFunction: "async function* "
};
const o = {
Function: "",
GeneratorFunction: "*",
AsyncFunction: "async ",
AsyncGeneratorFunction: "async *"
};
const u = new Set("case delete else in instanceof new return throw typeof void , ; : + - ! ~ & | ^ * / % < > ? =".split(" "));
t.USED_METHOD_KEY = new WeakSet;
const functionToString = (e, s, n, i)=>{
const r = "string" == typeof i ? i : void 0;
if (void 0 !== r) t.USED_METHOD_KEY.add(e);
return new FunctionParser(e, s, n, r).stringify();
};
t.functionToString = functionToString;
function dedentFunction(e) {
let t;
for (const s of e.split("\n").slice(1)){
const n = /^[\s\t]+/.exec(s);
if (!n) return e;
const [i] = n;
if (void 0 === t) t = i;
else if (i.length < t.length) t = i;
}
return t ? e.split(`\n${t}`).join("\n") : e;
}
t.dedentFunction = dedentFunction;
class FunctionParser {
constructor(e, t, s, i){
this.fn = e;
this.indent = t;
this.next = s;
this.key = i;
this.pos = 0;
this.hadKeyword = false;
this.fnString = Function.prototype.toString.call(e);
this.fnType = e.constructor.name;
this.keyQuote = void 0 === i ? "" : n.quoteKey(i, s);
this.keyPrefix = void 0 === i ? "" : `${this.keyQuote}:${t ? " " : ""}`;
this.isMethodCandidate = void 0 === i ? false : "" === this.fn.name || this.fn.name === i;
}
stringify() {
const e = this.tryParse();
if (!e) return `${this.keyPrefix}void ${this.next(this.fnString)}`;
return dedentFunction(e);
}
getPrefix() {
if (this.isMethodCandidate && !this.hadKeyword) return o[this.fnType] + this.keyQuote;
return this.keyPrefix + r[this.fnType];
}
tryParse() {
if ("}" !== this.fnString[this.fnString.length - 1]) return this.keyPrefix + this.fnString;
if (this.fn.name) {
const e = this.tryStrippingName();
if (e) return e;
}
const e = this.pos;
if ("class" === this.consumeSyntax()) return this.fnString;
this.pos = e;
if (this.tryParsePrefixTokens()) {
const e = this.tryStrippingName();
if (e) return e;
let t = this.pos;
switch(this.consumeSyntax("WORD_LIKE")){
case "WORD_LIKE":
if (this.isMethodCandidate && !this.hadKeyword) t = this.pos;
case "()":
if ("=>" === this.fnString.substr(this.pos, 2)) return this.keyPrefix + this.fnString;
this.pos = t;
case '"':
case "'":
case "[]":
return this.getPrefix() + this.fnString.substr(this.pos);
}
}
}
tryStrippingName() {
if (i) return;
let e = this.pos;
const t = this.fnString.substr(this.pos, this.fn.name.length);
if (t === this.fn.name) {
this.pos += t.length;
if ("()" === this.consumeSyntax() && "{}" === this.consumeSyntax() && this.pos === this.fnString.length) {
if (this.isMethodCandidate || !n.isValidVariableName(t)) e += t.length;
return this.getPrefix() + this.fnString.substr(e);
}
}
this.pos = e;
}
tryParsePrefixTokens() {
let e = this.pos;
this.hadKeyword = false;
switch(this.fnType){
case "AsyncFunction":
if ("async" !== this.consumeSyntax()) return false;
e = this.pos;
case "Function":
if ("function" === this.consumeSyntax()) this.hadKeyword = true;
else this.pos = e;
return true;
case "AsyncGeneratorFunction":
if ("async" !== this.consumeSyntax()) return false;
case "GeneratorFunction":
let t = this.consumeSyntax();
if ("function" === t) {
t = this.consumeSyntax();
this.hadKeyword = true;
}
return "*" === t;
}
}
consumeSyntax(e) {
const t = this.consumeMatch(/^(?:([A-Za-z_0-9$\xA0-\uFFFF]+)|=>|\+\+|\-\-|.)/);
if (!t) return;
const [s, n] = t;
this.consumeWhitespace();
if (n) return e || n;
switch(s){
case "(":
return this.consumeSyntaxUntil("(", ")");
case "[":
return this.consumeSyntaxUntil("[", "]");
case "{":
return this.consumeSyntaxUntil("{", "}");
case "`":
return this.consumeTemplate();
case '"':
return this.consumeRegExp(/^(?:[^\\"]|\\.)*"/, '"');
case "'":
return this.consumeRegExp(/^(?:[^\\']|\\.)*'/, "'");
}
return s;
}
consumeSyntaxUntil(e, t) {
let s = true;
for(;;){
const n = this.consumeSyntax();
if (n === t) return e + t;
if (!n || ")" === n || "]" === n || "}" === n) return;
if ("/" === n && s && this.consumeMatch(/^(?:\\.|[^\\\/\n[]|\[(?:\\.|[^\]])*\])+\/[a-z]*/)) {
s = false;
this.consumeWhitespace();
} else s = u.has(n);
}
}
consumeMatch(e) {
const t = e.exec(this.fnString.substr(this.pos));
if (t) this.pos += t[0].length;
return t;
}
consumeRegExp(e, t) {
const s = e.exec(this.fnString.substr(this.pos));
if (!s) return;
this.pos += s[0].length;
this.consumeWhitespace();
return t;
}
consumeTemplate() {
for(;;){
this.consumeMatch(/^(?:[^`$\\]|\\.|\$(?!{))*/);
if ("`" === this.fnString[this.pos]) {
this.pos++;
this.consumeWhitespace();
return "`";
}
if ("${" === this.fnString.substr(this.pos, 2)) {
this.pos += 2;
this.consumeWhitespace();
if (this.consumeSyntaxUntil("{", "}")) continue;
}
return;
}
}
consumeWhitespace() {
this.consumeMatch(/^(?:\s|\/\/.*|\/\*[^]*?\*\/)*/);
}
}
t.FunctionParser = FunctionParser;
},
592: (e, t, s)=>{
"use strict";
Object.defineProperty(t, "__esModule", {
value: true
});
t.stringify = void 0;
const n = s(761);
const i = s(893);
const r = Symbol("root");
function stringify(e, t, s, n = {}) {
const o = "string" == typeof s ? s : " ".repeat(s || 0);
const u = [];
const a = new Set;
const c = new Map;
const l = new Map;
let h = 0;
const { maxDepth: f = 100, references: p = false, skipUndefinedProperties: d = false, maxValues: g = 1e5 } = n;
const m = replacerToString(t);
const onNext = (e, t)=>{
if (++h > g) return;
if (d && void 0 === e) return;
if (u.length > f) return;
if (void 0 === t) return m(e, o, onNext, t);
u.push(t);
const s = y(e, t === r ? void 0 : t);
u.pop();
return s;
};
const y = p ? (e, t)=>{
if (null !== e && ("object" == typeof e || "function" == typeof e || "symbol" == typeof e)) {
if (c.has(e)) {
l.set(u.slice(1), c.get(e));
return m(void 0, o, onNext, t);
}
c.set(e, u.slice(1));
}
return m(e, o, onNext, t);
} : (e, t)=>{
if (a.has(e)) return;
a.add(e);
const s = m(e, o, onNext, t);
a.delete(e);
return s;
};
const b = onNext(e, r);
if (l.size) {
const e = o ? " " : "";
const t = o ? "\n" : "";
let s = `var x${e}=${e}${b};${t}`;
for (const [n, r] of l.entries()){
const o = i.stringifyPath(n, onNext);
const u = i.stringifyPath(r, onNext);
s += `x${o}${e}=${e}x${u};${t}`;
}
return `(function${e}()${e}{${t}${s}return x;${t}}())`;
}
return b;
}
t.stringify = stringify;
function replacerToString(e) {
if (!e) return n.toString;
return (t, s, i, r)=>e(t, s, (e)=>n.toString(e, s, i, r), r);
}
},
125: (e, t, s)=>{
"use strict";
Object.defineProperty(t, "__esModule", {
value: true
});
t.objectToString = void 0;
const n = s(893);
const i = s(262);
const r = s(210);
const objectToString = (e, t, s, n)=>{
if ("function" == typeof Buffer && Buffer.isBuffer(e)) return `Buffer.from(${s(e.toString("base64"))}, 'base64')`;
if ("object" == typeof global && e === global) return globalToString(e, t, s);
const i = o[Object.prototype.toString.call(e)];
return i ? i(e, t, s, n) : void 0;
};
t.objectToString = objectToString;
const rawObjectToString = (e, t, s, r)=>{
const o = t ? "\n" : "";
const u = t ? " " : "";
const a = Object.keys(e).reduce(function(r, o) {
const a = e[o];
const c = s(a, o);
if (void 0 === c) return r;
const l = c.split("\n").join(`\n${t}`);
if (i.USED_METHOD_KEY.has(a)) {
r.push(`${t}${l}`);
return r;
}
r.push(`${t}${n.quoteKey(o, s)}:${u}${l}`);
return r;
}, []).join(`,${o}`);
if ("" === a) return "{}";
return `{${o}${a}${o}}`;
};
const globalToString = (e, t, s)=>`Function(${s("return this")})()`;
const o = {
"[object Array]": r.arrayToString,
"[object Object]": rawObjectToString,
"[object Error]": (e, t, s)=>`new Error(${s(e.message)})`,
"[object Date]": (e)=>`new Date(${e.getTime()})`,
"[object String]": (e, t, s)=>`new String(${s(e.toString())})`,
"[object Number]": (e)=>`new Number(${e})`,
"[object Boolean]": (e)=>`new Boolean(${e})`,
"[object Set]": (e, t, s)=>`new Set(${s(Array.from(e))})`,
"[object Map]": (e, t, s)=>`new Map(${s(Array.from(e))})`,
"[object RegExp]": String,
"[object global]": globalToString,
"[object Window]": globalToString
};
},
893: (e, t)=>{
"use strict";
Object.defineProperty(t, "__esModule", {
value: true
});
t.stringifyPath = t.quoteKey = t.isValidVariableName = t.IS_VALID_IDENTIFIER = t.quoteString = void 0;
const s = /[\\\'\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g;
const n = new Map([
[
"\b",
"\\b"
],
[
"\t",
"\\t"
],
[
"\n",
"\\n"
],
[
"\f",
"\\f"
],
[
"\r",
"\\r"
],
[
"'",
"\\'"
],
[
'"',
'\\"'
],
[
"\\",
"\\\\"
]
]);
function escapeChar(e) {
return n.get(e) || `\\u${`0000${e.charCodeAt(0).toString(16)}`.slice(-4)}`;
}
function quoteString(e) {
return `'${e.replace(s, escapeChar)}'`;
}
t.quoteString = quoteString;
const i = new Set("break else new var case finally return void catch for switch while continue function this with default if throw delete in try do instanceof typeof abstract enum int short boolean export interface static byte extends long super char final native synchronized class float package throws const goto private transient debugger implements protected volatile double import public let yield".split(" "));
t.IS_VALID_IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
function isValidVariableName(e) {
return "string" == typeof e && !i.has(e) && t.IS_VALID_IDENTIFIER.test(e);
}
t.isValidVariableName = isValidVariableName;
function quoteKey(e, t) {
return isValidVariableName(e) ? e : t(e);
}
t.quoteKey = quoteKey;
function stringifyPath(e, t) {
let s = "";
for (const n of e)if (isValidVariableName(n)) s += `.${n}`;
else s += `[${t(n)}]`;
return s;
}
t.stringifyPath = stringifyPath;
},
761: (e, t, s)=>{
"use strict";
Object.defineProperty(t, "__esModule", {
value: true
});
t.toString = void 0;
const n = s(893);
const i = s(125);
const r = s(262);
const o = {
string: n.quoteString,
number: (e)=>Object.is(e, -0) ? "-0" : String(e),
boolean: String,
symbol: (e, t, s)=>{
const n = Symbol.keyFor(e);
if (void 0 !== n) return `Symbol.for(${s(n)})`;
return `Symbol(${s(e.description)})`;
},
bigint: (e, t, s)=>`BigInt(${s(String(e))})`,
undefined: String,
object: i.objectToString,
function: r.functionToString
};
const toString = (e, t, s, n)=>{
if (null === e) return "null";
return o[typeof e](e, t, s, n);
};
t.toString = toString;
},
741: (e)=>{
e.exports = class extends Function {
constructor(){
super();
return new Proxy(this, {
apply: (e, t, s)=>e.classCall(...s)
});
}
classCall() {
throw new Error("not implemented");
}
};
},
572: (e, t, s)=>{
const n = s(437);
const i = s(621);
e.exports = n(i(Object));
},
745: (e, t, s)=>{
const n = s(845);
const i = s(621);
e.exports = n(i(Object));
},
659: (e, t, s)=>{
const n = s(741);
const i = s(437);
const r = s(621);
const o = s(49);
e.exports = o(i(r(n)));
},
122: (e, t, s)=>{
const n = s(572);
const i = s(659);
const r = s(745);
const o = s(222);
const u = s(417);
const a = s(430);
const c = s(736);
const l = s(740);
const h = s(64);
const f = s(223);
const p = s(10);
e.exports = class extends n {
constructor(){
super();
this.entryPoints = new n(this);
this.output = new a(this);
this.module = new h(this);
this.resolve = new o(this);
this.resolveLoader = new u(this);
this.optimization = new f(this);
this.plugins = new n(this);
this.devServer = new c(this);
this.performance = new p(this);
this.node = new i(this);
this.extend([
"context",
"mode",
"devtool",
"target",
"watch",
"watchOptions",
"externals",
"externalsType",
"externalsPresets",
"stats",
"experiments",
"amd",
"bail",
"cache",
"dependencies",
"ignoreWarnings",
"loader",
"parallelism",
"profile",
"recordsPath",
"recordsInputPath",
"recordsOutputPath",
"name",
"infrastructureLogging",
"snapshot"
]);
}
static toString(e, { verbose: t = false, configPrefix: n = "config" } = {}) {
const { stringify: i } = s(592);
return i(e, (e, s, i)=>{
if (e && e.__pluginName) {
const t = `/* ${n}.${e.__pluginType}('${e.__pluginName}') */\n`;
const s = e.__pluginPath ? `(require(${i(e.__pluginPath)}))` : e.__pluginConstructorName;
if (s) {
const n = i(e.__pluginArgs).slice(1, -1);
return `${t}new ${s}(${n})`;
}
return t + i(e.__pluginArgs && e.__pluginArgs.length ? {
args: e.__pluginArgs
} : {});
}
if (e && e.__ruleNames) {
const t = e.__ruleTypes;
const s = `/* ${n}.module${e.__ruleNames.map((e, s)=>`.${t ? t[s] : "rule"}('${e}')`).join("")}${e.__useName ? `.use('${e.__useName}')` : ""} */\n`;
return s + i(e);
}
if (e && e.__expression) return e.__expression;
if ("function" == typeof e) {
if (!t && e.toString().length > 100) return "function () { /* omitted long function */ }";
}
return i(e);
}, 2);
}
entry(e) {
return this.entryPoints.getOrCompute(e, ()=>new r(this));
}
plugin(e) {
return this.plugins.getOrCompute(e, ()=>new l(this, e));
}
toConfig() {
const e = this.entryPoints.entries() || {};
const t = this.entries() || {};
return this.clean(Object.assign(t, {
node: this.node.entries(),
output: this.output.entries(),
resolve: this.resolve.toConfig(),
resolveLoader: this.resolveLoader.toConfig(),
devServer: this.devServer.toConfig(),
module: this.module.toConfig(),
optimization: this.optimization.toConfig(),
plugins: this.plugins.values().map((e)=>e.toConfig()),
performance: this.performance.entries(),
entry: Object.keys(e).reduce((t, s)=>Object.assign(t, {
[s]: e[s].values()
}), {})
}));
}
toString(t) {
return e.exports.toString(this.toConfig(), t);
}
merge(e = {}, t = []) {
const s = [
"node",
"output",
"resolve",
"resolveLoader",
"devServer",
"optimization",
"performance",
"module"
];
if (!t.includes("entry") && "entry" in e) Object.keys(e.entry).forEach((t)=>this.entry(t).merge([].concat(e.entry[t])));
if (!t.includes("plugin") && "plugin" in e) Object.keys(e.plugin).forEach((t)=>this.plugin(t).merge(e.plugin[t]));
s.forEach((s)=>{
if (!t.includes(s) && s in e) this[s].merge(e[s]);
});
return super.merge(e, [
...t,
...s,
"entry",
"plugin"
]);
}
};
},
736: (e, t, s)=>{
const n = s(572);
const i = s(745);
e.exports = class extends n {
constructor(e){
super(e);
this.allowedHosts = new i(this);
this.extend([
"after",
"before",
"bonjour",
"clientLogLevel",
"compress",
"contentBase",
"contentBasePublicPath",
"disableHostCheck",
"filename",
"headers",
"historyApiFallback",
"host",
"hot",
"hotOnly",
"http2",
"https",
"index",
"injectClient",
"injectHot",
"inline",
"lazy",
"liveReload",
"mimeTypes",
"noInfo",
"onListening",
"open",
"openPage",
"overlay",
"pfx",
"pfxPassphrase",
"port",
"proxy",
"progress",
"public",
"publicPath",
"quiet",
"serveIndex",
"setup",
"socket",
"sockHost",
"sockPath",
"sockPort",
"staticOptions",
"stats",
"stdin",
"transportMode",
"useLocalIp",
"watchContentBase",
"watchOptions",
"writeToDisk"
]);
}
toConfig() {
return this.clean({
allowedHosts: this.allowedHosts.values(),
...this.entries() || {}
});
}
merge(e, t = []) {
if (!t.includes("allowedHosts") && "allowedHosts" in e) this.allowedHosts.merge(e.allowedHosts);
return super.merge(e, [
"allowedHosts"
]);
}
};
},
64: (e, t, s)=>{
const n = s(572);
const i = s(159);
e.exports = class extends n {
constructor(e){
super(e);
this.rules = new n(this);
this.defaultRules = new n(this);
this.generator = new n(this);
this.parser = new n(this);
this.extend([
"noParse",
"unsafeCache",
"wrappedContextCritical",
"exprContextRegExp",
"wrappedContextRecursive",
"strictExportPresence",
"wrappedContextRegExp"
]);
}
defaultRule(e) {
return this.defaultRules.getOrCompute(e, ()=>new i(this, e, "defaultRule"));
}
rule(e) {
return this.rules.getOrCompute(e, ()=>new i(this, e, "rule"));
}
toConfig() {
return this.clean(Object.assign(this.entries() || {}, {
defaultRules: this.defaultRules.values().map((e)=>e.toConfig()),
generator: this.generator.entries(),
parser: this.parser.entries(),
rules: this.rules.values().map((e)=>e.toConfig())
}));
}
merge(e, t = []) {
if (!t.includes("rule") && "rule" in e) Object.keys(e.rule).forEach((t)=>this.rule(t).merge(e.rule[t]));
if (!t.includes("defaultRule") && "defaultRule" in e) Object.keys(e.defaultRule).forEach((t)=>this.defaultRule(t).merge(e.defaultRule[t]));
return super.merge(e, [
"rule",
"defaultRule"
]);
}
};
},
223: (e, t, s)=>{
const n = s(572);
const i = s(659);
const r = s(740);
e.exports = class extends n {
constructor(e){
super(e);
this.minimizers = new n(this);
this.splitChunks = new i(this);
this.extend([
"minimize",
"runtimeChunk",
"emitOnErrors",
"moduleIds",
"chunkIds",
"nodeEnv",
"mangleWasmImports",
"removeAvailableModules",
"removeEmptyChunks",
"mergeDuplicateChunks",
"flagIncludedChunks",
"providedExports",
"usedExports",
"concatenateModules",
"sideEffects",
"portableRecords",
"mangleExports",
"innerGraph",
"realContentHash"
]);
}
minimizer(e) {
if (Array.isArray(e)) throw new Error("optimization.minimizer() no longer supports being passed an array. Either switch to the new syntax (https://github.com/neutrinojs/webpack-chain#config-optimization-minimizers-adding) or downgrade to webpack-chain 4. If using Vue this likely means a Vue plugin has not yet been updated to support Vue CLI 4+.");
return this.minimizers.getOrCompute(e, ()=>new r(this, e, "optimization.minimizer"));
}
toConfig() {
return this.clean(Object.assign(this.entries() || {}, {
splitChunks: this.splitChunks.entries(),
minimizer: this.minimizers.values().map((e)=>e.toConfig())
}));
}
merge(e, t = []) {
if (!t.includes("minimizer") && "minimizer" in e) Object.keys(e.minimizer).forEach((t)=>this.minimizer(t).merge(e.minimizer[t]));
return super.merge(e, [
...t,
"minimizer"
]);
}
};
},
434: (e)=>{
e.exports = (e)=>class extends e {
before(e) {
if (this.__after) throw new Error(`Unable to set .before(${JSON.stringify(e)}) with existing value for .after()`);
this.__before = e;
return this;
}
after(e) {
if (this.__before) throw new Error(`Unable to set .after(${JSON.stringify(e)}) with existing value for .before()`);
this.__after = e;
return this;
}
merge(e, t = []) {
if (e.before) this.before(e.before);
if (e.after) this.after(e.after);
return super.merge(e, [
...t,
"before",
"after"
]);
}
};
},
430: (e, t, s)=>{
const n = s(572);
e.exports = class extends n {
constructor(e){
super(e);
this.extend([
"auxiliaryComment",
"charset",
"chunkFilename",
"chunkLoadTimeout",
"chunkLoadingGlobal",
"chunkLoading",
"chunkFormat",
"enabledChunkLoadingTypes",
"crossOriginLoading",
"devtoolFallbackModuleFilenameTemplate",
"devtoolModuleFilenameTemplate",
"devtoolNamespace",
"filename",
"assetModuleFilename",
"globalObject",
"uniqueName",
"hashDigest",
"hashDigestLength",
"hashFunction",
"hashSalt",
"hotUpdateChunkFilename",
"hotUpdateGlobal",
"hotUpdateMainFilename",
"library",
"libraryExport",
"libraryTarget",
"importFunctionName",
"path",
"pathinfo",
"publicPath",
"scriptType",
"sourceMapFilename",
"sourcePrefix",
"strictModuleErrorHandling",
"strictModuleExceptionHandling",
"umdNamedDefine",
"workerChunkLoading",
"enabledLibraryTypes",
"environment",
"compareBeforeEmit",
"wasmLoading",
"enabledWasmLoadingTypes",
"iife",
"module",
"clean"
]);
}
};
},
10: (e, t, s)=>{
const n = s(659);
e.exports = class extends n {
constructor(e){
super(e);
this.extend([
"assetFilter",
"hints",
"maxAssetSize",
"maxEntrypointSize"
]);
}
};
},
740: (e, t, s)=>{
const n = s(572);
const i = s(434);
e.exports = i(class extends n {
constructor(e, t, s = "plugin"){
super(e);
this.name = t;
this.type = s;
this.extend([
"init"
]);
this.init((e, t = [])=>{
if ("function" == typeof e) return new e(...t);
return e;
});
}
use(e, t = []) {
return this.set("plugin", e).set("args", t);
}
tap(e) {
if (!this.has("plugin")) throw new Error(`Cannot call .tap() on a plugin that has not yet been defined. Call ${this.type}('${this.name}').use(<Plugin>) first.`);
this.set("args", e(this.get("args") || []));
return this;
}
set(e, t) {
if ("args" === e && !Array.isArray(t)) throw new Error("args must be an array of arguments");
return super.set(e, t);
}
merge(e, t = []) {
if ("plugin" in e) this.set("plugin", e.plugin);
if ("args" in e) this.set("args", e.args);
return super.merge(e, [
...t,
"args",
"plugin"
]);
}
toConfig() {
const e = this.get("init");
let t = this.get("plugin");
const n = this.get("args");
let i = null;
if (void 0 === t) throw new Error(`Invalid ${this.type} configuration: ${this.type}('${this.name}').use(<Plugin>) was not called to specify the plugin`);
if ("string" == typeof t) {
i = t;
t = s(875)(i);
}
const r = t.__expression ? `(${t.__expression})` : t.name;
const o = e(t, n);
Object.defineProperties(o, {
__pluginName: {
value: this.name
},
__pluginType: {
value: this.type
},
__pluginArgs: {
value: n
},
__pluginConstructorName: {
value: r
},
__pluginPath: {
value: i
}
});
return o;
}
});
},
222: (e, t, s)=>{
const n = s(572);
const i = s(745);
const r = s(740);
e.exports = class extends n {
constructor(e){
super(e);
this.alias = new n(this);
this.aliasFields = new i(this);
this.descriptionFiles = new i(this);
this.extensions = new i(this);
this.mainFields = new i(this);
this.mainFiles = new i(this);
this.exportsFields = new i(this);
this.importsFields = new i(this);
this.restrictions = new i(this);
this.roots = new i(this);
this.modules = new i(this);
this.plugins = new n(this);
this.fallback = new n(this);
this.byDependency = new n(this);
this.extend([
"cachePredicate",
"cacheWithContext",
"enforceExtension",
"symlinks",
"unsafeCache",
"preferRelative",
"preferAbsolute"
]);
}
plugin(e) {
return this.plugins.getOrCompute(e, ()=>new r(this, e, "resolve.plugin"));
}
toConfig() {
return this.clean(Object.assign(this.entries() || {}, {
alias: this.alias.entries(),
aliasFields: this.aliasFields.values(),
descriptionFiles: this.descriptionFiles.values(),
extensions: this.extensions.values(),
mainFields: this.mainFields.values(),
mainFiles: this.mainFiles.values(),
modules: this.modules.values(),
exportsFields: this.exportsFields.values(),
importsFields: this.importsFields.values(),
restrictions: this.restrictions.values(),
roots: this.roots.values(),
fallback: this.fallback.entries(),
byDependency: this.byDependency.entries(),
plugins: this.plugins.values().map((e)=>e.toConfig())
}));
}
merge(e, t = []) {
const s = [
"alias",
"aliasFields",
"descriptionFiles",
"extensions",
"mainFields",
"mainFiles",
"exportsFields",
"importsFields",
"restrictions",
"roots",
"modules"
];
if (!t.includes("plugin") && "plugin" in e) Object.keys(e.plugin).forEach((t)=>this.plugin(t).merge(e.plugin[t]));
s.forEach((s)=>{
if (!t.includes(s) && s in e) this[s].merge(e[s]);
});
return super.merge(e, [
...t,
...s,
"plugin"
]);
}
};
},
417: (e, t, s)=>{
const n = s(222);
const i = s(745);
e.exports = class extends n {
constructor(e){
super(e);
this.modules = new i(this);
this.moduleExtensions = new i(this);
this.packageMains = new i(this);
}
toConfig() {
return this.clean({
modules: this.modules.values(),
moduleExtensions: this.moduleExtensions.values(),
packageMains: this.packageMains.values(),
...super.toConfig()
});
}
merge(e, t = []) {
const s = [
"modules",
"moduleExtensions",
"packageMains"
];
s.forEach((s)=>{
if (!t.includes(s) && s in e) this[s].merge(e[s]);
});
return super.merge(e, [
...t,
...s
]);
}
};
},
159: (e, t, s)=>{
const n = s(572);
const i = s(745);
const r = s(434);
const o = s(688);
const u = s(222);
function toArray(e) {
return Array.isArray(e) ? e : [
e
];
}
const a = r(class extends n {
constructor(e, t, s = "rule"){
super(e);
this.ruleName = t;
this.names = [];
this.ruleType = s;
this.ruleTypes = [];
let r = this;
while(r instanceof a){
this.names.unshift(r.ruleName);
this.ruleTypes.unshift(r.ruleType);
r = r.parent;
}
this.uses = new n(this);
this.include = new i(this);
this.exclude = new i(this);
this.rules = new n(this);
this.oneOfs = new n(this);
this.resolve = new u(this);
this.resolve.extend([
"fullySpecified"
]);
this.extend([
"enforce",
"issuer",
"issuerLayer",
"layer",
"mimetype",
"parser",
"generator",
"resource",
"resourceQuery",
"sideEffects",
"test",
"type"
]);
}
use(e) {
return this.uses.getOrCompute(e, ()=>new o(this, e));
}
rule(e) {
return this.rules.getOrCompute(e, ()=>new a(this, e, "rule"));
}
oneOf(e) {
return this.oneOfs.getOrCompute(e, ()=>new a(this, e, "oneOf"));
}
pre() {
return this.enforce("pre");
}
post() {
return this.enforce("post");
}
toConfig() {
const e = this.clean(Object.assign(this.entries() || {}, {
include: this.include.values(),
exclude: this.exclude.values(),
rules: this.rules.values().map((e)=>e.toConfig()),
oneOf: this.oneOfs.values().map((e)=>e.toConfig()),
use: this.uses.values().map((e)=>e.toConfig()),
resolve: this.resolve.toConfig()
}));
Object.defineProperties(e, {
__ruleNames: {
value: this.names
},
__ruleTypes: {
value: this.ruleTypes
}
});
return e;
}
merge(e, t = []) {
if (!t.includes("include") && "include" in e) this.include.merge(toArray(e.include));
if (!t.includes("exclude") && "exclude" in e) this.exclude.merge(toArray(e.exclude));
if (!t.includes("use") && "use" in e) Object.keys(e.use).forEach((t)=>this.use(t).merge(e.use[t]));
if (!t.inclu