9483 lines
341 KiB
JavaScript
9483 lines
341 KiB
JavaScript
var bm = Object.create;
|
||
var Mt = Object.defineProperty;
|
||
var vm = Object.getOwnPropertyDescriptor;
|
||
var Em = Object.getOwnPropertyNames;
|
||
var Tm = Object.getPrototypeOf, Rm = Object.prototype.hasOwnProperty;
|
||
var n = (r, e) => Mt(r, "name", { value: e, configurable: !0 }), qr = /* @__PURE__ */ ((r) => typeof require < "u" ? require : typeof Proxy <
|
||
"u" ? new Proxy(r, {
|
||
get: (e, t) => (typeof require < "u" ? require : e)[t]
|
||
}) : r)(function(r) {
|
||
if (typeof require < "u") return require.apply(this, arguments);
|
||
throw Error('Dynamic require of "' + r + '" is not supported');
|
||
});
|
||
var d = (r, e) => () => (e || r((e = { exports: {} }).exports, e), e.exports), Ce = (r, e) => {
|
||
for (var t in e)
|
||
Mt(r, t, { get: e[t], enumerable: !0 });
|
||
}, Am = (r, e, t, o) => {
|
||
if (e && typeof e == "object" || typeof e == "function")
|
||
for (let a of Em(e))
|
||
!Rm.call(r, a) && a !== t && Mt(r, a, { get: () => e[a], enumerable: !(o = vm(e, a)) || o.enumerable });
|
||
return r;
|
||
};
|
||
var Y = (r, e, t) => (t = r != null ? bm(Tm(r)) : {}, Am(
|
||
// If the importer is in node compatibility mode or this is not an ESM
|
||
// file that has been converted to a CommonJS file using a Babel-
|
||
// compatible transform (i.e. "__esModule" has not been set), then set
|
||
// "default" to the CommonJS "module.exports" for node compatibility.
|
||
e || !r || !r.__esModule ? Mt(t, "default", { value: r, enumerable: !0 }) : t,
|
||
r
|
||
));
|
||
|
||
// ../node_modules/memoizerific/memoizerific.js
|
||
var Ht = d((ps, _n) => {
|
||
(function(r) {
|
||
if (typeof ps == "object" && typeof _n < "u")
|
||
_n.exports = r();
|
||
else if (typeof define == "function" && define.amd)
|
||
define([], r);
|
||
else {
|
||
var e;
|
||
typeof window < "u" ? e = window : typeof global < "u" ? e = global : typeof self < "u" ? e = self : e = this, e.memoizerific = r();
|
||
}
|
||
})(function() {
|
||
var r, e, t;
|
||
return (/* @__PURE__ */ n(function o(a, i, s) {
|
||
function c(p, h) {
|
||
if (!i[p]) {
|
||
if (!a[p]) {
|
||
var y = typeof qr == "function" && qr;
|
||
if (!h && y) return y(p, !0);
|
||
if (l) return l(p, !0);
|
||
var g = new Error("Cannot find module '" + p + "'");
|
||
throw g.code = "MODULE_NOT_FOUND", g;
|
||
}
|
||
var m = i[p] = { exports: {} };
|
||
a[p][0].call(m.exports, function(b) {
|
||
var S = a[p][1][b];
|
||
return c(S || b);
|
||
}, m, m.exports, o, a, i, s);
|
||
}
|
||
return i[p].exports;
|
||
}
|
||
n(c, "s");
|
||
for (var l = typeof qr == "function" && qr, u = 0; u < s.length; u++) c(s[u]);
|
||
return c;
|
||
}, "e"))({ 1: [function(o, a, i) {
|
||
a.exports = function(s) {
|
||
if (typeof Map != "function" || s) {
|
||
var c = o("./similar");
|
||
return new c();
|
||
} else
|
||
return /* @__PURE__ */ new Map();
|
||
};
|
||
}, { "./similar": 2 }], 2: [function(o, a, i) {
|
||
function s() {
|
||
return this.list = [], this.lastItem = void 0, this.size = 0, this;
|
||
}
|
||
n(s, "Similar"), s.prototype.get = function(c) {
|
||
var l;
|
||
if (this.lastItem && this.isEqual(this.lastItem.key, c))
|
||
return this.lastItem.val;
|
||
if (l = this.indexOf(c), l >= 0)
|
||
return this.lastItem = this.list[l], this.list[l].val;
|
||
}, s.prototype.set = function(c, l) {
|
||
var u;
|
||
return this.lastItem && this.isEqual(this.lastItem.key, c) ? (this.lastItem.val = l, this) : (u = this.indexOf(c), u >= 0 ? (this.lastItem =
|
||
this.list[u], this.list[u].val = l, this) : (this.lastItem = { key: c, val: l }, this.list.push(this.lastItem), this.size++, this));
|
||
}, s.prototype.delete = function(c) {
|
||
var l;
|
||
if (this.lastItem && this.isEqual(this.lastItem.key, c) && (this.lastItem = void 0), l = this.indexOf(c), l >= 0)
|
||
return this.size--, this.list.splice(l, 1)[0];
|
||
}, s.prototype.has = function(c) {
|
||
var l;
|
||
return this.lastItem && this.isEqual(this.lastItem.key, c) ? !0 : (l = this.indexOf(c), l >= 0 ? (this.lastItem = this.list[l], !0) :
|
||
!1);
|
||
}, s.prototype.forEach = function(c, l) {
|
||
var u;
|
||
for (u = 0; u < this.size; u++)
|
||
c.call(l || this, this.list[u].val, this.list[u].key, this);
|
||
}, s.prototype.indexOf = function(c) {
|
||
var l;
|
||
for (l = 0; l < this.size; l++)
|
||
if (this.isEqual(this.list[l].key, c))
|
||
return l;
|
||
return -1;
|
||
}, s.prototype.isEqual = function(c, l) {
|
||
return c === l || c !== c && l !== l;
|
||
}, a.exports = s;
|
||
}, {}], 3: [function(o, a, i) {
|
||
var s = o("map-or-similar");
|
||
a.exports = function(p) {
|
||
var h = new s(!1), y = [];
|
||
return function(g) {
|
||
var m = /* @__PURE__ */ n(function() {
|
||
var b = h, S, w, E = arguments.length - 1, v = Array(E + 1), x = !0, R;
|
||
if ((m.numArgs || m.numArgs === 0) && m.numArgs !== E + 1)
|
||
throw new Error("Memoizerific functions should always be called with the same number of arguments");
|
||
for (R = 0; R < E; R++) {
|
||
if (v[R] = {
|
||
cacheItem: b,
|
||
arg: arguments[R]
|
||
}, b.has(arguments[R])) {
|
||
b = b.get(arguments[R]);
|
||
continue;
|
||
}
|
||
x = !1, S = new s(!1), b.set(arguments[R], S), b = S;
|
||
}
|
||
return x && (b.has(arguments[E]) ? w = b.get(arguments[E]) : x = !1), x || (w = g.apply(null, arguments), b.set(arguments[E], w)),
|
||
p > 0 && (v[E] = {
|
||
cacheItem: b,
|
||
arg: arguments[E]
|
||
}, x ? c(y, v) : y.push(v), y.length > p && l(y.shift())), m.wasMemoized = x, m.numArgs = E + 1, w;
|
||
}, "memoizerific");
|
||
return m.limit = p, m.wasMemoized = !1, m.cache = h, m.lru = y, m;
|
||
};
|
||
};
|
||
function c(p, h) {
|
||
var y = p.length, g = h.length, m, b, S;
|
||
for (b = 0; b < y; b++) {
|
||
for (m = !0, S = 0; S < g; S++)
|
||
if (!u(p[b][S].arg, h[S].arg)) {
|
||
m = !1;
|
||
break;
|
||
}
|
||
if (m)
|
||
break;
|
||
}
|
||
p.push(p.splice(b, 1)[0]);
|
||
}
|
||
n(c, "moveToMostRecentLru");
|
||
function l(p) {
|
||
var h = p.length, y = p[h - 1], g, m;
|
||
for (y.cacheItem.delete(y.arg), m = h - 2; m >= 0 && (y = p[m], g = y.cacheItem.get(y.arg), !g || !g.size); m--)
|
||
y.cacheItem.delete(y.arg);
|
||
}
|
||
n(l, "removeCachedResult");
|
||
function u(p, h) {
|
||
return p === h || p !== p && h !== h;
|
||
}
|
||
n(u, "isEqual");
|
||
}, { "map-or-similar": 1 }] }, {}, [3])(3);
|
||
});
|
||
});
|
||
|
||
// ../node_modules/lodash/_freeGlobal.js
|
||
var ma = d((gD, Ws) => {
|
||
var Xb = typeof global == "object" && global && global.Object === Object && global;
|
||
Ws.exports = Xb;
|
||
});
|
||
|
||
// ../node_modules/lodash/_root.js
|
||
var ie = d((SD, zs) => {
|
||
var Jb = ma(), Qb = typeof self == "object" && self && self.Object === Object && self, Zb = Jb || Qb || Function("return this")();
|
||
zs.exports = Zb;
|
||
});
|
||
|
||
// ../node_modules/lodash/_Symbol.js
|
||
var ir = d((bD, Ys) => {
|
||
var ev = ie(), rv = ev.Symbol;
|
||
Ys.exports = rv;
|
||
});
|
||
|
||
// ../node_modules/lodash/_getRawTag.js
|
||
var Qs = d((vD, Js) => {
|
||
var Ks = ir(), Xs = Object.prototype, tv = Xs.hasOwnProperty, ov = Xs.toString, at = Ks ? Ks.toStringTag : void 0;
|
||
function nv(r) {
|
||
var e = tv.call(r, at), t = r[at];
|
||
try {
|
||
r[at] = void 0;
|
||
var o = !0;
|
||
} catch {
|
||
}
|
||
var a = ov.call(r);
|
||
return o && (e ? r[at] = t : delete r[at]), a;
|
||
}
|
||
n(nv, "getRawTag");
|
||
Js.exports = nv;
|
||
});
|
||
|
||
// ../node_modules/lodash/_objectToString.js
|
||
var el = d((TD, Zs) => {
|
||
var av = Object.prototype, iv = av.toString;
|
||
function sv(r) {
|
||
return iv.call(r);
|
||
}
|
||
n(sv, "objectToString");
|
||
Zs.exports = sv;
|
||
});
|
||
|
||
// ../node_modules/lodash/_baseGetTag.js
|
||
var De = d((AD, ol) => {
|
||
var rl = ir(), lv = Qs(), cv = el(), uv = "[object Null]", pv = "[object Undefined]", tl = rl ? rl.toStringTag : void 0;
|
||
function dv(r) {
|
||
return r == null ? r === void 0 ? pv : uv : tl && tl in Object(r) ? lv(r) : cv(r);
|
||
}
|
||
n(dv, "baseGetTag");
|
||
ol.exports = dv;
|
||
});
|
||
|
||
// ../node_modules/lodash/isObject.js
|
||
var sr = d((xD, nl) => {
|
||
function fv(r) {
|
||
var e = typeof r;
|
||
return r != null && (e == "object" || e == "function");
|
||
}
|
||
n(fv, "isObject");
|
||
nl.exports = fv;
|
||
});
|
||
|
||
// ../node_modules/lodash/isFunction.js
|
||
var ga = d((PD, al) => {
|
||
var yv = De(), hv = sr(), mv = "[object AsyncFunction]", gv = "[object Function]", Sv = "[object GeneratorFunction]", bv = "[object Proxy]";
|
||
function vv(r) {
|
||
if (!hv(r))
|
||
return !1;
|
||
var e = yv(r);
|
||
return e == gv || e == Sv || e == mv || e == bv;
|
||
}
|
||
n(vv, "isFunction");
|
||
al.exports = vv;
|
||
});
|
||
|
||
// ../node_modules/lodash/_coreJsData.js
|
||
var sl = d((CD, il) => {
|
||
var Ev = ie(), Tv = Ev["__core-js_shared__"];
|
||
il.exports = Tv;
|
||
});
|
||
|
||
// ../node_modules/lodash/_isMasked.js
|
||
var ul = d((ID, cl) => {
|
||
var Sa = sl(), ll = function() {
|
||
var r = /[^.]+$/.exec(Sa && Sa.keys && Sa.keys.IE_PROTO || "");
|
||
return r ? "Symbol(src)_1." + r : "";
|
||
}();
|
||
function Rv(r) {
|
||
return !!ll && ll in r;
|
||
}
|
||
n(Rv, "isMasked");
|
||
cl.exports = Rv;
|
||
});
|
||
|
||
// ../node_modules/lodash/_toSource.js
|
||
var ba = d((DD, pl) => {
|
||
var Av = Function.prototype, wv = Av.toString;
|
||
function xv(r) {
|
||
if (r != null) {
|
||
try {
|
||
return wv.call(r);
|
||
} catch {
|
||
}
|
||
try {
|
||
return r + "";
|
||
} catch {
|
||
}
|
||
}
|
||
return "";
|
||
}
|
||
n(xv, "toSource");
|
||
pl.exports = xv;
|
||
});
|
||
|
||
// ../node_modules/lodash/_baseIsNative.js
|
||
var fl = d((qD, dl) => {
|
||
var _v = ga(), Pv = ul(), Ov = sr(), Cv = ba(), Iv = /[\\^$.*+?()[\]{}|]/g, Fv = /^\[object .+?Constructor\]$/, Dv = Function.prototype, Nv = Object.
|
||
prototype, qv = Dv.toString, Lv = Nv.hasOwnProperty, kv = RegExp(
|
||
"^" + qv.call(Lv).replace(Iv, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
|
||
);
|
||
function Mv(r) {
|
||
if (!Ov(r) || Pv(r))
|
||
return !1;
|
||
var e = _v(r) ? kv : Fv;
|
||
return e.test(Cv(r));
|
||
}
|
||
n(Mv, "baseIsNative");
|
||
dl.exports = Mv;
|
||
});
|
||
|
||
// ../node_modules/lodash/_getValue.js
|
||
var hl = d((kD, yl) => {
|
||
function jv(r, e) {
|
||
return r?.[e];
|
||
}
|
||
n(jv, "getValue");
|
||
yl.exports = jv;
|
||
});
|
||
|
||
// ../node_modules/lodash/_getNative.js
|
||
var Re = d((jD, ml) => {
|
||
var Bv = fl(), Uv = hl();
|
||
function Gv(r, e) {
|
||
var t = Uv(r, e);
|
||
return Bv(t) ? t : void 0;
|
||
}
|
||
n(Gv, "getNative");
|
||
ml.exports = Gv;
|
||
});
|
||
|
||
// ../node_modules/lodash/_defineProperty.js
|
||
var va = d((UD, gl) => {
|
||
var Hv = Re(), Vv = function() {
|
||
try {
|
||
var r = Hv(Object, "defineProperty");
|
||
return r({}, "", {}), r;
|
||
} catch {
|
||
}
|
||
}();
|
||
gl.exports = Vv;
|
||
});
|
||
|
||
// ../node_modules/lodash/_baseAssignValue.js
|
||
var Ea = d((GD, bl) => {
|
||
var Sl = va();
|
||
function $v(r, e, t) {
|
||
e == "__proto__" && Sl ? Sl(r, e, {
|
||
configurable: !0,
|
||
enumerable: !0,
|
||
value: t,
|
||
writable: !0
|
||
}) : r[e] = t;
|
||
}
|
||
n($v, "baseAssignValue");
|
||
bl.exports = $v;
|
||
});
|
||
|
||
// ../node_modules/lodash/_createBaseFor.js
|
||
var El = d((VD, vl) => {
|
||
function Wv(r) {
|
||
return function(e, t, o) {
|
||
for (var a = -1, i = Object(e), s = o(e), c = s.length; c--; ) {
|
||
var l = s[r ? c : ++a];
|
||
if (t(i[l], l, i) === !1)
|
||
break;
|
||
}
|
||
return e;
|
||
};
|
||
}
|
||
n(Wv, "createBaseFor");
|
||
vl.exports = Wv;
|
||
});
|
||
|
||
// ../node_modules/lodash/_baseFor.js
|
||
var Rl = d((WD, Tl) => {
|
||
var zv = El(), Yv = zv();
|
||
Tl.exports = Yv;
|
||
});
|
||
|
||
// ../node_modules/lodash/_baseTimes.js
|
||
var wl = d((zD, Al) => {
|
||
function Kv(r, e) {
|
||
for (var t = -1, o = Array(r); ++t < r; )
|
||
o[t] = e(t);
|
||
return o;
|
||
}
|
||
n(Kv, "baseTimes");
|
||
Al.exports = Kv;
|
||
});
|
||
|
||
// ../node_modules/lodash/isObjectLike.js
|
||
var Ne = d((KD, xl) => {
|
||
function Xv(r) {
|
||
return r != null && typeof r == "object";
|
||
}
|
||
n(Xv, "isObjectLike");
|
||
xl.exports = Xv;
|
||
});
|
||
|
||
// ../node_modules/lodash/_baseIsArguments.js
|
||
var Pl = d((JD, _l) => {
|
||
var Jv = De(), Qv = Ne(), Zv = "[object Arguments]";
|
||
function eE(r) {
|
||
return Qv(r) && Jv(r) == Zv;
|
||
}
|
||
n(eE, "baseIsArguments");
|
||
_l.exports = eE;
|
||
});
|
||
|
||
// ../node_modules/lodash/isArguments.js
|
||
var Zt = d((ZD, Il) => {
|
||
var Ol = Pl(), rE = Ne(), Cl = Object.prototype, tE = Cl.hasOwnProperty, oE = Cl.propertyIsEnumerable, nE = Ol(/* @__PURE__ */ function() {
|
||
return arguments;
|
||
}()) ? Ol : function(r) {
|
||
return rE(r) && tE.call(r, "callee") && !oE.call(r, "callee");
|
||
};
|
||
Il.exports = nE;
|
||
});
|
||
|
||
// ../node_modules/lodash/isArray.js
|
||
var se = d((eN, Fl) => {
|
||
var aE = Array.isArray;
|
||
Fl.exports = aE;
|
||
});
|
||
|
||
// ../node_modules/lodash/stubFalse.js
|
||
var Nl = d((rN, Dl) => {
|
||
function iE() {
|
||
return !1;
|
||
}
|
||
n(iE, "stubFalse");
|
||
Dl.exports = iE;
|
||
});
|
||
|
||
// ../node_modules/lodash/isBuffer.js
|
||
var Ta = d((it, lr) => {
|
||
var sE = ie(), lE = Nl(), kl = typeof it == "object" && it && !it.nodeType && it, ql = kl && typeof lr == "object" && lr && !lr.nodeType &&
|
||
lr, cE = ql && ql.exports === kl, Ll = cE ? sE.Buffer : void 0, uE = Ll ? Ll.isBuffer : void 0, pE = uE || lE;
|
||
lr.exports = pE;
|
||
});
|
||
|
||
// ../node_modules/lodash/_isIndex.js
|
||
var eo = d((oN, Ml) => {
|
||
var dE = 9007199254740991, fE = /^(?:0|[1-9]\d*)$/;
|
||
function yE(r, e) {
|
||
var t = typeof r;
|
||
return e = e ?? dE, !!e && (t == "number" || t != "symbol" && fE.test(r)) && r > -1 && r % 1 == 0 && r < e;
|
||
}
|
||
n(yE, "isIndex");
|
||
Ml.exports = yE;
|
||
});
|
||
|
||
// ../node_modules/lodash/isLength.js
|
||
var ro = d((aN, jl) => {
|
||
var hE = 9007199254740991;
|
||
function mE(r) {
|
||
return typeof r == "number" && r > -1 && r % 1 == 0 && r <= hE;
|
||
}
|
||
n(mE, "isLength");
|
||
jl.exports = mE;
|
||
});
|
||
|
||
// ../node_modules/lodash/_baseIsTypedArray.js
|
||
var Ul = d((sN, Bl) => {
|
||
var gE = De(), SE = ro(), bE = Ne(), vE = "[object Arguments]", EE = "[object Array]", TE = "[object Boolean]", RE = "[object Date]", AE = "\
|
||
[object Error]", wE = "[object Function]", xE = "[object Map]", _E = "[object Number]", PE = "[object Object]", OE = "[object RegExp]", CE = "\
|
||
[object Set]", IE = "[object String]", FE = "[object WeakMap]", DE = "[object ArrayBuffer]", NE = "[object DataView]", qE = "[object Float32\
|
||
Array]", LE = "[object Float64Array]", kE = "[object Int8Array]", ME = "[object Int16Array]", jE = "[object Int32Array]", BE = "[object Uint\
|
||
8Array]", UE = "[object Uint8ClampedArray]", GE = "[object Uint16Array]", HE = "[object Uint32Array]", L = {};
|
||
L[qE] = L[LE] = L[kE] = L[ME] = L[jE] = L[BE] = L[UE] = L[GE] = L[HE] = !0;
|
||
L[vE] = L[EE] = L[DE] = L[TE] = L[NE] = L[RE] = L[AE] = L[wE] = L[xE] = L[_E] = L[PE] = L[OE] = L[CE] = L[IE] = L[FE] = !1;
|
||
function VE(r) {
|
||
return bE(r) && SE(r.length) && !!L[gE(r)];
|
||
}
|
||
n(VE, "baseIsTypedArray");
|
||
Bl.exports = VE;
|
||
});
|
||
|
||
// ../node_modules/lodash/_baseUnary.js
|
||
var Hl = d((cN, Gl) => {
|
||
function $E(r) {
|
||
return function(e) {
|
||
return r(e);
|
||
};
|
||
}
|
||
n($E, "baseUnary");
|
||
Gl.exports = $E;
|
||
});
|
||
|
||
// ../node_modules/lodash/_nodeUtil.js
|
||
var $l = d((st, cr) => {
|
||
var WE = ma(), Vl = typeof st == "object" && st && !st.nodeType && st, lt = Vl && typeof cr == "object" && cr && !cr.nodeType && cr, zE = lt &&
|
||
lt.exports === Vl, Ra = zE && WE.process, YE = function() {
|
||
try {
|
||
var r = lt && lt.require && lt.require("util").types;
|
||
return r || Ra && Ra.binding && Ra.binding("util");
|
||
} catch {
|
||
}
|
||
}();
|
||
cr.exports = YE;
|
||
});
|
||
|
||
// ../node_modules/lodash/isTypedArray.js
|
||
var Aa = d((pN, Yl) => {
|
||
var KE = Ul(), XE = Hl(), Wl = $l(), zl = Wl && Wl.isTypedArray, JE = zl ? XE(zl) : KE;
|
||
Yl.exports = JE;
|
||
});
|
||
|
||
// ../node_modules/lodash/_arrayLikeKeys.js
|
||
var wa = d((dN, Kl) => {
|
||
var QE = wl(), ZE = Zt(), eT = se(), rT = Ta(), tT = eo(), oT = Aa(), nT = Object.prototype, aT = nT.hasOwnProperty;
|
||
function iT(r, e) {
|
||
var t = eT(r), o = !t && ZE(r), a = !t && !o && rT(r), i = !t && !o && !a && oT(r), s = t || o || a || i, c = s ? QE(r.length, String) :
|
||
[], l = c.length;
|
||
for (var u in r)
|
||
(e || aT.call(r, u)) && !(s && // Safari 9 has enumerable `arguments.length` in strict mode.
|
||
(u == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
|
||
a && (u == "offset" || u == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
|
||
i && (u == "buffer" || u == "byteLength" || u == "byteOffset") || // Skip index properties.
|
||
tT(u, l))) && c.push(u);
|
||
return c;
|
||
}
|
||
n(iT, "arrayLikeKeys");
|
||
Kl.exports = iT;
|
||
});
|
||
|
||
// ../node_modules/lodash/_isPrototype.js
|
||
var xa = d((yN, Xl) => {
|
||
var sT = Object.prototype;
|
||
function lT(r) {
|
||
var e = r && r.constructor, t = typeof e == "function" && e.prototype || sT;
|
||
return r === t;
|
||
}
|
||
n(lT, "isPrototype");
|
||
Xl.exports = lT;
|
||
});
|
||
|
||
// ../node_modules/lodash/_overArg.js
|
||
var _a = d((mN, Jl) => {
|
||
function cT(r, e) {
|
||
return function(t) {
|
||
return r(e(t));
|
||
};
|
||
}
|
||
n(cT, "overArg");
|
||
Jl.exports = cT;
|
||
});
|
||
|
||
// ../node_modules/lodash/_nativeKeys.js
|
||
var Zl = d((SN, Ql) => {
|
||
var uT = _a(), pT = uT(Object.keys, Object);
|
||
Ql.exports = pT;
|
||
});
|
||
|
||
// ../node_modules/lodash/_baseKeys.js
|
||
var rc = d((bN, ec) => {
|
||
var dT = xa(), fT = Zl(), yT = Object.prototype, hT = yT.hasOwnProperty;
|
||
function mT(r) {
|
||
if (!dT(r))
|
||
return fT(r);
|
||
var e = [];
|
||
for (var t in Object(r))
|
||
hT.call(r, t) && t != "constructor" && e.push(t);
|
||
return e;
|
||
}
|
||
n(mT, "baseKeys");
|
||
ec.exports = mT;
|
||
});
|
||
|
||
// ../node_modules/lodash/isArrayLike.js
|
||
var Pa = d((EN, tc) => {
|
||
var gT = ga(), ST = ro();
|
||
function bT(r) {
|
||
return r != null && ST(r.length) && !gT(r);
|
||
}
|
||
n(bT, "isArrayLike");
|
||
tc.exports = bT;
|
||
});
|
||
|
||
// ../node_modules/lodash/keys.js
|
||
var to = d((RN, oc) => {
|
||
var vT = wa(), ET = rc(), TT = Pa();
|
||
function RT(r) {
|
||
return TT(r) ? vT(r) : ET(r);
|
||
}
|
||
n(RT, "keys");
|
||
oc.exports = RT;
|
||
});
|
||
|
||
// ../node_modules/lodash/_baseForOwn.js
|
||
var ac = d((wN, nc) => {
|
||
var AT = Rl(), wT = to();
|
||
function xT(r, e) {
|
||
return r && AT(r, e, wT);
|
||
}
|
||
n(xT, "baseForOwn");
|
||
nc.exports = xT;
|
||
});
|
||
|
||
// ../node_modules/lodash/_listCacheClear.js
|
||
var sc = d((_N, ic) => {
|
||
function _T() {
|
||
this.__data__ = [], this.size = 0;
|
||
}
|
||
n(_T, "listCacheClear");
|
||
ic.exports = _T;
|
||
});
|
||
|
||
// ../node_modules/lodash/eq.js
|
||
var oo = d((ON, lc) => {
|
||
function PT(r, e) {
|
||
return r === e || r !== r && e !== e;
|
||
}
|
||
n(PT, "eq");
|
||
lc.exports = PT;
|
||
});
|
||
|
||
// ../node_modules/lodash/_assocIndexOf.js
|
||
var ct = d((IN, cc) => {
|
||
var OT = oo();
|
||
function CT(r, e) {
|
||
for (var t = r.length; t--; )
|
||
if (OT(r[t][0], e))
|
||
return t;
|
||
return -1;
|
||
}
|
||
n(CT, "assocIndexOf");
|
||
cc.exports = CT;
|
||
});
|
||
|
||
// ../node_modules/lodash/_listCacheDelete.js
|
||
var pc = d((DN, uc) => {
|
||
var IT = ct(), FT = Array.prototype, DT = FT.splice;
|
||
function NT(r) {
|
||
var e = this.__data__, t = IT(e, r);
|
||
if (t < 0)
|
||
return !1;
|
||
var o = e.length - 1;
|
||
return t == o ? e.pop() : DT.call(e, t, 1), --this.size, !0;
|
||
}
|
||
n(NT, "listCacheDelete");
|
||
uc.exports = NT;
|
||
});
|
||
|
||
// ../node_modules/lodash/_listCacheGet.js
|
||
var fc = d((qN, dc) => {
|
||
var qT = ct();
|
||
function LT(r) {
|
||
var e = this.__data__, t = qT(e, r);
|
||
return t < 0 ? void 0 : e[t][1];
|
||
}
|
||
n(LT, "listCacheGet");
|
||
dc.exports = LT;
|
||
});
|
||
|
||
// ../node_modules/lodash/_listCacheHas.js
|
||
var hc = d((kN, yc) => {
|
||
var kT = ct();
|
||
function MT(r) {
|
||
return kT(this.__data__, r) > -1;
|
||
}
|
||
n(MT, "listCacheHas");
|
||
yc.exports = MT;
|
||
});
|
||
|
||
// ../node_modules/lodash/_listCacheSet.js
|
||
var gc = d((jN, mc) => {
|
||
var jT = ct();
|
||
function BT(r, e) {
|
||
var t = this.__data__, o = jT(t, r);
|
||
return o < 0 ? (++this.size, t.push([r, e])) : t[o][1] = e, this;
|
||
}
|
||
n(BT, "listCacheSet");
|
||
mc.exports = BT;
|
||
});
|
||
|
||
// ../node_modules/lodash/_ListCache.js
|
||
var ut = d((UN, Sc) => {
|
||
var UT = sc(), GT = pc(), HT = fc(), VT = hc(), $T = gc();
|
||
function ur(r) {
|
||
var e = -1, t = r == null ? 0 : r.length;
|
||
for (this.clear(); ++e < t; ) {
|
||
var o = r[e];
|
||
this.set(o[0], o[1]);
|
||
}
|
||
}
|
||
n(ur, "ListCache");
|
||
ur.prototype.clear = UT;
|
||
ur.prototype.delete = GT;
|
||
ur.prototype.get = HT;
|
||
ur.prototype.has = VT;
|
||
ur.prototype.set = $T;
|
||
Sc.exports = ur;
|
||
});
|
||
|
||
// ../node_modules/lodash/_stackClear.js
|
||
var vc = d((HN, bc) => {
|
||
var WT = ut();
|
||
function zT() {
|
||
this.__data__ = new WT(), this.size = 0;
|
||
}
|
||
n(zT, "stackClear");
|
||
bc.exports = zT;
|
||
});
|
||
|
||
// ../node_modules/lodash/_stackDelete.js
|
||
var Tc = d(($N, Ec) => {
|
||
function YT(r) {
|
||
var e = this.__data__, t = e.delete(r);
|
||
return this.size = e.size, t;
|
||
}
|
||
n(YT, "stackDelete");
|
||
Ec.exports = YT;
|
||
});
|
||
|
||
// ../node_modules/lodash/_stackGet.js
|
||
var Ac = d((zN, Rc) => {
|
||
function KT(r) {
|
||
return this.__data__.get(r);
|
||
}
|
||
n(KT, "stackGet");
|
||
Rc.exports = KT;
|
||
});
|
||
|
||
// ../node_modules/lodash/_stackHas.js
|
||
var xc = d((KN, wc) => {
|
||
function XT(r) {
|
||
return this.__data__.has(r);
|
||
}
|
||
n(XT, "stackHas");
|
||
wc.exports = XT;
|
||
});
|
||
|
||
// ../node_modules/lodash/_Map.js
|
||
var no = d((JN, _c) => {
|
||
var JT = Re(), QT = ie(), ZT = JT(QT, "Map");
|
||
_c.exports = ZT;
|
||
});
|
||
|
||
// ../node_modules/lodash/_nativeCreate.js
|
||
var pt = d((QN, Pc) => {
|
||
var eR = Re(), rR = eR(Object, "create");
|
||
Pc.exports = rR;
|
||
});
|
||
|
||
// ../node_modules/lodash/_hashClear.js
|
||
var Ic = d((ZN, Cc) => {
|
||
var Oc = pt();
|
||
function tR() {
|
||
this.__data__ = Oc ? Oc(null) : {}, this.size = 0;
|
||
}
|
||
n(tR, "hashClear");
|
||
Cc.exports = tR;
|
||
});
|
||
|
||
// ../node_modules/lodash/_hashDelete.js
|
||
var Dc = d((rq, Fc) => {
|
||
function oR(r) {
|
||
var e = this.has(r) && delete this.__data__[r];
|
||
return this.size -= e ? 1 : 0, e;
|
||
}
|
||
n(oR, "hashDelete");
|
||
Fc.exports = oR;
|
||
});
|
||
|
||
// ../node_modules/lodash/_hashGet.js
|
||
var qc = d((oq, Nc) => {
|
||
var nR = pt(), aR = "__lodash_hash_undefined__", iR = Object.prototype, sR = iR.hasOwnProperty;
|
||
function lR(r) {
|
||
var e = this.__data__;
|
||
if (nR) {
|
||
var t = e[r];
|
||
return t === aR ? void 0 : t;
|
||
}
|
||
return sR.call(e, r) ? e[r] : void 0;
|
||
}
|
||
n(lR, "hashGet");
|
||
Nc.exports = lR;
|
||
});
|
||
|
||
// ../node_modules/lodash/_hashHas.js
|
||
var kc = d((aq, Lc) => {
|
||
var cR = pt(), uR = Object.prototype, pR = uR.hasOwnProperty;
|
||
function dR(r) {
|
||
var e = this.__data__;
|
||
return cR ? e[r] !== void 0 : pR.call(e, r);
|
||
}
|
||
n(dR, "hashHas");
|
||
Lc.exports = dR;
|
||
});
|
||
|
||
// ../node_modules/lodash/_hashSet.js
|
||
var jc = d((sq, Mc) => {
|
||
var fR = pt(), yR = "__lodash_hash_undefined__";
|
||
function hR(r, e) {
|
||
var t = this.__data__;
|
||
return this.size += this.has(r) ? 0 : 1, t[r] = fR && e === void 0 ? yR : e, this;
|
||
}
|
||
n(hR, "hashSet");
|
||
Mc.exports = hR;
|
||
});
|
||
|
||
// ../node_modules/lodash/_Hash.js
|
||
var Uc = d((cq, Bc) => {
|
||
var mR = Ic(), gR = Dc(), SR = qc(), bR = kc(), vR = jc();
|
||
function pr(r) {
|
||
var e = -1, t = r == null ? 0 : r.length;
|
||
for (this.clear(); ++e < t; ) {
|
||
var o = r[e];
|
||
this.set(o[0], o[1]);
|
||
}
|
||
}
|
||
n(pr, "Hash");
|
||
pr.prototype.clear = mR;
|
||
pr.prototype.delete = gR;
|
||
pr.prototype.get = SR;
|
||
pr.prototype.has = bR;
|
||
pr.prototype.set = vR;
|
||
Bc.exports = pr;
|
||
});
|
||
|
||
// ../node_modules/lodash/_mapCacheClear.js
|
||
var Vc = d((pq, Hc) => {
|
||
var Gc = Uc(), ER = ut(), TR = no();
|
||
function RR() {
|
||
this.size = 0, this.__data__ = {
|
||
hash: new Gc(),
|
||
map: new (TR || ER)(),
|
||
string: new Gc()
|
||
};
|
||
}
|
||
n(RR, "mapCacheClear");
|
||
Hc.exports = RR;
|
||
});
|
||
|
||
// ../node_modules/lodash/_isKeyable.js
|
||
var Wc = d((fq, $c) => {
|
||
function AR(r) {
|
||
var e = typeof r;
|
||
return e == "string" || e == "number" || e == "symbol" || e == "boolean" ? r !== "__proto__" : r === null;
|
||
}
|
||
n(AR, "isKeyable");
|
||
$c.exports = AR;
|
||
});
|
||
|
||
// ../node_modules/lodash/_getMapData.js
|
||
var dt = d((hq, zc) => {
|
||
var wR = Wc();
|
||
function xR(r, e) {
|
||
var t = r.__data__;
|
||
return wR(e) ? t[typeof e == "string" ? "string" : "hash"] : t.map;
|
||
}
|
||
n(xR, "getMapData");
|
||
zc.exports = xR;
|
||
});
|
||
|
||
// ../node_modules/lodash/_mapCacheDelete.js
|
||
var Kc = d((gq, Yc) => {
|
||
var _R = dt();
|
||
function PR(r) {
|
||
var e = _R(this, r).delete(r);
|
||
return this.size -= e ? 1 : 0, e;
|
||
}
|
||
n(PR, "mapCacheDelete");
|
||
Yc.exports = PR;
|
||
});
|
||
|
||
// ../node_modules/lodash/_mapCacheGet.js
|
||
var Jc = d((bq, Xc) => {
|
||
var OR = dt();
|
||
function CR(r) {
|
||
return OR(this, r).get(r);
|
||
}
|
||
n(CR, "mapCacheGet");
|
||
Xc.exports = CR;
|
||
});
|
||
|
||
// ../node_modules/lodash/_mapCacheHas.js
|
||
var Zc = d((Eq, Qc) => {
|
||
var IR = dt();
|
||
function FR(r) {
|
||
return IR(this, r).has(r);
|
||
}
|
||
n(FR, "mapCacheHas");
|
||
Qc.exports = FR;
|
||
});
|
||
|
||
// ../node_modules/lodash/_mapCacheSet.js
|
||
var ru = d((Rq, eu) => {
|
||
var DR = dt();
|
||
function NR(r, e) {
|
||
var t = DR(this, r), o = t.size;
|
||
return t.set(r, e), this.size += t.size == o ? 0 : 1, this;
|
||
}
|
||
n(NR, "mapCacheSet");
|
||
eu.exports = NR;
|
||
});
|
||
|
||
// ../node_modules/lodash/_MapCache.js
|
||
var ao = d((wq, tu) => {
|
||
var qR = Vc(), LR = Kc(), kR = Jc(), MR = Zc(), jR = ru();
|
||
function dr(r) {
|
||
var e = -1, t = r == null ? 0 : r.length;
|
||
for (this.clear(); ++e < t; ) {
|
||
var o = r[e];
|
||
this.set(o[0], o[1]);
|
||
}
|
||
}
|
||
n(dr, "MapCache");
|
||
dr.prototype.clear = qR;
|
||
dr.prototype.delete = LR;
|
||
dr.prototype.get = kR;
|
||
dr.prototype.has = MR;
|
||
dr.prototype.set = jR;
|
||
tu.exports = dr;
|
||
});
|
||
|
||
// ../node_modules/lodash/_stackSet.js
|
||
var nu = d((_q, ou) => {
|
||
var BR = ut(), UR = no(), GR = ao(), HR = 200;
|
||
function VR(r, e) {
|
||
var t = this.__data__;
|
||
if (t instanceof BR) {
|
||
var o = t.__data__;
|
||
if (!UR || o.length < HR - 1)
|
||
return o.push([r, e]), this.size = ++t.size, this;
|
||
t = this.__data__ = new GR(o);
|
||
}
|
||
return t.set(r, e), this.size = t.size, this;
|
||
}
|
||
n(VR, "stackSet");
|
||
ou.exports = VR;
|
||
});
|
||
|
||
// ../node_modules/lodash/_Stack.js
|
||
var Oa = d((Oq, au) => {
|
||
var $R = ut(), WR = vc(), zR = Tc(), YR = Ac(), KR = xc(), XR = nu();
|
||
function fr(r) {
|
||
var e = this.__data__ = new $R(r);
|
||
this.size = e.size;
|
||
}
|
||
n(fr, "Stack");
|
||
fr.prototype.clear = WR;
|
||
fr.prototype.delete = zR;
|
||
fr.prototype.get = YR;
|
||
fr.prototype.has = KR;
|
||
fr.prototype.set = XR;
|
||
au.exports = fr;
|
||
});
|
||
|
||
// ../node_modules/lodash/_setCacheAdd.js
|
||
var su = d((Iq, iu) => {
|
||
var JR = "__lodash_hash_undefined__";
|
||
function QR(r) {
|
||
return this.__data__.set(r, JR), this;
|
||
}
|
||
n(QR, "setCacheAdd");
|
||
iu.exports = QR;
|
||
});
|
||
|
||
// ../node_modules/lodash/_setCacheHas.js
|
||
var cu = d((Dq, lu) => {
|
||
function ZR(r) {
|
||
return this.__data__.has(r);
|
||
}
|
||
n(ZR, "setCacheHas");
|
||
lu.exports = ZR;
|
||
});
|
||
|
||
// ../node_modules/lodash/_SetCache.js
|
||
var pu = d((qq, uu) => {
|
||
var eA = ao(), rA = su(), tA = cu();
|
||
function io(r) {
|
||
var e = -1, t = r == null ? 0 : r.length;
|
||
for (this.__data__ = new eA(); ++e < t; )
|
||
this.add(r[e]);
|
||
}
|
||
n(io, "SetCache");
|
||
io.prototype.add = io.prototype.push = rA;
|
||
io.prototype.has = tA;
|
||
uu.exports = io;
|
||
});
|
||
|
||
// ../node_modules/lodash/_arraySome.js
|
||
var fu = d((kq, du) => {
|
||
function oA(r, e) {
|
||
for (var t = -1, o = r == null ? 0 : r.length; ++t < o; )
|
||
if (e(r[t], t, r))
|
||
return !0;
|
||
return !1;
|
||
}
|
||
n(oA, "arraySome");
|
||
du.exports = oA;
|
||
});
|
||
|
||
// ../node_modules/lodash/_cacheHas.js
|
||
var hu = d((jq, yu) => {
|
||
function nA(r, e) {
|
||
return r.has(e);
|
||
}
|
||
n(nA, "cacheHas");
|
||
yu.exports = nA;
|
||
});
|
||
|
||
// ../node_modules/lodash/_equalArrays.js
|
||
var Ca = d((Uq, mu) => {
|
||
var aA = pu(), iA = fu(), sA = hu(), lA = 1, cA = 2;
|
||
function uA(r, e, t, o, a, i) {
|
||
var s = t & lA, c = r.length, l = e.length;
|
||
if (c != l && !(s && l > c))
|
||
return !1;
|
||
var u = i.get(r), p = i.get(e);
|
||
if (u && p)
|
||
return u == e && p == r;
|
||
var h = -1, y = !0, g = t & cA ? new aA() : void 0;
|
||
for (i.set(r, e), i.set(e, r); ++h < c; ) {
|
||
var m = r[h], b = e[h];
|
||
if (o)
|
||
var S = s ? o(b, m, h, e, r, i) : o(m, b, h, r, e, i);
|
||
if (S !== void 0) {
|
||
if (S)
|
||
continue;
|
||
y = !1;
|
||
break;
|
||
}
|
||
if (g) {
|
||
if (!iA(e, function(w, E) {
|
||
if (!sA(g, E) && (m === w || a(m, w, t, o, i)))
|
||
return g.push(E);
|
||
})) {
|
||
y = !1;
|
||
break;
|
||
}
|
||
} else if (!(m === b || a(m, b, t, o, i))) {
|
||
y = !1;
|
||
break;
|
||
}
|
||
}
|
||
return i.delete(r), i.delete(e), y;
|
||
}
|
||
n(uA, "equalArrays");
|
||
mu.exports = uA;
|
||
});
|
||
|
||
// ../node_modules/lodash/_Uint8Array.js
|
||
var Su = d((Hq, gu) => {
|
||
var pA = ie(), dA = pA.Uint8Array;
|
||
gu.exports = dA;
|
||
});
|
||
|
||
// ../node_modules/lodash/_mapToArray.js
|
||
var vu = d((Vq, bu) => {
|
||
function fA(r) {
|
||
var e = -1, t = Array(r.size);
|
||
return r.forEach(function(o, a) {
|
||
t[++e] = [a, o];
|
||
}), t;
|
||
}
|
||
n(fA, "mapToArray");
|
||
bu.exports = fA;
|
||
});
|
||
|
||
// ../node_modules/lodash/_setToArray.js
|
||
var Tu = d((Wq, Eu) => {
|
||
function yA(r) {
|
||
var e = -1, t = Array(r.size);
|
||
return r.forEach(function(o) {
|
||
t[++e] = o;
|
||
}), t;
|
||
}
|
||
n(yA, "setToArray");
|
||
Eu.exports = yA;
|
||
});
|
||
|
||
// ../node_modules/lodash/_equalByTag.js
|
||
var _u = d((Yq, xu) => {
|
||
var Ru = ir(), Au = Su(), hA = oo(), mA = Ca(), gA = vu(), SA = Tu(), bA = 1, vA = 2, EA = "[object Boolean]", TA = "[object Date]", RA = "\
|
||
[object Error]", AA = "[object Map]", wA = "[object Number]", xA = "[object RegExp]", _A = "[object Set]", PA = "[object String]", OA = "[ob\
|
||
ject Symbol]", CA = "[object ArrayBuffer]", IA = "[object DataView]", wu = Ru ? Ru.prototype : void 0, Ia = wu ? wu.valueOf : void 0;
|
||
function FA(r, e, t, o, a, i, s) {
|
||
switch (t) {
|
||
case IA:
|
||
if (r.byteLength != e.byteLength || r.byteOffset != e.byteOffset)
|
||
return !1;
|
||
r = r.buffer, e = e.buffer;
|
||
case CA:
|
||
return !(r.byteLength != e.byteLength || !i(new Au(r), new Au(e)));
|
||
case EA:
|
||
case TA:
|
||
case wA:
|
||
return hA(+r, +e);
|
||
case RA:
|
||
return r.name == e.name && r.message == e.message;
|
||
case xA:
|
||
case PA:
|
||
return r == e + "";
|
||
case AA:
|
||
var c = gA;
|
||
case _A:
|
||
var l = o & bA;
|
||
if (c || (c = SA), r.size != e.size && !l)
|
||
return !1;
|
||
var u = s.get(r);
|
||
if (u)
|
||
return u == e;
|
||
o |= vA, s.set(r, e);
|
||
var p = mA(c(r), c(e), o, a, i, s);
|
||
return s.delete(r), p;
|
||
case OA:
|
||
if (Ia)
|
||
return Ia.call(r) == Ia.call(e);
|
||
}
|
||
return !1;
|
||
}
|
||
n(FA, "equalByTag");
|
||
xu.exports = FA;
|
||
});
|
||
|
||
// ../node_modules/lodash/_arrayPush.js
|
||
var so = d((Xq, Pu) => {
|
||
function DA(r, e) {
|
||
for (var t = -1, o = e.length, a = r.length; ++t < o; )
|
||
r[a + t] = e[t];
|
||
return r;
|
||
}
|
||
n(DA, "arrayPush");
|
||
Pu.exports = DA;
|
||
});
|
||
|
||
// ../node_modules/lodash/_baseGetAllKeys.js
|
||
var Fa = d((Qq, Ou) => {
|
||
var NA = so(), qA = se();
|
||
function LA(r, e, t) {
|
||
var o = e(r);
|
||
return qA(r) ? o : NA(o, t(r));
|
||
}
|
||
n(LA, "baseGetAllKeys");
|
||
Ou.exports = LA;
|
||
});
|
||
|
||
// ../node_modules/lodash/_arrayFilter.js
|
||
var Iu = d((e0, Cu) => {
|
||
function kA(r, e) {
|
||
for (var t = -1, o = r == null ? 0 : r.length, a = 0, i = []; ++t < o; ) {
|
||
var s = r[t];
|
||
e(s, t, r) && (i[a++] = s);
|
||
}
|
||
return i;
|
||
}
|
||
n(kA, "arrayFilter");
|
||
Cu.exports = kA;
|
||
});
|
||
|
||
// ../node_modules/lodash/stubArray.js
|
||
var Da = d((t0, Fu) => {
|
||
function MA() {
|
||
return [];
|
||
}
|
||
n(MA, "stubArray");
|
||
Fu.exports = MA;
|
||
});
|
||
|
||
// ../node_modules/lodash/_getSymbols.js
|
||
var Na = d((n0, Nu) => {
|
||
var jA = Iu(), BA = Da(), UA = Object.prototype, GA = UA.propertyIsEnumerable, Du = Object.getOwnPropertySymbols, HA = Du ? function(r) {
|
||
return r == null ? [] : (r = Object(r), jA(Du(r), function(e) {
|
||
return GA.call(r, e);
|
||
}));
|
||
} : BA;
|
||
Nu.exports = HA;
|
||
});
|
||
|
||
// ../node_modules/lodash/_getAllKeys.js
|
||
var Lu = d((a0, qu) => {
|
||
var VA = Fa(), $A = Na(), WA = to();
|
||
function zA(r) {
|
||
return VA(r, WA, $A);
|
||
}
|
||
n(zA, "getAllKeys");
|
||
qu.exports = zA;
|
||
});
|
||
|
||
// ../node_modules/lodash/_equalObjects.js
|
||
var ju = d((s0, Mu) => {
|
||
var ku = Lu(), YA = 1, KA = Object.prototype, XA = KA.hasOwnProperty;
|
||
function JA(r, e, t, o, a, i) {
|
||
var s = t & YA, c = ku(r), l = c.length, u = ku(e), p = u.length;
|
||
if (l != p && !s)
|
||
return !1;
|
||
for (var h = l; h--; ) {
|
||
var y = c[h];
|
||
if (!(s ? y in e : XA.call(e, y)))
|
||
return !1;
|
||
}
|
||
var g = i.get(r), m = i.get(e);
|
||
if (g && m)
|
||
return g == e && m == r;
|
||
var b = !0;
|
||
i.set(r, e), i.set(e, r);
|
||
for (var S = s; ++h < l; ) {
|
||
y = c[h];
|
||
var w = r[y], E = e[y];
|
||
if (o)
|
||
var v = s ? o(E, w, y, e, r, i) : o(w, E, y, r, e, i);
|
||
if (!(v === void 0 ? w === E || a(w, E, t, o, i) : v)) {
|
||
b = !1;
|
||
break;
|
||
}
|
||
S || (S = y == "constructor");
|
||
}
|
||
if (b && !S) {
|
||
var x = r.constructor, R = e.constructor;
|
||
x != R && "constructor" in r && "constructor" in e && !(typeof x == "function" && x instanceof x && typeof R == "function" && R instanceof
|
||
R) && (b = !1);
|
||
}
|
||
return i.delete(r), i.delete(e), b;
|
||
}
|
||
n(JA, "equalObjects");
|
||
Mu.exports = JA;
|
||
});
|
||
|
||
// ../node_modules/lodash/_DataView.js
|
||
var Uu = d((c0, Bu) => {
|
||
var QA = Re(), ZA = ie(), ew = QA(ZA, "DataView");
|
||
Bu.exports = ew;
|
||
});
|
||
|
||
// ../node_modules/lodash/_Promise.js
|
||
var Hu = d((u0, Gu) => {
|
||
var rw = Re(), tw = ie(), ow = rw(tw, "Promise");
|
||
Gu.exports = ow;
|
||
});
|
||
|
||
// ../node_modules/lodash/_Set.js
|
||
var $u = d((p0, Vu) => {
|
||
var nw = Re(), aw = ie(), iw = nw(aw, "Set");
|
||
Vu.exports = iw;
|
||
});
|
||
|
||
// ../node_modules/lodash/_WeakMap.js
|
||
var zu = d((d0, Wu) => {
|
||
var sw = Re(), lw = ie(), cw = sw(lw, "WeakMap");
|
||
Wu.exports = cw;
|
||
});
|
||
|
||
// ../node_modules/lodash/_getTag.js
|
||
var rp = d((f0, ep) => {
|
||
var qa = Uu(), La = no(), ka = Hu(), Ma = $u(), ja = zu(), Zu = De(), yr = ba(), Yu = "[object Map]", uw = "[object Object]", Ku = "[objec\
|
||
t Promise]", Xu = "[object Set]", Ju = "[object WeakMap]", Qu = "[object DataView]", pw = yr(qa), dw = yr(La), fw = yr(ka), yw = yr(Ma), hw = yr(
|
||
ja), qe = Zu;
|
||
(qa && qe(new qa(new ArrayBuffer(1))) != Qu || La && qe(new La()) != Yu || ka && qe(ka.resolve()) != Ku || Ma && qe(new Ma()) != Xu || ja &&
|
||
qe(new ja()) != Ju) && (qe = /* @__PURE__ */ n(function(r) {
|
||
var e = Zu(r), t = e == uw ? r.constructor : void 0, o = t ? yr(t) : "";
|
||
if (o)
|
||
switch (o) {
|
||
case pw:
|
||
return Qu;
|
||
case dw:
|
||
return Yu;
|
||
case fw:
|
||
return Ku;
|
||
case yw:
|
||
return Xu;
|
||
case hw:
|
||
return Ju;
|
||
}
|
||
return e;
|
||
}, "getTag"));
|
||
ep.exports = qe;
|
||
});
|
||
|
||
// ../node_modules/lodash/_baseIsEqualDeep.js
|
||
var cp = d((h0, lp) => {
|
||
var Ba = Oa(), mw = Ca(), gw = _u(), Sw = ju(), tp = rp(), op = se(), np = Ta(), bw = Aa(), vw = 1, ap = "[object Arguments]", ip = "[obje\
|
||
ct Array]", lo = "[object Object]", Ew = Object.prototype, sp = Ew.hasOwnProperty;
|
||
function Tw(r, e, t, o, a, i) {
|
||
var s = op(r), c = op(e), l = s ? ip : tp(r), u = c ? ip : tp(e);
|
||
l = l == ap ? lo : l, u = u == ap ? lo : u;
|
||
var p = l == lo, h = u == lo, y = l == u;
|
||
if (y && np(r)) {
|
||
if (!np(e))
|
||
return !1;
|
||
s = !0, p = !1;
|
||
}
|
||
if (y && !p)
|
||
return i || (i = new Ba()), s || bw(r) ? mw(r, e, t, o, a, i) : gw(r, e, l, t, o, a, i);
|
||
if (!(t & vw)) {
|
||
var g = p && sp.call(r, "__wrapped__"), m = h && sp.call(e, "__wrapped__");
|
||
if (g || m) {
|
||
var b = g ? r.value() : r, S = m ? e.value() : e;
|
||
return i || (i = new Ba()), a(b, S, t, o, i);
|
||
}
|
||
}
|
||
return y ? (i || (i = new Ba()), Sw(r, e, t, o, a, i)) : !1;
|
||
}
|
||
n(Tw, "baseIsEqualDeep");
|
||
lp.exports = Tw;
|
||
});
|
||
|
||
// ../node_modules/lodash/_baseIsEqual.js
|
||
var Ua = d((g0, dp) => {
|
||
var Rw = cp(), up = Ne();
|
||
function pp(r, e, t, o, a) {
|
||
return r === e ? !0 : r == null || e == null || !up(r) && !up(e) ? r !== r && e !== e : Rw(r, e, t, o, pp, a);
|
||
}
|
||
n(pp, "baseIsEqual");
|
||
dp.exports = pp;
|
||
});
|
||
|
||
// ../node_modules/lodash/_baseIsMatch.js
|
||
var yp = d((b0, fp) => {
|
||
var Aw = Oa(), ww = Ua(), xw = 1, _w = 2;
|
||
function Pw(r, e, t, o) {
|
||
var a = t.length, i = a, s = !o;
|
||
if (r == null)
|
||
return !i;
|
||
for (r = Object(r); a--; ) {
|
||
var c = t[a];
|
||
if (s && c[2] ? c[1] !== r[c[0]] : !(c[0] in r))
|
||
return !1;
|
||
}
|
||
for (; ++a < i; ) {
|
||
c = t[a];
|
||
var l = c[0], u = r[l], p = c[1];
|
||
if (s && c[2]) {
|
||
if (u === void 0 && !(l in r))
|
||
return !1;
|
||
} else {
|
||
var h = new Aw();
|
||
if (o)
|
||
var y = o(u, p, l, r, e, h);
|
||
if (!(y === void 0 ? ww(p, u, xw | _w, o, h) : y))
|
||
return !1;
|
||
}
|
||
}
|
||
return !0;
|
||
}
|
||
n(Pw, "baseIsMatch");
|
||
fp.exports = Pw;
|
||
});
|
||
|
||
// ../node_modules/lodash/_isStrictComparable.js
|
||
var Ga = d((E0, hp) => {
|
||
var Ow = sr();
|
||
function Cw(r) {
|
||
return r === r && !Ow(r);
|
||
}
|
||
n(Cw, "isStrictComparable");
|
||
hp.exports = Cw;
|
||
});
|
||
|
||
// ../node_modules/lodash/_getMatchData.js
|
||
var gp = d((R0, mp) => {
|
||
var Iw = Ga(), Fw = to();
|
||
function Dw(r) {
|
||
for (var e = Fw(r), t = e.length; t--; ) {
|
||
var o = e[t], a = r[o];
|
||
e[t] = [o, a, Iw(a)];
|
||
}
|
||
return e;
|
||
}
|
||
n(Dw, "getMatchData");
|
||
mp.exports = Dw;
|
||
});
|
||
|
||
// ../node_modules/lodash/_matchesStrictComparable.js
|
||
var Ha = d((w0, Sp) => {
|
||
function Nw(r, e) {
|
||
return function(t) {
|
||
return t == null ? !1 : t[r] === e && (e !== void 0 || r in Object(t));
|
||
};
|
||
}
|
||
n(Nw, "matchesStrictComparable");
|
||
Sp.exports = Nw;
|
||
});
|
||
|
||
// ../node_modules/lodash/_baseMatches.js
|
||
var vp = d((_0, bp) => {
|
||
var qw = yp(), Lw = gp(), kw = Ha();
|
||
function Mw(r) {
|
||
var e = Lw(r);
|
||
return e.length == 1 && e[0][2] ? kw(e[0][0], e[0][1]) : function(t) {
|
||
return t === r || qw(t, r, e);
|
||
};
|
||
}
|
||
n(Mw, "baseMatches");
|
||
bp.exports = Mw;
|
||
});
|
||
|
||
// ../node_modules/lodash/isSymbol.js
|
||
var co = d((O0, Ep) => {
|
||
var jw = De(), Bw = Ne(), Uw = "[object Symbol]";
|
||
function Gw(r) {
|
||
return typeof r == "symbol" || Bw(r) && jw(r) == Uw;
|
||
}
|
||
n(Gw, "isSymbol");
|
||
Ep.exports = Gw;
|
||
});
|
||
|
||
// ../node_modules/lodash/_isKey.js
|
||
var uo = d((I0, Tp) => {
|
||
var Hw = se(), Vw = co(), $w = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, Ww = /^\w*$/;
|
||
function zw(r, e) {
|
||
if (Hw(r))
|
||
return !1;
|
||
var t = typeof r;
|
||
return t == "number" || t == "symbol" || t == "boolean" || r == null || Vw(r) ? !0 : Ww.test(r) || !$w.test(r) || e != null && r in Object(
|
||
e);
|
||
}
|
||
n(zw, "isKey");
|
||
Tp.exports = zw;
|
||
});
|
||
|
||
// ../node_modules/lodash/memoize.js
|
||
var wp = d((D0, Ap) => {
|
||
var Rp = ao(), Yw = "Expected a function";
|
||
function Va(r, e) {
|
||
if (typeof r != "function" || e != null && typeof e != "function")
|
||
throw new TypeError(Yw);
|
||
var t = /* @__PURE__ */ n(function() {
|
||
var o = arguments, a = e ? e.apply(this, o) : o[0], i = t.cache;
|
||
if (i.has(a))
|
||
return i.get(a);
|
||
var s = r.apply(this, o);
|
||
return t.cache = i.set(a, s) || i, s;
|
||
}, "memoized");
|
||
return t.cache = new (Va.Cache || Rp)(), t;
|
||
}
|
||
n(Va, "memoize");
|
||
Va.Cache = Rp;
|
||
Ap.exports = Va;
|
||
});
|
||
|
||
// ../node_modules/lodash/_memoizeCapped.js
|
||
var _p = d((q0, xp) => {
|
||
var Kw = wp(), Xw = 500;
|
||
function Jw(r) {
|
||
var e = Kw(r, function(o) {
|
||
return t.size === Xw && t.clear(), o;
|
||
}), t = e.cache;
|
||
return e;
|
||
}
|
||
n(Jw, "memoizeCapped");
|
||
xp.exports = Jw;
|
||
});
|
||
|
||
// ../node_modules/lodash/_stringToPath.js
|
||
var Op = d((k0, Pp) => {
|
||
var Qw = _p(), Zw = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g, ex = /\\(\\)?/g, rx = Qw(
|
||
function(r) {
|
||
var e = [];
|
||
return r.charCodeAt(0) === 46 && e.push(""), r.replace(Zw, function(t, o, a, i) {
|
||
e.push(a ? i.replace(ex, "$1") : o || t);
|
||
}), e;
|
||
});
|
||
Pp.exports = rx;
|
||
});
|
||
|
||
// ../node_modules/lodash/_arrayMap.js
|
||
var $a = d((M0, Cp) => {
|
||
function tx(r, e) {
|
||
for (var t = -1, o = r == null ? 0 : r.length, a = Array(o); ++t < o; )
|
||
a[t] = e(r[t], t, r);
|
||
return a;
|
||
}
|
||
n(tx, "arrayMap");
|
||
Cp.exports = tx;
|
||
});
|
||
|
||
// ../node_modules/lodash/_baseToString.js
|
||
var Lp = d((B0, qp) => {
|
||
var Ip = ir(), ox = $a(), nx = se(), ax = co(), ix = 1 / 0, Fp = Ip ? Ip.prototype : void 0, Dp = Fp ? Fp.toString : void 0;
|
||
function Np(r) {
|
||
if (typeof r == "string")
|
||
return r;
|
||
if (nx(r))
|
||
return ox(r, Np) + "";
|
||
if (ax(r))
|
||
return Dp ? Dp.call(r) : "";
|
||
var e = r + "";
|
||
return e == "0" && 1 / r == -ix ? "-0" : e;
|
||
}
|
||
n(Np, "baseToString");
|
||
qp.exports = Np;
|
||
});
|
||
|
||
// ../node_modules/lodash/toString.js
|
||
var Mp = d((G0, kp) => {
|
||
var sx = Lp();
|
||
function lx(r) {
|
||
return r == null ? "" : sx(r);
|
||
}
|
||
n(lx, "toString");
|
||
kp.exports = lx;
|
||
});
|
||
|
||
// ../node_modules/lodash/_castPath.js
|
||
var ft = d((V0, jp) => {
|
||
var cx = se(), ux = uo(), px = Op(), dx = Mp();
|
||
function fx(r, e) {
|
||
return cx(r) ? r : ux(r, e) ? [r] : px(dx(r));
|
||
}
|
||
n(fx, "castPath");
|
||
jp.exports = fx;
|
||
});
|
||
|
||
// ../node_modules/lodash/_toKey.js
|
||
var hr = d((W0, Bp) => {
|
||
var yx = co(), hx = 1 / 0;
|
||
function mx(r) {
|
||
if (typeof r == "string" || yx(r))
|
||
return r;
|
||
var e = r + "";
|
||
return e == "0" && 1 / r == -hx ? "-0" : e;
|
||
}
|
||
n(mx, "toKey");
|
||
Bp.exports = mx;
|
||
});
|
||
|
||
// ../node_modules/lodash/_baseGet.js
|
||
var po = d((Y0, Up) => {
|
||
var gx = ft(), Sx = hr();
|
||
function bx(r, e) {
|
||
e = gx(e, r);
|
||
for (var t = 0, o = e.length; r != null && t < o; )
|
||
r = r[Sx(e[t++])];
|
||
return t && t == o ? r : void 0;
|
||
}
|
||
n(bx, "baseGet");
|
||
Up.exports = bx;
|
||
});
|
||
|
||
// ../node_modules/lodash/get.js
|
||
var Hp = d((X0, Gp) => {
|
||
var vx = po();
|
||
function Ex(r, e, t) {
|
||
var o = r == null ? void 0 : vx(r, e);
|
||
return o === void 0 ? t : o;
|
||
}
|
||
n(Ex, "get");
|
||
Gp.exports = Ex;
|
||
});
|
||
|
||
// ../node_modules/lodash/_baseHasIn.js
|
||
var $p = d((Q0, Vp) => {
|
||
function Tx(r, e) {
|
||
return r != null && e in Object(r);
|
||
}
|
||
n(Tx, "baseHasIn");
|
||
Vp.exports = Tx;
|
||
});
|
||
|
||
// ../node_modules/lodash/_hasPath.js
|
||
var zp = d((eL, Wp) => {
|
||
var Rx = ft(), Ax = Zt(), wx = se(), xx = eo(), _x = ro(), Px = hr();
|
||
function Ox(r, e, t) {
|
||
e = Rx(e, r);
|
||
for (var o = -1, a = e.length, i = !1; ++o < a; ) {
|
||
var s = Px(e[o]);
|
||
if (!(i = r != null && t(r, s)))
|
||
break;
|
||
r = r[s];
|
||
}
|
||
return i || ++o != a ? i : (a = r == null ? 0 : r.length, !!a && _x(a) && xx(s, a) && (wx(r) || Ax(r)));
|
||
}
|
||
n(Ox, "hasPath");
|
||
Wp.exports = Ox;
|
||
});
|
||
|
||
// ../node_modules/lodash/hasIn.js
|
||
var Wa = d((tL, Yp) => {
|
||
var Cx = $p(), Ix = zp();
|
||
function Fx(r, e) {
|
||
return r != null && Ix(r, e, Cx);
|
||
}
|
||
n(Fx, "hasIn");
|
||
Yp.exports = Fx;
|
||
});
|
||
|
||
// ../node_modules/lodash/_baseMatchesProperty.js
|
||
var Xp = d((nL, Kp) => {
|
||
var Dx = Ua(), Nx = Hp(), qx = Wa(), Lx = uo(), kx = Ga(), Mx = Ha(), jx = hr(), Bx = 1, Ux = 2;
|
||
function Gx(r, e) {
|
||
return Lx(r) && kx(e) ? Mx(jx(r), e) : function(t) {
|
||
var o = Nx(t, r);
|
||
return o === void 0 && o === e ? qx(t, r) : Dx(e, o, Bx | Ux);
|
||
};
|
||
}
|
||
n(Gx, "baseMatchesProperty");
|
||
Kp.exports = Gx;
|
||
});
|
||
|
||
// ../node_modules/lodash/identity.js
|
||
var za = d((iL, Jp) => {
|
||
function Hx(r) {
|
||
return r;
|
||
}
|
||
n(Hx, "identity");
|
||
Jp.exports = Hx;
|
||
});
|
||
|
||
// ../node_modules/lodash/_baseProperty.js
|
||
var Zp = d((lL, Qp) => {
|
||
function Vx(r) {
|
||
return function(e) {
|
||
return e?.[r];
|
||
};
|
||
}
|
||
n(Vx, "baseProperty");
|
||
Qp.exports = Vx;
|
||
});
|
||
|
||
// ../node_modules/lodash/_basePropertyDeep.js
|
||
var rd = d((uL, ed) => {
|
||
var $x = po();
|
||
function Wx(r) {
|
||
return function(e) {
|
||
return $x(e, r);
|
||
};
|
||
}
|
||
n(Wx, "basePropertyDeep");
|
||
ed.exports = Wx;
|
||
});
|
||
|
||
// ../node_modules/lodash/property.js
|
||
var od = d((dL, td) => {
|
||
var zx = Zp(), Yx = rd(), Kx = uo(), Xx = hr();
|
||
function Jx(r) {
|
||
return Kx(r) ? zx(Xx(r)) : Yx(r);
|
||
}
|
||
n(Jx, "property");
|
||
td.exports = Jx;
|
||
});
|
||
|
||
// ../node_modules/lodash/_baseIteratee.js
|
||
var Ya = d((yL, nd) => {
|
||
var Qx = vp(), Zx = Xp(), e_ = za(), r_ = se(), t_ = od();
|
||
function o_(r) {
|
||
return typeof r == "function" ? r : r == null ? e_ : typeof r == "object" ? r_(r) ? Zx(r[0], r[1]) : Qx(r) : t_(r);
|
||
}
|
||
n(o_, "baseIteratee");
|
||
nd.exports = o_;
|
||
});
|
||
|
||
// ../node_modules/lodash/mapValues.js
|
||
var yt = d((mL, ad) => {
|
||
var n_ = Ea(), a_ = ac(), i_ = Ya();
|
||
function s_(r, e) {
|
||
var t = {};
|
||
return e = i_(e, 3), a_(r, function(o, a, i) {
|
||
n_(t, a, e(o, a, i));
|
||
}), t;
|
||
}
|
||
n(s_, "mapValues");
|
||
ad.exports = s_;
|
||
});
|
||
|
||
// ../node_modules/lodash/_assignValue.js
|
||
var sd = d((SL, id) => {
|
||
var l_ = Ea(), c_ = oo(), u_ = Object.prototype, p_ = u_.hasOwnProperty;
|
||
function d_(r, e, t) {
|
||
var o = r[e];
|
||
(!(p_.call(r, e) && c_(o, t)) || t === void 0 && !(e in r)) && l_(r, e, t);
|
||
}
|
||
n(d_, "assignValue");
|
||
id.exports = d_;
|
||
});
|
||
|
||
// ../node_modules/lodash/_baseSet.js
|
||
var ud = d((vL, cd) => {
|
||
var f_ = sd(), y_ = ft(), h_ = eo(), ld = sr(), m_ = hr();
|
||
function g_(r, e, t, o) {
|
||
if (!ld(r))
|
||
return r;
|
||
e = y_(e, r);
|
||
for (var a = -1, i = e.length, s = i - 1, c = r; c != null && ++a < i; ) {
|
||
var l = m_(e[a]), u = t;
|
||
if (l === "__proto__" || l === "constructor" || l === "prototype")
|
||
return r;
|
||
if (a != s) {
|
||
var p = c[l];
|
||
u = o ? o(p, l, c) : void 0, u === void 0 && (u = ld(p) ? p : h_(e[a + 1]) ? [] : {});
|
||
}
|
||
f_(c, l, u), c = c[l];
|
||
}
|
||
return r;
|
||
}
|
||
n(g_, "baseSet");
|
||
cd.exports = g_;
|
||
});
|
||
|
||
// ../node_modules/lodash/_basePickBy.js
|
||
var Ka = d((TL, pd) => {
|
||
var S_ = po(), b_ = ud(), v_ = ft();
|
||
function E_(r, e, t) {
|
||
for (var o = -1, a = e.length, i = {}; ++o < a; ) {
|
||
var s = e[o], c = S_(r, s);
|
||
t(c, s) && b_(i, v_(s, r), c);
|
||
}
|
||
return i;
|
||
}
|
||
n(E_, "basePickBy");
|
||
pd.exports = E_;
|
||
});
|
||
|
||
// ../node_modules/lodash/_basePick.js
|
||
var fd = d((AL, dd) => {
|
||
var T_ = Ka(), R_ = Wa();
|
||
function A_(r, e) {
|
||
return T_(r, e, function(t, o) {
|
||
return R_(r, o);
|
||
});
|
||
}
|
||
n(A_, "basePick");
|
||
dd.exports = A_;
|
||
});
|
||
|
||
// ../node_modules/lodash/_isFlattenable.js
|
||
var gd = d((xL, md) => {
|
||
var yd = ir(), w_ = Zt(), x_ = se(), hd = yd ? yd.isConcatSpreadable : void 0;
|
||
function __(r) {
|
||
return x_(r) || w_(r) || !!(hd && r && r[hd]);
|
||
}
|
||
n(__, "isFlattenable");
|
||
md.exports = __;
|
||
});
|
||
|
||
// ../node_modules/lodash/_baseFlatten.js
|
||
var vd = d((PL, bd) => {
|
||
var P_ = so(), O_ = gd();
|
||
function Sd(r, e, t, o, a) {
|
||
var i = -1, s = r.length;
|
||
for (t || (t = O_), a || (a = []); ++i < s; ) {
|
||
var c = r[i];
|
||
e > 0 && t(c) ? e > 1 ? Sd(c, e - 1, t, o, a) : P_(a, c) : o || (a[a.length] = c);
|
||
}
|
||
return a;
|
||
}
|
||
n(Sd, "baseFlatten");
|
||
bd.exports = Sd;
|
||
});
|
||
|
||
// ../node_modules/lodash/flatten.js
|
||
var Td = d((CL, Ed) => {
|
||
var C_ = vd();
|
||
function I_(r) {
|
||
var e = r == null ? 0 : r.length;
|
||
return e ? C_(r, 1) : [];
|
||
}
|
||
n(I_, "flatten");
|
||
Ed.exports = I_;
|
||
});
|
||
|
||
// ../node_modules/lodash/_apply.js
|
||
var Ad = d((FL, Rd) => {
|
||
function F_(r, e, t) {
|
||
switch (t.length) {
|
||
case 0:
|
||
return r.call(e);
|
||
case 1:
|
||
return r.call(e, t[0]);
|
||
case 2:
|
||
return r.call(e, t[0], t[1]);
|
||
case 3:
|
||
return r.call(e, t[0], t[1], t[2]);
|
||
}
|
||
return r.apply(e, t);
|
||
}
|
||
n(F_, "apply");
|
||
Rd.exports = F_;
|
||
});
|
||
|
||
// ../node_modules/lodash/_overRest.js
|
||
var _d = d((NL, xd) => {
|
||
var D_ = Ad(), wd = Math.max;
|
||
function N_(r, e, t) {
|
||
return e = wd(e === void 0 ? r.length - 1 : e, 0), function() {
|
||
for (var o = arguments, a = -1, i = wd(o.length - e, 0), s = Array(i); ++a < i; )
|
||
s[a] = o[e + a];
|
||
a = -1;
|
||
for (var c = Array(e + 1); ++a < e; )
|
||
c[a] = o[a];
|
||
return c[e] = t(s), D_(r, this, c);
|
||
};
|
||
}
|
||
n(N_, "overRest");
|
||
xd.exports = N_;
|
||
});
|
||
|
||
// ../node_modules/lodash/constant.js
|
||
var Od = d((LL, Pd) => {
|
||
function q_(r) {
|
||
return function() {
|
||
return r;
|
||
};
|
||
}
|
||
n(q_, "constant");
|
||
Pd.exports = q_;
|
||
});
|
||
|
||
// ../node_modules/lodash/_baseSetToString.js
|
||
var Fd = d((ML, Id) => {
|
||
var L_ = Od(), Cd = va(), k_ = za(), M_ = Cd ? function(r, e) {
|
||
return Cd(r, "toString", {
|
||
configurable: !0,
|
||
enumerable: !1,
|
||
value: L_(e),
|
||
writable: !0
|
||
});
|
||
} : k_;
|
||
Id.exports = M_;
|
||
});
|
||
|
||
// ../node_modules/lodash/_shortOut.js
|
||
var Nd = d((jL, Dd) => {
|
||
var j_ = 800, B_ = 16, U_ = Date.now;
|
||
function G_(r) {
|
||
var e = 0, t = 0;
|
||
return function() {
|
||
var o = U_(), a = B_ - (o - t);
|
||
if (t = o, a > 0) {
|
||
if (++e >= j_)
|
||
return arguments[0];
|
||
} else
|
||
e = 0;
|
||
return r.apply(void 0, arguments);
|
||
};
|
||
}
|
||
n(G_, "shortOut");
|
||
Dd.exports = G_;
|
||
});
|
||
|
||
// ../node_modules/lodash/_setToString.js
|
||
var Ld = d((UL, qd) => {
|
||
var H_ = Fd(), V_ = Nd(), $_ = V_(H_);
|
||
qd.exports = $_;
|
||
});
|
||
|
||
// ../node_modules/lodash/_flatRest.js
|
||
var Md = d((GL, kd) => {
|
||
var W_ = Td(), z_ = _d(), Y_ = Ld();
|
||
function K_(r) {
|
||
return Y_(z_(r, void 0, W_), r + "");
|
||
}
|
||
n(K_, "flatRest");
|
||
kd.exports = K_;
|
||
});
|
||
|
||
// ../node_modules/lodash/pick.js
|
||
var Bd = d((VL, jd) => {
|
||
var X_ = fd(), J_ = Md(), Q_ = J_(function(r, e) {
|
||
return r == null ? {} : X_(r, e);
|
||
});
|
||
jd.exports = Q_;
|
||
});
|
||
|
||
// ../node_modules/lodash/_getPrototype.js
|
||
var Ja = d((XL, Vd) => {
|
||
var eP = _a(), rP = eP(Object.getPrototypeOf, Object);
|
||
Vd.exports = rP;
|
||
});
|
||
|
||
// ../node_modules/lodash/isPlainObject.js
|
||
var yo = d((JL, Wd) => {
|
||
var tP = De(), oP = Ja(), nP = Ne(), aP = "[object Object]", iP = Function.prototype, sP = Object.prototype, $d = iP.toString, lP = sP.hasOwnProperty,
|
||
cP = $d.call(Object);
|
||
function uP(r) {
|
||
if (!nP(r) || tP(r) != aP)
|
||
return !1;
|
||
var e = oP(r);
|
||
if (e === null)
|
||
return !0;
|
||
var t = lP.call(e, "constructor") && e.constructor;
|
||
return typeof t == "function" && t instanceof t && $d.call(t) == cP;
|
||
}
|
||
n(uP, "isPlainObject");
|
||
Wd.exports = uP;
|
||
});
|
||
|
||
// ../node_modules/lodash/_getSymbolsIn.js
|
||
var ff = d((iM, df) => {
|
||
var CP = so(), IP = Ja(), FP = Na(), DP = Da(), NP = Object.getOwnPropertySymbols, qP = NP ? function(r) {
|
||
for (var e = []; r; )
|
||
CP(e, FP(r)), r = IP(r);
|
||
return e;
|
||
} : DP;
|
||
df.exports = qP;
|
||
});
|
||
|
||
// ../node_modules/lodash/_nativeKeysIn.js
|
||
var hf = d((sM, yf) => {
|
||
function LP(r) {
|
||
var e = [];
|
||
if (r != null)
|
||
for (var t in Object(r))
|
||
e.push(t);
|
||
return e;
|
||
}
|
||
n(LP, "nativeKeysIn");
|
||
yf.exports = LP;
|
||
});
|
||
|
||
// ../node_modules/lodash/_baseKeysIn.js
|
||
var gf = d((cM, mf) => {
|
||
var kP = sr(), MP = xa(), jP = hf(), BP = Object.prototype, UP = BP.hasOwnProperty;
|
||
function GP(r) {
|
||
if (!kP(r))
|
||
return jP(r);
|
||
var e = MP(r), t = [];
|
||
for (var o in r)
|
||
o == "constructor" && (e || !UP.call(r, o)) || t.push(o);
|
||
return t;
|
||
}
|
||
n(GP, "baseKeysIn");
|
||
mf.exports = GP;
|
||
});
|
||
|
||
// ../node_modules/lodash/keysIn.js
|
||
var bf = d((pM, Sf) => {
|
||
var HP = wa(), VP = gf(), $P = Pa();
|
||
function WP(r) {
|
||
return $P(r) ? HP(r, !0) : VP(r);
|
||
}
|
||
n(WP, "keysIn");
|
||
Sf.exports = WP;
|
||
});
|
||
|
||
// ../node_modules/lodash/_getAllKeysIn.js
|
||
var Ef = d((fM, vf) => {
|
||
var zP = Fa(), YP = ff(), KP = bf();
|
||
function XP(r) {
|
||
return zP(r, KP, YP);
|
||
}
|
||
n(XP, "getAllKeysIn");
|
||
vf.exports = XP;
|
||
});
|
||
|
||
// ../node_modules/lodash/pickBy.js
|
||
var Rf = d((hM, Tf) => {
|
||
var JP = $a(), QP = Ya(), ZP = Ka(), eO = Ef();
|
||
function rO(r, e) {
|
||
if (r == null)
|
||
return {};
|
||
var t = JP(eO(r), function(o) {
|
||
return [o];
|
||
});
|
||
return e = QP(e), ZP(r, t, function(o, a) {
|
||
return e(o, a[0]);
|
||
});
|
||
}
|
||
n(rO, "pickBy");
|
||
Tf.exports = rO;
|
||
});
|
||
|
||
// ../node_modules/es-errors/index.js
|
||
var Hf = d((vj, Gf) => {
|
||
"use strict";
|
||
Gf.exports = Error;
|
||
});
|
||
|
||
// ../node_modules/es-errors/eval.js
|
||
var $f = d((Ej, Vf) => {
|
||
"use strict";
|
||
Vf.exports = EvalError;
|
||
});
|
||
|
||
// ../node_modules/es-errors/range.js
|
||
var zf = d((Tj, Wf) => {
|
||
"use strict";
|
||
Wf.exports = RangeError;
|
||
});
|
||
|
||
// ../node_modules/es-errors/ref.js
|
||
var Kf = d((Rj, Yf) => {
|
||
"use strict";
|
||
Yf.exports = ReferenceError;
|
||
});
|
||
|
||
// ../node_modules/es-errors/syntax.js
|
||
var Si = d((Aj, Xf) => {
|
||
"use strict";
|
||
Xf.exports = SyntaxError;
|
||
});
|
||
|
||
// ../node_modules/es-errors/type.js
|
||
var wr = d((wj, Jf) => {
|
||
"use strict";
|
||
Jf.exports = TypeError;
|
||
});
|
||
|
||
// ../node_modules/es-errors/uri.js
|
||
var Zf = d((xj, Qf) => {
|
||
"use strict";
|
||
Qf.exports = URIError;
|
||
});
|
||
|
||
// ../node_modules/has-symbols/shams.js
|
||
var ry = d((_j, ey) => {
|
||
"use strict";
|
||
ey.exports = /* @__PURE__ */ n(function() {
|
||
if (typeof Symbol != "function" || typeof Object.getOwnPropertySymbols != "function")
|
||
return !1;
|
||
if (typeof Symbol.iterator == "symbol")
|
||
return !0;
|
||
var e = {}, t = Symbol("test"), o = Object(t);
|
||
if (typeof t == "string" || Object.prototype.toString.call(t) !== "[object Symbol]" || Object.prototype.toString.call(o) !== "[object Sy\
|
||
mbol]")
|
||
return !1;
|
||
var a = 42;
|
||
e[t] = a;
|
||
for (t in e)
|
||
return !1;
|
||
if (typeof Object.keys == "function" && Object.keys(e).length !== 0 || typeof Object.getOwnPropertyNames == "function" && Object.getOwnPropertyNames(
|
||
e).length !== 0)
|
||
return !1;
|
||
var i = Object.getOwnPropertySymbols(e);
|
||
if (i.length !== 1 || i[0] !== t || !Object.prototype.propertyIsEnumerable.call(e, t))
|
||
return !1;
|
||
if (typeof Object.getOwnPropertyDescriptor == "function") {
|
||
var s = Object.getOwnPropertyDescriptor(e, t);
|
||
if (s.value !== a || s.enumerable !== !0)
|
||
return !1;
|
||
}
|
||
return !0;
|
||
}, "hasSymbols");
|
||
});
|
||
|
||
// ../node_modules/has-symbols/index.js
|
||
var ny = d((Oj, oy) => {
|
||
"use strict";
|
||
var ty = typeof Symbol < "u" && Symbol, SO = ry();
|
||
oy.exports = /* @__PURE__ */ n(function() {
|
||
return typeof ty != "function" || typeof Symbol != "function" || typeof ty("foo") != "symbol" || typeof Symbol("bar") != "symbol" ? !1 :
|
||
SO();
|
||
}, "hasNativeSymbols");
|
||
});
|
||
|
||
// ../node_modules/has-proto/index.js
|
||
var iy = d((Ij, ay) => {
|
||
"use strict";
|
||
var bi = {
|
||
__proto__: null,
|
||
foo: {}
|
||
}, bO = Object;
|
||
ay.exports = /* @__PURE__ */ n(function() {
|
||
return { __proto__: bi }.foo === bi.foo && !(bi instanceof bO);
|
||
}, "hasProto");
|
||
});
|
||
|
||
// ../node_modules/function-bind/implementation.js
|
||
var cy = d((Dj, ly) => {
|
||
"use strict";
|
||
var vO = "Function.prototype.bind called on incompatible ", EO = Object.prototype.toString, TO = Math.max, RO = "[object Function]", sy = /* @__PURE__ */ n(
|
||
function(e, t) {
|
||
for (var o = [], a = 0; a < e.length; a += 1)
|
||
o[a] = e[a];
|
||
for (var i = 0; i < t.length; i += 1)
|
||
o[i + e.length] = t[i];
|
||
return o;
|
||
}, "concatty"), AO = /* @__PURE__ */ n(function(e, t) {
|
||
for (var o = [], a = t || 0, i = 0; a < e.length; a += 1, i += 1)
|
||
o[i] = e[a];
|
||
return o;
|
||
}, "slicy"), wO = /* @__PURE__ */ n(function(r, e) {
|
||
for (var t = "", o = 0; o < r.length; o += 1)
|
||
t += r[o], o + 1 < r.length && (t += e);
|
||
return t;
|
||
}, "joiny");
|
||
ly.exports = /* @__PURE__ */ n(function(e) {
|
||
var t = this;
|
||
if (typeof t != "function" || EO.apply(t) !== RO)
|
||
throw new TypeError(vO + t);
|
||
for (var o = AO(arguments, 1), a, i = /* @__PURE__ */ n(function() {
|
||
if (this instanceof a) {
|
||
var p = t.apply(
|
||
this,
|
||
sy(o, arguments)
|
||
);
|
||
return Object(p) === p ? p : this;
|
||
}
|
||
return t.apply(
|
||
e,
|
||
sy(o, arguments)
|
||
);
|
||
}, "binder"), s = TO(0, t.length - o.length), c = [], l = 0; l < s; l++)
|
||
c[l] = "$" + l;
|
||
if (a = Function("binder", "return function (" + wO(c, ",") + "){ return binder.apply(this,arguments); }")(i), t.prototype) {
|
||
var u = /* @__PURE__ */ n(function() {
|
||
}, "Empty");
|
||
u.prototype = t.prototype, a.prototype = new u(), u.prototype = null;
|
||
}
|
||
return a;
|
||
}, "bind");
|
||
});
|
||
|
||
// ../node_modules/function-bind/index.js
|
||
var Po = d((qj, uy) => {
|
||
"use strict";
|
||
var xO = cy();
|
||
uy.exports = Function.prototype.bind || xO;
|
||
});
|
||
|
||
// ../node_modules/hasown/index.js
|
||
var dy = d((Lj, py) => {
|
||
"use strict";
|
||
var _O = Function.prototype.call, PO = Object.prototype.hasOwnProperty, OO = Po();
|
||
py.exports = OO.call(_O, PO);
|
||
});
|
||
|
||
// ../node_modules/get-intrinsic/index.js
|
||
var $e = d((kj, gy) => {
|
||
"use strict";
|
||
var I, CO = Hf(), IO = $f(), FO = zf(), DO = Kf(), Or = Si(), Pr = wr(), NO = Zf(), my = Function, vi = /* @__PURE__ */ n(function(r) {
|
||
try {
|
||
return my('"use strict"; return (' + r + ").constructor;")();
|
||
} catch {
|
||
}
|
||
}, "getEvalledConstructor"), He = Object.getOwnPropertyDescriptor;
|
||
if (He)
|
||
try {
|
||
He({}, "");
|
||
} catch {
|
||
He = null;
|
||
}
|
||
var Ei = /* @__PURE__ */ n(function() {
|
||
throw new Pr();
|
||
}, "throwTypeError"), qO = He ? function() {
|
||
try {
|
||
return arguments.callee, Ei;
|
||
} catch {
|
||
try {
|
||
return He(arguments, "callee").get;
|
||
} catch {
|
||
return Ei;
|
||
}
|
||
}
|
||
}() : Ei, xr = ny()(), LO = iy()(), W = Object.getPrototypeOf || (LO ? function(r) {
|
||
return r.__proto__;
|
||
} : null), _r = {}, kO = typeof Uint8Array > "u" || !W ? I : W(Uint8Array), Ve = {
|
||
__proto__: null,
|
||
"%AggregateError%": typeof AggregateError > "u" ? I : AggregateError,
|
||
"%Array%": Array,
|
||
"%ArrayBuffer%": typeof ArrayBuffer > "u" ? I : ArrayBuffer,
|
||
"%ArrayIteratorPrototype%": xr && W ? W([][Symbol.iterator]()) : I,
|
||
"%AsyncFromSyncIteratorPrototype%": I,
|
||
"%AsyncFunction%": _r,
|
||
"%AsyncGenerator%": _r,
|
||
"%AsyncGeneratorFunction%": _r,
|
||
"%AsyncIteratorPrototype%": _r,
|
||
"%Atomics%": typeof Atomics > "u" ? I : Atomics,
|
||
"%BigInt%": typeof BigInt > "u" ? I : BigInt,
|
||
"%BigInt64Array%": typeof BigInt64Array > "u" ? I : BigInt64Array,
|
||
"%BigUint64Array%": typeof BigUint64Array > "u" ? I : BigUint64Array,
|
||
"%Boolean%": Boolean,
|
||
"%DataView%": typeof DataView > "u" ? I : DataView,
|
||
"%Date%": Date,
|
||
"%decodeURI%": decodeURI,
|
||
"%decodeURIComponent%": decodeURIComponent,
|
||
"%encodeURI%": encodeURI,
|
||
"%encodeURIComponent%": encodeURIComponent,
|
||
"%Error%": CO,
|
||
"%eval%": eval,
|
||
// eslint-disable-line no-eval
|
||
"%EvalError%": IO,
|
||
"%Float32Array%": typeof Float32Array > "u" ? I : Float32Array,
|
||
"%Float64Array%": typeof Float64Array > "u" ? I : Float64Array,
|
||
"%FinalizationRegistry%": typeof FinalizationRegistry > "u" ? I : FinalizationRegistry,
|
||
"%Function%": my,
|
||
"%GeneratorFunction%": _r,
|
||
"%Int8Array%": typeof Int8Array > "u" ? I : Int8Array,
|
||
"%Int16Array%": typeof Int16Array > "u" ? I : Int16Array,
|
||
"%Int32Array%": typeof Int32Array > "u" ? I : Int32Array,
|
||
"%isFinite%": isFinite,
|
||
"%isNaN%": isNaN,
|
||
"%IteratorPrototype%": xr && W ? W(W([][Symbol.iterator]())) : I,
|
||
"%JSON%": typeof JSON == "object" ? JSON : I,
|
||
"%Map%": typeof Map > "u" ? I : Map,
|
||
"%MapIteratorPrototype%": typeof Map > "u" || !xr || !W ? I : W((/* @__PURE__ */ new Map())[Symbol.iterator]()),
|
||
"%Math%": Math,
|
||
"%Number%": Number,
|
||
"%Object%": Object,
|
||
"%parseFloat%": parseFloat,
|
||
"%parseInt%": parseInt,
|
||
"%Promise%": typeof Promise > "u" ? I : Promise,
|
||
"%Proxy%": typeof Proxy > "u" ? I : Proxy,
|
||
"%RangeError%": FO,
|
||
"%ReferenceError%": DO,
|
||
"%Reflect%": typeof Reflect > "u" ? I : Reflect,
|
||
"%RegExp%": RegExp,
|
||
"%Set%": typeof Set > "u" ? I : Set,
|
||
"%SetIteratorPrototype%": typeof Set > "u" || !xr || !W ? I : W((/* @__PURE__ */ new Set())[Symbol.iterator]()),
|
||
"%SharedArrayBuffer%": typeof SharedArrayBuffer > "u" ? I : SharedArrayBuffer,
|
||
"%String%": String,
|
||
"%StringIteratorPrototype%": xr && W ? W(""[Symbol.iterator]()) : I,
|
||
"%Symbol%": xr ? Symbol : I,
|
||
"%SyntaxError%": Or,
|
||
"%ThrowTypeError%": qO,
|
||
"%TypedArray%": kO,
|
||
"%TypeError%": Pr,
|
||
"%Uint8Array%": typeof Uint8Array > "u" ? I : Uint8Array,
|
||
"%Uint8ClampedArray%": typeof Uint8ClampedArray > "u" ? I : Uint8ClampedArray,
|
||
"%Uint16Array%": typeof Uint16Array > "u" ? I : Uint16Array,
|
||
"%Uint32Array%": typeof Uint32Array > "u" ? I : Uint32Array,
|
||
"%URIError%": NO,
|
||
"%WeakMap%": typeof WeakMap > "u" ? I : WeakMap,
|
||
"%WeakRef%": typeof WeakRef > "u" ? I : WeakRef,
|
||
"%WeakSet%": typeof WeakSet > "u" ? I : WeakSet
|
||
};
|
||
if (W)
|
||
try {
|
||
null.error;
|
||
} catch (r) {
|
||
fy = W(W(r)), Ve["%Error.prototype%"] = fy;
|
||
}
|
||
var fy, MO = /* @__PURE__ */ n(function r(e) {
|
||
var t;
|
||
if (e === "%AsyncFunction%")
|
||
t = vi("async function () {}");
|
||
else if (e === "%GeneratorFunction%")
|
||
t = vi("function* () {}");
|
||
else if (e === "%AsyncGeneratorFunction%")
|
||
t = vi("async function* () {}");
|
||
else if (e === "%AsyncGenerator%") {
|
||
var o = r("%AsyncGeneratorFunction%");
|
||
o && (t = o.prototype);
|
||
} else if (e === "%AsyncIteratorPrototype%") {
|
||
var a = r("%AsyncGenerator%");
|
||
a && W && (t = W(a.prototype));
|
||
}
|
||
return Ve[e] = t, t;
|
||
}, "doEval"), yy = {
|
||
__proto__: null,
|
||
"%ArrayBufferPrototype%": ["ArrayBuffer", "prototype"],
|
||
"%ArrayPrototype%": ["Array", "prototype"],
|
||
"%ArrayProto_entries%": ["Array", "prototype", "entries"],
|
||
"%ArrayProto_forEach%": ["Array", "prototype", "forEach"],
|
||
"%ArrayProto_keys%": ["Array", "prototype", "keys"],
|
||
"%ArrayProto_values%": ["Array", "prototype", "values"],
|
||
"%AsyncFunctionPrototype%": ["AsyncFunction", "prototype"],
|
||
"%AsyncGenerator%": ["AsyncGeneratorFunction", "prototype"],
|
||
"%AsyncGeneratorPrototype%": ["AsyncGeneratorFunction", "prototype", "prototype"],
|
||
"%BooleanPrototype%": ["Boolean", "prototype"],
|
||
"%DataViewPrototype%": ["DataView", "prototype"],
|
||
"%DatePrototype%": ["Date", "prototype"],
|
||
"%ErrorPrototype%": ["Error", "prototype"],
|
||
"%EvalErrorPrototype%": ["EvalError", "prototype"],
|
||
"%Float32ArrayPrototype%": ["Float32Array", "prototype"],
|
||
"%Float64ArrayPrototype%": ["Float64Array", "prototype"],
|
||
"%FunctionPrototype%": ["Function", "prototype"],
|
||
"%Generator%": ["GeneratorFunction", "prototype"],
|
||
"%GeneratorPrototype%": ["GeneratorFunction", "prototype", "prototype"],
|
||
"%Int8ArrayPrototype%": ["Int8Array", "prototype"],
|
||
"%Int16ArrayPrototype%": ["Int16Array", "prototype"],
|
||
"%Int32ArrayPrototype%": ["Int32Array", "prototype"],
|
||
"%JSONParse%": ["JSON", "parse"],
|
||
"%JSONStringify%": ["JSON", "stringify"],
|
||
"%MapPrototype%": ["Map", "prototype"],
|
||
"%NumberPrototype%": ["Number", "prototype"],
|
||
"%ObjectPrototype%": ["Object", "prototype"],
|
||
"%ObjProto_toString%": ["Object", "prototype", "toString"],
|
||
"%ObjProto_valueOf%": ["Object", "prototype", "valueOf"],
|
||
"%PromisePrototype%": ["Promise", "prototype"],
|
||
"%PromiseProto_then%": ["Promise", "prototype", "then"],
|
||
"%Promise_all%": ["Promise", "all"],
|
||
"%Promise_reject%": ["Promise", "reject"],
|
||
"%Promise_resolve%": ["Promise", "resolve"],
|
||
"%RangeErrorPrototype%": ["RangeError", "prototype"],
|
||
"%ReferenceErrorPrototype%": ["ReferenceError", "prototype"],
|
||
"%RegExpPrototype%": ["RegExp", "prototype"],
|
||
"%SetPrototype%": ["Set", "prototype"],
|
||
"%SharedArrayBufferPrototype%": ["SharedArrayBuffer", "prototype"],
|
||
"%StringPrototype%": ["String", "prototype"],
|
||
"%SymbolPrototype%": ["Symbol", "prototype"],
|
||
"%SyntaxErrorPrototype%": ["SyntaxError", "prototype"],
|
||
"%TypedArrayPrototype%": ["TypedArray", "prototype"],
|
||
"%TypeErrorPrototype%": ["TypeError", "prototype"],
|
||
"%Uint8ArrayPrototype%": ["Uint8Array", "prototype"],
|
||
"%Uint8ClampedArrayPrototype%": ["Uint8ClampedArray", "prototype"],
|
||
"%Uint16ArrayPrototype%": ["Uint16Array", "prototype"],
|
||
"%Uint32ArrayPrototype%": ["Uint32Array", "prototype"],
|
||
"%URIErrorPrototype%": ["URIError", "prototype"],
|
||
"%WeakMapPrototype%": ["WeakMap", "prototype"],
|
||
"%WeakSetPrototype%": ["WeakSet", "prototype"]
|
||
}, Rt = Po(), Oo = dy(), jO = Rt.call(Function.call, Array.prototype.concat), BO = Rt.call(Function.apply, Array.prototype.splice), hy = Rt.
|
||
call(Function.call, String.prototype.replace), Co = Rt.call(Function.call, String.prototype.slice), UO = Rt.call(Function.call, RegExp.prototype.
|
||
exec), GO = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g, HO = /\\(\\)?/g, VO = /* @__PURE__ */ n(
|
||
function(e) {
|
||
var t = Co(e, 0, 1), o = Co(e, -1);
|
||
if (t === "%" && o !== "%")
|
||
throw new Or("invalid intrinsic syntax, expected closing `%`");
|
||
if (o === "%" && t !== "%")
|
||
throw new Or("invalid intrinsic syntax, expected opening `%`");
|
||
var a = [];
|
||
return hy(e, GO, function(i, s, c, l) {
|
||
a[a.length] = c ? hy(l, HO, "$1") : s || i;
|
||
}), a;
|
||
}, "stringToPath"), $O = /* @__PURE__ */ n(function(e, t) {
|
||
var o = e, a;
|
||
if (Oo(yy, o) && (a = yy[o], o = "%" + a[0] + "%"), Oo(Ve, o)) {
|
||
var i = Ve[o];
|
||
if (i === _r && (i = MO(o)), typeof i > "u" && !t)
|
||
throw new Pr("intrinsic " + e + " exists, but is not available. Please file an issue!");
|
||
return {
|
||
alias: a,
|
||
name: o,
|
||
value: i
|
||
};
|
||
}
|
||
throw new Or("intrinsic " + e + " does not exist!");
|
||
}, "getBaseIntrinsic");
|
||
gy.exports = /* @__PURE__ */ n(function(e, t) {
|
||
if (typeof e != "string" || e.length === 0)
|
||
throw new Pr("intrinsic name must be a non-empty string");
|
||
if (arguments.length > 1 && typeof t != "boolean")
|
||
throw new Pr('"allowMissing" argument must be a boolean');
|
||
if (UO(/^%?[^%]*%?$/, e) === null)
|
||
throw new Or("`%` may not be present anywhere but at the beginning and end of the intrinsic name");
|
||
var o = VO(e), a = o.length > 0 ? o[0] : "", i = $O("%" + a + "%", t), s = i.name, c = i.value, l = !1, u = i.alias;
|
||
u && (a = u[0], BO(o, jO([0, 1], u)));
|
||
for (var p = 1, h = !0; p < o.length; p += 1) {
|
||
var y = o[p], g = Co(y, 0, 1), m = Co(y, -1);
|
||
if ((g === '"' || g === "'" || g === "`" || m === '"' || m === "'" || m === "`") && g !== m)
|
||
throw new Or("property names with quotes must have matching quotes");
|
||
if ((y === "constructor" || !h) && (l = !0), a += "." + y, s = "%" + a + "%", Oo(Ve, s))
|
||
c = Ve[s];
|
||
else if (c != null) {
|
||
if (!(y in c)) {
|
||
if (!t)
|
||
throw new Pr("base intrinsic for " + e + " exists, but the property is not available.");
|
||
return;
|
||
}
|
||
if (He && p + 1 >= o.length) {
|
||
var b = He(c, y);
|
||
h = !!b, h && "get" in b && !("originalValue" in b.get) ? c = b.get : c = c[y];
|
||
} else
|
||
h = Oo(c, y), c = c[y];
|
||
h && !l && (Ve[s] = c);
|
||
}
|
||
}
|
||
return c;
|
||
}, "GetIntrinsic");
|
||
});
|
||
|
||
// ../node_modules/es-define-property/index.js
|
||
var Fo = d((jj, Sy) => {
|
||
"use strict";
|
||
var WO = $e(), Io = WO("%Object.defineProperty%", !0) || !1;
|
||
if (Io)
|
||
try {
|
||
Io({}, "a", { value: 1 });
|
||
} catch {
|
||
Io = !1;
|
||
}
|
||
Sy.exports = Io;
|
||
});
|
||
|
||
// ../node_modules/gopd/index.js
|
||
var Ti = d((Bj, by) => {
|
||
"use strict";
|
||
var zO = $e(), Do = zO("%Object.getOwnPropertyDescriptor%", !0);
|
||
if (Do)
|
||
try {
|
||
Do([], "length");
|
||
} catch {
|
||
Do = null;
|
||
}
|
||
by.exports = Do;
|
||
});
|
||
|
||
// ../node_modules/define-data-property/index.js
|
||
var Ry = d((Uj, Ty) => {
|
||
"use strict";
|
||
var vy = Fo(), YO = Si(), Cr = wr(), Ey = Ti();
|
||
Ty.exports = /* @__PURE__ */ n(function(e, t, o) {
|
||
if (!e || typeof e != "object" && typeof e != "function")
|
||
throw new Cr("`obj` must be an object or a function`");
|
||
if (typeof t != "string" && typeof t != "symbol")
|
||
throw new Cr("`property` must be a string or a symbol`");
|
||
if (arguments.length > 3 && typeof arguments[3] != "boolean" && arguments[3] !== null)
|
||
throw new Cr("`nonEnumerable`, if provided, must be a boolean or null");
|
||
if (arguments.length > 4 && typeof arguments[4] != "boolean" && arguments[4] !== null)
|
||
throw new Cr("`nonWritable`, if provided, must be a boolean or null");
|
||
if (arguments.length > 5 && typeof arguments[5] != "boolean" && arguments[5] !== null)
|
||
throw new Cr("`nonConfigurable`, if provided, must be a boolean or null");
|
||
if (arguments.length > 6 && typeof arguments[6] != "boolean")
|
||
throw new Cr("`loose`, if provided, must be a boolean");
|
||
var a = arguments.length > 3 ? arguments[3] : null, i = arguments.length > 4 ? arguments[4] : null, s = arguments.length > 5 ? arguments[5] :
|
||
null, c = arguments.length > 6 ? arguments[6] : !1, l = !!Ey && Ey(e, t);
|
||
if (vy)
|
||
vy(e, t, {
|
||
configurable: s === null && l ? l.configurable : !s,
|
||
enumerable: a === null && l ? l.enumerable : !a,
|
||
value: o,
|
||
writable: i === null && l ? l.writable : !i
|
||
});
|
||
else if (c || !a && !i && !s)
|
||
e[t] = o;
|
||
else
|
||
throw new YO("This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.");
|
||
}, "defineDataProperty");
|
||
});
|
||
|
||
// ../node_modules/has-property-descriptors/index.js
|
||
var xy = d((Hj, wy) => {
|
||
"use strict";
|
||
var Ri = Fo(), Ay = /* @__PURE__ */ n(function() {
|
||
return !!Ri;
|
||
}, "hasPropertyDescriptors");
|
||
Ay.hasArrayLengthDefineBug = /* @__PURE__ */ n(function() {
|
||
if (!Ri)
|
||
return null;
|
||
try {
|
||
return Ri([], "length", { value: 1 }).length !== 1;
|
||
} catch {
|
||
return !0;
|
||
}
|
||
}, "hasArrayLengthDefineBug");
|
||
wy.exports = Ay;
|
||
});
|
||
|
||
// ../node_modules/set-function-length/index.js
|
||
var Iy = d(($j, Cy) => {
|
||
"use strict";
|
||
var KO = $e(), _y = Ry(), XO = xy()(), Py = Ti(), Oy = wr(), JO = KO("%Math.floor%");
|
||
Cy.exports = /* @__PURE__ */ n(function(e, t) {
|
||
if (typeof e != "function")
|
||
throw new Oy("`fn` is not a function");
|
||
if (typeof t != "number" || t < 0 || t > 4294967295 || JO(t) !== t)
|
||
throw new Oy("`length` must be a positive 32-bit integer");
|
||
var o = arguments.length > 2 && !!arguments[2], a = !0, i = !0;
|
||
if ("length" in e && Py) {
|
||
var s = Py(e, "length");
|
||
s && !s.configurable && (a = !1), s && !s.writable && (i = !1);
|
||
}
|
||
return (a || i || !o) && (XO ? _y(
|
||
/** @type {Parameters<define>[0]} */
|
||
e,
|
||
"length",
|
||
t,
|
||
!0,
|
||
!0
|
||
) : _y(
|
||
/** @type {Parameters<define>[0]} */
|
||
e,
|
||
"length",
|
||
t
|
||
)), e;
|
||
}, "setFunctionLength");
|
||
});
|
||
|
||
// ../node_modules/call-bind/index.js
|
||
var ky = d((zj, No) => {
|
||
"use strict";
|
||
var Ai = Po(), qo = $e(), QO = Iy(), ZO = wr(), Ny = qo("%Function.prototype.apply%"), qy = qo("%Function.prototype.call%"), Ly = qo("%Ref\
|
||
lect.apply%", !0) || Ai.call(qy, Ny), Fy = Fo(), eC = qo("%Math.max%");
|
||
No.exports = /* @__PURE__ */ n(function(e) {
|
||
if (typeof e != "function")
|
||
throw new ZO("a function is required");
|
||
var t = Ly(Ai, qy, arguments);
|
||
return QO(
|
||
t,
|
||
1 + eC(0, e.length - (arguments.length - 1)),
|
||
!0
|
||
);
|
||
}, "callBind");
|
||
var Dy = /* @__PURE__ */ n(function() {
|
||
return Ly(Ai, Ny, arguments);
|
||
}, "applyBind");
|
||
Fy ? Fy(No.exports, "apply", { value: Dy }) : No.exports.apply = Dy;
|
||
});
|
||
|
||
// ../node_modules/call-bind/callBound.js
|
||
var Uy = d((Kj, By) => {
|
||
"use strict";
|
||
var My = $e(), jy = ky(), rC = jy(My("String.prototype.indexOf"));
|
||
By.exports = /* @__PURE__ */ n(function(e, t) {
|
||
var o = My(e, !!t);
|
||
return typeof o == "function" && rC(e, ".prototype.") > -1 ? jy(o) : o;
|
||
}, "callBoundIntrinsic");
|
||
});
|
||
|
||
// (disabled):../node_modules/object-inspect/util.inspect
|
||
var Gy = d(() => {
|
||
});
|
||
|
||
// ../node_modules/object-inspect/index.js
|
||
var lh = d((Zj, sh) => {
|
||
var Ni = typeof Map == "function" && Map.prototype, wi = Object.getOwnPropertyDescriptor && Ni ? Object.getOwnPropertyDescriptor(Map.prototype,
|
||
"size") : null, ko = Ni && wi && typeof wi.get == "function" ? wi.get : null, Hy = Ni && Map.prototype.forEach, qi = typeof Set == "functi\
|
||
on" && Set.prototype, xi = Object.getOwnPropertyDescriptor && qi ? Object.getOwnPropertyDescriptor(Set.prototype, "size") : null, Mo = qi &&
|
||
xi && typeof xi.get == "function" ? xi.get : null, Vy = qi && Set.prototype.forEach, tC = typeof WeakMap == "function" && WeakMap.prototype,
|
||
wt = tC ? WeakMap.prototype.has : null, oC = typeof WeakSet == "function" && WeakSet.prototype, xt = oC ? WeakSet.prototype.has : null, nC = typeof WeakRef ==
|
||
"function" && WeakRef.prototype, $y = nC ? WeakRef.prototype.deref : null, aC = Boolean.prototype.valueOf, iC = Object.prototype.toString,
|
||
sC = Function.prototype.toString, lC = String.prototype.match, Li = String.prototype.slice, xe = String.prototype.replace, cC = String.prototype.
|
||
toUpperCase, Wy = String.prototype.toLowerCase, rh = RegExp.prototype.test, zy = Array.prototype.concat, le = Array.prototype.join, uC = Array.
|
||
prototype.slice, Yy = Math.floor, Oi = typeof BigInt == "function" ? BigInt.prototype.valueOf : null, _i = Object.getOwnPropertySymbols, Ci = typeof Symbol ==
|
||
"function" && typeof Symbol.iterator == "symbol" ? Symbol.prototype.toString : null, Ir = typeof Symbol == "function" && typeof Symbol.iterator ==
|
||
"object", X = typeof Symbol == "function" && Symbol.toStringTag && (typeof Symbol.toStringTag === Ir || !0) ? Symbol.toStringTag : null, th = Object.
|
||
prototype.propertyIsEnumerable, Ky = (typeof Reflect == "function" ? Reflect.getPrototypeOf : Object.getPrototypeOf) || ([].__proto__ === Array.
|
||
prototype ? function(r) {
|
||
return r.__proto__;
|
||
} : null);
|
||
function Xy(r, e) {
|
||
if (r === 1 / 0 || r === -1 / 0 || r !== r || r && r > -1e3 && r < 1e3 || rh.call(/e/, e))
|
||
return e;
|
||
var t = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;
|
||
if (typeof r == "number") {
|
||
var o = r < 0 ? -Yy(-r) : Yy(r);
|
||
if (o !== r) {
|
||
var a = String(o), i = Li.call(e, a.length + 1);
|
||
return xe.call(a, t, "$&_") + "." + xe.call(xe.call(i, /([0-9]{3})/g, "$&_"), /_$/, "");
|
||
}
|
||
}
|
||
return xe.call(e, t, "$&_");
|
||
}
|
||
n(Xy, "addNumericSeparator");
|
||
var Ii = Gy(), Jy = Ii.custom, Qy = nh(Jy) ? Jy : null;
|
||
sh.exports = /* @__PURE__ */ n(function r(e, t, o, a) {
|
||
var i = t || {};
|
||
if (we(i, "quoteStyle") && i.quoteStyle !== "single" && i.quoteStyle !== "double")
|
||
throw new TypeError('option "quoteStyle" must be "single" or "double"');
|
||
if (we(i, "maxStringLength") && (typeof i.maxStringLength == "number" ? i.maxStringLength < 0 && i.maxStringLength !== 1 / 0 : i.maxStringLength !==
|
||
null))
|
||
throw new TypeError('option "maxStringLength", if provided, must be a positive integer, Infinity, or `null`');
|
||
var s = we(i, "customInspect") ? i.customInspect : !0;
|
||
if (typeof s != "boolean" && s !== "symbol")
|
||
throw new TypeError("option \"customInspect\", if provided, must be `true`, `false`, or `'symbol'`");
|
||
if (we(i, "indent") && i.indent !== null && i.indent !== " " && !(parseInt(i.indent, 10) === i.indent && i.indent > 0))
|
||
throw new TypeError('option "indent" must be "\\t", an integer > 0, or `null`');
|
||
if (we(i, "numericSeparator") && typeof i.numericSeparator != "boolean")
|
||
throw new TypeError('option "numericSeparator", if provided, must be `true` or `false`');
|
||
var c = i.numericSeparator;
|
||
if (typeof e > "u")
|
||
return "undefined";
|
||
if (e === null)
|
||
return "null";
|
||
if (typeof e == "boolean")
|
||
return e ? "true" : "false";
|
||
if (typeof e == "string")
|
||
return ih(e, i);
|
||
if (typeof e == "number") {
|
||
if (e === 0)
|
||
return 1 / 0 / e > 0 ? "0" : "-0";
|
||
var l = String(e);
|
||
return c ? Xy(e, l) : l;
|
||
}
|
||
if (typeof e == "bigint") {
|
||
var u = String(e) + "n";
|
||
return c ? Xy(e, u) : u;
|
||
}
|
||
var p = typeof i.depth > "u" ? 5 : i.depth;
|
||
if (typeof o > "u" && (o = 0), o >= p && p > 0 && typeof e == "object")
|
||
return Fi(e) ? "[Array]" : "[Object]";
|
||
var h = PC(i, o);
|
||
if (typeof a > "u")
|
||
a = [];
|
||
else if (ah(a, e) >= 0)
|
||
return "[Circular]";
|
||
function y(D, q, N) {
|
||
if (q && (a = uC.call(a), a.push(q)), N) {
|
||
var B = {
|
||
depth: i.depth
|
||
};
|
||
return we(i, "quoteStyle") && (B.quoteStyle = i.quoteStyle), r(D, B, o + 1, a);
|
||
}
|
||
return r(D, i, o + 1, a);
|
||
}
|
||
if (n(y, "inspect"), typeof e == "function" && !Zy(e)) {
|
||
var g = bC(e), m = Lo(e, y);
|
||
return "[Function" + (g ? ": " + g : " (anonymous)") + "]" + (m.length > 0 ? " { " + le.call(m, ", ") + " }" : "");
|
||
}
|
||
if (nh(e)) {
|
||
var b = Ir ? xe.call(String(e), /^(Symbol\(.*\))_[^)]*$/, "$1") : Ci.call(e);
|
||
return typeof e == "object" && !Ir ? At(b) : b;
|
||
}
|
||
if (wC(e)) {
|
||
for (var S = "<" + Wy.call(String(e.nodeName)), w = e.attributes || [], E = 0; E < w.length; E++)
|
||
S += " " + w[E].name + "=" + oh(pC(w[E].value), "double", i);
|
||
return S += ">", e.childNodes && e.childNodes.length && (S += "..."), S += "</" + Wy.call(String(e.nodeName)) + ">", S;
|
||
}
|
||
if (Fi(e)) {
|
||
if (e.length === 0)
|
||
return "[]";
|
||
var v = Lo(e, y);
|
||
return h && !_C(v) ? "[" + Di(v, h) + "]" : "[ " + le.call(v, ", ") + " ]";
|
||
}
|
||
if (fC(e)) {
|
||
var x = Lo(e, y);
|
||
return !("cause" in Error.prototype) && "cause" in e && !th.call(e, "cause") ? "{ [" + String(e) + "] " + le.call(zy.call("[cause]: " +
|
||
y(e.cause), x), ", ") + " }" : x.length === 0 ? "[" + String(e) + "]" : "{ [" + String(e) + "] " + le.call(x, ", ") + " }";
|
||
}
|
||
if (typeof e == "object" && s) {
|
||
if (Qy && typeof e[Qy] == "function" && Ii)
|
||
return Ii(e, { depth: p - o });
|
||
if (s !== "symbol" && typeof e.inspect == "function")
|
||
return e.inspect();
|
||
}
|
||
if (vC(e)) {
|
||
var R = [];
|
||
return Hy && Hy.call(e, function(D, q) {
|
||
R.push(y(q, e, !0) + " => " + y(D, e));
|
||
}), eh("Map", ko.call(e), R, h);
|
||
}
|
||
if (RC(e)) {
|
||
var P = [];
|
||
return Vy && Vy.call(e, function(D) {
|
||
P.push(y(D, e));
|
||
}), eh("Set", Mo.call(e), P, h);
|
||
}
|
||
if (EC(e))
|
||
return Pi("WeakMap");
|
||
if (AC(e))
|
||
return Pi("WeakSet");
|
||
if (TC(e))
|
||
return Pi("WeakRef");
|
||
if (hC(e))
|
||
return At(y(Number(e)));
|
||
if (gC(e))
|
||
return At(y(Oi.call(e)));
|
||
if (mC(e))
|
||
return At(aC.call(e));
|
||
if (yC(e))
|
||
return At(y(String(e)));
|
||
if (typeof window < "u" && e === window)
|
||
return "{ [object Window] }";
|
||
if (e === global)
|
||
return "{ [object globalThis] }";
|
||
if (!dC(e) && !Zy(e)) {
|
||
var k = Lo(e, y), F = Ky ? Ky(e) === Object.prototype : e instanceof Object || e.constructor === Object, H = e instanceof Object ? "" :
|
||
"null prototype", Z = !F && X && Object(e) === e && X in e ? Li.call(_e(e), 8, -1) : H ? "Object" : "", me = F || typeof e.constructor !=
|
||
"function" ? "" : e.constructor.name ? e.constructor.name + " " : "", V = me + (Z || H ? "[" + le.call(zy.call([], Z || [], H || []), "\
|
||
: ") + "] " : "");
|
||
return k.length === 0 ? V + "{}" : h ? V + "{" + Di(k, h) + "}" : V + "{ " + le.call(k, ", ") + " }";
|
||
}
|
||
return String(e);
|
||
}, "inspect_");
|
||
function oh(r, e, t) {
|
||
var o = (t.quoteStyle || e) === "double" ? '"' : "'";
|
||
return o + r + o;
|
||
}
|
||
n(oh, "wrapQuotes");
|
||
function pC(r) {
|
||
return xe.call(String(r), /"/g, """);
|
||
}
|
||
n(pC, "quote");
|
||
function Fi(r) {
|
||
return _e(r) === "[object Array]" && (!X || !(typeof r == "object" && X in r));
|
||
}
|
||
n(Fi, "isArray");
|
||
function dC(r) {
|
||
return _e(r) === "[object Date]" && (!X || !(typeof r == "object" && X in r));
|
||
}
|
||
n(dC, "isDate");
|
||
function Zy(r) {
|
||
return _e(r) === "[object RegExp]" && (!X || !(typeof r == "object" && X in r));
|
||
}
|
||
n(Zy, "isRegExp");
|
||
function fC(r) {
|
||
return _e(r) === "[object Error]" && (!X || !(typeof r == "object" && X in r));
|
||
}
|
||
n(fC, "isError");
|
||
function yC(r) {
|
||
return _e(r) === "[object String]" && (!X || !(typeof r == "object" && X in r));
|
||
}
|
||
n(yC, "isString");
|
||
function hC(r) {
|
||
return _e(r) === "[object Number]" && (!X || !(typeof r == "object" && X in r));
|
||
}
|
||
n(hC, "isNumber");
|
||
function mC(r) {
|
||
return _e(r) === "[object Boolean]" && (!X || !(typeof r == "object" && X in r));
|
||
}
|
||
n(mC, "isBoolean");
|
||
function nh(r) {
|
||
if (Ir)
|
||
return r && typeof r == "object" && r instanceof Symbol;
|
||
if (typeof r == "symbol")
|
||
return !0;
|
||
if (!r || typeof r != "object" || !Ci)
|
||
return !1;
|
||
try {
|
||
return Ci.call(r), !0;
|
||
} catch {
|
||
}
|
||
return !1;
|
||
}
|
||
n(nh, "isSymbol");
|
||
function gC(r) {
|
||
if (!r || typeof r != "object" || !Oi)
|
||
return !1;
|
||
try {
|
||
return Oi.call(r), !0;
|
||
} catch {
|
||
}
|
||
return !1;
|
||
}
|
||
n(gC, "isBigInt");
|
||
var SC = Object.prototype.hasOwnProperty || function(r) {
|
||
return r in this;
|
||
};
|
||
function we(r, e) {
|
||
return SC.call(r, e);
|
||
}
|
||
n(we, "has");
|
||
function _e(r) {
|
||
return iC.call(r);
|
||
}
|
||
n(_e, "toStr");
|
||
function bC(r) {
|
||
if (r.name)
|
||
return r.name;
|
||
var e = lC.call(sC.call(r), /^function\s*([\w$]+)/);
|
||
return e ? e[1] : null;
|
||
}
|
||
n(bC, "nameOf");
|
||
function ah(r, e) {
|
||
if (r.indexOf)
|
||
return r.indexOf(e);
|
||
for (var t = 0, o = r.length; t < o; t++)
|
||
if (r[t] === e)
|
||
return t;
|
||
return -1;
|
||
}
|
||
n(ah, "indexOf");
|
||
function vC(r) {
|
||
if (!ko || !r || typeof r != "object")
|
||
return !1;
|
||
try {
|
||
ko.call(r);
|
||
try {
|
||
Mo.call(r);
|
||
} catch {
|
||
return !0;
|
||
}
|
||
return r instanceof Map;
|
||
} catch {
|
||
}
|
||
return !1;
|
||
}
|
||
n(vC, "isMap");
|
||
function EC(r) {
|
||
if (!wt || !r || typeof r != "object")
|
||
return !1;
|
||
try {
|
||
wt.call(r, wt);
|
||
try {
|
||
xt.call(r, xt);
|
||
} catch {
|
||
return !0;
|
||
}
|
||
return r instanceof WeakMap;
|
||
} catch {
|
||
}
|
||
return !1;
|
||
}
|
||
n(EC, "isWeakMap");
|
||
function TC(r) {
|
||
if (!$y || !r || typeof r != "object")
|
||
return !1;
|
||
try {
|
||
return $y.call(r), !0;
|
||
} catch {
|
||
}
|
||
return !1;
|
||
}
|
||
n(TC, "isWeakRef");
|
||
function RC(r) {
|
||
if (!Mo || !r || typeof r != "object")
|
||
return !1;
|
||
try {
|
||
Mo.call(r);
|
||
try {
|
||
ko.call(r);
|
||
} catch {
|
||
return !0;
|
||
}
|
||
return r instanceof Set;
|
||
} catch {
|
||
}
|
||
return !1;
|
||
}
|
||
n(RC, "isSet");
|
||
function AC(r) {
|
||
if (!xt || !r || typeof r != "object")
|
||
return !1;
|
||
try {
|
||
xt.call(r, xt);
|
||
try {
|
||
wt.call(r, wt);
|
||
} catch {
|
||
return !0;
|
||
}
|
||
return r instanceof WeakSet;
|
||
} catch {
|
||
}
|
||
return !1;
|
||
}
|
||
n(AC, "isWeakSet");
|
||
function wC(r) {
|
||
return !r || typeof r != "object" ? !1 : typeof HTMLElement < "u" && r instanceof HTMLElement ? !0 : typeof r.nodeName == "string" && typeof r.
|
||
getAttribute == "function";
|
||
}
|
||
n(wC, "isElement");
|
||
function ih(r, e) {
|
||
if (r.length > e.maxStringLength) {
|
||
var t = r.length - e.maxStringLength, o = "... " + t + " more character" + (t > 1 ? "s" : "");
|
||
return ih(Li.call(r, 0, e.maxStringLength), e) + o;
|
||
}
|
||
var a = xe.call(xe.call(r, /(['\\])/g, "\\$1"), /[\x00-\x1f]/g, xC);
|
||
return oh(a, "single", e);
|
||
}
|
||
n(ih, "inspectString");
|
||
function xC(r) {
|
||
var e = r.charCodeAt(0), t = {
|
||
8: "b",
|
||
9: "t",
|
||
10: "n",
|
||
12: "f",
|
||
13: "r"
|
||
}[e];
|
||
return t ? "\\" + t : "\\x" + (e < 16 ? "0" : "") + cC.call(e.toString(16));
|
||
}
|
||
n(xC, "lowbyte");
|
||
function At(r) {
|
||
return "Object(" + r + ")";
|
||
}
|
||
n(At, "markBoxed");
|
||
function Pi(r) {
|
||
return r + " { ? }";
|
||
}
|
||
n(Pi, "weakCollectionOf");
|
||
function eh(r, e, t, o) {
|
||
var a = o ? Di(t, o) : le.call(t, ", ");
|
||
return r + " (" + e + ") {" + a + "}";
|
||
}
|
||
n(eh, "collectionOf");
|
||
function _C(r) {
|
||
for (var e = 0; e < r.length; e++)
|
||
if (ah(r[e], `
|
||
`) >= 0)
|
||
return !1;
|
||
return !0;
|
||
}
|
||
n(_C, "singleLineValues");
|
||
function PC(r, e) {
|
||
var t;
|
||
if (r.indent === " ")
|
||
t = " ";
|
||
else if (typeof r.indent == "number" && r.indent > 0)
|
||
t = le.call(Array(r.indent + 1), " ");
|
||
else
|
||
return null;
|
||
return {
|
||
base: t,
|
||
prev: le.call(Array(e + 1), t)
|
||
};
|
||
}
|
||
n(PC, "getIndent");
|
||
function Di(r, e) {
|
||
if (r.length === 0)
|
||
return "";
|
||
var t = `
|
||
` + e.prev + e.base;
|
||
return t + le.call(r, "," + t) + `
|
||
` + e.prev;
|
||
}
|
||
n(Di, "indentedJoin");
|
||
function Lo(r, e) {
|
||
var t = Fi(r), o = [];
|
||
if (t) {
|
||
o.length = r.length;
|
||
for (var a = 0; a < r.length; a++)
|
||
o[a] = we(r, a) ? e(r[a], r) : "";
|
||
}
|
||
var i = typeof _i == "function" ? _i(r) : [], s;
|
||
if (Ir) {
|
||
s = {};
|
||
for (var c = 0; c < i.length; c++)
|
||
s["$" + i[c]] = i[c];
|
||
}
|
||
for (var l in r)
|
||
we(r, l) && (t && String(Number(l)) === l && l < r.length || Ir && s["$" + l] instanceof Symbol || (rh.call(/[^\w$]/, l) ? o.push(e(l,
|
||
r) + ": " + e(r[l], r)) : o.push(l + ": " + e(r[l], r))));
|
||
if (typeof _i == "function")
|
||
for (var u = 0; u < i.length; u++)
|
||
th.call(r, i[u]) && o.push("[" + e(i[u]) + "]: " + e(r[i[u]], r));
|
||
return o;
|
||
}
|
||
n(Lo, "arrObjKeys");
|
||
});
|
||
|
||
// ../node_modules/side-channel/index.js
|
||
var ph = d((rB, uh) => {
|
||
"use strict";
|
||
var ch = $e(), Fr = Uy(), OC = lh(), CC = wr(), jo = ch("%WeakMap%", !0), Bo = ch("%Map%", !0), IC = Fr("WeakMap.prototype.get", !0), FC = Fr(
|
||
"WeakMap.prototype.set", !0), DC = Fr("WeakMap.prototype.has", !0), NC = Fr("Map.prototype.get", !0), qC = Fr("Map.prototype.set", !0), LC = Fr(
|
||
"Map.prototype.has", !0), ki = /* @__PURE__ */ n(function(r, e) {
|
||
for (var t = r, o; (o = t.next) !== null; t = o)
|
||
if (o.key === e)
|
||
return t.next = o.next, o.next = /** @type {NonNullable<typeof list.next>} */
|
||
r.next, r.next = o, o;
|
||
}, "listGetNode"), kC = /* @__PURE__ */ n(function(r, e) {
|
||
var t = ki(r, e);
|
||
return t && t.value;
|
||
}, "listGet"), MC = /* @__PURE__ */ n(function(r, e, t) {
|
||
var o = ki(r, e);
|
||
o ? o.value = t : r.next = /** @type {import('.').ListNode<typeof value>} */
|
||
{
|
||
// eslint-disable-line no-param-reassign, no-extra-parens
|
||
key: e,
|
||
next: r.next,
|
||
value: t
|
||
};
|
||
}, "listSet"), jC = /* @__PURE__ */ n(function(r, e) {
|
||
return !!ki(r, e);
|
||
}, "listHas");
|
||
uh.exports = /* @__PURE__ */ n(function() {
|
||
var e, t, o, a = {
|
||
assert: /* @__PURE__ */ n(function(i) {
|
||
if (!a.has(i))
|
||
throw new CC("Side channel does not contain " + OC(i));
|
||
}, "assert"),
|
||
get: /* @__PURE__ */ n(function(i) {
|
||
if (jo && i && (typeof i == "object" || typeof i == "function")) {
|
||
if (e)
|
||
return IC(e, i);
|
||
} else if (Bo) {
|
||
if (t)
|
||
return NC(t, i);
|
||
} else if (o)
|
||
return kC(o, i);
|
||
}, "get"),
|
||
has: /* @__PURE__ */ n(function(i) {
|
||
if (jo && i && (typeof i == "object" || typeof i == "function")) {
|
||
if (e)
|
||
return DC(e, i);
|
||
} else if (Bo) {
|
||
if (t)
|
||
return LC(t, i);
|
||
} else if (o)
|
||
return jC(o, i);
|
||
return !1;
|
||
}, "has"),
|
||
set: /* @__PURE__ */ n(function(i, s) {
|
||
jo && i && (typeof i == "object" || typeof i == "function") ? (e || (e = new jo()), FC(e, i, s)) : Bo ? (t || (t = new Bo()), qC(t, i,
|
||
s)) : (o || (o = { key: {}, next: null }), MC(o, i, s));
|
||
}, "set")
|
||
};
|
||
return a;
|
||
}, "getSideChannel");
|
||
});
|
||
|
||
// ../node_modules/qs/lib/formats.js
|
||
var Uo = d((oB, dh) => {
|
||
"use strict";
|
||
var BC = String.prototype.replace, UC = /%20/g, Mi = {
|
||
RFC1738: "RFC1738",
|
||
RFC3986: "RFC3986"
|
||
};
|
||
dh.exports = {
|
||
default: Mi.RFC3986,
|
||
formatters: {
|
||
RFC1738: /* @__PURE__ */ n(function(r) {
|
||
return BC.call(r, UC, "+");
|
||
}, "RFC1738"),
|
||
RFC3986: /* @__PURE__ */ n(function(r) {
|
||
return String(r);
|
||
}, "RFC3986")
|
||
},
|
||
RFC1738: Mi.RFC1738,
|
||
RFC3986: Mi.RFC3986
|
||
};
|
||
});
|
||
|
||
// ../node_modules/qs/lib/utils.js
|
||
var Ui = d((aB, yh) => {
|
||
"use strict";
|
||
var GC = Uo(), ji = Object.prototype.hasOwnProperty, We = Array.isArray, ce = function() {
|
||
for (var r = [], e = 0; e < 256; ++e)
|
||
r.push("%" + ((e < 16 ? "0" : "") + e.toString(16)).toUpperCase());
|
||
return r;
|
||
}(), HC = /* @__PURE__ */ n(function(e) {
|
||
for (; e.length > 1; ) {
|
||
var t = e.pop(), o = t.obj[t.prop];
|
||
if (We(o)) {
|
||
for (var a = [], i = 0; i < o.length; ++i)
|
||
typeof o[i] < "u" && a.push(o[i]);
|
||
t.obj[t.prop] = a;
|
||
}
|
||
}
|
||
}, "compactQueue"), fh = /* @__PURE__ */ n(function(e, t) {
|
||
for (var o = t && t.plainObjects ? /* @__PURE__ */ Object.create(null) : {}, a = 0; a < e.length; ++a)
|
||
typeof e[a] < "u" && (o[a] = e[a]);
|
||
return o;
|
||
}, "arrayToObject"), VC = /* @__PURE__ */ n(function r(e, t, o) {
|
||
if (!t)
|
||
return e;
|
||
if (typeof t != "object") {
|
||
if (We(e))
|
||
e.push(t);
|
||
else if (e && typeof e == "object")
|
||
(o && (o.plainObjects || o.allowPrototypes) || !ji.call(Object.prototype, t)) && (e[t] = !0);
|
||
else
|
||
return [e, t];
|
||
return e;
|
||
}
|
||
if (!e || typeof e != "object")
|
||
return [e].concat(t);
|
||
var a = e;
|
||
return We(e) && !We(t) && (a = fh(e, o)), We(e) && We(t) ? (t.forEach(function(i, s) {
|
||
if (ji.call(e, s)) {
|
||
var c = e[s];
|
||
c && typeof c == "object" && i && typeof i == "object" ? e[s] = r(c, i, o) : e.push(i);
|
||
} else
|
||
e[s] = i;
|
||
}), e) : Object.keys(t).reduce(function(i, s) {
|
||
var c = t[s];
|
||
return ji.call(i, s) ? i[s] = r(i[s], c, o) : i[s] = c, i;
|
||
}, a);
|
||
}, "merge"), $C = /* @__PURE__ */ n(function(e, t) {
|
||
return Object.keys(t).reduce(function(o, a) {
|
||
return o[a] = t[a], o;
|
||
}, e);
|
||
}, "assignSingleSource"), WC = /* @__PURE__ */ n(function(r, e, t) {
|
||
var o = r.replace(/\+/g, " ");
|
||
if (t === "iso-8859-1")
|
||
return o.replace(/%[0-9a-f]{2}/gi, unescape);
|
||
try {
|
||
return decodeURIComponent(o);
|
||
} catch {
|
||
return o;
|
||
}
|
||
}, "decode"), Bi = 1024, zC = /* @__PURE__ */ n(function(e, t, o, a, i) {
|
||
if (e.length === 0)
|
||
return e;
|
||
var s = e;
|
||
if (typeof e == "symbol" ? s = Symbol.prototype.toString.call(e) : typeof e != "string" && (s = String(e)), o === "iso-8859-1")
|
||
return escape(s).replace(/%u[0-9a-f]{4}/gi, function(g) {
|
||
return "%26%23" + parseInt(g.slice(2), 16) + "%3B";
|
||
});
|
||
for (var c = "", l = 0; l < s.length; l += Bi) {
|
||
for (var u = s.length >= Bi ? s.slice(l, l + Bi) : s, p = [], h = 0; h < u.length; ++h) {
|
||
var y = u.charCodeAt(h);
|
||
if (y === 45 || y === 46 || y === 95 || y === 126 || y >= 48 && y <= 57 || y >= 65 && y <= 90 || y >= 97 && y <= 122 || i === GC.RFC1738 &&
|
||
(y === 40 || y === 41)) {
|
||
p[p.length] = u.charAt(h);
|
||
continue;
|
||
}
|
||
if (y < 128) {
|
||
p[p.length] = ce[y];
|
||
continue;
|
||
}
|
||
if (y < 2048) {
|
||
p[p.length] = ce[192 | y >> 6] + ce[128 | y & 63];
|
||
continue;
|
||
}
|
||
if (y < 55296 || y >= 57344) {
|
||
p[p.length] = ce[224 | y >> 12] + ce[128 | y >> 6 & 63] + ce[128 | y & 63];
|
||
continue;
|
||
}
|
||
h += 1, y = 65536 + ((y & 1023) << 10 | u.charCodeAt(h) & 1023), p[p.length] = ce[240 | y >> 18] + ce[128 | y >> 12 & 63] + ce[128 |
|
||
y >> 6 & 63] + ce[128 | y & 63];
|
||
}
|
||
c += p.join("");
|
||
}
|
||
return c;
|
||
}, "encode"), YC = /* @__PURE__ */ n(function(e) {
|
||
for (var t = [{ obj: { o: e }, prop: "o" }], o = [], a = 0; a < t.length; ++a)
|
||
for (var i = t[a], s = i.obj[i.prop], c = Object.keys(s), l = 0; l < c.length; ++l) {
|
||
var u = c[l], p = s[u];
|
||
typeof p == "object" && p !== null && o.indexOf(p) === -1 && (t.push({ obj: s, prop: u }), o.push(p));
|
||
}
|
||
return HC(t), e;
|
||
}, "compact"), KC = /* @__PURE__ */ n(function(e) {
|
||
return Object.prototype.toString.call(e) === "[object RegExp]";
|
||
}, "isRegExp"), XC = /* @__PURE__ */ n(function(e) {
|
||
return !e || typeof e != "object" ? !1 : !!(e.constructor && e.constructor.isBuffer && e.constructor.isBuffer(e));
|
||
}, "isBuffer"), JC = /* @__PURE__ */ n(function(e, t) {
|
||
return [].concat(e, t);
|
||
}, "combine"), QC = /* @__PURE__ */ n(function(e, t) {
|
||
if (We(e)) {
|
||
for (var o = [], a = 0; a < e.length; a += 1)
|
||
o.push(t(e[a]));
|
||
return o;
|
||
}
|
||
return t(e);
|
||
}, "maybeMap");
|
||
yh.exports = {
|
||
arrayToObject: fh,
|
||
assign: $C,
|
||
combine: JC,
|
||
compact: YC,
|
||
decode: WC,
|
||
encode: zC,
|
||
isBuffer: XC,
|
||
isRegExp: KC,
|
||
maybeMap: QC,
|
||
merge: VC
|
||
};
|
||
});
|
||
|
||
// ../node_modules/qs/lib/stringify.js
|
||
var vh = d((sB, bh) => {
|
||
"use strict";
|
||
var mh = ph(), Go = Ui(), _t = Uo(), ZC = Object.prototype.hasOwnProperty, gh = {
|
||
brackets: /* @__PURE__ */ n(function(e) {
|
||
return e + "[]";
|
||
}, "brackets"),
|
||
comma: "comma",
|
||
indices: /* @__PURE__ */ n(function(e, t) {
|
||
return e + "[" + t + "]";
|
||
}, "indices"),
|
||
repeat: /* @__PURE__ */ n(function(e) {
|
||
return e;
|
||
}, "repeat")
|
||
}, ue = Array.isArray, eI = Array.prototype.push, Sh = /* @__PURE__ */ n(function(r, e) {
|
||
eI.apply(r, ue(e) ? e : [e]);
|
||
}, "pushToArray"), rI = Date.prototype.toISOString, hh = _t.default, $ = {
|
||
addQueryPrefix: !1,
|
||
allowDots: !1,
|
||
allowEmptyArrays: !1,
|
||
arrayFormat: "indices",
|
||
charset: "utf-8",
|
||
charsetSentinel: !1,
|
||
delimiter: "&",
|
||
encode: !0,
|
||
encodeDotInKeys: !1,
|
||
encoder: Go.encode,
|
||
encodeValuesOnly: !1,
|
||
format: hh,
|
||
formatter: _t.formatters[hh],
|
||
// deprecated
|
||
indices: !1,
|
||
serializeDate: /* @__PURE__ */ n(function(e) {
|
||
return rI.call(e);
|
||
}, "serializeDate"),
|
||
skipNulls: !1,
|
||
strictNullHandling: !1
|
||
}, tI = /* @__PURE__ */ n(function(e) {
|
||
return typeof e == "string" || typeof e == "number" || typeof e == "boolean" || typeof e == "symbol" || typeof e == "bigint";
|
||
}, "isNonNullishPrimitive"), Gi = {}, oI = /* @__PURE__ */ n(function r(e, t, o, a, i, s, c, l, u, p, h, y, g, m, b, S, w, E) {
|
||
for (var v = e, x = E, R = 0, P = !1; (x = x.get(Gi)) !== void 0 && !P; ) {
|
||
var k = x.get(e);
|
||
if (R += 1, typeof k < "u") {
|
||
if (k === R)
|
||
throw new RangeError("Cyclic object value");
|
||
P = !0;
|
||
}
|
||
typeof x.get(Gi) > "u" && (R = 0);
|
||
}
|
||
if (typeof p == "function" ? v = p(t, v) : v instanceof Date ? v = g(v) : o === "comma" && ue(v) && (v = Go.maybeMap(v, function(Se) {
|
||
return Se instanceof Date ? g(Se) : Se;
|
||
})), v === null) {
|
||
if (s)
|
||
return u && !S ? u(t, $.encoder, w, "key", m) : t;
|
||
v = "";
|
||
}
|
||
if (tI(v) || Go.isBuffer(v)) {
|
||
if (u) {
|
||
var F = S ? t : u(t, $.encoder, w, "key", m);
|
||
return [b(F) + "=" + b(u(v, $.encoder, w, "value", m))];
|
||
}
|
||
return [b(t) + "=" + b(String(v))];
|
||
}
|
||
var H = [];
|
||
if (typeof v > "u")
|
||
return H;
|
||
var Z;
|
||
if (o === "comma" && ue(v))
|
||
S && u && (v = Go.maybeMap(v, u)), Z = [{ value: v.length > 0 ? v.join(",") || null : void 0 }];
|
||
else if (ue(p))
|
||
Z = p;
|
||
else {
|
||
var me = Object.keys(v);
|
||
Z = h ? me.sort(h) : me;
|
||
}
|
||
var V = l ? t.replace(/\./g, "%2E") : t, D = a && ue(v) && v.length === 1 ? V + "[]" : V;
|
||
if (i && ue(v) && v.length === 0)
|
||
return D + "[]";
|
||
for (var q = 0; q < Z.length; ++q) {
|
||
var N = Z[q], B = typeof N == "object" && typeof N.value < "u" ? N.value : v[N];
|
||
if (!(c && B === null)) {
|
||
var ee = y && l ? N.replace(/\./g, "%2E") : N, ge = ue(v) ? typeof o == "function" ? o(D, ee) : D : D + (y ? "." + ee : "[" + ee + "\
|
||
]");
|
||
E.set(e, R);
|
||
var z = mh();
|
||
z.set(Gi, E), Sh(H, r(
|
||
B,
|
||
ge,
|
||
o,
|
||
a,
|
||
i,
|
||
s,
|
||
c,
|
||
l,
|
||
o === "comma" && S && ue(v) ? null : u,
|
||
p,
|
||
h,
|
||
y,
|
||
g,
|
||
m,
|
||
b,
|
||
S,
|
||
w,
|
||
z
|
||
));
|
||
}
|
||
}
|
||
return H;
|
||
}, "stringify"), nI = /* @__PURE__ */ n(function(e) {
|
||
if (!e)
|
||
return $;
|
||
if (typeof e.allowEmptyArrays < "u" && typeof e.allowEmptyArrays != "boolean")
|
||
throw new TypeError("`allowEmptyArrays` option can only be `true` or `false`, when provided");
|
||
if (typeof e.encodeDotInKeys < "u" && typeof e.encodeDotInKeys != "boolean")
|
||
throw new TypeError("`encodeDotInKeys` option can only be `true` or `false`, when provided");
|
||
if (e.encoder !== null && typeof e.encoder < "u" && typeof e.encoder != "function")
|
||
throw new TypeError("Encoder has to be a function.");
|
||
var t = e.charset || $.charset;
|
||
if (typeof e.charset < "u" && e.charset !== "utf-8" && e.charset !== "iso-8859-1")
|
||
throw new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined");
|
||
var o = _t.default;
|
||
if (typeof e.format < "u") {
|
||
if (!ZC.call(_t.formatters, e.format))
|
||
throw new TypeError("Unknown format option provided.");
|
||
o = e.format;
|
||
}
|
||
var a = _t.formatters[o], i = $.filter;
|
||
(typeof e.filter == "function" || ue(e.filter)) && (i = e.filter);
|
||
var s;
|
||
if (e.arrayFormat in gh ? s = e.arrayFormat : "indices" in e ? s = e.indices ? "indices" : "repeat" : s = $.arrayFormat, "commaRoundTrip" in
|
||
e && typeof e.commaRoundTrip != "boolean")
|
||
throw new TypeError("`commaRoundTrip` must be a boolean, or absent");
|
||
var c = typeof e.allowDots > "u" ? e.encodeDotInKeys === !0 ? !0 : $.allowDots : !!e.allowDots;
|
||
return {
|
||
addQueryPrefix: typeof e.addQueryPrefix == "boolean" ? e.addQueryPrefix : $.addQueryPrefix,
|
||
allowDots: c,
|
||
allowEmptyArrays: typeof e.allowEmptyArrays == "boolean" ? !!e.allowEmptyArrays : $.allowEmptyArrays,
|
||
arrayFormat: s,
|
||
charset: t,
|
||
charsetSentinel: typeof e.charsetSentinel == "boolean" ? e.charsetSentinel : $.charsetSentinel,
|
||
commaRoundTrip: e.commaRoundTrip,
|
||
delimiter: typeof e.delimiter > "u" ? $.delimiter : e.delimiter,
|
||
encode: typeof e.encode == "boolean" ? e.encode : $.encode,
|
||
encodeDotInKeys: typeof e.encodeDotInKeys == "boolean" ? e.encodeDotInKeys : $.encodeDotInKeys,
|
||
encoder: typeof e.encoder == "function" ? e.encoder : $.encoder,
|
||
encodeValuesOnly: typeof e.encodeValuesOnly == "boolean" ? e.encodeValuesOnly : $.encodeValuesOnly,
|
||
filter: i,
|
||
format: o,
|
||
formatter: a,
|
||
serializeDate: typeof e.serializeDate == "function" ? e.serializeDate : $.serializeDate,
|
||
skipNulls: typeof e.skipNulls == "boolean" ? e.skipNulls : $.skipNulls,
|
||
sort: typeof e.sort == "function" ? e.sort : null,
|
||
strictNullHandling: typeof e.strictNullHandling == "boolean" ? e.strictNullHandling : $.strictNullHandling
|
||
};
|
||
}, "normalizeStringifyOptions");
|
||
bh.exports = function(r, e) {
|
||
var t = r, o = nI(e), a, i;
|
||
typeof o.filter == "function" ? (i = o.filter, t = i("", t)) : ue(o.filter) && (i = o.filter, a = i);
|
||
var s = [];
|
||
if (typeof t != "object" || t === null)
|
||
return "";
|
||
var c = gh[o.arrayFormat], l = c === "comma" && o.commaRoundTrip;
|
||
a || (a = Object.keys(t)), o.sort && a.sort(o.sort);
|
||
for (var u = mh(), p = 0; p < a.length; ++p) {
|
||
var h = a[p];
|
||
o.skipNulls && t[h] === null || Sh(s, oI(
|
||
t[h],
|
||
h,
|
||
c,
|
||
l,
|
||
o.allowEmptyArrays,
|
||
o.strictNullHandling,
|
||
o.skipNulls,
|
||
o.encodeDotInKeys,
|
||
o.encode ? o.encoder : null,
|
||
o.filter,
|
||
o.sort,
|
||
o.allowDots,
|
||
o.serializeDate,
|
||
o.format,
|
||
o.formatter,
|
||
o.encodeValuesOnly,
|
||
o.charset,
|
||
u
|
||
));
|
||
}
|
||
var y = s.join(o.delimiter), g = o.addQueryPrefix === !0 ? "?" : "";
|
||
return o.charsetSentinel && (o.charset === "iso-8859-1" ? g += "utf8=%26%2310003%3B&" : g += "utf8=%E2%9C%93&"), y.length > 0 ? g + y : "";
|
||
};
|
||
});
|
||
|
||
// ../node_modules/qs/lib/parse.js
|
||
var Rh = d((cB, Th) => {
|
||
"use strict";
|
||
var Dr = Ui(), Hi = Object.prototype.hasOwnProperty, aI = Array.isArray, G = {
|
||
allowDots: !1,
|
||
allowEmptyArrays: !1,
|
||
allowPrototypes: !1,
|
||
allowSparse: !1,
|
||
arrayLimit: 20,
|
||
charset: "utf-8",
|
||
charsetSentinel: !1,
|
||
comma: !1,
|
||
decodeDotInKeys: !1,
|
||
decoder: Dr.decode,
|
||
delimiter: "&",
|
||
depth: 5,
|
||
duplicates: "combine",
|
||
ignoreQueryPrefix: !1,
|
||
interpretNumericEntities: !1,
|
||
parameterLimit: 1e3,
|
||
parseArrays: !0,
|
||
plainObjects: !1,
|
||
strictNullHandling: !1
|
||
}, iI = /* @__PURE__ */ n(function(r) {
|
||
return r.replace(/&#(\d+);/g, function(e, t) {
|
||
return String.fromCharCode(parseInt(t, 10));
|
||
});
|
||
}, "interpretNumericEntities"), Eh = /* @__PURE__ */ n(function(r, e) {
|
||
return r && typeof r == "string" && e.comma && r.indexOf(",") > -1 ? r.split(",") : r;
|
||
}, "parseArrayValue"), sI = "utf8=%26%2310003%3B", lI = "utf8=%E2%9C%93", cI = /* @__PURE__ */ n(function(e, t) {
|
||
var o = { __proto__: null }, a = t.ignoreQueryPrefix ? e.replace(/^\?/, "") : e;
|
||
a = a.replace(/%5B/gi, "[").replace(/%5D/gi, "]");
|
||
var i = t.parameterLimit === 1 / 0 ? void 0 : t.parameterLimit, s = a.split(t.delimiter, i), c = -1, l, u = t.charset;
|
||
if (t.charsetSentinel)
|
||
for (l = 0; l < s.length; ++l)
|
||
s[l].indexOf("utf8=") === 0 && (s[l] === lI ? u = "utf-8" : s[l] === sI && (u = "iso-8859-1"), c = l, l = s.length);
|
||
for (l = 0; l < s.length; ++l)
|
||
if (l !== c) {
|
||
var p = s[l], h = p.indexOf("]="), y = h === -1 ? p.indexOf("=") : h + 1, g, m;
|
||
y === -1 ? (g = t.decoder(p, G.decoder, u, "key"), m = t.strictNullHandling ? null : "") : (g = t.decoder(p.slice(0, y), G.decoder, u,
|
||
"key"), m = Dr.maybeMap(
|
||
Eh(p.slice(y + 1), t),
|
||
function(S) {
|
||
return t.decoder(S, G.decoder, u, "value");
|
||
}
|
||
)), m && t.interpretNumericEntities && u === "iso-8859-1" && (m = iI(m)), p.indexOf("[]=") > -1 && (m = aI(m) ? [m] : m);
|
||
var b = Hi.call(o, g);
|
||
b && t.duplicates === "combine" ? o[g] = Dr.combine(o[g], m) : (!b || t.duplicates === "last") && (o[g] = m);
|
||
}
|
||
return o;
|
||
}, "parseQueryStringValues"), uI = /* @__PURE__ */ n(function(r, e, t, o) {
|
||
for (var a = o ? e : Eh(e, t), i = r.length - 1; i >= 0; --i) {
|
||
var s, c = r[i];
|
||
if (c === "[]" && t.parseArrays)
|
||
s = t.allowEmptyArrays && (a === "" || t.strictNullHandling && a === null) ? [] : [].concat(a);
|
||
else {
|
||
s = t.plainObjects ? /* @__PURE__ */ Object.create(null) : {};
|
||
var l = c.charAt(0) === "[" && c.charAt(c.length - 1) === "]" ? c.slice(1, -1) : c, u = t.decodeDotInKeys ? l.replace(/%2E/g, ".") :
|
||
l, p = parseInt(u, 10);
|
||
!t.parseArrays && u === "" ? s = { 0: a } : !isNaN(p) && c !== u && String(p) === u && p >= 0 && t.parseArrays && p <= t.arrayLimit ?
|
||
(s = [], s[p] = a) : u !== "__proto__" && (s[u] = a);
|
||
}
|
||
a = s;
|
||
}
|
||
return a;
|
||
}, "parseObject"), pI = /* @__PURE__ */ n(function(e, t, o, a) {
|
||
if (e) {
|
||
var i = o.allowDots ? e.replace(/\.([^.[]+)/g, "[$1]") : e, s = /(\[[^[\]]*])/, c = /(\[[^[\]]*])/g, l = o.depth > 0 && s.exec(i), u = l ?
|
||
i.slice(0, l.index) : i, p = [];
|
||
if (u) {
|
||
if (!o.plainObjects && Hi.call(Object.prototype, u) && !o.allowPrototypes)
|
||
return;
|
||
p.push(u);
|
||
}
|
||
for (var h = 0; o.depth > 0 && (l = c.exec(i)) !== null && h < o.depth; ) {
|
||
if (h += 1, !o.plainObjects && Hi.call(Object.prototype, l[1].slice(1, -1)) && !o.allowPrototypes)
|
||
return;
|
||
p.push(l[1]);
|
||
}
|
||
return l && p.push("[" + i.slice(l.index) + "]"), uI(p, t, o, a);
|
||
}
|
||
}, "parseQueryStringKeys"), dI = /* @__PURE__ */ n(function(e) {
|
||
if (!e)
|
||
return G;
|
||
if (typeof e.allowEmptyArrays < "u" && typeof e.allowEmptyArrays != "boolean")
|
||
throw new TypeError("`allowEmptyArrays` option can only be `true` or `false`, when provided");
|
||
if (typeof e.decodeDotInKeys < "u" && typeof e.decodeDotInKeys != "boolean")
|
||
throw new TypeError("`decodeDotInKeys` option can only be `true` or `false`, when provided");
|
||
if (e.decoder !== null && typeof e.decoder < "u" && typeof e.decoder != "function")
|
||
throw new TypeError("Decoder has to be a function.");
|
||
if (typeof e.charset < "u" && e.charset !== "utf-8" && e.charset !== "iso-8859-1")
|
||
throw new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined");
|
||
var t = typeof e.charset > "u" ? G.charset : e.charset, o = typeof e.duplicates > "u" ? G.duplicates : e.duplicates;
|
||
if (o !== "combine" && o !== "first" && o !== "last")
|
||
throw new TypeError("The duplicates option must be either combine, first, or last");
|
||
var a = typeof e.allowDots > "u" ? e.decodeDotInKeys === !0 ? !0 : G.allowDots : !!e.allowDots;
|
||
return {
|
||
allowDots: a,
|
||
allowEmptyArrays: typeof e.allowEmptyArrays == "boolean" ? !!e.allowEmptyArrays : G.allowEmptyArrays,
|
||
allowPrototypes: typeof e.allowPrototypes == "boolean" ? e.allowPrototypes : G.allowPrototypes,
|
||
allowSparse: typeof e.allowSparse == "boolean" ? e.allowSparse : G.allowSparse,
|
||
arrayLimit: typeof e.arrayLimit == "number" ? e.arrayLimit : G.arrayLimit,
|
||
charset: t,
|
||
charsetSentinel: typeof e.charsetSentinel == "boolean" ? e.charsetSentinel : G.charsetSentinel,
|
||
comma: typeof e.comma == "boolean" ? e.comma : G.comma,
|
||
decodeDotInKeys: typeof e.decodeDotInKeys == "boolean" ? e.decodeDotInKeys : G.decodeDotInKeys,
|
||
decoder: typeof e.decoder == "function" ? e.decoder : G.decoder,
|
||
delimiter: typeof e.delimiter == "string" || Dr.isRegExp(e.delimiter) ? e.delimiter : G.delimiter,
|
||
// eslint-disable-next-line no-implicit-coercion, no-extra-parens
|
||
depth: typeof e.depth == "number" || e.depth === !1 ? +e.depth : G.depth,
|
||
duplicates: o,
|
||
ignoreQueryPrefix: e.ignoreQueryPrefix === !0,
|
||
interpretNumericEntities: typeof e.interpretNumericEntities == "boolean" ? e.interpretNumericEntities : G.interpretNumericEntities,
|
||
parameterLimit: typeof e.parameterLimit == "number" ? e.parameterLimit : G.parameterLimit,
|
||
parseArrays: e.parseArrays !== !1,
|
||
plainObjects: typeof e.plainObjects == "boolean" ? e.plainObjects : G.plainObjects,
|
||
strictNullHandling: typeof e.strictNullHandling == "boolean" ? e.strictNullHandling : G.strictNullHandling
|
||
};
|
||
}, "normalizeParseOptions");
|
||
Th.exports = function(r, e) {
|
||
var t = dI(e);
|
||
if (r === "" || r === null || typeof r > "u")
|
||
return t.plainObjects ? /* @__PURE__ */ Object.create(null) : {};
|
||
for (var o = typeof r == "string" ? cI(r, t) : r, a = t.plainObjects ? /* @__PURE__ */ Object.create(null) : {}, i = Object.keys(o), s = 0; s <
|
||
i.length; ++s) {
|
||
var c = i[s], l = pI(c, o[c], t, typeof r == "string");
|
||
a = Dr.merge(a, l, t);
|
||
}
|
||
return t.allowSparse === !0 ? a : Dr.compact(a);
|
||
};
|
||
});
|
||
|
||
// ../node_modules/qs/lib/index.js
|
||
var Ho = d((pB, Ah) => {
|
||
"use strict";
|
||
var fI = vh(), yI = Rh(), hI = Uo();
|
||
Ah.exports = {
|
||
formats: hI,
|
||
parse: yI,
|
||
stringify: fI
|
||
};
|
||
});
|
||
|
||
// ../node_modules/ansi-to-html/node_modules/entities/lib/maps/entities.json
|
||
var zi = d((vB, TI) => {
|
||
TI.exports = { Aacute: "\xC1", aacute: "\xE1", Abreve: "\u0102", abreve: "\u0103", ac: "\u223E", acd: "\u223F", acE: "\u223E\u0333", Acirc: "\
|
||
\xC2", acirc: "\xE2", acute: "\xB4", Acy: "\u0410", acy: "\u0430", AElig: "\xC6", aelig: "\xE6", af: "\u2061", Afr: "\u{1D504}", afr: "\u{1D51E}",
|
||
Agrave: "\xC0", agrave: "\xE0", alefsym: "\u2135", aleph: "\u2135", Alpha: "\u0391", alpha: "\u03B1", Amacr: "\u0100", amacr: "\u0101", amalg: "\
|
||
\u2A3F", amp: "&", AMP: "&", andand: "\u2A55", And: "\u2A53", and: "\u2227", andd: "\u2A5C", andslope: "\u2A58", andv: "\u2A5A", ang: "\u2220",
|
||
ange: "\u29A4", angle: "\u2220", angmsdaa: "\u29A8", angmsdab: "\u29A9", angmsdac: "\u29AA", angmsdad: "\u29AB", angmsdae: "\u29AC", angmsdaf: "\
|
||
\u29AD", angmsdag: "\u29AE", angmsdah: "\u29AF", angmsd: "\u2221", angrt: "\u221F", angrtvb: "\u22BE", angrtvbd: "\u299D", angsph: "\u2222",
|
||
angst: "\xC5", angzarr: "\u237C", Aogon: "\u0104", aogon: "\u0105", Aopf: "\u{1D538}", aopf: "\u{1D552}", apacir: "\u2A6F", ap: "\u2248", apE: "\
|
||
\u2A70", ape: "\u224A", apid: "\u224B", apos: "'", ApplyFunction: "\u2061", approx: "\u2248", approxeq: "\u224A", Aring: "\xC5", aring: "\xE5",
|
||
Ascr: "\u{1D49C}", ascr: "\u{1D4B6}", Assign: "\u2254", ast: "*", asymp: "\u2248", asympeq: "\u224D", Atilde: "\xC3", atilde: "\xE3", Auml: "\
|
||
\xC4", auml: "\xE4", awconint: "\u2233", awint: "\u2A11", backcong: "\u224C", backepsilon: "\u03F6", backprime: "\u2035", backsim: "\u223D",
|
||
backsimeq: "\u22CD", Backslash: "\u2216", Barv: "\u2AE7", barvee: "\u22BD", barwed: "\u2305", Barwed: "\u2306", barwedge: "\u2305", bbrk: "\
|
||
\u23B5", bbrktbrk: "\u23B6", bcong: "\u224C", Bcy: "\u0411", bcy: "\u0431", bdquo: "\u201E", becaus: "\u2235", because: "\u2235", Because: "\
|
||
\u2235", bemptyv: "\u29B0", bepsi: "\u03F6", bernou: "\u212C", Bernoullis: "\u212C", Beta: "\u0392", beta: "\u03B2", beth: "\u2136", between: "\
|
||
\u226C", Bfr: "\u{1D505}", bfr: "\u{1D51F}", bigcap: "\u22C2", bigcirc: "\u25EF", bigcup: "\u22C3", bigodot: "\u2A00", bigoplus: "\u2A01", bigotimes: "\
|
||
\u2A02", bigsqcup: "\u2A06", bigstar: "\u2605", bigtriangledown: "\u25BD", bigtriangleup: "\u25B3", biguplus: "\u2A04", bigvee: "\u22C1", bigwedge: "\
|
||
\u22C0", bkarow: "\u290D", blacklozenge: "\u29EB", blacksquare: "\u25AA", blacktriangle: "\u25B4", blacktriangledown: "\u25BE", blacktriangleleft: "\
|
||
\u25C2", blacktriangleright: "\u25B8", blank: "\u2423", blk12: "\u2592", blk14: "\u2591", blk34: "\u2593", block: "\u2588", bne: "=\u20E5", bnequiv: "\
|
||
\u2261\u20E5", bNot: "\u2AED", bnot: "\u2310", Bopf: "\u{1D539}", bopf: "\u{1D553}", bot: "\u22A5", bottom: "\u22A5", bowtie: "\u22C8", boxbox: "\
|
||
\u29C9", boxdl: "\u2510", boxdL: "\u2555", boxDl: "\u2556", boxDL: "\u2557", boxdr: "\u250C", boxdR: "\u2552", boxDr: "\u2553", boxDR: "\u2554",
|
||
boxh: "\u2500", boxH: "\u2550", boxhd: "\u252C", boxHd: "\u2564", boxhD: "\u2565", boxHD: "\u2566", boxhu: "\u2534", boxHu: "\u2567", boxhU: "\
|
||
\u2568", boxHU: "\u2569", boxminus: "\u229F", boxplus: "\u229E", boxtimes: "\u22A0", boxul: "\u2518", boxuL: "\u255B", boxUl: "\u255C", boxUL: "\
|
||
\u255D", boxur: "\u2514", boxuR: "\u2558", boxUr: "\u2559", boxUR: "\u255A", boxv: "\u2502", boxV: "\u2551", boxvh: "\u253C", boxvH: "\u256A",
|
||
boxVh: "\u256B", boxVH: "\u256C", boxvl: "\u2524", boxvL: "\u2561", boxVl: "\u2562", boxVL: "\u2563", boxvr: "\u251C", boxvR: "\u255E", boxVr: "\
|
||
\u255F", boxVR: "\u2560", bprime: "\u2035", breve: "\u02D8", Breve: "\u02D8", brvbar: "\xA6", bscr: "\u{1D4B7}", Bscr: "\u212C", bsemi: "\u204F",
|
||
bsim: "\u223D", bsime: "\u22CD", bsolb: "\u29C5", bsol: "\\", bsolhsub: "\u27C8", bull: "\u2022", bullet: "\u2022", bump: "\u224E", bumpE: "\
|
||
\u2AAE", bumpe: "\u224F", Bumpeq: "\u224E", bumpeq: "\u224F", Cacute: "\u0106", cacute: "\u0107", capand: "\u2A44", capbrcup: "\u2A49", capcap: "\
|
||
\u2A4B", cap: "\u2229", Cap: "\u22D2", capcup: "\u2A47", capdot: "\u2A40", CapitalDifferentialD: "\u2145", caps: "\u2229\uFE00", caret: "\u2041",
|
||
caron: "\u02C7", Cayleys: "\u212D", ccaps: "\u2A4D", Ccaron: "\u010C", ccaron: "\u010D", Ccedil: "\xC7", ccedil: "\xE7", Ccirc: "\u0108", ccirc: "\
|
||
\u0109", Cconint: "\u2230", ccups: "\u2A4C", ccupssm: "\u2A50", Cdot: "\u010A", cdot: "\u010B", cedil: "\xB8", Cedilla: "\xB8", cemptyv: "\u29B2",
|
||
cent: "\xA2", centerdot: "\xB7", CenterDot: "\xB7", cfr: "\u{1D520}", Cfr: "\u212D", CHcy: "\u0427", chcy: "\u0447", check: "\u2713", checkmark: "\
|
||
\u2713", Chi: "\u03A7", chi: "\u03C7", circ: "\u02C6", circeq: "\u2257", circlearrowleft: "\u21BA", circlearrowright: "\u21BB", circledast: "\
|
||
\u229B", circledcirc: "\u229A", circleddash: "\u229D", CircleDot: "\u2299", circledR: "\xAE", circledS: "\u24C8", CircleMinus: "\u2296", CirclePlus: "\
|
||
\u2295", CircleTimes: "\u2297", cir: "\u25CB", cirE: "\u29C3", cire: "\u2257", cirfnint: "\u2A10", cirmid: "\u2AEF", cirscir: "\u29C2", ClockwiseContourIntegral: "\
|
||
\u2232", CloseCurlyDoubleQuote: "\u201D", CloseCurlyQuote: "\u2019", clubs: "\u2663", clubsuit: "\u2663", colon: ":", Colon: "\u2237", Colone: "\
|
||
\u2A74", colone: "\u2254", coloneq: "\u2254", comma: ",", commat: "@", comp: "\u2201", compfn: "\u2218", complement: "\u2201", complexes: "\u2102",
|
||
cong: "\u2245", congdot: "\u2A6D", Congruent: "\u2261", conint: "\u222E", Conint: "\u222F", ContourIntegral: "\u222E", copf: "\u{1D554}", Copf: "\
|
||
\u2102", coprod: "\u2210", Coproduct: "\u2210", copy: "\xA9", COPY: "\xA9", copysr: "\u2117", CounterClockwiseContourIntegral: "\u2233", crarr: "\
|
||
\u21B5", cross: "\u2717", Cross: "\u2A2F", Cscr: "\u{1D49E}", cscr: "\u{1D4B8}", csub: "\u2ACF", csube: "\u2AD1", csup: "\u2AD0", csupe: "\u2AD2",
|
||
ctdot: "\u22EF", cudarrl: "\u2938", cudarrr: "\u2935", cuepr: "\u22DE", cuesc: "\u22DF", cularr: "\u21B6", cularrp: "\u293D", cupbrcap: "\u2A48",
|
||
cupcap: "\u2A46", CupCap: "\u224D", cup: "\u222A", Cup: "\u22D3", cupcup: "\u2A4A", cupdot: "\u228D", cupor: "\u2A45", cups: "\u222A\uFE00",
|
||
curarr: "\u21B7", curarrm: "\u293C", curlyeqprec: "\u22DE", curlyeqsucc: "\u22DF", curlyvee: "\u22CE", curlywedge: "\u22CF", curren: "\xA4",
|
||
curvearrowleft: "\u21B6", curvearrowright: "\u21B7", cuvee: "\u22CE", cuwed: "\u22CF", cwconint: "\u2232", cwint: "\u2231", cylcty: "\u232D",
|
||
dagger: "\u2020", Dagger: "\u2021", daleth: "\u2138", darr: "\u2193", Darr: "\u21A1", dArr: "\u21D3", dash: "\u2010", Dashv: "\u2AE4", dashv: "\
|
||
\u22A3", dbkarow: "\u290F", dblac: "\u02DD", Dcaron: "\u010E", dcaron: "\u010F", Dcy: "\u0414", dcy: "\u0434", ddagger: "\u2021", ddarr: "\u21CA",
|
||
DD: "\u2145", dd: "\u2146", DDotrahd: "\u2911", ddotseq: "\u2A77", deg: "\xB0", Del: "\u2207", Delta: "\u0394", delta: "\u03B4", demptyv: "\
|
||
\u29B1", dfisht: "\u297F", Dfr: "\u{1D507}", dfr: "\u{1D521}", dHar: "\u2965", dharl: "\u21C3", dharr: "\u21C2", DiacriticalAcute: "\xB4", DiacriticalDot: "\
|
||
\u02D9", DiacriticalDoubleAcute: "\u02DD", DiacriticalGrave: "`", DiacriticalTilde: "\u02DC", diam: "\u22C4", diamond: "\u22C4", Diamond: "\u22C4",
|
||
diamondsuit: "\u2666", diams: "\u2666", die: "\xA8", DifferentialD: "\u2146", digamma: "\u03DD", disin: "\u22F2", div: "\xF7", divide: "\xF7",
|
||
divideontimes: "\u22C7", divonx: "\u22C7", DJcy: "\u0402", djcy: "\u0452", dlcorn: "\u231E", dlcrop: "\u230D", dollar: "$", Dopf: "\u{1D53B}",
|
||
dopf: "\u{1D555}", Dot: "\xA8", dot: "\u02D9", DotDot: "\u20DC", doteq: "\u2250", doteqdot: "\u2251", DotEqual: "\u2250", dotminus: "\u2238",
|
||
dotplus: "\u2214", dotsquare: "\u22A1", doublebarwedge: "\u2306", DoubleContourIntegral: "\u222F", DoubleDot: "\xA8", DoubleDownArrow: "\u21D3",
|
||
DoubleLeftArrow: "\u21D0", DoubleLeftRightArrow: "\u21D4", DoubleLeftTee: "\u2AE4", DoubleLongLeftArrow: "\u27F8", DoubleLongLeftRightArrow: "\
|
||
\u27FA", DoubleLongRightArrow: "\u27F9", DoubleRightArrow: "\u21D2", DoubleRightTee: "\u22A8", DoubleUpArrow: "\u21D1", DoubleUpDownArrow: "\
|
||
\u21D5", DoubleVerticalBar: "\u2225", DownArrowBar: "\u2913", downarrow: "\u2193", DownArrow: "\u2193", Downarrow: "\u21D3", DownArrowUpArrow: "\
|
||
\u21F5", DownBreve: "\u0311", downdownarrows: "\u21CA", downharpoonleft: "\u21C3", downharpoonright: "\u21C2", DownLeftRightVector: "\u2950",
|
||
DownLeftTeeVector: "\u295E", DownLeftVectorBar: "\u2956", DownLeftVector: "\u21BD", DownRightTeeVector: "\u295F", DownRightVectorBar: "\u2957",
|
||
DownRightVector: "\u21C1", DownTeeArrow: "\u21A7", DownTee: "\u22A4", drbkarow: "\u2910", drcorn: "\u231F", drcrop: "\u230C", Dscr: "\u{1D49F}",
|
||
dscr: "\u{1D4B9}", DScy: "\u0405", dscy: "\u0455", dsol: "\u29F6", Dstrok: "\u0110", dstrok: "\u0111", dtdot: "\u22F1", dtri: "\u25BF", dtrif: "\
|
||
\u25BE", duarr: "\u21F5", duhar: "\u296F", dwangle: "\u29A6", DZcy: "\u040F", dzcy: "\u045F", dzigrarr: "\u27FF", Eacute: "\xC9", eacute: "\xE9",
|
||
easter: "\u2A6E", Ecaron: "\u011A", ecaron: "\u011B", Ecirc: "\xCA", ecirc: "\xEA", ecir: "\u2256", ecolon: "\u2255", Ecy: "\u042D", ecy: "\
|
||
\u044D", eDDot: "\u2A77", Edot: "\u0116", edot: "\u0117", eDot: "\u2251", ee: "\u2147", efDot: "\u2252", Efr: "\u{1D508}", efr: "\u{1D522}",
|
||
eg: "\u2A9A", Egrave: "\xC8", egrave: "\xE8", egs: "\u2A96", egsdot: "\u2A98", el: "\u2A99", Element: "\u2208", elinters: "\u23E7", ell: "\
|
||
\u2113", els: "\u2A95", elsdot: "\u2A97", Emacr: "\u0112", emacr: "\u0113", empty: "\u2205", emptyset: "\u2205", EmptySmallSquare: "\u25FB",
|
||
emptyv: "\u2205", EmptyVerySmallSquare: "\u25AB", emsp13: "\u2004", emsp14: "\u2005", emsp: "\u2003", ENG: "\u014A", eng: "\u014B", ensp: "\
|
||
\u2002", Eogon: "\u0118", eogon: "\u0119", Eopf: "\u{1D53C}", eopf: "\u{1D556}", epar: "\u22D5", eparsl: "\u29E3", eplus: "\u2A71", epsi: "\u03B5",
|
||
Epsilon: "\u0395", epsilon: "\u03B5", epsiv: "\u03F5", eqcirc: "\u2256", eqcolon: "\u2255", eqsim: "\u2242", eqslantgtr: "\u2A96", eqslantless: "\
|
||
\u2A95", Equal: "\u2A75", equals: "=", EqualTilde: "\u2242", equest: "\u225F", Equilibrium: "\u21CC", equiv: "\u2261", equivDD: "\u2A78", eqvparsl: "\
|
||
\u29E5", erarr: "\u2971", erDot: "\u2253", escr: "\u212F", Escr: "\u2130", esdot: "\u2250", Esim: "\u2A73", esim: "\u2242", Eta: "\u0397", eta: "\
|
||
\u03B7", ETH: "\xD0", eth: "\xF0", Euml: "\xCB", euml: "\xEB", euro: "\u20AC", excl: "!", exist: "\u2203", Exists: "\u2203", expectation: "\u2130",
|
||
exponentiale: "\u2147", ExponentialE: "\u2147", fallingdotseq: "\u2252", Fcy: "\u0424", fcy: "\u0444", female: "\u2640", ffilig: "\uFB03",
|
||
fflig: "\uFB00", ffllig: "\uFB04", Ffr: "\u{1D509}", ffr: "\u{1D523}", filig: "\uFB01", FilledSmallSquare: "\u25FC", FilledVerySmallSquare: "\
|
||
\u25AA", fjlig: "fj", flat: "\u266D", fllig: "\uFB02", fltns: "\u25B1", fnof: "\u0192", Fopf: "\u{1D53D}", fopf: "\u{1D557}", forall: "\u2200",
|
||
ForAll: "\u2200", fork: "\u22D4", forkv: "\u2AD9", Fouriertrf: "\u2131", fpartint: "\u2A0D", frac12: "\xBD", frac13: "\u2153", frac14: "\xBC",
|
||
frac15: "\u2155", frac16: "\u2159", frac18: "\u215B", frac23: "\u2154", frac25: "\u2156", frac34: "\xBE", frac35: "\u2157", frac38: "\u215C",
|
||
frac45: "\u2158", frac56: "\u215A", frac58: "\u215D", frac78: "\u215E", frasl: "\u2044", frown: "\u2322", fscr: "\u{1D4BB}", Fscr: "\u2131",
|
||
gacute: "\u01F5", Gamma: "\u0393", gamma: "\u03B3", Gammad: "\u03DC", gammad: "\u03DD", gap: "\u2A86", Gbreve: "\u011E", gbreve: "\u011F",
|
||
Gcedil: "\u0122", Gcirc: "\u011C", gcirc: "\u011D", Gcy: "\u0413", gcy: "\u0433", Gdot: "\u0120", gdot: "\u0121", ge: "\u2265", gE: "\u2267",
|
||
gEl: "\u2A8C", gel: "\u22DB", geq: "\u2265", geqq: "\u2267", geqslant: "\u2A7E", gescc: "\u2AA9", ges: "\u2A7E", gesdot: "\u2A80", gesdoto: "\
|
||
\u2A82", gesdotol: "\u2A84", gesl: "\u22DB\uFE00", gesles: "\u2A94", Gfr: "\u{1D50A}", gfr: "\u{1D524}", gg: "\u226B", Gg: "\u22D9", ggg: "\u22D9",
|
||
gimel: "\u2137", GJcy: "\u0403", gjcy: "\u0453", gla: "\u2AA5", gl: "\u2277", glE: "\u2A92", glj: "\u2AA4", gnap: "\u2A8A", gnapprox: "\u2A8A",
|
||
gne: "\u2A88", gnE: "\u2269", gneq: "\u2A88", gneqq: "\u2269", gnsim: "\u22E7", Gopf: "\u{1D53E}", gopf: "\u{1D558}", grave: "`", GreaterEqual: "\
|
||
\u2265", GreaterEqualLess: "\u22DB", GreaterFullEqual: "\u2267", GreaterGreater: "\u2AA2", GreaterLess: "\u2277", GreaterSlantEqual: "\u2A7E",
|
||
GreaterTilde: "\u2273", Gscr: "\u{1D4A2}", gscr: "\u210A", gsim: "\u2273", gsime: "\u2A8E", gsiml: "\u2A90", gtcc: "\u2AA7", gtcir: "\u2A7A",
|
||
gt: ">", GT: ">", Gt: "\u226B", gtdot: "\u22D7", gtlPar: "\u2995", gtquest: "\u2A7C", gtrapprox: "\u2A86", gtrarr: "\u2978", gtrdot: "\u22D7",
|
||
gtreqless: "\u22DB", gtreqqless: "\u2A8C", gtrless: "\u2277", gtrsim: "\u2273", gvertneqq: "\u2269\uFE00", gvnE: "\u2269\uFE00", Hacek: "\u02C7",
|
||
hairsp: "\u200A", half: "\xBD", hamilt: "\u210B", HARDcy: "\u042A", hardcy: "\u044A", harrcir: "\u2948", harr: "\u2194", hArr: "\u21D4", harrw: "\
|
||
\u21AD", Hat: "^", hbar: "\u210F", Hcirc: "\u0124", hcirc: "\u0125", hearts: "\u2665", heartsuit: "\u2665", hellip: "\u2026", hercon: "\u22B9",
|
||
hfr: "\u{1D525}", Hfr: "\u210C", HilbertSpace: "\u210B", hksearow: "\u2925", hkswarow: "\u2926", hoarr: "\u21FF", homtht: "\u223B", hookleftarrow: "\
|
||
\u21A9", hookrightarrow: "\u21AA", hopf: "\u{1D559}", Hopf: "\u210D", horbar: "\u2015", HorizontalLine: "\u2500", hscr: "\u{1D4BD}", Hscr: "\
|
||
\u210B", hslash: "\u210F", Hstrok: "\u0126", hstrok: "\u0127", HumpDownHump: "\u224E", HumpEqual: "\u224F", hybull: "\u2043", hyphen: "\u2010",
|
||
Iacute: "\xCD", iacute: "\xED", ic: "\u2063", Icirc: "\xCE", icirc: "\xEE", Icy: "\u0418", icy: "\u0438", Idot: "\u0130", IEcy: "\u0415", iecy: "\
|
||
\u0435", iexcl: "\xA1", iff: "\u21D4", ifr: "\u{1D526}", Ifr: "\u2111", Igrave: "\xCC", igrave: "\xEC", ii: "\u2148", iiiint: "\u2A0C", iiint: "\
|
||
\u222D", iinfin: "\u29DC", iiota: "\u2129", IJlig: "\u0132", ijlig: "\u0133", Imacr: "\u012A", imacr: "\u012B", image: "\u2111", ImaginaryI: "\
|
||
\u2148", imagline: "\u2110", imagpart: "\u2111", imath: "\u0131", Im: "\u2111", imof: "\u22B7", imped: "\u01B5", Implies: "\u21D2", incare: "\
|
||
\u2105", in: "\u2208", infin: "\u221E", infintie: "\u29DD", inodot: "\u0131", intcal: "\u22BA", int: "\u222B", Int: "\u222C", integers: "\u2124",
|
||
Integral: "\u222B", intercal: "\u22BA", Intersection: "\u22C2", intlarhk: "\u2A17", intprod: "\u2A3C", InvisibleComma: "\u2063", InvisibleTimes: "\
|
||
\u2062", IOcy: "\u0401", iocy: "\u0451", Iogon: "\u012E", iogon: "\u012F", Iopf: "\u{1D540}", iopf: "\u{1D55A}", Iota: "\u0399", iota: "\u03B9",
|
||
iprod: "\u2A3C", iquest: "\xBF", iscr: "\u{1D4BE}", Iscr: "\u2110", isin: "\u2208", isindot: "\u22F5", isinE: "\u22F9", isins: "\u22F4", isinsv: "\
|
||
\u22F3", isinv: "\u2208", it: "\u2062", Itilde: "\u0128", itilde: "\u0129", Iukcy: "\u0406", iukcy: "\u0456", Iuml: "\xCF", iuml: "\xEF", Jcirc: "\
|
||
\u0134", jcirc: "\u0135", Jcy: "\u0419", jcy: "\u0439", Jfr: "\u{1D50D}", jfr: "\u{1D527}", jmath: "\u0237", Jopf: "\u{1D541}", jopf: "\u{1D55B}",
|
||
Jscr: "\u{1D4A5}", jscr: "\u{1D4BF}", Jsercy: "\u0408", jsercy: "\u0458", Jukcy: "\u0404", jukcy: "\u0454", Kappa: "\u039A", kappa: "\u03BA",
|
||
kappav: "\u03F0", Kcedil: "\u0136", kcedil: "\u0137", Kcy: "\u041A", kcy: "\u043A", Kfr: "\u{1D50E}", kfr: "\u{1D528}", kgreen: "\u0138", KHcy: "\
|
||
\u0425", khcy: "\u0445", KJcy: "\u040C", kjcy: "\u045C", Kopf: "\u{1D542}", kopf: "\u{1D55C}", Kscr: "\u{1D4A6}", kscr: "\u{1D4C0}", lAarr: "\
|
||
\u21DA", Lacute: "\u0139", lacute: "\u013A", laemptyv: "\u29B4", lagran: "\u2112", Lambda: "\u039B", lambda: "\u03BB", lang: "\u27E8", Lang: "\
|
||
\u27EA", langd: "\u2991", langle: "\u27E8", lap: "\u2A85", Laplacetrf: "\u2112", laquo: "\xAB", larrb: "\u21E4", larrbfs: "\u291F", larr: "\u2190",
|
||
Larr: "\u219E", lArr: "\u21D0", larrfs: "\u291D", larrhk: "\u21A9", larrlp: "\u21AB", larrpl: "\u2939", larrsim: "\u2973", larrtl: "\u21A2",
|
||
latail: "\u2919", lAtail: "\u291B", lat: "\u2AAB", late: "\u2AAD", lates: "\u2AAD\uFE00", lbarr: "\u290C", lBarr: "\u290E", lbbrk: "\u2772",
|
||
lbrace: "{", lbrack: "[", lbrke: "\u298B", lbrksld: "\u298F", lbrkslu: "\u298D", Lcaron: "\u013D", lcaron: "\u013E", Lcedil: "\u013B", lcedil: "\
|
||
\u013C", lceil: "\u2308", lcub: "{", Lcy: "\u041B", lcy: "\u043B", ldca: "\u2936", ldquo: "\u201C", ldquor: "\u201E", ldrdhar: "\u2967", ldrushar: "\
|
||
\u294B", ldsh: "\u21B2", le: "\u2264", lE: "\u2266", LeftAngleBracket: "\u27E8", LeftArrowBar: "\u21E4", leftarrow: "\u2190", LeftArrow: "\u2190",
|
||
Leftarrow: "\u21D0", LeftArrowRightArrow: "\u21C6", leftarrowtail: "\u21A2", LeftCeiling: "\u2308", LeftDoubleBracket: "\u27E6", LeftDownTeeVector: "\
|
||
\u2961", LeftDownVectorBar: "\u2959", LeftDownVector: "\u21C3", LeftFloor: "\u230A", leftharpoondown: "\u21BD", leftharpoonup: "\u21BC", leftleftarrows: "\
|
||
\u21C7", leftrightarrow: "\u2194", LeftRightArrow: "\u2194", Leftrightarrow: "\u21D4", leftrightarrows: "\u21C6", leftrightharpoons: "\u21CB",
|
||
leftrightsquigarrow: "\u21AD", LeftRightVector: "\u294E", LeftTeeArrow: "\u21A4", LeftTee: "\u22A3", LeftTeeVector: "\u295A", leftthreetimes: "\
|
||
\u22CB", LeftTriangleBar: "\u29CF", LeftTriangle: "\u22B2", LeftTriangleEqual: "\u22B4", LeftUpDownVector: "\u2951", LeftUpTeeVector: "\u2960",
|
||
LeftUpVectorBar: "\u2958", LeftUpVector: "\u21BF", LeftVectorBar: "\u2952", LeftVector: "\u21BC", lEg: "\u2A8B", leg: "\u22DA", leq: "\u2264",
|
||
leqq: "\u2266", leqslant: "\u2A7D", lescc: "\u2AA8", les: "\u2A7D", lesdot: "\u2A7F", lesdoto: "\u2A81", lesdotor: "\u2A83", lesg: "\u22DA\uFE00",
|
||
lesges: "\u2A93", lessapprox: "\u2A85", lessdot: "\u22D6", lesseqgtr: "\u22DA", lesseqqgtr: "\u2A8B", LessEqualGreater: "\u22DA", LessFullEqual: "\
|
||
\u2266", LessGreater: "\u2276", lessgtr: "\u2276", LessLess: "\u2AA1", lesssim: "\u2272", LessSlantEqual: "\u2A7D", LessTilde: "\u2272", lfisht: "\
|
||
\u297C", lfloor: "\u230A", Lfr: "\u{1D50F}", lfr: "\u{1D529}", lg: "\u2276", lgE: "\u2A91", lHar: "\u2962", lhard: "\u21BD", lharu: "\u21BC",
|
||
lharul: "\u296A", lhblk: "\u2584", LJcy: "\u0409", ljcy: "\u0459", llarr: "\u21C7", ll: "\u226A", Ll: "\u22D8", llcorner: "\u231E", Lleftarrow: "\
|
||
\u21DA", llhard: "\u296B", lltri: "\u25FA", Lmidot: "\u013F", lmidot: "\u0140", lmoustache: "\u23B0", lmoust: "\u23B0", lnap: "\u2A89", lnapprox: "\
|
||
\u2A89", lne: "\u2A87", lnE: "\u2268", lneq: "\u2A87", lneqq: "\u2268", lnsim: "\u22E6", loang: "\u27EC", loarr: "\u21FD", lobrk: "\u27E6", longleftarrow: "\
|
||
\u27F5", LongLeftArrow: "\u27F5", Longleftarrow: "\u27F8", longleftrightarrow: "\u27F7", LongLeftRightArrow: "\u27F7", Longleftrightarrow: "\
|
||
\u27FA", longmapsto: "\u27FC", longrightarrow: "\u27F6", LongRightArrow: "\u27F6", Longrightarrow: "\u27F9", looparrowleft: "\u21AB", looparrowright: "\
|
||
\u21AC", lopar: "\u2985", Lopf: "\u{1D543}", lopf: "\u{1D55D}", loplus: "\u2A2D", lotimes: "\u2A34", lowast: "\u2217", lowbar: "_", LowerLeftArrow: "\
|
||
\u2199", LowerRightArrow: "\u2198", loz: "\u25CA", lozenge: "\u25CA", lozf: "\u29EB", lpar: "(", lparlt: "\u2993", lrarr: "\u21C6", lrcorner: "\
|
||
\u231F", lrhar: "\u21CB", lrhard: "\u296D", lrm: "\u200E", lrtri: "\u22BF", lsaquo: "\u2039", lscr: "\u{1D4C1}", Lscr: "\u2112", lsh: "\u21B0",
|
||
Lsh: "\u21B0", lsim: "\u2272", lsime: "\u2A8D", lsimg: "\u2A8F", lsqb: "[", lsquo: "\u2018", lsquor: "\u201A", Lstrok: "\u0141", lstrok: "\
|
||
\u0142", ltcc: "\u2AA6", ltcir: "\u2A79", lt: "<", LT: "<", Lt: "\u226A", ltdot: "\u22D6", lthree: "\u22CB", ltimes: "\u22C9", ltlarr: "\u2976",
|
||
ltquest: "\u2A7B", ltri: "\u25C3", ltrie: "\u22B4", ltrif: "\u25C2", ltrPar: "\u2996", lurdshar: "\u294A", luruhar: "\u2966", lvertneqq: "\
|
||
\u2268\uFE00", lvnE: "\u2268\uFE00", macr: "\xAF", male: "\u2642", malt: "\u2720", maltese: "\u2720", Map: "\u2905", map: "\u21A6", mapsto: "\
|
||
\u21A6", mapstodown: "\u21A7", mapstoleft: "\u21A4", mapstoup: "\u21A5", marker: "\u25AE", mcomma: "\u2A29", Mcy: "\u041C", mcy: "\u043C", mdash: "\
|
||
\u2014", mDDot: "\u223A", measuredangle: "\u2221", MediumSpace: "\u205F", Mellintrf: "\u2133", Mfr: "\u{1D510}", mfr: "\u{1D52A}", mho: "\u2127",
|
||
micro: "\xB5", midast: "*", midcir: "\u2AF0", mid: "\u2223", middot: "\xB7", minusb: "\u229F", minus: "\u2212", minusd: "\u2238", minusdu: "\
|
||
\u2A2A", MinusPlus: "\u2213", mlcp: "\u2ADB", mldr: "\u2026", mnplus: "\u2213", models: "\u22A7", Mopf: "\u{1D544}", mopf: "\u{1D55E}", mp: "\
|
||
\u2213", mscr: "\u{1D4C2}", Mscr: "\u2133", mstpos: "\u223E", Mu: "\u039C", mu: "\u03BC", multimap: "\u22B8", mumap: "\u22B8", nabla: "\u2207",
|
||
Nacute: "\u0143", nacute: "\u0144", nang: "\u2220\u20D2", nap: "\u2249", napE: "\u2A70\u0338", napid: "\u224B\u0338", napos: "\u0149", napprox: "\
|
||
\u2249", natural: "\u266E", naturals: "\u2115", natur: "\u266E", nbsp: "\xA0", nbump: "\u224E\u0338", nbumpe: "\u224F\u0338", ncap: "\u2A43",
|
||
Ncaron: "\u0147", ncaron: "\u0148", Ncedil: "\u0145", ncedil: "\u0146", ncong: "\u2247", ncongdot: "\u2A6D\u0338", ncup: "\u2A42", Ncy: "\u041D",
|
||
ncy: "\u043D", ndash: "\u2013", nearhk: "\u2924", nearr: "\u2197", neArr: "\u21D7", nearrow: "\u2197", ne: "\u2260", nedot: "\u2250\u0338",
|
||
NegativeMediumSpace: "\u200B", NegativeThickSpace: "\u200B", NegativeThinSpace: "\u200B", NegativeVeryThinSpace: "\u200B", nequiv: "\u2262",
|
||
nesear: "\u2928", nesim: "\u2242\u0338", NestedGreaterGreater: "\u226B", NestedLessLess: "\u226A", NewLine: `
|
||
`, nexist: "\u2204", nexists: "\u2204", Nfr: "\u{1D511}", nfr: "\u{1D52B}", ngE: "\u2267\u0338", nge: "\u2271", ngeq: "\u2271", ngeqq: "\u2267\u0338",
|
||
ngeqslant: "\u2A7E\u0338", nges: "\u2A7E\u0338", nGg: "\u22D9\u0338", ngsim: "\u2275", nGt: "\u226B\u20D2", ngt: "\u226F", ngtr: "\u226F",
|
||
nGtv: "\u226B\u0338", nharr: "\u21AE", nhArr: "\u21CE", nhpar: "\u2AF2", ni: "\u220B", nis: "\u22FC", nisd: "\u22FA", niv: "\u220B", NJcy: "\
|
||
\u040A", njcy: "\u045A", nlarr: "\u219A", nlArr: "\u21CD", nldr: "\u2025", nlE: "\u2266\u0338", nle: "\u2270", nleftarrow: "\u219A", nLeftarrow: "\
|
||
\u21CD", nleftrightarrow: "\u21AE", nLeftrightarrow: "\u21CE", nleq: "\u2270", nleqq: "\u2266\u0338", nleqslant: "\u2A7D\u0338", nles: "\u2A7D\u0338",
|
||
nless: "\u226E", nLl: "\u22D8\u0338", nlsim: "\u2274", nLt: "\u226A\u20D2", nlt: "\u226E", nltri: "\u22EA", nltrie: "\u22EC", nLtv: "\u226A\u0338",
|
||
nmid: "\u2224", NoBreak: "\u2060", NonBreakingSpace: "\xA0", nopf: "\u{1D55F}", Nopf: "\u2115", Not: "\u2AEC", not: "\xAC", NotCongruent: "\
|
||
\u2262", NotCupCap: "\u226D", NotDoubleVerticalBar: "\u2226", NotElement: "\u2209", NotEqual: "\u2260", NotEqualTilde: "\u2242\u0338", NotExists: "\
|
||
\u2204", NotGreater: "\u226F", NotGreaterEqual: "\u2271", NotGreaterFullEqual: "\u2267\u0338", NotGreaterGreater: "\u226B\u0338", NotGreaterLess: "\
|
||
\u2279", NotGreaterSlantEqual: "\u2A7E\u0338", NotGreaterTilde: "\u2275", NotHumpDownHump: "\u224E\u0338", NotHumpEqual: "\u224F\u0338", notin: "\
|
||
\u2209", notindot: "\u22F5\u0338", notinE: "\u22F9\u0338", notinva: "\u2209", notinvb: "\u22F7", notinvc: "\u22F6", NotLeftTriangleBar: "\u29CF\u0338",
|
||
NotLeftTriangle: "\u22EA", NotLeftTriangleEqual: "\u22EC", NotLess: "\u226E", NotLessEqual: "\u2270", NotLessGreater: "\u2278", NotLessLess: "\
|
||
\u226A\u0338", NotLessSlantEqual: "\u2A7D\u0338", NotLessTilde: "\u2274", NotNestedGreaterGreater: "\u2AA2\u0338", NotNestedLessLess: "\u2AA1\u0338",
|
||
notni: "\u220C", notniva: "\u220C", notnivb: "\u22FE", notnivc: "\u22FD", NotPrecedes: "\u2280", NotPrecedesEqual: "\u2AAF\u0338", NotPrecedesSlantEqual: "\
|
||
\u22E0", NotReverseElement: "\u220C", NotRightTriangleBar: "\u29D0\u0338", NotRightTriangle: "\u22EB", NotRightTriangleEqual: "\u22ED", NotSquareSubset: "\
|
||
\u228F\u0338", NotSquareSubsetEqual: "\u22E2", NotSquareSuperset: "\u2290\u0338", NotSquareSupersetEqual: "\u22E3", NotSubset: "\u2282\u20D2",
|
||
NotSubsetEqual: "\u2288", NotSucceeds: "\u2281", NotSucceedsEqual: "\u2AB0\u0338", NotSucceedsSlantEqual: "\u22E1", NotSucceedsTilde: "\u227F\u0338",
|
||
NotSuperset: "\u2283\u20D2", NotSupersetEqual: "\u2289", NotTilde: "\u2241", NotTildeEqual: "\u2244", NotTildeFullEqual: "\u2247", NotTildeTilde: "\
|
||
\u2249", NotVerticalBar: "\u2224", nparallel: "\u2226", npar: "\u2226", nparsl: "\u2AFD\u20E5", npart: "\u2202\u0338", npolint: "\u2A14", npr: "\
|
||
\u2280", nprcue: "\u22E0", nprec: "\u2280", npreceq: "\u2AAF\u0338", npre: "\u2AAF\u0338", nrarrc: "\u2933\u0338", nrarr: "\u219B", nrArr: "\
|
||
\u21CF", nrarrw: "\u219D\u0338", nrightarrow: "\u219B", nRightarrow: "\u21CF", nrtri: "\u22EB", nrtrie: "\u22ED", nsc: "\u2281", nsccue: "\u22E1",
|
||
nsce: "\u2AB0\u0338", Nscr: "\u{1D4A9}", nscr: "\u{1D4C3}", nshortmid: "\u2224", nshortparallel: "\u2226", nsim: "\u2241", nsime: "\u2244",
|
||
nsimeq: "\u2244", nsmid: "\u2224", nspar: "\u2226", nsqsube: "\u22E2", nsqsupe: "\u22E3", nsub: "\u2284", nsubE: "\u2AC5\u0338", nsube: "\u2288",
|
||
nsubset: "\u2282\u20D2", nsubseteq: "\u2288", nsubseteqq: "\u2AC5\u0338", nsucc: "\u2281", nsucceq: "\u2AB0\u0338", nsup: "\u2285", nsupE: "\
|
||
\u2AC6\u0338", nsupe: "\u2289", nsupset: "\u2283\u20D2", nsupseteq: "\u2289", nsupseteqq: "\u2AC6\u0338", ntgl: "\u2279", Ntilde: "\xD1", ntilde: "\
|
||
\xF1", ntlg: "\u2278", ntriangleleft: "\u22EA", ntrianglelefteq: "\u22EC", ntriangleright: "\u22EB", ntrianglerighteq: "\u22ED", Nu: "\u039D",
|
||
nu: "\u03BD", num: "#", numero: "\u2116", numsp: "\u2007", nvap: "\u224D\u20D2", nvdash: "\u22AC", nvDash: "\u22AD", nVdash: "\u22AE", nVDash: "\
|
||
\u22AF", nvge: "\u2265\u20D2", nvgt: ">\u20D2", nvHarr: "\u2904", nvinfin: "\u29DE", nvlArr: "\u2902", nvle: "\u2264\u20D2", nvlt: "<\u20D2",
|
||
nvltrie: "\u22B4\u20D2", nvrArr: "\u2903", nvrtrie: "\u22B5\u20D2", nvsim: "\u223C\u20D2", nwarhk: "\u2923", nwarr: "\u2196", nwArr: "\u21D6",
|
||
nwarrow: "\u2196", nwnear: "\u2927", Oacute: "\xD3", oacute: "\xF3", oast: "\u229B", Ocirc: "\xD4", ocirc: "\xF4", ocir: "\u229A", Ocy: "\u041E",
|
||
ocy: "\u043E", odash: "\u229D", Odblac: "\u0150", odblac: "\u0151", odiv: "\u2A38", odot: "\u2299", odsold: "\u29BC", OElig: "\u0152", oelig: "\
|
||
\u0153", ofcir: "\u29BF", Ofr: "\u{1D512}", ofr: "\u{1D52C}", ogon: "\u02DB", Ograve: "\xD2", ograve: "\xF2", ogt: "\u29C1", ohbar: "\u29B5",
|
||
ohm: "\u03A9", oint: "\u222E", olarr: "\u21BA", olcir: "\u29BE", olcross: "\u29BB", oline: "\u203E", olt: "\u29C0", Omacr: "\u014C", omacr: "\
|
||
\u014D", Omega: "\u03A9", omega: "\u03C9", Omicron: "\u039F", omicron: "\u03BF", omid: "\u29B6", ominus: "\u2296", Oopf: "\u{1D546}", oopf: "\
|
||
\u{1D560}", opar: "\u29B7", OpenCurlyDoubleQuote: "\u201C", OpenCurlyQuote: "\u2018", operp: "\u29B9", oplus: "\u2295", orarr: "\u21BB", Or: "\
|
||
\u2A54", or: "\u2228", ord: "\u2A5D", order: "\u2134", orderof: "\u2134", ordf: "\xAA", ordm: "\xBA", origof: "\u22B6", oror: "\u2A56", orslope: "\
|
||
\u2A57", orv: "\u2A5B", oS: "\u24C8", Oscr: "\u{1D4AA}", oscr: "\u2134", Oslash: "\xD8", oslash: "\xF8", osol: "\u2298", Otilde: "\xD5", otilde: "\
|
||
\xF5", otimesas: "\u2A36", Otimes: "\u2A37", otimes: "\u2297", Ouml: "\xD6", ouml: "\xF6", ovbar: "\u233D", OverBar: "\u203E", OverBrace: "\u23DE",
|
||
OverBracket: "\u23B4", OverParenthesis: "\u23DC", para: "\xB6", parallel: "\u2225", par: "\u2225", parsim: "\u2AF3", parsl: "\u2AFD", part: "\
|
||
\u2202", PartialD: "\u2202", Pcy: "\u041F", pcy: "\u043F", percnt: "%", period: ".", permil: "\u2030", perp: "\u22A5", pertenk: "\u2031", Pfr: "\
|
||
\u{1D513}", pfr: "\u{1D52D}", Phi: "\u03A6", phi: "\u03C6", phiv: "\u03D5", phmmat: "\u2133", phone: "\u260E", Pi: "\u03A0", pi: "\u03C0", pitchfork: "\
|
||
\u22D4", piv: "\u03D6", planck: "\u210F", planckh: "\u210E", plankv: "\u210F", plusacir: "\u2A23", plusb: "\u229E", pluscir: "\u2A22", plus: "\
|
||
+", plusdo: "\u2214", plusdu: "\u2A25", pluse: "\u2A72", PlusMinus: "\xB1", plusmn: "\xB1", plussim: "\u2A26", plustwo: "\u2A27", pm: "\xB1",
|
||
Poincareplane: "\u210C", pointint: "\u2A15", popf: "\u{1D561}", Popf: "\u2119", pound: "\xA3", prap: "\u2AB7", Pr: "\u2ABB", pr: "\u227A",
|
||
prcue: "\u227C", precapprox: "\u2AB7", prec: "\u227A", preccurlyeq: "\u227C", Precedes: "\u227A", PrecedesEqual: "\u2AAF", PrecedesSlantEqual: "\
|
||
\u227C", PrecedesTilde: "\u227E", preceq: "\u2AAF", precnapprox: "\u2AB9", precneqq: "\u2AB5", precnsim: "\u22E8", pre: "\u2AAF", prE: "\u2AB3",
|
||
precsim: "\u227E", prime: "\u2032", Prime: "\u2033", primes: "\u2119", prnap: "\u2AB9", prnE: "\u2AB5", prnsim: "\u22E8", prod: "\u220F", Product: "\
|
||
\u220F", profalar: "\u232E", profline: "\u2312", profsurf: "\u2313", prop: "\u221D", Proportional: "\u221D", Proportion: "\u2237", propto: "\
|
||
\u221D", prsim: "\u227E", prurel: "\u22B0", Pscr: "\u{1D4AB}", pscr: "\u{1D4C5}", Psi: "\u03A8", psi: "\u03C8", puncsp: "\u2008", Qfr: "\u{1D514}",
|
||
qfr: "\u{1D52E}", qint: "\u2A0C", qopf: "\u{1D562}", Qopf: "\u211A", qprime: "\u2057", Qscr: "\u{1D4AC}", qscr: "\u{1D4C6}", quaternions: "\
|
||
\u210D", quatint: "\u2A16", quest: "?", questeq: "\u225F", quot: '"', QUOT: '"', rAarr: "\u21DB", race: "\u223D\u0331", Racute: "\u0154", racute: "\
|
||
\u0155", radic: "\u221A", raemptyv: "\u29B3", rang: "\u27E9", Rang: "\u27EB", rangd: "\u2992", range: "\u29A5", rangle: "\u27E9", raquo: "\xBB",
|
||
rarrap: "\u2975", rarrb: "\u21E5", rarrbfs: "\u2920", rarrc: "\u2933", rarr: "\u2192", Rarr: "\u21A0", rArr: "\u21D2", rarrfs: "\u291E", rarrhk: "\
|
||
\u21AA", rarrlp: "\u21AC", rarrpl: "\u2945", rarrsim: "\u2974", Rarrtl: "\u2916", rarrtl: "\u21A3", rarrw: "\u219D", ratail: "\u291A", rAtail: "\
|
||
\u291C", ratio: "\u2236", rationals: "\u211A", rbarr: "\u290D", rBarr: "\u290F", RBarr: "\u2910", rbbrk: "\u2773", rbrace: "}", rbrack: "]",
|
||
rbrke: "\u298C", rbrksld: "\u298E", rbrkslu: "\u2990", Rcaron: "\u0158", rcaron: "\u0159", Rcedil: "\u0156", rcedil: "\u0157", rceil: "\u2309",
|
||
rcub: "}", Rcy: "\u0420", rcy: "\u0440", rdca: "\u2937", rdldhar: "\u2969", rdquo: "\u201D", rdquor: "\u201D", rdsh: "\u21B3", real: "\u211C",
|
||
realine: "\u211B", realpart: "\u211C", reals: "\u211D", Re: "\u211C", rect: "\u25AD", reg: "\xAE", REG: "\xAE", ReverseElement: "\u220B", ReverseEquilibrium: "\
|
||
\u21CB", ReverseUpEquilibrium: "\u296F", rfisht: "\u297D", rfloor: "\u230B", rfr: "\u{1D52F}", Rfr: "\u211C", rHar: "\u2964", rhard: "\u21C1",
|
||
rharu: "\u21C0", rharul: "\u296C", Rho: "\u03A1", rho: "\u03C1", rhov: "\u03F1", RightAngleBracket: "\u27E9", RightArrowBar: "\u21E5", rightarrow: "\
|
||
\u2192", RightArrow: "\u2192", Rightarrow: "\u21D2", RightArrowLeftArrow: "\u21C4", rightarrowtail: "\u21A3", RightCeiling: "\u2309", RightDoubleBracket: "\
|
||
\u27E7", RightDownTeeVector: "\u295D", RightDownVectorBar: "\u2955", RightDownVector: "\u21C2", RightFloor: "\u230B", rightharpoondown: "\u21C1",
|
||
rightharpoonup: "\u21C0", rightleftarrows: "\u21C4", rightleftharpoons: "\u21CC", rightrightarrows: "\u21C9", rightsquigarrow: "\u219D", RightTeeArrow: "\
|
||
\u21A6", RightTee: "\u22A2", RightTeeVector: "\u295B", rightthreetimes: "\u22CC", RightTriangleBar: "\u29D0", RightTriangle: "\u22B3", RightTriangleEqual: "\
|
||
\u22B5", RightUpDownVector: "\u294F", RightUpTeeVector: "\u295C", RightUpVectorBar: "\u2954", RightUpVector: "\u21BE", RightVectorBar: "\u2953",
|
||
RightVector: "\u21C0", ring: "\u02DA", risingdotseq: "\u2253", rlarr: "\u21C4", rlhar: "\u21CC", rlm: "\u200F", rmoustache: "\u23B1", rmoust: "\
|
||
\u23B1", rnmid: "\u2AEE", roang: "\u27ED", roarr: "\u21FE", robrk: "\u27E7", ropar: "\u2986", ropf: "\u{1D563}", Ropf: "\u211D", roplus: "\u2A2E",
|
||
rotimes: "\u2A35", RoundImplies: "\u2970", rpar: ")", rpargt: "\u2994", rppolint: "\u2A12", rrarr: "\u21C9", Rrightarrow: "\u21DB", rsaquo: "\
|
||
\u203A", rscr: "\u{1D4C7}", Rscr: "\u211B", rsh: "\u21B1", Rsh: "\u21B1", rsqb: "]", rsquo: "\u2019", rsquor: "\u2019", rthree: "\u22CC", rtimes: "\
|
||
\u22CA", rtri: "\u25B9", rtrie: "\u22B5", rtrif: "\u25B8", rtriltri: "\u29CE", RuleDelayed: "\u29F4", ruluhar: "\u2968", rx: "\u211E", Sacute: "\
|
||
\u015A", sacute: "\u015B", sbquo: "\u201A", scap: "\u2AB8", Scaron: "\u0160", scaron: "\u0161", Sc: "\u2ABC", sc: "\u227B", sccue: "\u227D",
|
||
sce: "\u2AB0", scE: "\u2AB4", Scedil: "\u015E", scedil: "\u015F", Scirc: "\u015C", scirc: "\u015D", scnap: "\u2ABA", scnE: "\u2AB6", scnsim: "\
|
||
\u22E9", scpolint: "\u2A13", scsim: "\u227F", Scy: "\u0421", scy: "\u0441", sdotb: "\u22A1", sdot: "\u22C5", sdote: "\u2A66", searhk: "\u2925",
|
||
searr: "\u2198", seArr: "\u21D8", searrow: "\u2198", sect: "\xA7", semi: ";", seswar: "\u2929", setminus: "\u2216", setmn: "\u2216", sext: "\
|
||
\u2736", Sfr: "\u{1D516}", sfr: "\u{1D530}", sfrown: "\u2322", sharp: "\u266F", SHCHcy: "\u0429", shchcy: "\u0449", SHcy: "\u0428", shcy: "\u0448",
|
||
ShortDownArrow: "\u2193", ShortLeftArrow: "\u2190", shortmid: "\u2223", shortparallel: "\u2225", ShortRightArrow: "\u2192", ShortUpArrow: "\
|
||
\u2191", shy: "\xAD", Sigma: "\u03A3", sigma: "\u03C3", sigmaf: "\u03C2", sigmav: "\u03C2", sim: "\u223C", simdot: "\u2A6A", sime: "\u2243",
|
||
simeq: "\u2243", simg: "\u2A9E", simgE: "\u2AA0", siml: "\u2A9D", simlE: "\u2A9F", simne: "\u2246", simplus: "\u2A24", simrarr: "\u2972", slarr: "\
|
||
\u2190", SmallCircle: "\u2218", smallsetminus: "\u2216", smashp: "\u2A33", smeparsl: "\u29E4", smid: "\u2223", smile: "\u2323", smt: "\u2AAA",
|
||
smte: "\u2AAC", smtes: "\u2AAC\uFE00", SOFTcy: "\u042C", softcy: "\u044C", solbar: "\u233F", solb: "\u29C4", sol: "/", Sopf: "\u{1D54A}", sopf: "\
|
||
\u{1D564}", spades: "\u2660", spadesuit: "\u2660", spar: "\u2225", sqcap: "\u2293", sqcaps: "\u2293\uFE00", sqcup: "\u2294", sqcups: "\u2294\uFE00",
|
||
Sqrt: "\u221A", sqsub: "\u228F", sqsube: "\u2291", sqsubset: "\u228F", sqsubseteq: "\u2291", sqsup: "\u2290", sqsupe: "\u2292", sqsupset: "\
|
||
\u2290", sqsupseteq: "\u2292", square: "\u25A1", Square: "\u25A1", SquareIntersection: "\u2293", SquareSubset: "\u228F", SquareSubsetEqual: "\
|
||
\u2291", SquareSuperset: "\u2290", SquareSupersetEqual: "\u2292", SquareUnion: "\u2294", squarf: "\u25AA", squ: "\u25A1", squf: "\u25AA", srarr: "\
|
||
\u2192", Sscr: "\u{1D4AE}", sscr: "\u{1D4C8}", ssetmn: "\u2216", ssmile: "\u2323", sstarf: "\u22C6", Star: "\u22C6", star: "\u2606", starf: "\
|
||
\u2605", straightepsilon: "\u03F5", straightphi: "\u03D5", strns: "\xAF", sub: "\u2282", Sub: "\u22D0", subdot: "\u2ABD", subE: "\u2AC5", sube: "\
|
||
\u2286", subedot: "\u2AC3", submult: "\u2AC1", subnE: "\u2ACB", subne: "\u228A", subplus: "\u2ABF", subrarr: "\u2979", subset: "\u2282", Subset: "\
|
||
\u22D0", subseteq: "\u2286", subseteqq: "\u2AC5", SubsetEqual: "\u2286", subsetneq: "\u228A", subsetneqq: "\u2ACB", subsim: "\u2AC7", subsub: "\
|
||
\u2AD5", subsup: "\u2AD3", succapprox: "\u2AB8", succ: "\u227B", succcurlyeq: "\u227D", Succeeds: "\u227B", SucceedsEqual: "\u2AB0", SucceedsSlantEqual: "\
|
||
\u227D", SucceedsTilde: "\u227F", succeq: "\u2AB0", succnapprox: "\u2ABA", succneqq: "\u2AB6", succnsim: "\u22E9", succsim: "\u227F", SuchThat: "\
|
||
\u220B", sum: "\u2211", Sum: "\u2211", sung: "\u266A", sup1: "\xB9", sup2: "\xB2", sup3: "\xB3", sup: "\u2283", Sup: "\u22D1", supdot: "\u2ABE",
|
||
supdsub: "\u2AD8", supE: "\u2AC6", supe: "\u2287", supedot: "\u2AC4", Superset: "\u2283", SupersetEqual: "\u2287", suphsol: "\u27C9", suphsub: "\
|
||
\u2AD7", suplarr: "\u297B", supmult: "\u2AC2", supnE: "\u2ACC", supne: "\u228B", supplus: "\u2AC0", supset: "\u2283", Supset: "\u22D1", supseteq: "\
|
||
\u2287", supseteqq: "\u2AC6", supsetneq: "\u228B", supsetneqq: "\u2ACC", supsim: "\u2AC8", supsub: "\u2AD4", supsup: "\u2AD6", swarhk: "\u2926",
|
||
swarr: "\u2199", swArr: "\u21D9", swarrow: "\u2199", swnwar: "\u292A", szlig: "\xDF", Tab: " ", target: "\u2316", Tau: "\u03A4", tau: "\u03C4",
|
||
tbrk: "\u23B4", Tcaron: "\u0164", tcaron: "\u0165", Tcedil: "\u0162", tcedil: "\u0163", Tcy: "\u0422", tcy: "\u0442", tdot: "\u20DB", telrec: "\
|
||
\u2315", Tfr: "\u{1D517}", tfr: "\u{1D531}", there4: "\u2234", therefore: "\u2234", Therefore: "\u2234", Theta: "\u0398", theta: "\u03B8", thetasym: "\
|
||
\u03D1", thetav: "\u03D1", thickapprox: "\u2248", thicksim: "\u223C", ThickSpace: "\u205F\u200A", ThinSpace: "\u2009", thinsp: "\u2009", thkap: "\
|
||
\u2248", thksim: "\u223C", THORN: "\xDE", thorn: "\xFE", tilde: "\u02DC", Tilde: "\u223C", TildeEqual: "\u2243", TildeFullEqual: "\u2245", TildeTilde: "\
|
||
\u2248", timesbar: "\u2A31", timesb: "\u22A0", times: "\xD7", timesd: "\u2A30", tint: "\u222D", toea: "\u2928", topbot: "\u2336", topcir: "\u2AF1",
|
||
top: "\u22A4", Topf: "\u{1D54B}", topf: "\u{1D565}", topfork: "\u2ADA", tosa: "\u2929", tprime: "\u2034", trade: "\u2122", TRADE: "\u2122",
|
||
triangle: "\u25B5", triangledown: "\u25BF", triangleleft: "\u25C3", trianglelefteq: "\u22B4", triangleq: "\u225C", triangleright: "\u25B9",
|
||
trianglerighteq: "\u22B5", tridot: "\u25EC", trie: "\u225C", triminus: "\u2A3A", TripleDot: "\u20DB", triplus: "\u2A39", trisb: "\u29CD", tritime: "\
|
||
\u2A3B", trpezium: "\u23E2", Tscr: "\u{1D4AF}", tscr: "\u{1D4C9}", TScy: "\u0426", tscy: "\u0446", TSHcy: "\u040B", tshcy: "\u045B", Tstrok: "\
|
||
\u0166", tstrok: "\u0167", twixt: "\u226C", twoheadleftarrow: "\u219E", twoheadrightarrow: "\u21A0", Uacute: "\xDA", uacute: "\xFA", uarr: "\
|
||
\u2191", Uarr: "\u219F", uArr: "\u21D1", Uarrocir: "\u2949", Ubrcy: "\u040E", ubrcy: "\u045E", Ubreve: "\u016C", ubreve: "\u016D", Ucirc: "\xDB",
|
||
ucirc: "\xFB", Ucy: "\u0423", ucy: "\u0443", udarr: "\u21C5", Udblac: "\u0170", udblac: "\u0171", udhar: "\u296E", ufisht: "\u297E", Ufr: "\
|
||
\u{1D518}", ufr: "\u{1D532}", Ugrave: "\xD9", ugrave: "\xF9", uHar: "\u2963", uharl: "\u21BF", uharr: "\u21BE", uhblk: "\u2580", ulcorn: "\u231C",
|
||
ulcorner: "\u231C", ulcrop: "\u230F", ultri: "\u25F8", Umacr: "\u016A", umacr: "\u016B", uml: "\xA8", UnderBar: "_", UnderBrace: "\u23DF",
|
||
UnderBracket: "\u23B5", UnderParenthesis: "\u23DD", Union: "\u22C3", UnionPlus: "\u228E", Uogon: "\u0172", uogon: "\u0173", Uopf: "\u{1D54C}",
|
||
uopf: "\u{1D566}", UpArrowBar: "\u2912", uparrow: "\u2191", UpArrow: "\u2191", Uparrow: "\u21D1", UpArrowDownArrow: "\u21C5", updownarrow: "\
|
||
\u2195", UpDownArrow: "\u2195", Updownarrow: "\u21D5", UpEquilibrium: "\u296E", upharpoonleft: "\u21BF", upharpoonright: "\u21BE", uplus: "\u228E",
|
||
UpperLeftArrow: "\u2196", UpperRightArrow: "\u2197", upsi: "\u03C5", Upsi: "\u03D2", upsih: "\u03D2", Upsilon: "\u03A5", upsilon: "\u03C5",
|
||
UpTeeArrow: "\u21A5", UpTee: "\u22A5", upuparrows: "\u21C8", urcorn: "\u231D", urcorner: "\u231D", urcrop: "\u230E", Uring: "\u016E", uring: "\
|
||
\u016F", urtri: "\u25F9", Uscr: "\u{1D4B0}", uscr: "\u{1D4CA}", utdot: "\u22F0", Utilde: "\u0168", utilde: "\u0169", utri: "\u25B5", utrif: "\
|
||
\u25B4", uuarr: "\u21C8", Uuml: "\xDC", uuml: "\xFC", uwangle: "\u29A7", vangrt: "\u299C", varepsilon: "\u03F5", varkappa: "\u03F0", varnothing: "\
|
||
\u2205", varphi: "\u03D5", varpi: "\u03D6", varpropto: "\u221D", varr: "\u2195", vArr: "\u21D5", varrho: "\u03F1", varsigma: "\u03C2", varsubsetneq: "\
|
||
\u228A\uFE00", varsubsetneqq: "\u2ACB\uFE00", varsupsetneq: "\u228B\uFE00", varsupsetneqq: "\u2ACC\uFE00", vartheta: "\u03D1", vartriangleleft: "\
|
||
\u22B2", vartriangleright: "\u22B3", vBar: "\u2AE8", Vbar: "\u2AEB", vBarv: "\u2AE9", Vcy: "\u0412", vcy: "\u0432", vdash: "\u22A2", vDash: "\
|
||
\u22A8", Vdash: "\u22A9", VDash: "\u22AB", Vdashl: "\u2AE6", veebar: "\u22BB", vee: "\u2228", Vee: "\u22C1", veeeq: "\u225A", vellip: "\u22EE",
|
||
verbar: "|", Verbar: "\u2016", vert: "|", Vert: "\u2016", VerticalBar: "\u2223", VerticalLine: "|", VerticalSeparator: "\u2758", VerticalTilde: "\
|
||
\u2240", VeryThinSpace: "\u200A", Vfr: "\u{1D519}", vfr: "\u{1D533}", vltri: "\u22B2", vnsub: "\u2282\u20D2", vnsup: "\u2283\u20D2", Vopf: "\
|
||
\u{1D54D}", vopf: "\u{1D567}", vprop: "\u221D", vrtri: "\u22B3", Vscr: "\u{1D4B1}", vscr: "\u{1D4CB}", vsubnE: "\u2ACB\uFE00", vsubne: "\u228A\uFE00",
|
||
vsupnE: "\u2ACC\uFE00", vsupne: "\u228B\uFE00", Vvdash: "\u22AA", vzigzag: "\u299A", Wcirc: "\u0174", wcirc: "\u0175", wedbar: "\u2A5F", wedge: "\
|
||
\u2227", Wedge: "\u22C0", wedgeq: "\u2259", weierp: "\u2118", Wfr: "\u{1D51A}", wfr: "\u{1D534}", Wopf: "\u{1D54E}", wopf: "\u{1D568}", wp: "\
|
||
\u2118", wr: "\u2240", wreath: "\u2240", Wscr: "\u{1D4B2}", wscr: "\u{1D4CC}", xcap: "\u22C2", xcirc: "\u25EF", xcup: "\u22C3", xdtri: "\u25BD",
|
||
Xfr: "\u{1D51B}", xfr: "\u{1D535}", xharr: "\u27F7", xhArr: "\u27FA", Xi: "\u039E", xi: "\u03BE", xlarr: "\u27F5", xlArr: "\u27F8", xmap: "\
|
||
\u27FC", xnis: "\u22FB", xodot: "\u2A00", Xopf: "\u{1D54F}", xopf: "\u{1D569}", xoplus: "\u2A01", xotime: "\u2A02", xrarr: "\u27F6", xrArr: "\
|
||
\u27F9", Xscr: "\u{1D4B3}", xscr: "\u{1D4CD}", xsqcup: "\u2A06", xuplus: "\u2A04", xutri: "\u25B3", xvee: "\u22C1", xwedge: "\u22C0", Yacute: "\
|
||
\xDD", yacute: "\xFD", YAcy: "\u042F", yacy: "\u044F", Ycirc: "\u0176", ycirc: "\u0177", Ycy: "\u042B", ycy: "\u044B", yen: "\xA5", Yfr: "\u{1D51C}",
|
||
yfr: "\u{1D536}", YIcy: "\u0407", yicy: "\u0457", Yopf: "\u{1D550}", yopf: "\u{1D56A}", Yscr: "\u{1D4B4}", yscr: "\u{1D4CE}", YUcy: "\u042E",
|
||
yucy: "\u044E", yuml: "\xFF", Yuml: "\u0178", Zacute: "\u0179", zacute: "\u017A", Zcaron: "\u017D", zcaron: "\u017E", Zcy: "\u0417", zcy: "\
|
||
\u0437", Zdot: "\u017B", zdot: "\u017C", zeetrf: "\u2128", ZeroWidthSpace: "\u200B", Zeta: "\u0396", zeta: "\u03B6", zfr: "\u{1D537}", Zfr: "\
|
||
\u2128", ZHcy: "\u0416", zhcy: "\u0436", zigrarr: "\u21DD", zopf: "\u{1D56B}", Zopf: "\u2124", Zscr: "\u{1D4B5}", zscr: "\u{1D4CF}", zwj: "\u200D",
|
||
zwnj: "\u200C" };
|
||
});
|
||
|
||
// ../node_modules/ansi-to-html/node_modules/entities/lib/maps/legacy.json
|
||
var Fh = d((EB, RI) => {
|
||
RI.exports = { Aacute: "\xC1", aacute: "\xE1", Acirc: "\xC2", acirc: "\xE2", acute: "\xB4", AElig: "\xC6", aelig: "\xE6", Agrave: "\xC0", agrave: "\
|
||
\xE0", amp: "&", AMP: "&", Aring: "\xC5", aring: "\xE5", Atilde: "\xC3", atilde: "\xE3", Auml: "\xC4", auml: "\xE4", brvbar: "\xA6", Ccedil: "\
|
||
\xC7", ccedil: "\xE7", cedil: "\xB8", cent: "\xA2", copy: "\xA9", COPY: "\xA9", curren: "\xA4", deg: "\xB0", divide: "\xF7", Eacute: "\xC9",
|
||
eacute: "\xE9", Ecirc: "\xCA", ecirc: "\xEA", Egrave: "\xC8", egrave: "\xE8", ETH: "\xD0", eth: "\xF0", Euml: "\xCB", euml: "\xEB", frac12: "\
|
||
\xBD", frac14: "\xBC", frac34: "\xBE", gt: ">", GT: ">", Iacute: "\xCD", iacute: "\xED", Icirc: "\xCE", icirc: "\xEE", iexcl: "\xA1", Igrave: "\
|
||
\xCC", igrave: "\xEC", iquest: "\xBF", Iuml: "\xCF", iuml: "\xEF", laquo: "\xAB", lt: "<", LT: "<", macr: "\xAF", micro: "\xB5", middot: "\xB7",
|
||
nbsp: "\xA0", not: "\xAC", Ntilde: "\xD1", ntilde: "\xF1", Oacute: "\xD3", oacute: "\xF3", Ocirc: "\xD4", ocirc: "\xF4", Ograve: "\xD2", ograve: "\
|
||
\xF2", ordf: "\xAA", ordm: "\xBA", Oslash: "\xD8", oslash: "\xF8", Otilde: "\xD5", otilde: "\xF5", Ouml: "\xD6", ouml: "\xF6", para: "\xB6",
|
||
plusmn: "\xB1", pound: "\xA3", quot: '"', QUOT: '"', raquo: "\xBB", reg: "\xAE", REG: "\xAE", sect: "\xA7", shy: "\xAD", sup1: "\xB9", sup2: "\
|
||
\xB2", sup3: "\xB3", szlig: "\xDF", THORN: "\xDE", thorn: "\xFE", times: "\xD7", Uacute: "\xDA", uacute: "\xFA", Ucirc: "\xDB", ucirc: "\xFB",
|
||
Ugrave: "\xD9", ugrave: "\xF9", uml: "\xA8", Uuml: "\xDC", uuml: "\xFC", Yacute: "\xDD", yacute: "\xFD", yen: "\xA5", yuml: "\xFF" };
|
||
});
|
||
|
||
// ../node_modules/ansi-to-html/node_modules/entities/lib/maps/xml.json
|
||
var Yi = d((TB, AI) => {
|
||
AI.exports = { amp: "&", apos: "'", gt: ">", lt: "<", quot: '"' };
|
||
});
|
||
|
||
// ../node_modules/ansi-to-html/node_modules/entities/lib/maps/decode.json
|
||
var Dh = d((RB, wI) => {
|
||
wI.exports = { "0": 65533, "128": 8364, "130": 8218, "131": 402, "132": 8222, "133": 8230, "134": 8224, "135": 8225, "136": 710, "137": 8240,
|
||
"138": 352, "139": 8249, "140": 338, "142": 381, "145": 8216, "146": 8217, "147": 8220, "148": 8221, "149": 8226, "150": 8211, "151": 8212,
|
||
"152": 732, "153": 8482, "154": 353, "155": 8250, "156": 339, "158": 382, "159": 376 };
|
||
});
|
||
|
||
// ../node_modules/ansi-to-html/node_modules/entities/lib/decode_codepoint.js
|
||
var qh = d((Ot) => {
|
||
"use strict";
|
||
var xI = Ot && Ot.__importDefault || function(r) {
|
||
return r && r.__esModule ? r : { default: r };
|
||
};
|
||
Object.defineProperty(Ot, "__esModule", { value: !0 });
|
||
var Nh = xI(Dh()), _I = (
|
||
// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
|
||
String.fromCodePoint || function(r) {
|
||
var e = "";
|
||
return r > 65535 && (r -= 65536, e += String.fromCharCode(r >>> 10 & 1023 | 55296), r = 56320 | r & 1023), e += String.fromCharCode(r),
|
||
e;
|
||
}
|
||
);
|
||
function PI(r) {
|
||
return r >= 55296 && r <= 57343 || r > 1114111 ? "\uFFFD" : (r in Nh.default && (r = Nh.default[r]), _I(r));
|
||
}
|
||
n(PI, "decodeCodePoint");
|
||
Ot.default = PI;
|
||
});
|
||
|
||
// ../node_modules/ansi-to-html/node_modules/entities/lib/decode.js
|
||
var Xi = d((pe) => {
|
||
"use strict";
|
||
var $o = pe && pe.__importDefault || function(r) {
|
||
return r && r.__esModule ? r : { default: r };
|
||
};
|
||
Object.defineProperty(pe, "__esModule", { value: !0 });
|
||
pe.decodeHTML = pe.decodeHTMLStrict = pe.decodeXML = void 0;
|
||
var Ki = $o(zi()), OI = $o(Fh()), CI = $o(Yi()), Lh = $o(qh()), II = /&(?:[a-zA-Z0-9]+|#[xX][\da-fA-F]+|#\d+);/g;
|
||
pe.decodeXML = Mh(CI.default);
|
||
pe.decodeHTMLStrict = Mh(Ki.default);
|
||
function Mh(r) {
|
||
var e = jh(r);
|
||
return function(t) {
|
||
return String(t).replace(II, e);
|
||
};
|
||
}
|
||
n(Mh, "getStrictDecoder");
|
||
var kh = /* @__PURE__ */ n(function(r, e) {
|
||
return r < e ? 1 : -1;
|
||
}, "sorter");
|
||
pe.decodeHTML = function() {
|
||
for (var r = Object.keys(OI.default).sort(kh), e = Object.keys(Ki.default).sort(kh), t = 0, o = 0; t < e.length; t++)
|
||
r[o] === e[t] ? (e[t] += ";?", o++) : e[t] += ";";
|
||
var a = new RegExp("&(?:" + e.join("|") + "|#[xX][\\da-fA-F]+;?|#\\d+;?)", "g"), i = jh(Ki.default);
|
||
function s(c) {
|
||
return c.substr(-1) !== ";" && (c += ";"), i(c);
|
||
}
|
||
return n(s, "replacer"), function(c) {
|
||
return String(c).replace(a, s);
|
||
};
|
||
}();
|
||
function jh(r) {
|
||
return /* @__PURE__ */ n(function(t) {
|
||
if (t.charAt(1) === "#") {
|
||
var o = t.charAt(2);
|
||
return o === "X" || o === "x" ? Lh.default(parseInt(t.substr(3), 16)) : Lh.default(parseInt(t.substr(2), 10));
|
||
}
|
||
return r[t.slice(1, -1)] || t;
|
||
}, "replace");
|
||
}
|
||
n(jh, "getReplacer");
|
||
});
|
||
|
||
// ../node_modules/ansi-to-html/node_modules/entities/lib/encode.js
|
||
var Qi = d((te) => {
|
||
"use strict";
|
||
var Bh = te && te.__importDefault || function(r) {
|
||
return r && r.__esModule ? r : { default: r };
|
||
};
|
||
Object.defineProperty(te, "__esModule", { value: !0 });
|
||
te.escapeUTF8 = te.escape = te.encodeNonAsciiHTML = te.encodeHTML = te.encodeXML = void 0;
|
||
var FI = Bh(Yi()), Uh = Hh(FI.default), Gh = Vh(Uh);
|
||
te.encodeXML = zh(Uh);
|
||
var DI = Bh(zi()), Ji = Hh(DI.default), NI = Vh(Ji);
|
||
te.encodeHTML = LI(Ji, NI);
|
||
te.encodeNonAsciiHTML = zh(Ji);
|
||
function Hh(r) {
|
||
return Object.keys(r).sort().reduce(function(e, t) {
|
||
return e[r[t]] = "&" + t + ";", e;
|
||
}, {});
|
||
}
|
||
n(Hh, "getInverseObj");
|
||
function Vh(r) {
|
||
for (var e = [], t = [], o = 0, a = Object.keys(r); o < a.length; o++) {
|
||
var i = a[o];
|
||
i.length === 1 ? e.push("\\" + i) : t.push(i);
|
||
}
|
||
e.sort();
|
||
for (var s = 0; s < e.length - 1; s++) {
|
||
for (var c = s; c < e.length - 1 && e[c].charCodeAt(1) + 1 === e[c + 1].charCodeAt(1); )
|
||
c += 1;
|
||
var l = 1 + c - s;
|
||
l < 3 || e.splice(s, l, e[s] + "-" + e[c]);
|
||
}
|
||
return t.unshift("[" + e.join("") + "]"), new RegExp(t.join("|"), "g");
|
||
}
|
||
n(Vh, "getInverseReplacer");
|
||
var $h = /(?:[\x80-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])/g,
|
||
qI = (
|
||
// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
|
||
String.prototype.codePointAt != null ? (
|
||
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
|
||
function(r) {
|
||
return r.codePointAt(0);
|
||
}
|
||
) : (
|
||
// http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
|
||
function(r) {
|
||
return (r.charCodeAt(0) - 55296) * 1024 + r.charCodeAt(1) - 56320 + 65536;
|
||
}
|
||
)
|
||
);
|
||
function Wo(r) {
|
||
return "&#x" + (r.length > 1 ? qI(r) : r.charCodeAt(0)).toString(16).toUpperCase() + ";";
|
||
}
|
||
n(Wo, "singleCharReplacer");
|
||
function LI(r, e) {
|
||
return function(t) {
|
||
return t.replace(e, function(o) {
|
||
return r[o];
|
||
}).replace($h, Wo);
|
||
};
|
||
}
|
||
n(LI, "getInverse");
|
||
var Wh = new RegExp(Gh.source + "|" + $h.source, "g");
|
||
function kI(r) {
|
||
return r.replace(Wh, Wo);
|
||
}
|
||
n(kI, "escape");
|
||
te.escape = kI;
|
||
function MI(r) {
|
||
return r.replace(Gh, Wo);
|
||
}
|
||
n(MI, "escapeUTF8");
|
||
te.escapeUTF8 = MI;
|
||
function zh(r) {
|
||
return function(e) {
|
||
return e.replace(Wh, function(t) {
|
||
return r[t] || Wo(t);
|
||
});
|
||
};
|
||
}
|
||
n(zh, "getASCIIEncoder");
|
||
});
|
||
|
||
// ../node_modules/ansi-to-html/node_modules/entities/lib/index.js
|
||
var Kh = d((O) => {
|
||
"use strict";
|
||
Object.defineProperty(O, "__esModule", { value: !0 });
|
||
O.decodeXMLStrict = O.decodeHTML5Strict = O.decodeHTML4Strict = O.decodeHTML5 = O.decodeHTML4 = O.decodeHTMLStrict = O.decodeHTML = O.decodeXML =
|
||
O.encodeHTML5 = O.encodeHTML4 = O.escapeUTF8 = O.escape = O.encodeNonAsciiHTML = O.encodeHTML = O.encodeXML = O.encode = O.decodeStrict = O.
|
||
decode = void 0;
|
||
var zo = Xi(), Yh = Qi();
|
||
function jI(r, e) {
|
||
return (!e || e <= 0 ? zo.decodeXML : zo.decodeHTML)(r);
|
||
}
|
||
n(jI, "decode");
|
||
O.decode = jI;
|
||
function BI(r, e) {
|
||
return (!e || e <= 0 ? zo.decodeXML : zo.decodeHTMLStrict)(r);
|
||
}
|
||
n(BI, "decodeStrict");
|
||
O.decodeStrict = BI;
|
||
function UI(r, e) {
|
||
return (!e || e <= 0 ? Yh.encodeXML : Yh.encodeHTML)(r);
|
||
}
|
||
n(UI, "encode");
|
||
O.encode = UI;
|
||
var Ye = Qi();
|
||
Object.defineProperty(O, "encodeXML", { enumerable: !0, get: /* @__PURE__ */ n(function() {
|
||
return Ye.encodeXML;
|
||
}, "get") });
|
||
Object.defineProperty(O, "encodeHTML", { enumerable: !0, get: /* @__PURE__ */ n(function() {
|
||
return Ye.encodeHTML;
|
||
}, "get") });
|
||
Object.defineProperty(O, "encodeNonAsciiHTML", { enumerable: !0, get: /* @__PURE__ */ n(function() {
|
||
return Ye.encodeNonAsciiHTML;
|
||
}, "get") });
|
||
Object.defineProperty(O, "escape", { enumerable: !0, get: /* @__PURE__ */ n(function() {
|
||
return Ye.escape;
|
||
}, "get") });
|
||
Object.defineProperty(O, "escapeUTF8", { enumerable: !0, get: /* @__PURE__ */ n(function() {
|
||
return Ye.escapeUTF8;
|
||
}, "get") });
|
||
Object.defineProperty(O, "encodeHTML4", { enumerable: !0, get: /* @__PURE__ */ n(function() {
|
||
return Ye.encodeHTML;
|
||
}, "get") });
|
||
Object.defineProperty(O, "encodeHTML5", { enumerable: !0, get: /* @__PURE__ */ n(function() {
|
||
return Ye.encodeHTML;
|
||
}, "get") });
|
||
var Pe = Xi();
|
||
Object.defineProperty(O, "decodeXML", { enumerable: !0, get: /* @__PURE__ */ n(function() {
|
||
return Pe.decodeXML;
|
||
}, "get") });
|
||
Object.defineProperty(O, "decodeHTML", { enumerable: !0, get: /* @__PURE__ */ n(function() {
|
||
return Pe.decodeHTML;
|
||
}, "get") });
|
||
Object.defineProperty(O, "decodeHTMLStrict", { enumerable: !0, get: /* @__PURE__ */ n(function() {
|
||
return Pe.decodeHTMLStrict;
|
||
}, "get") });
|
||
Object.defineProperty(O, "decodeHTML4", { enumerable: !0, get: /* @__PURE__ */ n(function() {
|
||
return Pe.decodeHTML;
|
||
}, "get") });
|
||
Object.defineProperty(O, "decodeHTML5", { enumerable: !0, get: /* @__PURE__ */ n(function() {
|
||
return Pe.decodeHTML;
|
||
}, "get") });
|
||
Object.defineProperty(O, "decodeHTML4Strict", { enumerable: !0, get: /* @__PURE__ */ n(function() {
|
||
return Pe.decodeHTMLStrict;
|
||
}, "get") });
|
||
Object.defineProperty(O, "decodeHTML5Strict", { enumerable: !0, get: /* @__PURE__ */ n(function() {
|
||
return Pe.decodeHTMLStrict;
|
||
}, "get") });
|
||
Object.defineProperty(O, "decodeXMLStrict", { enumerable: !0, get: /* @__PURE__ */ n(function() {
|
||
return Pe.decodeXML;
|
||
}, "get") });
|
||
});
|
||
|
||
// ../node_modules/ansi-to-html/lib/ansi_to_html.js
|
||
var im = d((FB, am) => {
|
||
"use strict";
|
||
function GI(r, e) {
|
||
if (!(r instanceof e))
|
||
throw new TypeError("Cannot call a class as a function");
|
||
}
|
||
n(GI, "_classCallCheck");
|
||
function Xh(r, e) {
|
||
for (var t = 0; t < e.length; t++) {
|
||
var o = e[t];
|
||
o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(r, o.key, o);
|
||
}
|
||
}
|
||
n(Xh, "_defineProperties");
|
||
function HI(r, e, t) {
|
||
return e && Xh(r.prototype, e), t && Xh(r, t), r;
|
||
}
|
||
n(HI, "_createClass");
|
||
function tm(r, e) {
|
||
var t = typeof Symbol < "u" && r[Symbol.iterator] || r["@@iterator"];
|
||
if (!t) {
|
||
if (Array.isArray(r) || (t = VI(r)) || e && r && typeof r.length == "number") {
|
||
t && (r = t);
|
||
var o = 0, a = /* @__PURE__ */ n(function() {
|
||
}, "F");
|
||
return { s: a, n: /* @__PURE__ */ n(function() {
|
||
return o >= r.length ? { done: !0 } : { done: !1, value: r[o++] };
|
||
}, "n"), e: /* @__PURE__ */ n(function(u) {
|
||
throw u;
|
||
}, "e"), f: a };
|
||
}
|
||
throw new TypeError(`Invalid attempt to iterate non-iterable instance.
|
||
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
|
||
}
|
||
var i = !0, s = !1, c;
|
||
return { s: /* @__PURE__ */ n(function() {
|
||
t = t.call(r);
|
||
}, "s"), n: /* @__PURE__ */ n(function() {
|
||
var u = t.next();
|
||
return i = u.done, u;
|
||
}, "n"), e: /* @__PURE__ */ n(function(u) {
|
||
s = !0, c = u;
|
||
}, "e"), f: /* @__PURE__ */ n(function() {
|
||
try {
|
||
!i && t.return != null && t.return();
|
||
} finally {
|
||
if (s) throw c;
|
||
}
|
||
}, "f") };
|
||
}
|
||
n(tm, "_createForOfIteratorHelper");
|
||
function VI(r, e) {
|
||
if (r) {
|
||
if (typeof r == "string") return Jh(r, e);
|
||
var t = Object.prototype.toString.call(r).slice(8, -1);
|
||
if (t === "Object" && r.constructor && (t = r.constructor.name), t === "Map" || t === "Set") return Array.from(r);
|
||
if (t === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t)) return Jh(r, e);
|
||
}
|
||
}
|
||
n(VI, "_unsupportedIterableToArray");
|
||
function Jh(r, e) {
|
||
(e == null || e > r.length) && (e = r.length);
|
||
for (var t = 0, o = new Array(e); t < e; t++)
|
||
o[t] = r[t];
|
||
return o;
|
||
}
|
||
n(Jh, "_arrayLikeToArray");
|
||
var $I = Kh(), Qh = {
|
||
fg: "#FFF",
|
||
bg: "#000",
|
||
newline: !1,
|
||
escapeXML: !1,
|
||
stream: !1,
|
||
colors: WI()
|
||
};
|
||
function WI() {
|
||
var r = {
|
||
0: "#000",
|
||
1: "#A00",
|
||
2: "#0A0",
|
||
3: "#A50",
|
||
4: "#00A",
|
||
5: "#A0A",
|
||
6: "#0AA",
|
||
7: "#AAA",
|
||
8: "#555",
|
||
9: "#F55",
|
||
10: "#5F5",
|
||
11: "#FF5",
|
||
12: "#55F",
|
||
13: "#F5F",
|
||
14: "#5FF",
|
||
15: "#FFF"
|
||
};
|
||
return Yo(0, 5).forEach(function(e) {
|
||
Yo(0, 5).forEach(function(t) {
|
||
Yo(0, 5).forEach(function(o) {
|
||
return zI(e, t, o, r);
|
||
});
|
||
});
|
||
}), Yo(0, 23).forEach(function(e) {
|
||
var t = e + 232, o = om(e * 10 + 8);
|
||
r[t] = "#" + o + o + o;
|
||
}), r;
|
||
}
|
||
n(WI, "getDefaultColors");
|
||
function zI(r, e, t, o) {
|
||
var a = 16 + r * 36 + e * 6 + t, i = r > 0 ? r * 40 + 55 : 0, s = e > 0 ? e * 40 + 55 : 0, c = t > 0 ? t * 40 + 55 : 0;
|
||
o[a] = YI([i, s, c]);
|
||
}
|
||
n(zI, "setStyleColor");
|
||
function om(r) {
|
||
for (var e = r.toString(16); e.length < 2; )
|
||
e = "0" + e;
|
||
return e;
|
||
}
|
||
n(om, "toHexString");
|
||
function YI(r) {
|
||
var e = [], t = tm(r), o;
|
||
try {
|
||
for (t.s(); !(o = t.n()).done; ) {
|
||
var a = o.value;
|
||
e.push(om(a));
|
||
}
|
||
} catch (i) {
|
||
t.e(i);
|
||
} finally {
|
||
t.f();
|
||
}
|
||
return "#" + e.join("");
|
||
}
|
||
n(YI, "toColorHexString");
|
||
function Zh(r, e, t, o) {
|
||
var a;
|
||
return e === "text" ? a = QI(t, o) : e === "display" ? a = XI(r, t, o) : e === "xterm256Foreground" ? a = Xo(r, o.colors[t]) : e === "xt\
|
||
erm256Background" ? a = Jo(r, o.colors[t]) : e === "rgb" && (a = KI(r, t)), a;
|
||
}
|
||
n(Zh, "generateOutput");
|
||
function KI(r, e) {
|
||
e = e.substring(2).slice(0, -1);
|
||
var t = +e.substr(0, 2), o = e.substring(5).split(";"), a = o.map(function(i) {
|
||
return ("0" + Number(i).toString(16)).substr(-2);
|
||
}).join("");
|
||
return Ko(r, (t === 38 ? "color:#" : "background-color:#") + a);
|
||
}
|
||
n(KI, "handleRgb");
|
||
function XI(r, e, t) {
|
||
e = parseInt(e, 10);
|
||
var o = {
|
||
"-1": /* @__PURE__ */ n(function() {
|
||
return "<br/>";
|
||
}, "_"),
|
||
0: /* @__PURE__ */ n(function() {
|
||
return r.length && nm(r);
|
||
}, "_"),
|
||
1: /* @__PURE__ */ n(function() {
|
||
return Oe(r, "b");
|
||
}, "_"),
|
||
3: /* @__PURE__ */ n(function() {
|
||
return Oe(r, "i");
|
||
}, "_"),
|
||
4: /* @__PURE__ */ n(function() {
|
||
return Oe(r, "u");
|
||
}, "_"),
|
||
8: /* @__PURE__ */ n(function() {
|
||
return Ko(r, "display:none");
|
||
}, "_"),
|
||
9: /* @__PURE__ */ n(function() {
|
||
return Oe(r, "strike");
|
||
}, "_"),
|
||
22: /* @__PURE__ */ n(function() {
|
||
return Ko(r, "font-weight:normal;text-decoration:none;font-style:normal");
|
||
}, "_"),
|
||
23: /* @__PURE__ */ n(function() {
|
||
return rm(r, "i");
|
||
}, "_"),
|
||
24: /* @__PURE__ */ n(function() {
|
||
return rm(r, "u");
|
||
}, "_"),
|
||
39: /* @__PURE__ */ n(function() {
|
||
return Xo(r, t.fg);
|
||
}, "_"),
|
||
49: /* @__PURE__ */ n(function() {
|
||
return Jo(r, t.bg);
|
||
}, "_"),
|
||
53: /* @__PURE__ */ n(function() {
|
||
return Ko(r, "text-decoration:overline");
|
||
}, "_")
|
||
}, a;
|
||
return o[e] ? a = o[e]() : 4 < e && e < 7 ? a = Oe(r, "blink") : 29 < e && e < 38 ? a = Xo(r, t.colors[e - 30]) : 39 < e && e < 48 ? a =
|
||
Jo(r, t.colors[e - 40]) : 89 < e && e < 98 ? a = Xo(r, t.colors[8 + (e - 90)]) : 99 < e && e < 108 && (a = Jo(r, t.colors[8 + (e - 100)])),
|
||
a;
|
||
}
|
||
n(XI, "handleDisplay");
|
||
function nm(r) {
|
||
var e = r.slice(0);
|
||
return r.length = 0, e.reverse().map(function(t) {
|
||
return "</" + t + ">";
|
||
}).join("");
|
||
}
|
||
n(nm, "resetStyles");
|
||
function Yo(r, e) {
|
||
for (var t = [], o = r; o <= e; o++)
|
||
t.push(o);
|
||
return t;
|
||
}
|
||
n(Yo, "range");
|
||
function JI(r) {
|
||
return function(e) {
|
||
return (r === null || e.category !== r) && r !== "all";
|
||
};
|
||
}
|
||
n(JI, "notCategory");
|
||
function em(r) {
|
||
r = parseInt(r, 10);
|
||
var e = null;
|
||
return r === 0 ? e = "all" : r === 1 ? e = "bold" : 2 < r && r < 5 ? e = "underline" : 4 < r && r < 7 ? e = "blink" : r === 8 ? e = "hid\
|
||
e" : r === 9 ? e = "strike" : 29 < r && r < 38 || r === 39 || 89 < r && r < 98 ? e = "foreground-color" : (39 < r && r < 48 || r === 49 || 99 <
|
||
r && r < 108) && (e = "background-color"), e;
|
||
}
|
||
n(em, "categoryForCode");
|
||
function QI(r, e) {
|
||
return e.escapeXML ? $I.encodeXML(r) : r;
|
||
}
|
||
n(QI, "pushText");
|
||
function Oe(r, e, t) {
|
||
return t || (t = ""), r.push(e), "<".concat(e).concat(t ? ' style="'.concat(t, '"') : "", ">");
|
||
}
|
||
n(Oe, "pushTag");
|
||
function Ko(r, e) {
|
||
return Oe(r, "span", e);
|
||
}
|
||
n(Ko, "pushStyle");
|
||
function Xo(r, e) {
|
||
return Oe(r, "span", "color:" + e);
|
||
}
|
||
n(Xo, "pushForegroundColor");
|
||
function Jo(r, e) {
|
||
return Oe(r, "span", "background-color:" + e);
|
||
}
|
||
n(Jo, "pushBackgroundColor");
|
||
function rm(r, e) {
|
||
var t;
|
||
if (r.slice(-1)[0] === e && (t = r.pop()), t)
|
||
return "</" + e + ">";
|
||
}
|
||
n(rm, "closeTag");
|
||
function ZI(r, e, t) {
|
||
var o = !1, a = 3;
|
||
function i() {
|
||
return "";
|
||
}
|
||
n(i, "remove");
|
||
function s(R, P) {
|
||
return t("xterm256Foreground", P), "";
|
||
}
|
||
n(s, "removeXterm256Foreground");
|
||
function c(R, P) {
|
||
return t("xterm256Background", P), "";
|
||
}
|
||
n(c, "removeXterm256Background");
|
||
function l(R) {
|
||
return e.newline ? t("display", -1) : t("text", R), "";
|
||
}
|
||
n(l, "newline");
|
||
function u(R, P) {
|
||
o = !0, P.trim().length === 0 && (P = "0"), P = P.trimRight(";").split(";");
|
||
var k = tm(P), F;
|
||
try {
|
||
for (k.s(); !(F = k.n()).done; ) {
|
||
var H = F.value;
|
||
t("display", H);
|
||
}
|
||
} catch (Z) {
|
||
k.e(Z);
|
||
} finally {
|
||
k.f();
|
||
}
|
||
return "";
|
||
}
|
||
n(u, "ansiMess");
|
||
function p(R) {
|
||
return t("text", R), "";
|
||
}
|
||
n(p, "realText");
|
||
function h(R) {
|
||
return t("rgb", R), "";
|
||
}
|
||
n(h, "rgb");
|
||
var y = [{
|
||
pattern: /^\x08+/,
|
||
sub: i
|
||
}, {
|
||
pattern: /^\x1b\[[012]?K/,
|
||
sub: i
|
||
}, {
|
||
pattern: /^\x1b\[\(B/,
|
||
sub: i
|
||
}, {
|
||
pattern: /^\x1b\[[34]8;2;\d+;\d+;\d+m/,
|
||
sub: h
|
||
}, {
|
||
pattern: /^\x1b\[38;5;(\d+)m/,
|
||
sub: s
|
||
}, {
|
||
pattern: /^\x1b\[48;5;(\d+)m/,
|
||
sub: c
|
||
}, {
|
||
pattern: /^\n/,
|
||
sub: l
|
||
}, {
|
||
pattern: /^\r+\n/,
|
||
sub: l
|
||
}, {
|
||
pattern: /^\r/,
|
||
sub: l
|
||
}, {
|
||
pattern: /^\x1b\[((?:\d{1,3};?)+|)m/,
|
||
sub: u
|
||
}, {
|
||
// CSI n J
|
||
// ED - Erase in Display Clears part of the screen.
|
||
// If n is 0 (or missing), clear from cursor to end of screen.
|
||
// If n is 1, clear from cursor to beginning of the screen.
|
||
// If n is 2, clear entire screen (and moves cursor to upper left on DOS ANSI.SYS).
|
||
// If n is 3, clear entire screen and delete all lines saved in the scrollback buffer
|
||
// (this feature was added for xterm and is supported by other terminal applications).
|
||
pattern: /^\x1b\[\d?J/,
|
||
sub: i
|
||
}, {
|
||
// CSI n ; m f
|
||
// HVP - Horizontal Vertical Position Same as CUP
|
||
pattern: /^\x1b\[\d{0,3};\d{0,3}f/,
|
||
sub: i
|
||
}, {
|
||
// catch-all for CSI sequences?
|
||
pattern: /^\x1b\[?[\d;]{0,3}/,
|
||
sub: i
|
||
}, {
|
||
/**
|
||
* extracts real text - not containing:
|
||
* - `\x1b' - ESC - escape (Ascii 27)
|
||
* - '\x08' - BS - backspace (Ascii 8)
|
||
* - `\n` - Newline - linefeed (LF) (ascii 10)
|
||
* - `\r` - Windows Carriage Return (CR)
|
||
*/
|
||
pattern: /^(([^\x1b\x08\r\n])+)/,
|
||
sub: p
|
||
}];
|
||
function g(R, P) {
|
||
P > a && o || (o = !1, r = r.replace(R.pattern, R.sub));
|
||
}
|
||
n(g, "process");
|
||
var m = [], b = r, S = b.length;
|
||
e: for (; S > 0; ) {
|
||
for (var w = 0, E = 0, v = y.length; E < v; w = ++E) {
|
||
var x = y[w];
|
||
if (g(x, w), r.length !== S) {
|
||
S = r.length;
|
||
continue e;
|
||
}
|
||
}
|
||
if (r.length === S)
|
||
break;
|
||
m.push(0), S = r.length;
|
||
}
|
||
return m;
|
||
}
|
||
n(ZI, "tokenize");
|
||
function eF(r, e, t) {
|
||
return e !== "text" && (r = r.filter(JI(em(t))), r.push({
|
||
token: e,
|
||
data: t,
|
||
category: em(t)
|
||
})), r;
|
||
}
|
||
n(eF, "updateStickyStack");
|
||
var rF = /* @__PURE__ */ function() {
|
||
function r(e) {
|
||
GI(this, r), e = e || {}, e.colors && (e.colors = Object.assign({}, Qh.colors, e.colors)), this.options = Object.assign({}, Qh, e), this.
|
||
stack = [], this.stickyStack = [];
|
||
}
|
||
return n(r, "Filter"), HI(r, [{
|
||
key: "toHtml",
|
||
value: /* @__PURE__ */ n(function(t) {
|
||
var o = this;
|
||
t = typeof t == "string" ? [t] : t;
|
||
var a = this.stack, i = this.options, s = [];
|
||
return this.stickyStack.forEach(function(c) {
|
||
var l = Zh(a, c.token, c.data, i);
|
||
l && s.push(l);
|
||
}), ZI(t.join(""), i, function(c, l) {
|
||
var u = Zh(a, c, l, i);
|
||
u && s.push(u), i.stream && (o.stickyStack = eF(o.stickyStack, c, l));
|
||
}), a.length && s.push(nm(a)), s.join("");
|
||
}, "toHtml")
|
||
}]), r;
|
||
}();
|
||
am.exports = rF;
|
||
});
|
||
|
||
// ../node_modules/browser-dtector/browser-dtector.umd.min.js
|
||
var mm = d((ns, as) => {
|
||
(function(r, e) {
|
||
typeof ns == "object" && typeof as < "u" ? as.exports = e() : typeof define == "function" && define.amd ? define(e) : (r = typeof globalThis <
|
||
"u" ? globalThis : r || self).BrowserDetector = e();
|
||
})(ns, function() {
|
||
"use strict";
|
||
function r(s, c) {
|
||
for (var l = 0; l < c.length; l++) {
|
||
var u = c[l];
|
||
u.enumerable = u.enumerable || !1, u.configurable = !0, "value" in u && (u.writable = !0), Object.defineProperty(s, (p = u.key, h = void 0,
|
||
typeof (h = function(y, g) {
|
||
if (typeof y != "object" || y === null) return y;
|
||
var m = y[Symbol.toPrimitive];
|
||
if (m !== void 0) {
|
||
var b = m.call(y, g || "default");
|
||
if (typeof b != "object") return b;
|
||
throw new TypeError("@@toPrimitive must return a primitive value.");
|
||
}
|
||
return (g === "string" ? String : Number)(y);
|
||
}(p, "string")) == "symbol" ? h : String(h)), u);
|
||
}
|
||
var p, h;
|
||
}
|
||
n(r, "e");
|
||
var e = { chrome: "Google Chrome", brave: "Brave", crios: "Google Chrome", edge: "Microsoft Edge", edg: "Microsoft Edge", edgios: "Micro\
|
||
soft Edge", fennec: "Mozilla Firefox", jsdom: "JsDOM", mozilla: "Mozilla Firefox", fxios: "Mozilla Firefox", msie: "Microsoft Internet Explo\
|
||
rer", opera: "Opera", opios: "Opera", opr: "Opera", opt: "Opera", rv: "Microsoft Internet Explorer", safari: "Safari", samsungbrowser: "Sams\
|
||
ung Browser", electron: "Electron" }, t = { android: "Android", androidTablet: "Android Tablet", cros: "Chrome OS", fennec: "Android Tablet",
|
||
ipad: "IPad", iphone: "IPhone", jsdom: "JsDOM", linux: "Linux", mac: "Macintosh", tablet: "Android Tablet", win: "Windows", "windows pho\
|
||
ne": "Windows Phone", xbox: "Microsoft Xbox" }, o = /* @__PURE__ */ n(function(s) {
|
||
var c = new RegExp("^-?\\d+(?:.\\d{0,".concat(arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : -1, "})?")), l = Number(
|
||
s).toString().match(c);
|
||
return l ? l[0] : null;
|
||
}, "n"), a = /* @__PURE__ */ n(function() {
|
||
return typeof window < "u" ? window.navigator : null;
|
||
}, "i"), i = function() {
|
||
function s(p) {
|
||
var h;
|
||
(function(y, g) {
|
||
if (!(y instanceof g)) throw new TypeError("Cannot call a class as a function");
|
||
})(this, s), this.userAgent = p || ((h = a()) === null || h === void 0 ? void 0 : h.userAgent) || null;
|
||
}
|
||
n(s, "t");
|
||
var c, l, u;
|
||
return c = s, l = [{ key: "parseUserAgent", value: /* @__PURE__ */ n(function(p) {
|
||
var h, y, g, m = {}, b = p || this.userAgent || "", S = b.toLowerCase().replace(/\s\s+/g, " "), w = /(edge)\/([\w.]+)/.exec(S) || /(edg)[/]([\w.]+)/.
|
||
exec(S) || /(opr)[/]([\w.]+)/.exec(S) || /(opt)[/]([\w.]+)/.exec(S) || /(fxios)[/]([\w.]+)/.exec(S) || /(edgios)[/]([\w.]+)/.exec(S) ||
|
||
/(jsdom)[/]([\w.]+)/.exec(S) || /(samsungbrowser)[/]([\w.]+)/.exec(S) || /(electron)[/]([\w.]+)/.exec(S) || /(chrome)[/]([\w.]+)/.exec(
|
||
S) || /(crios)[/]([\w.]+)/.exec(S) || /(opios)[/]([\w.]+)/.exec(S) || /(version)(applewebkit)[/]([\w.]+).*(safari)[/]([\w.]+)/.exec(
|
||
S) || /(webkit)[/]([\w.]+).*(version)[/]([\w.]+).*(safari)[/]([\w.]+)/.exec(S) || /(applewebkit)[/]([\w.]+).*(safari)[/]([\w.]+)/.exec(
|
||
S) || /(webkit)[/]([\w.]+)/.exec(S) || /(opera)(?:.*version|)[/]([\w.]+)/.exec(S) || /(msie) ([\w.]+)/.exec(S) || /(fennec)[/]([\w.]+)/.
|
||
exec(S) || S.indexOf("trident") >= 0 && /(rv)(?::| )([\w.]+)/.exec(S) || S.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.
|
||
exec(S) || [], E = /(ipad)/.exec(S) || /(ipod)/.exec(S) || /(iphone)/.exec(S) || /(jsdom)/.exec(S) || /(windows phone)/.exec(S) || /(xbox)/.
|
||
exec(S) || /(win)/.exec(S) || /(tablet)/.exec(S) || /(android)/.test(S) && /(mobile)/.test(S) === !1 && ["androidTablet"] || /(android)/.
|
||
exec(S) || /(mac)/.exec(S) || /(linux)/.exec(S) || /(cros)/.exec(S) || [], v = w[5] || w[3] || w[1] || null, x = E[0] || null, R = w[4] ||
|
||
w[2] || null, P = a();
|
||
v === "chrome" && typeof (P == null || (h = P.brave) === null || h === void 0 ? void 0 : h.isBrave) == "function" && (v = "brave"), v &&
|
||
(m[v] = !0), x && (m[x] = !0);
|
||
var k = !!(m.tablet || m.android || m.androidTablet), F = !!(m.ipad || m.tablet || m.androidTablet), H = !!(m.android || m.androidTablet ||
|
||
m.tablet || m.ipad || m.ipod || m.iphone || m["windows phone"]), Z = !!(m.cros || m.mac || m.linux || m.win), me = !!(m.brave || m.chrome ||
|
||
m.crios || m.opr || m.safari || m.edg || m.electron), V = !!(m.msie || m.rv);
|
||
return { name: (y = e[v]) !== null && y !== void 0 ? y : null, platform: (g = t[x]) !== null && g !== void 0 ? g : null, userAgent: b,
|
||
version: R, shortVersion: R ? o(parseFloat(R), 2) : null, isAndroid: k, isTablet: F, isMobile: H, isDesktop: Z, isWebkit: me, isIE: V };
|
||
}, "value") }, { key: "getBrowserInfo", value: /* @__PURE__ */ n(function() {
|
||
var p = this.parseUserAgent();
|
||
return { name: p.name, platform: p.platform, userAgent: p.userAgent, version: p.version, shortVersion: p.shortVersion };
|
||
}, "value") }], u = [{ key: "VERSION", get: /* @__PURE__ */ n(function() {
|
||
return "3.4.0";
|
||
}, "get") }], l && r(c.prototype, l), u && r(c, u), Object.defineProperty(c, "prototype", { writable: !1 }), s;
|
||
}();
|
||
return i;
|
||
});
|
||
});
|
||
|
||
// src/core-events/index.ts
|
||
var be = {};
|
||
Ce(be, {
|
||
ARGTYPES_INFO_REQUEST: () => Tn,
|
||
ARGTYPES_INFO_RESPONSE: () => Ut,
|
||
CHANNEL_CREATED: () => xm,
|
||
CHANNEL_WS_DISCONNECT: () => en,
|
||
CONFIG_ERROR: () => rn,
|
||
CREATE_NEW_STORYFILE_REQUEST: () => _m,
|
||
CREATE_NEW_STORYFILE_RESPONSE: () => Pm,
|
||
CURRENT_STORY_WAS_SET: () => jt,
|
||
DOCS_PREPARED: () => tn,
|
||
DOCS_RENDERED: () => Lr,
|
||
FILE_COMPONENT_SEARCH_REQUEST: () => Om,
|
||
FILE_COMPONENT_SEARCH_RESPONSE: () => Cm,
|
||
FORCE_REMOUNT: () => on,
|
||
FORCE_RE_RENDER: () => kr,
|
||
GLOBALS_UPDATED: () => nn,
|
||
NAVIGATE_URL: () => Im,
|
||
PLAY_FUNCTION_THREW_EXCEPTION: () => an,
|
||
PRELOAD_ENTRIES: () => ln,
|
||
PREVIEW_BUILDER_PROGRESS: () => Fm,
|
||
PREVIEW_KEYDOWN: () => cn,
|
||
REGISTER_SUBSCRIPTION: () => Dm,
|
||
REQUEST_WHATS_NEW_DATA: () => Gm,
|
||
RESET_STORY_ARGS: () => Mr,
|
||
RESULT_WHATS_NEW_DATA: () => Hm,
|
||
SAVE_STORY_REQUEST: () => Wm,
|
||
SAVE_STORY_RESPONSE: () => zm,
|
||
SELECT_STORY: () => Nm,
|
||
SET_CONFIG: () => qm,
|
||
SET_CURRENT_STORY: () => un,
|
||
SET_GLOBALS: () => pn,
|
||
SET_INDEX: () => Lm,
|
||
SET_STORIES: () => km,
|
||
SET_WHATS_NEW_CACHE: () => Vm,
|
||
SHARED_STATE_CHANGED: () => Mm,
|
||
SHARED_STATE_SET: () => jm,
|
||
STORIES_COLLAPSE_ALL: () => Bm,
|
||
STORIES_EXPAND_ALL: () => Um,
|
||
STORY_ARGS_UPDATED: () => dn,
|
||
STORY_CHANGED: () => fn,
|
||
STORY_ERRORED: () => yn,
|
||
STORY_INDEX_INVALIDATED: () => hn,
|
||
STORY_MISSING: () => Bt,
|
||
STORY_PREPARED: () => mn,
|
||
STORY_RENDERED: () => Je,
|
||
STORY_RENDER_PHASE_CHANGED: () => Ie,
|
||
STORY_SPECIFIED: () => gn,
|
||
STORY_THREW_EXCEPTION: () => Sn,
|
||
STORY_UNCHANGED: () => bn,
|
||
TELEMETRY_ERROR: () => En,
|
||
TOGGLE_WHATS_NEW_NOTIFICATIONS: () => $m,
|
||
UNHANDLED_ERRORS_WHILE_PLAYING: () => sn,
|
||
UPDATE_GLOBALS: () => jr,
|
||
UPDATE_QUERY_PARAMS: () => vn,
|
||
UPDATE_STORY_ARGS: () => Br,
|
||
default: () => wm
|
||
});
|
||
var Zo = /* @__PURE__ */ ((A) => (A.CHANNEL_WS_DISCONNECT = "channelWSDisconnect", A.CHANNEL_CREATED = "channelCreated", A.CONFIG_ERROR = "c\
|
||
onfigError", A.STORY_INDEX_INVALIDATED = "storyIndexInvalidated", A.STORY_SPECIFIED = "storySpecified", A.SET_CONFIG = "setConfig", A.SET_STORIES =
|
||
"setStories", A.SET_INDEX = "setIndex", A.SET_CURRENT_STORY = "setCurrentStory", A.CURRENT_STORY_WAS_SET = "currentStoryWasSet", A.FORCE_RE_RENDER =
|
||
"forceReRender", A.FORCE_REMOUNT = "forceRemount", A.PRELOAD_ENTRIES = "preloadStories", A.STORY_PREPARED = "storyPrepared", A.DOCS_PREPARED =
|
||
"docsPrepared", A.STORY_CHANGED = "storyChanged", A.STORY_UNCHANGED = "storyUnchanged", A.STORY_RENDERED = "storyRendered", A.STORY_MISSING =
|
||
"storyMissing", A.STORY_ERRORED = "storyErrored", A.STORY_THREW_EXCEPTION = "storyThrewException", A.STORY_RENDER_PHASE_CHANGED = "storyRend\
|
||
erPhaseChanged", A.PLAY_FUNCTION_THREW_EXCEPTION = "playFunctionThrewException", A.UNHANDLED_ERRORS_WHILE_PLAYING = "unhandledErrorsWhilePla\
|
||
ying", A.UPDATE_STORY_ARGS = "updateStoryArgs", A.STORY_ARGS_UPDATED = "storyArgsUpdated", A.RESET_STORY_ARGS = "resetStoryArgs", A.SET_GLOBALS =
|
||
"setGlobals", A.UPDATE_GLOBALS = "updateGlobals", A.GLOBALS_UPDATED = "globalsUpdated", A.REGISTER_SUBSCRIPTION = "registerSubscription", A.
|
||
PREVIEW_KEYDOWN = "previewKeydown", A.PREVIEW_BUILDER_PROGRESS = "preview_builder_progress", A.SELECT_STORY = "selectStory", A.STORIES_COLLAPSE_ALL =
|
||
"storiesCollapseAll", A.STORIES_EXPAND_ALL = "storiesExpandAll", A.DOCS_RENDERED = "docsRendered", A.SHARED_STATE_CHANGED = "sharedStateChan\
|
||
ged", A.SHARED_STATE_SET = "sharedStateSet", A.NAVIGATE_URL = "navigateUrl", A.UPDATE_QUERY_PARAMS = "updateQueryParams", A.REQUEST_WHATS_NEW_DATA =
|
||
"requestWhatsNewData", A.RESULT_WHATS_NEW_DATA = "resultWhatsNewData", A.SET_WHATS_NEW_CACHE = "setWhatsNewCache", A.TOGGLE_WHATS_NEW_NOTIFICATIONS =
|
||
"toggleWhatsNewNotifications", A.TELEMETRY_ERROR = "telemetryError", A.FILE_COMPONENT_SEARCH_REQUEST = "fileComponentSearchRequest", A.FILE_COMPONENT_SEARCH_RESPONSE =
|
||
"fileComponentSearchResponse", A.SAVE_STORY_REQUEST = "saveStoryRequest", A.SAVE_STORY_RESPONSE = "saveStoryResponse", A.ARGTYPES_INFO_REQUEST =
|
||
"argtypesInfoRequest", A.ARGTYPES_INFO_RESPONSE = "argtypesInfoResponse", A.CREATE_NEW_STORYFILE_REQUEST = "createNewStoryfileRequest", A.CREATE_NEW_STORYFILE_RESPONSE =
|
||
"createNewStoryfileResponse", A))(Zo || {}), wm = Zo, {
|
||
CHANNEL_WS_DISCONNECT: en,
|
||
CHANNEL_CREATED: xm,
|
||
CONFIG_ERROR: rn,
|
||
CREATE_NEW_STORYFILE_REQUEST: _m,
|
||
CREATE_NEW_STORYFILE_RESPONSE: Pm,
|
||
CURRENT_STORY_WAS_SET: jt,
|
||
DOCS_PREPARED: tn,
|
||
DOCS_RENDERED: Lr,
|
||
FILE_COMPONENT_SEARCH_REQUEST: Om,
|
||
FILE_COMPONENT_SEARCH_RESPONSE: Cm,
|
||
FORCE_RE_RENDER: kr,
|
||
FORCE_REMOUNT: on,
|
||
GLOBALS_UPDATED: nn,
|
||
NAVIGATE_URL: Im,
|
||
PLAY_FUNCTION_THREW_EXCEPTION: an,
|
||
UNHANDLED_ERRORS_WHILE_PLAYING: sn,
|
||
PRELOAD_ENTRIES: ln,
|
||
PREVIEW_BUILDER_PROGRESS: Fm,
|
||
PREVIEW_KEYDOWN: cn,
|
||
REGISTER_SUBSCRIPTION: Dm,
|
||
RESET_STORY_ARGS: Mr,
|
||
SELECT_STORY: Nm,
|
||
SET_CONFIG: qm,
|
||
SET_CURRENT_STORY: un,
|
||
SET_GLOBALS: pn,
|
||
SET_INDEX: Lm,
|
||
SET_STORIES: km,
|
||
SHARED_STATE_CHANGED: Mm,
|
||
SHARED_STATE_SET: jm,
|
||
STORIES_COLLAPSE_ALL: Bm,
|
||
STORIES_EXPAND_ALL: Um,
|
||
STORY_ARGS_UPDATED: dn,
|
||
STORY_CHANGED: fn,
|
||
STORY_ERRORED: yn,
|
||
STORY_INDEX_INVALIDATED: hn,
|
||
STORY_MISSING: Bt,
|
||
STORY_PREPARED: mn,
|
||
STORY_RENDER_PHASE_CHANGED: Ie,
|
||
STORY_RENDERED: Je,
|
||
STORY_SPECIFIED: gn,
|
||
STORY_THREW_EXCEPTION: Sn,
|
||
STORY_UNCHANGED: bn,
|
||
UPDATE_GLOBALS: jr,
|
||
UPDATE_QUERY_PARAMS: vn,
|
||
UPDATE_STORY_ARGS: Br,
|
||
REQUEST_WHATS_NEW_DATA: Gm,
|
||
RESULT_WHATS_NEW_DATA: Hm,
|
||
SET_WHATS_NEW_CACHE: Vm,
|
||
TOGGLE_WHATS_NEW_NOTIFICATIONS: $m,
|
||
TELEMETRY_ERROR: En,
|
||
SAVE_STORY_REQUEST: Wm,
|
||
SAVE_STORY_RESPONSE: zm,
|
||
ARGTYPES_INFO_REQUEST: Tn,
|
||
ARGTYPES_INFO_RESPONSE: Ut
|
||
} = Zo;
|
||
|
||
// ../node_modules/@storybook/global/dist/index.mjs
|
||
var Rn = {};
|
||
Ce(Rn, {
|
||
global: () => T
|
||
});
|
||
var T = (() => {
|
||
let r;
|
||
return typeof window < "u" ? r = window : typeof globalThis < "u" ? r = globalThis : typeof global < "u" ? r = global : typeof self < "u" ?
|
||
r = self : r = {}, r;
|
||
})();
|
||
|
||
// src/preview/globals/globals.ts
|
||
var An = {
|
||
"@storybook/global": "__STORYBOOK_MODULE_GLOBAL__",
|
||
"storybook/internal/channels": "__STORYBOOK_MODULE_CHANNELS__",
|
||
"@storybook/channels": "__STORYBOOK_MODULE_CHANNELS__",
|
||
"@storybook/core/channels": "__STORYBOOK_MODULE_CHANNELS__",
|
||
"storybook/internal/client-logger": "__STORYBOOK_MODULE_CLIENT_LOGGER__",
|
||
"@storybook/client-logger": "__STORYBOOK_MODULE_CLIENT_LOGGER__",
|
||
"@storybook/core/client-logger": "__STORYBOOK_MODULE_CLIENT_LOGGER__",
|
||
"storybook/internal/core-events": "__STORYBOOK_MODULE_CORE_EVENTS__",
|
||
"@storybook/core-events": "__STORYBOOK_MODULE_CORE_EVENTS__",
|
||
"@storybook/core/core-events": "__STORYBOOK_MODULE_CORE_EVENTS__",
|
||
"storybook/internal/preview-errors": "__STORYBOOK_MODULE_CORE_EVENTS_PREVIEW_ERRORS__",
|
||
"@storybook/core-events/preview-errors": "__STORYBOOK_MODULE_CORE_EVENTS_PREVIEW_ERRORS__",
|
||
"@storybook/core/preview-errors": "__STORYBOOK_MODULE_CORE_EVENTS_PREVIEW_ERRORS__",
|
||
"storybook/internal/preview-api": "__STORYBOOK_MODULE_PREVIEW_API__",
|
||
"@storybook/preview-api": "__STORYBOOK_MODULE_PREVIEW_API__",
|
||
"@storybook/core/preview-api": "__STORYBOOK_MODULE_PREVIEW_API__",
|
||
"storybook/internal/types": "__STORYBOOK_MODULE_TYPES__",
|
||
"@storybook/types": "__STORYBOOK_MODULE_TYPES__",
|
||
"@storybook/core/types": "__STORYBOOK_MODULE_TYPES__"
|
||
}, ss = Object.keys(An);
|
||
|
||
// src/channels/index.ts
|
||
var $r = {};
|
||
Ce($r, {
|
||
Channel: () => ve,
|
||
PostMessageTransport: () => or,
|
||
WebsocketTransport: () => nr,
|
||
createBrowserChannel: () => Vb,
|
||
default: () => Hb
|
||
});
|
||
|
||
// src/channels/main.ts
|
||
var Ym = /* @__PURE__ */ n((r) => r.transports !== void 0, "isMulti"), Km = /* @__PURE__ */ n(() => Math.random().toString(16).slice(2), "ge\
|
||
nerateRandomId"), wn = class wn {
|
||
isAsync;
|
||
sender = Km();
|
||
events = {};
|
||
data = {};
|
||
transports = [];
|
||
constructor(e = {}) {
|
||
this.isAsync = e.async || !1, Ym(e) ? (this.transports = e.transports || [], this.transports.forEach((t) => {
|
||
t.setHandler((o) => this.handleEvent(o));
|
||
})) : this.transports = e.transport ? [e.transport] : [], this.transports.forEach((t) => {
|
||
t.setHandler((o) => this.handleEvent(o));
|
||
});
|
||
}
|
||
get hasTransport() {
|
||
return this.transports.length > 0;
|
||
}
|
||
addListener(e, t) {
|
||
this.events[e] = this.events[e] || [], this.events[e].push(t);
|
||
}
|
||
emit(e, ...t) {
|
||
let o = { type: e, args: t, from: this.sender }, a = {};
|
||
t.length >= 1 && t[0] && t[0].options && (a = t[0].options);
|
||
let i = /* @__PURE__ */ n(() => {
|
||
this.transports.forEach((s) => {
|
||
s.send(o, a);
|
||
}), this.handleEvent(o);
|
||
}, "handler");
|
||
this.isAsync ? setImmediate(i) : i();
|
||
}
|
||
last(e) {
|
||
return this.data[e];
|
||
}
|
||
eventNames() {
|
||
return Object.keys(this.events);
|
||
}
|
||
listenerCount(e) {
|
||
let t = this.listeners(e);
|
||
return t ? t.length : 0;
|
||
}
|
||
listeners(e) {
|
||
return this.events[e] || void 0;
|
||
}
|
||
once(e, t) {
|
||
let o = this.onceListener(e, t);
|
||
this.addListener(e, o);
|
||
}
|
||
removeAllListeners(e) {
|
||
e ? this.events[e] && delete this.events[e] : this.events = {};
|
||
}
|
||
removeListener(e, t) {
|
||
let o = this.listeners(e);
|
||
o && (this.events[e] = o.filter((a) => a !== t));
|
||
}
|
||
on(e, t) {
|
||
this.addListener(e, t);
|
||
}
|
||
off(e, t) {
|
||
this.removeListener(e, t);
|
||
}
|
||
handleEvent(e) {
|
||
let t = this.listeners(e.type);
|
||
t && t.length && t.forEach((o) => {
|
||
o.apply(e, e.args);
|
||
}), this.data[e.type] = e.args;
|
||
}
|
||
onceListener(e, t) {
|
||
let o = /* @__PURE__ */ n((...a) => (this.removeListener(e, o), t(...a)), "onceListener");
|
||
return o;
|
||
}
|
||
};
|
||
n(wn, "Channel");
|
||
var ve = wn;
|
||
|
||
// src/client-logger/index.ts
|
||
var Ur = {};
|
||
Ce(Ur, {
|
||
deprecate: () => ae,
|
||
logger: () => C,
|
||
once: () => M,
|
||
pretty: () => re
|
||
});
|
||
var { LOGLEVEL: Xm } = T, Ee = {
|
||
trace: 1,
|
||
debug: 2,
|
||
info: 3,
|
||
warn: 4,
|
||
error: 5,
|
||
silent: 10
|
||
}, Jm = Xm, Qe = Ee[Jm] || Ee.info, C = {
|
||
trace: /* @__PURE__ */ n((r, ...e) => {
|
||
Qe <= Ee.trace && console.trace(r, ...e);
|
||
}, "trace"),
|
||
debug: /* @__PURE__ */ n((r, ...e) => {
|
||
Qe <= Ee.debug && console.debug(r, ...e);
|
||
}, "debug"),
|
||
info: /* @__PURE__ */ n((r, ...e) => {
|
||
Qe <= Ee.info && console.info(r, ...e);
|
||
}, "info"),
|
||
warn: /* @__PURE__ */ n((r, ...e) => {
|
||
Qe <= Ee.warn && console.warn(r, ...e);
|
||
}, "warn"),
|
||
error: /* @__PURE__ */ n((r, ...e) => {
|
||
Qe <= Ee.error && console.error(r, ...e);
|
||
}, "error"),
|
||
log: /* @__PURE__ */ n((r, ...e) => {
|
||
Qe < Ee.silent && console.log(r, ...e);
|
||
}, "log")
|
||
}, xn = /* @__PURE__ */ new Set(), M = /* @__PURE__ */ n((r) => (e, ...t) => {
|
||
if (!xn.has(e))
|
||
return xn.add(e), C[r](e, ...t);
|
||
}, "once");
|
||
M.clear = () => xn.clear();
|
||
M.trace = M("trace");
|
||
M.debug = M("debug");
|
||
M.info = M("info");
|
||
M.warn = M("warn");
|
||
M.error = M("error");
|
||
M.log = M("log");
|
||
var ae = M("warn"), re = /* @__PURE__ */ n((r) => (...e) => {
|
||
let t = [];
|
||
if (e.length) {
|
||
let o = /<span\s+style=(['"])([^'"]*)\1\s*>/gi, a = /<\/span>/gi, i;
|
||
for (t.push(e[0].replace(o, "%c").replace(a, "%c")); i = o.exec(e[0]); )
|
||
t.push(i[2]), t.push("");
|
||
for (let s = 1; s < e.length; s++)
|
||
t.push(e[s]);
|
||
}
|
||
C[r].apply(C, t);
|
||
}, "pretty");
|
||
re.trace = re("trace");
|
||
re.debug = re("debug");
|
||
re.info = re("info");
|
||
re.warn = re("warn");
|
||
re.error = re("error");
|
||
|
||
// ../node_modules/telejson/dist/chunk-465TF3XA.mjs
|
||
var Qm = Object.create, ls = Object.defineProperty, Zm = Object.getOwnPropertyDescriptor, cs = Object.getOwnPropertyNames, eg = Object.getPrototypeOf,
|
||
rg = Object.prototype.hasOwnProperty, oe = /* @__PURE__ */ n((r, e) => /* @__PURE__ */ n(function() {
|
||
return e || (0, r[cs(r)[0]])((e = { exports: {} }).exports, e), e.exports;
|
||
}, "__require"), "__commonJS"), tg = /* @__PURE__ */ n((r, e, t, o) => {
|
||
if (e && typeof e == "object" || typeof e == "function")
|
||
for (let a of cs(e))
|
||
!rg.call(r, a) && a !== t && ls(r, a, { get: /* @__PURE__ */ n(() => e[a], "get"), enumerable: !(o = Zm(e, a)) || o.enumerable });
|
||
return r;
|
||
}, "__copyProps"), Gt = /* @__PURE__ */ n((r, e, t) => (t = r != null ? Qm(eg(r)) : {}, tg(
|
||
e || !r || !r.__esModule ? ls(t, "default", { value: r, enumerable: !0 }) : t,
|
||
r
|
||
)), "__toESM"), og = [
|
||
"bubbles",
|
||
"cancelBubble",
|
||
"cancelable",
|
||
"composed",
|
||
"currentTarget",
|
||
"defaultPrevented",
|
||
"eventPhase",
|
||
"isTrusted",
|
||
"returnValue",
|
||
"srcElement",
|
||
"target",
|
||
"timeStamp",
|
||
"type"
|
||
], ng = ["detail"];
|
||
function us(r) {
|
||
let e = og.filter((t) => r[t] !== void 0).reduce((t, o) => ({ ...t, [o]: r[o] }), {});
|
||
return r instanceof CustomEvent && ng.filter((t) => r[t] !== void 0).forEach((t) => {
|
||
e[t] = r[t];
|
||
}), e;
|
||
}
|
||
n(us, "extractEventHiddenProperties");
|
||
|
||
// ../node_modules/telejson/dist/index.mjs
|
||
var xs = Y(Ht(), 1);
|
||
var gs = oe({
|
||
"node_modules/has-symbols/shams.js"(r, e) {
|
||
"use strict";
|
||
e.exports = /* @__PURE__ */ n(function() {
|
||
if (typeof Symbol != "function" || typeof Object.getOwnPropertySymbols != "function")
|
||
return !1;
|
||
if (typeof Symbol.iterator == "symbol")
|
||
return !0;
|
||
var o = {}, a = Symbol("test"), i = Object(a);
|
||
if (typeof a == "string" || Object.prototype.toString.call(a) !== "[object Symbol]" || Object.prototype.toString.call(i) !== "[object \
|
||
Symbol]")
|
||
return !1;
|
||
var s = 42;
|
||
o[a] = s;
|
||
for (a in o)
|
||
return !1;
|
||
if (typeof Object.keys == "function" && Object.keys(o).length !== 0 || typeof Object.getOwnPropertyNames == "function" && Object.getOwnPropertyNames(
|
||
o).length !== 0)
|
||
return !1;
|
||
var c = Object.getOwnPropertySymbols(o);
|
||
if (c.length !== 1 || c[0] !== a || !Object.prototype.propertyIsEnumerable.call(o, a))
|
||
return !1;
|
||
if (typeof Object.getOwnPropertyDescriptor == "function") {
|
||
var l = Object.getOwnPropertyDescriptor(o, a);
|
||
if (l.value !== s || l.enumerable !== !0)
|
||
return !1;
|
||
}
|
||
return !0;
|
||
}, "hasSymbols");
|
||
}
|
||
}), Ss = oe({
|
||
"node_modules/has-symbols/index.js"(r, e) {
|
||
"use strict";
|
||
var t = typeof Symbol < "u" && Symbol, o = gs();
|
||
e.exports = /* @__PURE__ */ n(function() {
|
||
return typeof t != "function" || typeof Symbol != "function" || typeof t("foo") != "symbol" || typeof Symbol("bar") != "symbol" ? !1 :
|
||
o();
|
||
}, "hasNativeSymbols");
|
||
}
|
||
}), ag = oe({
|
||
"node_modules/function-bind/implementation.js"(r, e) {
|
||
"use strict";
|
||
var t = "Function.prototype.bind called on incompatible ", o = Array.prototype.slice, a = Object.prototype.toString, i = "[object Functi\
|
||
on]";
|
||
e.exports = /* @__PURE__ */ n(function(c) {
|
||
var l = this;
|
||
if (typeof l != "function" || a.call(l) !== i)
|
||
throw new TypeError(t + l);
|
||
for (var u = o.call(arguments, 1), p, h = /* @__PURE__ */ n(function() {
|
||
if (this instanceof p) {
|
||
var S = l.apply(
|
||
this,
|
||
u.concat(o.call(arguments))
|
||
);
|
||
return Object(S) === S ? S : this;
|
||
} else
|
||
return l.apply(
|
||
c,
|
||
u.concat(o.call(arguments))
|
||
);
|
||
}, "binder"), y = Math.max(0, l.length - u.length), g = [], m = 0; m < y; m++)
|
||
g.push("$" + m);
|
||
if (p = Function("binder", "return function (" + g.join(",") + "){ return binder.apply(this,arguments); }")(h), l.prototype) {
|
||
var b = /* @__PURE__ */ n(function() {
|
||
}, "Empty2");
|
||
b.prototype = l.prototype, p.prototype = new b(), b.prototype = null;
|
||
}
|
||
return p;
|
||
}, "bind");
|
||
}
|
||
}), On = oe({
|
||
"node_modules/function-bind/index.js"(r, e) {
|
||
"use strict";
|
||
var t = ag();
|
||
e.exports = Function.prototype.bind || t;
|
||
}
|
||
}), ig = oe({
|
||
"node_modules/has/src/index.js"(r, e) {
|
||
"use strict";
|
||
var t = On();
|
||
e.exports = t.call(Function.call, Object.prototype.hasOwnProperty);
|
||
}
|
||
}), bs = oe({
|
||
"node_modules/get-intrinsic/index.js"(r, e) {
|
||
"use strict";
|
||
var t, o = SyntaxError, a = Function, i = TypeError, s = /* @__PURE__ */ n(function(V) {
|
||
try {
|
||
return a('"use strict"; return (' + V + ").constructor;")();
|
||
} catch {
|
||
}
|
||
}, "getEvalledConstructor"), c = Object.getOwnPropertyDescriptor;
|
||
if (c)
|
||
try {
|
||
c({}, "");
|
||
} catch {
|
||
c = null;
|
||
}
|
||
var l = /* @__PURE__ */ n(function() {
|
||
throw new i();
|
||
}, "throwTypeError"), u = c ? function() {
|
||
try {
|
||
return arguments.callee, l;
|
||
} catch {
|
||
try {
|
||
return c(arguments, "callee").get;
|
||
} catch {
|
||
return l;
|
||
}
|
||
}
|
||
}() : l, p = Ss()(), h = Object.getPrototypeOf || function(V) {
|
||
return V.__proto__;
|
||
}, y = {}, g = typeof Uint8Array > "u" ? t : h(Uint8Array), m = {
|
||
"%AggregateError%": typeof AggregateError > "u" ? t : AggregateError,
|
||
"%Array%": Array,
|
||
"%ArrayBuffer%": typeof ArrayBuffer > "u" ? t : ArrayBuffer,
|
||
"%ArrayIteratorPrototype%": p ? h([][Symbol.iterator]()) : t,
|
||
"%AsyncFromSyncIteratorPrototype%": t,
|
||
"%AsyncFunction%": y,
|
||
"%AsyncGenerator%": y,
|
||
"%AsyncGeneratorFunction%": y,
|
||
"%AsyncIteratorPrototype%": y,
|
||
"%Atomics%": typeof Atomics > "u" ? t : Atomics,
|
||
"%BigInt%": typeof BigInt > "u" ? t : BigInt,
|
||
"%Boolean%": Boolean,
|
||
"%DataView%": typeof DataView > "u" ? t : DataView,
|
||
"%Date%": Date,
|
||
"%decodeURI%": decodeURI,
|
||
"%decodeURIComponent%": decodeURIComponent,
|
||
"%encodeURI%": encodeURI,
|
||
"%encodeURIComponent%": encodeURIComponent,
|
||
"%Error%": Error,
|
||
"%eval%": eval,
|
||
"%EvalError%": EvalError,
|
||
"%Float32Array%": typeof Float32Array > "u" ? t : Float32Array,
|
||
"%Float64Array%": typeof Float64Array > "u" ? t : Float64Array,
|
||
"%FinalizationRegistry%": typeof FinalizationRegistry > "u" ? t : FinalizationRegistry,
|
||
"%Function%": a,
|
||
"%GeneratorFunction%": y,
|
||
"%Int8Array%": typeof Int8Array > "u" ? t : Int8Array,
|
||
"%Int16Array%": typeof Int16Array > "u" ? t : Int16Array,
|
||
"%Int32Array%": typeof Int32Array > "u" ? t : Int32Array,
|
||
"%isFinite%": isFinite,
|
||
"%isNaN%": isNaN,
|
||
"%IteratorPrototype%": p ? h(h([][Symbol.iterator]())) : t,
|
||
"%JSON%": typeof JSON == "object" ? JSON : t,
|
||
"%Map%": typeof Map > "u" ? t : Map,
|
||
"%MapIteratorPrototype%": typeof Map > "u" || !p ? t : h((/* @__PURE__ */ new Map())[Symbol.iterator]()),
|
||
"%Math%": Math,
|
||
"%Number%": Number,
|
||
"%Object%": Object,
|
||
"%parseFloat%": parseFloat,
|
||
"%parseInt%": parseInt,
|
||
"%Promise%": typeof Promise > "u" ? t : Promise,
|
||
"%Proxy%": typeof Proxy > "u" ? t : Proxy,
|
||
"%RangeError%": RangeError,
|
||
"%ReferenceError%": ReferenceError,
|
||
"%Reflect%": typeof Reflect > "u" ? t : Reflect,
|
||
"%RegExp%": RegExp,
|
||
"%Set%": typeof Set > "u" ? t : Set,
|
||
"%SetIteratorPrototype%": typeof Set > "u" || !p ? t : h((/* @__PURE__ */ new Set())[Symbol.iterator]()),
|
||
"%SharedArrayBuffer%": typeof SharedArrayBuffer > "u" ? t : SharedArrayBuffer,
|
||
"%String%": String,
|
||
"%StringIteratorPrototype%": p ? h(""[Symbol.iterator]()) : t,
|
||
"%Symbol%": p ? Symbol : t,
|
||
"%SyntaxError%": o,
|
||
"%ThrowTypeError%": u,
|
||
"%TypedArray%": g,
|
||
"%TypeError%": i,
|
||
"%Uint8Array%": typeof Uint8Array > "u" ? t : Uint8Array,
|
||
"%Uint8ClampedArray%": typeof Uint8ClampedArray > "u" ? t : Uint8ClampedArray,
|
||
"%Uint16Array%": typeof Uint16Array > "u" ? t : Uint16Array,
|
||
"%Uint32Array%": typeof Uint32Array > "u" ? t : Uint32Array,
|
||
"%URIError%": URIError,
|
||
"%WeakMap%": typeof WeakMap > "u" ? t : WeakMap,
|
||
"%WeakRef%": typeof WeakRef > "u" ? t : WeakRef,
|
||
"%WeakSet%": typeof WeakSet > "u" ? t : WeakSet
|
||
}, b = /* @__PURE__ */ n(function V(D) {
|
||
var q;
|
||
if (D === "%AsyncFunction%")
|
||
q = s("async function () {}");
|
||
else if (D === "%GeneratorFunction%")
|
||
q = s("function* () {}");
|
||
else if (D === "%AsyncGeneratorFunction%")
|
||
q = s("async function* () {}");
|
||
else if (D === "%AsyncGenerator%") {
|
||
var N = V("%AsyncGeneratorFunction%");
|
||
N && (q = N.prototype);
|
||
} else if (D === "%AsyncIteratorPrototype%") {
|
||
var B = V("%AsyncGenerator%");
|
||
B && (q = h(B.prototype));
|
||
}
|
||
return m[D] = q, q;
|
||
}, "doEval2"), S = {
|
||
"%ArrayBufferPrototype%": ["ArrayBuffer", "prototype"],
|
||
"%ArrayPrototype%": ["Array", "prototype"],
|
||
"%ArrayProto_entries%": ["Array", "prototype", "entries"],
|
||
"%ArrayProto_forEach%": ["Array", "prototype", "forEach"],
|
||
"%ArrayProto_keys%": ["Array", "prototype", "keys"],
|
||
"%ArrayProto_values%": ["Array", "prototype", "values"],
|
||
"%AsyncFunctionPrototype%": ["AsyncFunction", "prototype"],
|
||
"%AsyncGenerator%": ["AsyncGeneratorFunction", "prototype"],
|
||
"%AsyncGeneratorPrototype%": ["AsyncGeneratorFunction", "prototype", "prototype"],
|
||
"%BooleanPrototype%": ["Boolean", "prototype"],
|
||
"%DataViewPrototype%": ["DataView", "prototype"],
|
||
"%DatePrototype%": ["Date", "prototype"],
|
||
"%ErrorPrototype%": ["Error", "prototype"],
|
||
"%EvalErrorPrototype%": ["EvalError", "prototype"],
|
||
"%Float32ArrayPrototype%": ["Float32Array", "prototype"],
|
||
"%Float64ArrayPrototype%": ["Float64Array", "prototype"],
|
||
"%FunctionPrototype%": ["Function", "prototype"],
|
||
"%Generator%": ["GeneratorFunction", "prototype"],
|
||
"%GeneratorPrototype%": ["GeneratorFunction", "prototype", "prototype"],
|
||
"%Int8ArrayPrototype%": ["Int8Array", "prototype"],
|
||
"%Int16ArrayPrototype%": ["Int16Array", "prototype"],
|
||
"%Int32ArrayPrototype%": ["Int32Array", "prototype"],
|
||
"%JSONParse%": ["JSON", "parse"],
|
||
"%JSONStringify%": ["JSON", "stringify"],
|
||
"%MapPrototype%": ["Map", "prototype"],
|
||
"%NumberPrototype%": ["Number", "prototype"],
|
||
"%ObjectPrototype%": ["Object", "prototype"],
|
||
"%ObjProto_toString%": ["Object", "prototype", "toString"],
|
||
"%ObjProto_valueOf%": ["Object", "prototype", "valueOf"],
|
||
"%PromisePrototype%": ["Promise", "prototype"],
|
||
"%PromiseProto_then%": ["Promise", "prototype", "then"],
|
||
"%Promise_all%": ["Promise", "all"],
|
||
"%Promise_reject%": ["Promise", "reject"],
|
||
"%Promise_resolve%": ["Promise", "resolve"],
|
||
"%RangeErrorPrototype%": ["RangeError", "prototype"],
|
||
"%ReferenceErrorPrototype%": ["ReferenceError", "prototype"],
|
||
"%RegExpPrototype%": ["RegExp", "prototype"],
|
||
"%SetPrototype%": ["Set", "prototype"],
|
||
"%SharedArrayBufferPrototype%": ["SharedArrayBuffer", "prototype"],
|
||
"%StringPrototype%": ["String", "prototype"],
|
||
"%SymbolPrototype%": ["Symbol", "prototype"],
|
||
"%SyntaxErrorPrototype%": ["SyntaxError", "prototype"],
|
||
"%TypedArrayPrototype%": ["TypedArray", "prototype"],
|
||
"%TypeErrorPrototype%": ["TypeError", "prototype"],
|
||
"%Uint8ArrayPrototype%": ["Uint8Array", "prototype"],
|
||
"%Uint8ClampedArrayPrototype%": ["Uint8ClampedArray", "prototype"],
|
||
"%Uint16ArrayPrototype%": ["Uint16Array", "prototype"],
|
||
"%Uint32ArrayPrototype%": ["Uint32Array", "prototype"],
|
||
"%URIErrorPrototype%": ["URIError", "prototype"],
|
||
"%WeakMapPrototype%": ["WeakMap", "prototype"],
|
||
"%WeakSetPrototype%": ["WeakSet", "prototype"]
|
||
}, w = On(), E = ig(), v = w.call(Function.call, Array.prototype.concat), x = w.call(Function.apply, Array.prototype.splice), R = w.call(
|
||
Function.call, String.prototype.replace), P = w.call(Function.call, String.prototype.slice), k = w.call(Function.call, RegExp.prototype.
|
||
exec), F = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g, H = /\\(\\)?/g, Z = /* @__PURE__ */ n(
|
||
function(D) {
|
||
var q = P(D, 0, 1), N = P(D, -1);
|
||
if (q === "%" && N !== "%")
|
||
throw new o("invalid intrinsic syntax, expected closing `%`");
|
||
if (N === "%" && q !== "%")
|
||
throw new o("invalid intrinsic syntax, expected opening `%`");
|
||
var B = [];
|
||
return R(D, F, function(ee, ge, z, Se) {
|
||
B[B.length] = z ? R(Se, H, "$1") : ge || ee;
|
||
}), B;
|
||
}, "stringToPath3"), me = /* @__PURE__ */ n(function(D, q) {
|
||
var N = D, B;
|
||
if (E(S, N) && (B = S[N], N = "%" + B[0] + "%"), E(m, N)) {
|
||
var ee = m[N];
|
||
if (ee === y && (ee = b(N)), typeof ee > "u" && !q)
|
||
throw new i("intrinsic " + D + " exists, but is not available. Please file an issue!");
|
||
return {
|
||
alias: B,
|
||
name: N,
|
||
value: ee
|
||
};
|
||
}
|
||
throw new o("intrinsic " + D + " does not exist!");
|
||
}, "getBaseIntrinsic2");
|
||
e.exports = /* @__PURE__ */ n(function(D, q) {
|
||
if (typeof D != "string" || D.length === 0)
|
||
throw new i("intrinsic name must be a non-empty string");
|
||
if (arguments.length > 1 && typeof q != "boolean")
|
||
throw new i('"allowMissing" argument must be a boolean');
|
||
if (k(/^%?[^%]*%?$/, D) === null)
|
||
throw new o("`%` may not be present anywhere but at the beginning and end of the intrinsic name");
|
||
var N = Z(D), B = N.length > 0 ? N[0] : "", ee = me("%" + B + "%", q), ge = ee.name, z = ee.value, Se = !1, Qo = ee.alias;
|
||
Qo && (B = Qo[0], x(N, v([0, 1], Qo)));
|
||
for (var Nt = 1, Nr = !0; Nt < N.length; Nt += 1) {
|
||
var de = N[Nt], qt = P(de, 0, 1), Lt = P(de, -1);
|
||
if ((qt === '"' || qt === "'" || qt === "`" || Lt === '"' || Lt === "'" || Lt === "`") && qt !== Lt)
|
||
throw new o("property names with quotes must have matching quotes");
|
||
if ((de === "constructor" || !Nr) && (Se = !0), B += "." + de, ge = "%" + B + "%", E(m, ge))
|
||
z = m[ge];
|
||
else if (z != null) {
|
||
if (!(de in z)) {
|
||
if (!q)
|
||
throw new i("base intrinsic for " + D + " exists, but the property is not available.");
|
||
return;
|
||
}
|
||
if (c && Nt + 1 >= N.length) {
|
||
var kt = c(z, de);
|
||
Nr = !!kt, Nr && "get" in kt && !("originalValue" in kt.get) ? z = kt.get : z = z[de];
|
||
} else
|
||
Nr = E(z, de), z = z[de];
|
||
Nr && !Se && (m[ge] = z);
|
||
}
|
||
}
|
||
return z;
|
||
}, "GetIntrinsic");
|
||
}
|
||
}), sg = oe({
|
||
"node_modules/call-bind/index.js"(r, e) {
|
||
"use strict";
|
||
var t = On(), o = bs(), a = o("%Function.prototype.apply%"), i = o("%Function.prototype.call%"), s = o("%Reflect.apply%", !0) || t.call(
|
||
i, a), c = o("%Object.getOwnPropertyDescriptor%", !0), l = o("%Object.defineProperty%", !0), u = o("%Math.max%");
|
||
if (l)
|
||
try {
|
||
l({}, "a", { value: 1 });
|
||
} catch {
|
||
l = null;
|
||
}
|
||
e.exports = /* @__PURE__ */ n(function(y) {
|
||
var g = s(t, i, arguments);
|
||
if (c && l) {
|
||
var m = c(g, "length");
|
||
m.configurable && l(
|
||
g,
|
||
"length",
|
||
{ value: 1 + u(0, y.length - (arguments.length - 1)) }
|
||
);
|
||
}
|
||
return g;
|
||
}, "callBind");
|
||
var p = /* @__PURE__ */ n(function() {
|
||
return s(t, a, arguments);
|
||
}, "applyBind2");
|
||
l ? l(e.exports, "apply", { value: p }) : e.exports.apply = p;
|
||
}
|
||
}), lg = oe({
|
||
"node_modules/call-bind/callBound.js"(r, e) {
|
||
"use strict";
|
||
var t = bs(), o = sg(), a = o(t("String.prototype.indexOf"));
|
||
e.exports = /* @__PURE__ */ n(function(s, c) {
|
||
var l = t(s, !!c);
|
||
return typeof l == "function" && a(s, ".prototype.") > -1 ? o(l) : l;
|
||
}, "callBoundIntrinsic");
|
||
}
|
||
}), cg = oe({
|
||
"node_modules/has-tostringtag/shams.js"(r, e) {
|
||
"use strict";
|
||
var t = gs();
|
||
e.exports = /* @__PURE__ */ n(function() {
|
||
return t() && !!Symbol.toStringTag;
|
||
}, "hasToStringTagShams");
|
||
}
|
||
}), ug = oe({
|
||
"node_modules/is-regex/index.js"(r, e) {
|
||
"use strict";
|
||
var t = lg(), o = cg()(), a, i, s, c;
|
||
o && (a = t("Object.prototype.hasOwnProperty"), i = t("RegExp.prototype.exec"), s = {}, l = /* @__PURE__ */ n(function() {
|
||
throw s;
|
||
}, "throwRegexMarker"), c = {
|
||
toString: l,
|
||
valueOf: l
|
||
}, typeof Symbol.toPrimitive == "symbol" && (c[Symbol.toPrimitive] = l));
|
||
var l, u = t("Object.prototype.toString"), p = Object.getOwnPropertyDescriptor, h = "[object RegExp]";
|
||
e.exports = /* @__PURE__ */ n(o ? function(g) {
|
||
if (!g || typeof g != "object")
|
||
return !1;
|
||
var m = p(g, "lastIndex"), b = m && a(m, "value");
|
||
if (!b)
|
||
return !1;
|
||
try {
|
||
i(g, c);
|
||
} catch (S) {
|
||
return S === s;
|
||
}
|
||
} : function(g) {
|
||
return !g || typeof g != "object" && typeof g != "function" ? !1 : u(g) === h;
|
||
}, "isRegex");
|
||
}
|
||
}), pg = oe({
|
||
"node_modules/is-function/index.js"(r, e) {
|
||
e.exports = o;
|
||
var t = Object.prototype.toString;
|
||
function o(a) {
|
||
if (!a)
|
||
return !1;
|
||
var i = t.call(a);
|
||
return i === "[object Function]" || typeof a == "function" && i !== "[object RegExp]" || typeof window < "u" && (a === window.setTimeout ||
|
||
a === window.alert || a === window.confirm || a === window.prompt);
|
||
}
|
||
n(o, "isFunction3");
|
||
}
|
||
}), dg = oe({
|
||
"node_modules/is-symbol/index.js"(r, e) {
|
||
"use strict";
|
||
var t = Object.prototype.toString, o = Ss()();
|
||
o ? (a = Symbol.prototype.toString, i = /^Symbol\(.*\)$/, s = /* @__PURE__ */ n(function(l) {
|
||
return typeof l.valueOf() != "symbol" ? !1 : i.test(a.call(l));
|
||
}, "isRealSymbolObject"), e.exports = /* @__PURE__ */ n(function(l) {
|
||
if (typeof l == "symbol")
|
||
return !0;
|
||
if (t.call(l) !== "[object Symbol]")
|
||
return !1;
|
||
try {
|
||
return s(l);
|
||
} catch {
|
||
return !1;
|
||
}
|
||
}, "isSymbol3")) : e.exports = /* @__PURE__ */ n(function(l) {
|
||
return !1;
|
||
}, "isSymbol3");
|
||
var a, i, s;
|
||
}
|
||
}), fg = Gt(ug()), yg = Gt(pg()), hg = Gt(dg());
|
||
function mg(r) {
|
||
return r != null && typeof r == "object" && Array.isArray(r) === !1;
|
||
}
|
||
n(mg, "isObject");
|
||
var gg = typeof global == "object" && global && global.Object === Object && global, Sg = gg, bg = typeof self == "object" && self && self.Object ===
|
||
Object && self, vg = Sg || bg || Function("return this")(), Cn = vg, Eg = Cn.Symbol, Ze = Eg, vs = Object.prototype, Tg = vs.hasOwnProperty,
|
||
Rg = vs.toString, Gr = Ze ? Ze.toStringTag : void 0;
|
||
function Ag(r) {
|
||
var e = Tg.call(r, Gr), t = r[Gr];
|
||
try {
|
||
r[Gr] = void 0;
|
||
var o = !0;
|
||
} catch {
|
||
}
|
||
var a = Rg.call(r);
|
||
return o && (e ? r[Gr] = t : delete r[Gr]), a;
|
||
}
|
||
n(Ag, "getRawTag");
|
||
var wg = Ag, xg = Object.prototype, _g = xg.toString;
|
||
function Pg(r) {
|
||
return _g.call(r);
|
||
}
|
||
n(Pg, "objectToString");
|
||
var Og = Pg, Cg = "[object Null]", Ig = "[object Undefined]", ds = Ze ? Ze.toStringTag : void 0;
|
||
function Fg(r) {
|
||
return r == null ? r === void 0 ? Ig : Cg : ds && ds in Object(r) ? wg(r) : Og(r);
|
||
}
|
||
n(Fg, "baseGetTag");
|
||
var Es = Fg;
|
||
function Dg(r) {
|
||
return r != null && typeof r == "object";
|
||
}
|
||
n(Dg, "isObjectLike");
|
||
var Ng = Dg, qg = "[object Symbol]";
|
||
function Lg(r) {
|
||
return typeof r == "symbol" || Ng(r) && Es(r) == qg;
|
||
}
|
||
n(Lg, "isSymbol");
|
||
var In = Lg;
|
||
function kg(r, e) {
|
||
for (var t = -1, o = r == null ? 0 : r.length, a = Array(o); ++t < o; )
|
||
a[t] = e(r[t], t, r);
|
||
return a;
|
||
}
|
||
n(kg, "arrayMap");
|
||
var Mg = kg, jg = Array.isArray, Fn = jg, Bg = 1 / 0, fs = Ze ? Ze.prototype : void 0, ys = fs ? fs.toString : void 0;
|
||
function Ts(r) {
|
||
if (typeof r == "string")
|
||
return r;
|
||
if (Fn(r))
|
||
return Mg(r, Ts) + "";
|
||
if (In(r))
|
||
return ys ? ys.call(r) : "";
|
||
var e = r + "";
|
||
return e == "0" && 1 / r == -Bg ? "-0" : e;
|
||
}
|
||
n(Ts, "baseToString");
|
||
var Ug = Ts;
|
||
function Gg(r) {
|
||
var e = typeof r;
|
||
return r != null && (e == "object" || e == "function");
|
||
}
|
||
n(Gg, "isObject2");
|
||
var Rs = Gg, Hg = "[object AsyncFunction]", Vg = "[object Function]", $g = "[object GeneratorFunction]", Wg = "[object Proxy]";
|
||
function zg(r) {
|
||
if (!Rs(r))
|
||
return !1;
|
||
var e = Es(r);
|
||
return e == Vg || e == $g || e == Hg || e == Wg;
|
||
}
|
||
n(zg, "isFunction");
|
||
var Yg = zg, Kg = Cn["__core-js_shared__"], Pn = Kg, hs = function() {
|
||
var r = /[^.]+$/.exec(Pn && Pn.keys && Pn.keys.IE_PROTO || "");
|
||
return r ? "Symbol(src)_1." + r : "";
|
||
}();
|
||
function Xg(r) {
|
||
return !!hs && hs in r;
|
||
}
|
||
n(Xg, "isMasked");
|
||
var Jg = Xg, Qg = Function.prototype, Zg = Qg.toString;
|
||
function eS(r) {
|
||
if (r != null) {
|
||
try {
|
||
return Zg.call(r);
|
||
} catch {
|
||
}
|
||
try {
|
||
return r + "";
|
||
} catch {
|
||
}
|
||
}
|
||
return "";
|
||
}
|
||
n(eS, "toSource");
|
||
var rS = eS, tS = /[\\^$.*+?()[\]{}|]/g, oS = /^\[object .+?Constructor\]$/, nS = Function.prototype, aS = Object.prototype, iS = nS.toString,
|
||
sS = aS.hasOwnProperty, lS = RegExp(
|
||
"^" + iS.call(sS).replace(tS, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
|
||
);
|
||
function cS(r) {
|
||
if (!Rs(r) || Jg(r))
|
||
return !1;
|
||
var e = Yg(r) ? lS : oS;
|
||
return e.test(rS(r));
|
||
}
|
||
n(cS, "baseIsNative");
|
||
var uS = cS;
|
||
function pS(r, e) {
|
||
return r?.[e];
|
||
}
|
||
n(pS, "getValue");
|
||
var dS = pS;
|
||
function fS(r, e) {
|
||
var t = dS(r, e);
|
||
return uS(t) ? t : void 0;
|
||
}
|
||
n(fS, "getNative");
|
||
var As = fS;
|
||
function yS(r, e) {
|
||
return r === e || r !== r && e !== e;
|
||
}
|
||
n(yS, "eq");
|
||
var hS = yS, mS = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, gS = /^\w*$/;
|
||
function SS(r, e) {
|
||
if (Fn(r))
|
||
return !1;
|
||
var t = typeof r;
|
||
return t == "number" || t == "symbol" || t == "boolean" || r == null || In(r) ? !0 : gS.test(r) || !mS.test(r) || e != null && r in Object(
|
||
e);
|
||
}
|
||
n(SS, "isKey");
|
||
var bS = SS, vS = As(Object, "create"), Hr = vS;
|
||
function ES() {
|
||
this.__data__ = Hr ? Hr(null) : {}, this.size = 0;
|
||
}
|
||
n(ES, "hashClear");
|
||
var TS = ES;
|
||
function RS(r) {
|
||
var e = this.has(r) && delete this.__data__[r];
|
||
return this.size -= e ? 1 : 0, e;
|
||
}
|
||
n(RS, "hashDelete");
|
||
var AS = RS, wS = "__lodash_hash_undefined__", xS = Object.prototype, _S = xS.hasOwnProperty;
|
||
function PS(r) {
|
||
var e = this.__data__;
|
||
if (Hr) {
|
||
var t = e[r];
|
||
return t === wS ? void 0 : t;
|
||
}
|
||
return _S.call(e, r) ? e[r] : void 0;
|
||
}
|
||
n(PS, "hashGet");
|
||
var OS = PS, CS = Object.prototype, IS = CS.hasOwnProperty;
|
||
function FS(r) {
|
||
var e = this.__data__;
|
||
return Hr ? e[r] !== void 0 : IS.call(e, r);
|
||
}
|
||
n(FS, "hashHas");
|
||
var DS = FS, NS = "__lodash_hash_undefined__";
|
||
function qS(r, e) {
|
||
var t = this.__data__;
|
||
return this.size += this.has(r) ? 0 : 1, t[r] = Hr && e === void 0 ? NS : e, this;
|
||
}
|
||
n(qS, "hashSet");
|
||
var LS = qS;
|
||
function er(r) {
|
||
var e = -1, t = r == null ? 0 : r.length;
|
||
for (this.clear(); ++e < t; ) {
|
||
var o = r[e];
|
||
this.set(o[0], o[1]);
|
||
}
|
||
}
|
||
n(er, "Hash");
|
||
er.prototype.clear = TS;
|
||
er.prototype.delete = AS;
|
||
er.prototype.get = OS;
|
||
er.prototype.has = DS;
|
||
er.prototype.set = LS;
|
||
var ms = er;
|
||
function kS() {
|
||
this.__data__ = [], this.size = 0;
|
||
}
|
||
n(kS, "listCacheClear");
|
||
var MS = kS;
|
||
function jS(r, e) {
|
||
for (var t = r.length; t--; )
|
||
if (hS(r[t][0], e))
|
||
return t;
|
||
return -1;
|
||
}
|
||
n(jS, "assocIndexOf");
|
||
var $t = jS, BS = Array.prototype, US = BS.splice;
|
||
function GS(r) {
|
||
var e = this.__data__, t = $t(e, r);
|
||
if (t < 0)
|
||
return !1;
|
||
var o = e.length - 1;
|
||
return t == o ? e.pop() : US.call(e, t, 1), --this.size, !0;
|
||
}
|
||
n(GS, "listCacheDelete");
|
||
var HS = GS;
|
||
function VS(r) {
|
||
var e = this.__data__, t = $t(e, r);
|
||
return t < 0 ? void 0 : e[t][1];
|
||
}
|
||
n(VS, "listCacheGet");
|
||
var $S = VS;
|
||
function WS(r) {
|
||
return $t(this.__data__, r) > -1;
|
||
}
|
||
n(WS, "listCacheHas");
|
||
var zS = WS;
|
||
function YS(r, e) {
|
||
var t = this.__data__, o = $t(t, r);
|
||
return o < 0 ? (++this.size, t.push([r, e])) : t[o][1] = e, this;
|
||
}
|
||
n(YS, "listCacheSet");
|
||
var KS = YS;
|
||
function rr(r) {
|
||
var e = -1, t = r == null ? 0 : r.length;
|
||
for (this.clear(); ++e < t; ) {
|
||
var o = r[e];
|
||
this.set(o[0], o[1]);
|
||
}
|
||
}
|
||
n(rr, "ListCache");
|
||
rr.prototype.clear = MS;
|
||
rr.prototype.delete = HS;
|
||
rr.prototype.get = $S;
|
||
rr.prototype.has = zS;
|
||
rr.prototype.set = KS;
|
||
var XS = rr, JS = As(Cn, "Map"), QS = JS;
|
||
function ZS() {
|
||
this.size = 0, this.__data__ = {
|
||
hash: new ms(),
|
||
map: new (QS || XS)(),
|
||
string: new ms()
|
||
};
|
||
}
|
||
n(ZS, "mapCacheClear");
|
||
var eb = ZS;
|
||
function rb(r) {
|
||
var e = typeof r;
|
||
return e == "string" || e == "number" || e == "symbol" || e == "boolean" ? r !== "__proto__" : r === null;
|
||
}
|
||
n(rb, "isKeyable");
|
||
var tb = rb;
|
||
function ob(r, e) {
|
||
var t = r.__data__;
|
||
return tb(e) ? t[typeof e == "string" ? "string" : "hash"] : t.map;
|
||
}
|
||
n(ob, "getMapData");
|
||
var Wt = ob;
|
||
function nb(r) {
|
||
var e = Wt(this, r).delete(r);
|
||
return this.size -= e ? 1 : 0, e;
|
||
}
|
||
n(nb, "mapCacheDelete");
|
||
var ab = nb;
|
||
function ib(r) {
|
||
return Wt(this, r).get(r);
|
||
}
|
||
n(ib, "mapCacheGet");
|
||
var sb = ib;
|
||
function lb(r) {
|
||
return Wt(this, r).has(r);
|
||
}
|
||
n(lb, "mapCacheHas");
|
||
var cb = lb;
|
||
function ub(r, e) {
|
||
var t = Wt(this, r), o = t.size;
|
||
return t.set(r, e), this.size += t.size == o ? 0 : 1, this;
|
||
}
|
||
n(ub, "mapCacheSet");
|
||
var pb = ub;
|
||
function tr(r) {
|
||
var e = -1, t = r == null ? 0 : r.length;
|
||
for (this.clear(); ++e < t; ) {
|
||
var o = r[e];
|
||
this.set(o[0], o[1]);
|
||
}
|
||
}
|
||
n(tr, "MapCache");
|
||
tr.prototype.clear = eb;
|
||
tr.prototype.delete = ab;
|
||
tr.prototype.get = sb;
|
||
tr.prototype.has = cb;
|
||
tr.prototype.set = pb;
|
||
var ws = tr, db = "Expected a function";
|
||
function Dn(r, e) {
|
||
if (typeof r != "function" || e != null && typeof e != "function")
|
||
throw new TypeError(db);
|
||
var t = /* @__PURE__ */ n(function() {
|
||
var o = arguments, a = e ? e.apply(this, o) : o[0], i = t.cache;
|
||
if (i.has(a))
|
||
return i.get(a);
|
||
var s = r.apply(this, o);
|
||
return t.cache = i.set(a, s) || i, s;
|
||
}, "memoized");
|
||
return t.cache = new (Dn.Cache || ws)(), t;
|
||
}
|
||
n(Dn, "memoize");
|
||
Dn.Cache = ws;
|
||
var fb = Dn, yb = 500;
|
||
function hb(r) {
|
||
var e = fb(r, function(o) {
|
||
return t.size === yb && t.clear(), o;
|
||
}), t = e.cache;
|
||
return e;
|
||
}
|
||
n(hb, "memoizeCapped");
|
||
var mb = hb, gb = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g, Sb = /\\(\\)?/g, bb = mb(
|
||
function(r) {
|
||
var e = [];
|
||
return r.charCodeAt(0) === 46 && e.push(""), r.replace(gb, function(t, o, a, i) {
|
||
e.push(a ? i.replace(Sb, "$1") : o || t);
|
||
}), e;
|
||
}), vb = bb;
|
||
function Eb(r) {
|
||
return r == null ? "" : Ug(r);
|
||
}
|
||
n(Eb, "toString");
|
||
var Tb = Eb;
|
||
function Rb(r, e) {
|
||
return Fn(r) ? r : bS(r, e) ? [r] : vb(Tb(r));
|
||
}
|
||
n(Rb, "castPath");
|
||
var Ab = Rb, wb = 1 / 0;
|
||
function xb(r) {
|
||
if (typeof r == "string" || In(r))
|
||
return r;
|
||
var e = r + "";
|
||
return e == "0" && 1 / r == -wb ? "-0" : e;
|
||
}
|
||
n(xb, "toKey");
|
||
var _b = xb;
|
||
function Pb(r, e) {
|
||
e = Ab(e, r);
|
||
for (var t = 0, o = e.length; r != null && t < o; )
|
||
r = r[_b(e[t++])];
|
||
return t && t == o ? r : void 0;
|
||
}
|
||
n(Pb, "baseGet");
|
||
var Ob = Pb;
|
||
function Cb(r, e, t) {
|
||
var o = r == null ? void 0 : Ob(r, e);
|
||
return o === void 0 ? t : o;
|
||
}
|
||
n(Cb, "get");
|
||
var Ib = Cb, Vt = mg, Fb = /* @__PURE__ */ n((r) => {
|
||
let e = null, t = !1, o = !1, a = !1, i = "";
|
||
if (r.indexOf("//") >= 0 || r.indexOf("/*") >= 0)
|
||
for (let s = 0; s < r.length; s += 1)
|
||
!e && !t && !o && !a ? r[s] === '"' || r[s] === "'" || r[s] === "`" ? e = r[s] : r[s] === "/" && r[s + 1] === "*" ? t = !0 : r[s] === "\
|
||
/" && r[s + 1] === "/" ? o = !0 : r[s] === "/" && r[s + 1] !== "/" && (a = !0) : (e && (r[s] === e && r[s - 1] !== "\\" || r[s] === `
|
||
` && e !== "`") && (e = null), a && (r[s] === "/" && r[s - 1] !== "\\" || r[s] === `
|
||
`) && (a = !1), t && r[s - 1] === "/" && r[s - 2] === "*" && (t = !1), o && r[s] === `
|
||
` && (o = !1)), !t && !o && (i += r[s]);
|
||
else
|
||
i = r;
|
||
return i;
|
||
}, "removeCodeComments"), Db = (0, xs.default)(1e4)(
|
||
(r) => Fb(r).replace(/\n\s*/g, "").trim()
|
||
), Nb = /* @__PURE__ */ n(function(e, t) {
|
||
let o = t.slice(0, t.indexOf("{")), a = t.slice(t.indexOf("{"));
|
||
if (o.includes("=>") || o.includes("function"))
|
||
return t;
|
||
let i = o;
|
||
return i = i.replace(e, "function"), i + a;
|
||
}, "convertShorthandMethods2"), qb = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z$/, Vr = /* @__PURE__ */ n((r) => r.match(/^[\[\{\"\}].*[\]\}\"]$/),
|
||
"isJSON");
|
||
function _s(r) {
|
||
if (!Vt(r))
|
||
return r;
|
||
let e = r, t = !1;
|
||
return typeof Event < "u" && r instanceof Event && (e = us(e), t = !0), e = Object.keys(e).reduce((o, a) => {
|
||
try {
|
||
e[a] && e[a].toJSON, o[a] = e[a];
|
||
} catch {
|
||
t = !0;
|
||
}
|
||
return o;
|
||
}, {}), t ? e : r;
|
||
}
|
||
n(_s, "convertUnconventionalData");
|
||
var Lb = /* @__PURE__ */ n(function(e) {
|
||
let t, o, a, i;
|
||
return /* @__PURE__ */ n(function(c, l) {
|
||
try {
|
||
if (c === "")
|
||
return i = [], t = /* @__PURE__ */ new Map([[l, "[]"]]), o = /* @__PURE__ */ new Map(), a = [], l;
|
||
let u = o.get(this) || this;
|
||
for (; a.length && u !== a[0]; )
|
||
a.shift(), i.pop();
|
||
if (typeof l == "boolean")
|
||
return l;
|
||
if (l === void 0)
|
||
return e.allowUndefined ? "_undefined_" : void 0;
|
||
if (l === null)
|
||
return null;
|
||
if (typeof l == "number")
|
||
return l === -1 / 0 ? "_-Infinity_" : l === 1 / 0 ? "_Infinity_" : Number.isNaN(l) ? "_NaN_" : l;
|
||
if (typeof l == "bigint")
|
||
return `_bigint_${l.toString()}`;
|
||
if (typeof l == "string")
|
||
return qb.test(l) ? e.allowDate ? `_date_${l}` : void 0 : l;
|
||
if ((0, fg.default)(l))
|
||
return e.allowRegExp ? `_regexp_${l.flags}|${l.source}` : void 0;
|
||
if ((0, yg.default)(l)) {
|
||
if (!e.allowFunction)
|
||
return;
|
||
let { name: h } = l, y = l.toString();
|
||
return y.match(
|
||
/(\[native code\]|WEBPACK_IMPORTED_MODULE|__webpack_exports__|__webpack_require__)/
|
||
) ? `_function_${h}|${(() => {
|
||
}).toString()}` : `_function_${h}|${Db(Nb(c, y))}`;
|
||
}
|
||
if ((0, hg.default)(l)) {
|
||
if (!e.allowSymbol)
|
||
return;
|
||
let h = Symbol.keyFor(l);
|
||
return h !== void 0 ? `_gsymbol_${h}` : `_symbol_${l.toString().slice(7, -1)}`;
|
||
}
|
||
if (a.length >= e.maxDepth)
|
||
return Array.isArray(l) ? `[Array(${l.length})]` : "[Object]";
|
||
if (l === this)
|
||
return `_duplicate_${JSON.stringify(i)}`;
|
||
if (l instanceof Error && e.allowError)
|
||
return {
|
||
__isConvertedError__: !0,
|
||
errorProperties: {
|
||
...l.cause ? { cause: l.cause } : {},
|
||
...l,
|
||
name: l.name,
|
||
message: l.message,
|
||
stack: l.stack,
|
||
"_constructor-name_": l.constructor.name
|
||
}
|
||
};
|
||
if (l.constructor && l.constructor.name && l.constructor.name !== "Object" && !Array.isArray(l) && !e.allowClass)
|
||
return;
|
||
let p = t.get(l);
|
||
if (!p) {
|
||
let h = Array.isArray(l) ? l : _s(l);
|
||
if (l.constructor && l.constructor.name && l.constructor.name !== "Object" && !Array.isArray(l) && e.allowClass)
|
||
try {
|
||
Object.assign(h, { "_constructor-name_": l.constructor.name });
|
||
} catch {
|
||
}
|
||
return i.push(c), a.unshift(h), t.set(l, JSON.stringify(i)), l !== h && o.set(l, h), h;
|
||
}
|
||
return `_duplicate_${p}`;
|
||
} catch {
|
||
return;
|
||
}
|
||
}, "replace");
|
||
}, "replacer2"), kb = /* @__PURE__ */ n(function reviver(options) {
|
||
let refs = [], root;
|
||
return /* @__PURE__ */ n(function revive(key, value) {
|
||
if (key === "" && (root = value, refs.forEach(({ target: r, container: e, replacement: t }) => {
|
||
let o = Vr(t) ? JSON.parse(t) : t.split(".");
|
||
o.length === 0 ? e[r] = root : e[r] = Ib(root, o);
|
||
})), key === "_constructor-name_")
|
||
return value;
|
||
if (Vt(value) && value.__isConvertedError__) {
|
||
let { message: r, ...e } = value.errorProperties, t = new Error(r);
|
||
return Object.assign(t, e), t;
|
||
}
|
||
if (Vt(value) && value["_constructor-name_"] && options.allowFunction) {
|
||
let r = value["_constructor-name_"];
|
||
if (r !== "Object") {
|
||
let e = new Function(`return function ${r.replace(/[^a-zA-Z0-9$_]+/g, "")}(){}`)();
|
||
Object.setPrototypeOf(value, new e());
|
||
}
|
||
return delete value["_constructor-name_"], value;
|
||
}
|
||
if (typeof value == "string" && value.startsWith("_function_") && options.allowFunction) {
|
||
let [, name, source] = value.match(/_function_([^|]*)\|(.*)/) || [], sourceSanitized = source.replace(/[(\(\))|\\| |\]|`]*$/, "");
|
||
if (!options.lazyEval)
|
||
return eval(`(${sourceSanitized})`);
|
||
let result = /* @__PURE__ */ n((...args) => {
|
||
let f = eval(`(${sourceSanitized})`);
|
||
return f(...args);
|
||
}, "result");
|
||
return Object.defineProperty(result, "toString", {
|
||
value: /* @__PURE__ */ n(() => sourceSanitized, "value")
|
||
}), Object.defineProperty(result, "name", {
|
||
value: name
|
||
}), result;
|
||
}
|
||
if (typeof value == "string" && value.startsWith("_regexp_") && options.allowRegExp) {
|
||
let [, r, e] = value.match(/_regexp_([^|]*)\|(.*)/) || [];
|
||
return new RegExp(e, r);
|
||
}
|
||
return typeof value == "string" && value.startsWith("_date_") && options.allowDate ? new Date(value.replace("_date_", "")) : typeof value ==
|
||
"string" && value.startsWith("_duplicate_") ? (refs.push({ target: key, container: this, replacement: value.replace(/^_duplicate_/, "") }),
|
||
null) : typeof value == "string" && value.startsWith("_symbol_") && options.allowSymbol ? Symbol(value.replace("_symbol_", "")) : typeof value ==
|
||
"string" && value.startsWith("_gsymbol_") && options.allowSymbol ? Symbol.for(value.replace("_gsymbol_", "")) : typeof value == "string" &&
|
||
value === "_-Infinity_" ? -1 / 0 : typeof value == "string" && value === "_Infinity_" ? 1 / 0 : typeof value == "string" && value === "_\
|
||
NaN_" ? NaN : typeof value == "string" && value.startsWith("_bigint_") && typeof BigInt == "function" ? BigInt(value.replace("_bigint_", "")) :
|
||
value;
|
||
}, "revive");
|
||
}, "reviver"), Ps = {
|
||
maxDepth: 10,
|
||
space: void 0,
|
||
allowFunction: !0,
|
||
allowRegExp: !0,
|
||
allowDate: !0,
|
||
allowClass: !0,
|
||
allowError: !0,
|
||
allowUndefined: !0,
|
||
allowSymbol: !0,
|
||
lazyEval: !0
|
||
}, zt = /* @__PURE__ */ n((r, e = {}) => {
|
||
let t = { ...Ps, ...e };
|
||
return JSON.stringify(_s(r), Lb(t), e.space);
|
||
}, "stringify"), Mb = /* @__PURE__ */ n(() => {
|
||
let r = /* @__PURE__ */ new Map();
|
||
return /* @__PURE__ */ n(function e(t) {
|
||
Vt(t) && Object.entries(t).forEach(([o, a]) => {
|
||
a === "_undefined_" ? t[o] = void 0 : r.get(a) || (r.set(a, !0), e(a));
|
||
}), Array.isArray(t) && t.forEach((o, a) => {
|
||
o === "_undefined_" ? (r.set(o, !0), t[a] = void 0) : r.get(o) || (r.set(o, !0), e(o));
|
||
});
|
||
}, "mutateUndefined");
|
||
}, "mutator"), Yt = /* @__PURE__ */ n((r, e = {}) => {
|
||
let t = { ...Ps, ...e }, o = JSON.parse(r, kb(t));
|
||
return Mb()(o), o;
|
||
}, "parse");
|
||
|
||
// ../node_modules/tiny-invariant/dist/esm/tiny-invariant.js
|
||
var jb = !1, Nn = "Invariant failed";
|
||
function fe(r, e) {
|
||
if (!r) {
|
||
if (jb)
|
||
throw new Error(Nn);
|
||
var t = typeof e == "function" ? e() : e, o = t ? "".concat(Nn, ": ").concat(t) : Nn;
|
||
throw new Error(o);
|
||
}
|
||
}
|
||
n(fe, "invariant");
|
||
|
||
// src/channels/postmessage/getEventSourceUrl.ts
|
||
var Os = /* @__PURE__ */ n((r) => {
|
||
let e = Array.from(
|
||
document.querySelectorAll("iframe[data-is-storybook]")
|
||
), [t, ...o] = e.filter((i) => {
|
||
try {
|
||
return i.contentWindow?.location.origin === r.source.location.origin && i.contentWindow?.location.pathname === r.source.location.pathname;
|
||
} catch {
|
||
}
|
||
try {
|
||
return i.contentWindow === r.source;
|
||
} catch {
|
||
}
|
||
let s = i.getAttribute("src"), c;
|
||
try {
|
||
if (!s)
|
||
return !1;
|
||
({ origin: c } = new URL(s, document.location.toString()));
|
||
} catch {
|
||
return !1;
|
||
}
|
||
return c === r.origin;
|
||
}), a = t?.getAttribute("src");
|
||
if (a && o.length === 0) {
|
||
let { protocol: i, host: s, pathname: c } = new URL(a, document.location.toString());
|
||
return `${i}//${s}${c}`;
|
||
}
|
||
return o.length > 0 && C.error("found multiple candidates for event source"), null;
|
||
}, "getEventSourceUrl");
|
||
|
||
// src/channels/postmessage/index.ts
|
||
var { document: qn, location: Ln } = T, Cs = "storybook-channel", Bb = { allowFunction: !1, maxDepth: 25 }, kn = class kn {
|
||
constructor(e) {
|
||
this.config = e;
|
||
if (this.buffer = [], typeof T?.addEventListener == "function" && T.addEventListener("message", this.handleEvent.bind(this), !1), e.page !==
|
||
"manager" && e.page !== "preview")
|
||
throw new Error(`postmsg-channel: "config.page" cannot be "${e.page}"`);
|
||
}
|
||
buffer;
|
||
handler;
|
||
connected = !1;
|
||
setHandler(e) {
|
||
this.handler = (...t) => {
|
||
e.apply(this, t), !this.connected && this.getLocalFrame().length && (this.flush(), this.connected = !0);
|
||
};
|
||
}
|
||
/**
|
||
* Sends `event` to the associated window. If the window does not yet exist
|
||
* the event will be stored in a buffer and sent when the window exists.
|
||
* @param event
|
||
*/
|
||
send(e, t) {
|
||
let {
|
||
target: o,
|
||
// telejson options
|
||
allowRegExp: a,
|
||
allowFunction: i,
|
||
allowSymbol: s,
|
||
allowDate: c,
|
||
allowError: l,
|
||
allowUndefined: u,
|
||
allowClass: p,
|
||
maxDepth: h,
|
||
space: y,
|
||
lazyEval: g
|
||
} = t || {}, m = Object.fromEntries(
|
||
Object.entries({
|
||
allowRegExp: a,
|
||
allowFunction: i,
|
||
allowSymbol: s,
|
||
allowDate: c,
|
||
allowError: l,
|
||
allowUndefined: u,
|
||
allowClass: p,
|
||
maxDepth: h,
|
||
space: y,
|
||
lazyEval: g
|
||
}).filter(([v, x]) => typeof x < "u")
|
||
), b = {
|
||
...Bb,
|
||
...T.CHANNEL_OPTIONS || {},
|
||
...m
|
||
}, S = this.getFrames(o), w = new URLSearchParams(Ln?.search || ""), E = zt(
|
||
{
|
||
key: Cs,
|
||
event: e,
|
||
refId: w.get("refId")
|
||
},
|
||
b
|
||
);
|
||
return S.length ? (this.buffer.length && this.flush(), S.forEach((v) => {
|
||
try {
|
||
v.postMessage(E, "*");
|
||
} catch {
|
||
C.error("sending over postmessage fail");
|
||
}
|
||
}), Promise.resolve(null)) : new Promise((v, x) => {
|
||
this.buffer.push({ event: e, resolve: v, reject: x });
|
||
});
|
||
}
|
||
flush() {
|
||
let { buffer: e } = this;
|
||
this.buffer = [], e.forEach((t) => {
|
||
this.send(t.event).then(t.resolve).catch(t.reject);
|
||
});
|
||
}
|
||
getFrames(e) {
|
||
if (this.config.page === "manager") {
|
||
let o = Array.from(
|
||
qn.querySelectorAll("iframe[data-is-storybook][data-is-loaded]")
|
||
).flatMap((a) => {
|
||
try {
|
||
return a.contentWindow && a.dataset.isStorybook !== void 0 && a.id === e ? [a.contentWindow] : [];
|
||
} catch {
|
||
return [];
|
||
}
|
||
});
|
||
return o?.length ? o : this.getCurrentFrames();
|
||
}
|
||
return T && T.parent && T.parent !== T.self ? [T.parent] : [];
|
||
}
|
||
getCurrentFrames() {
|
||
return this.config.page === "manager" ? Array.from(
|
||
qn.querySelectorAll('[data-is-storybook="true"]')
|
||
).flatMap((t) => t.contentWindow ? [t.contentWindow] : []) : T && T.parent ? [T.parent] : [];
|
||
}
|
||
getLocalFrame() {
|
||
return this.config.page === "manager" ? Array.from(
|
||
qn.querySelectorAll("#storybook-preview-iframe")
|
||
).flatMap((t) => t.contentWindow ? [t.contentWindow] : []) : T && T.parent ? [T.parent] : [];
|
||
}
|
||
handleEvent(e) {
|
||
try {
|
||
let { data: t } = e, { key: o, event: a, refId: i } = typeof t == "string" && Vr(t) ? Yt(t, T.CHANNEL_OPTIONS || {}) : t;
|
||
if (o === Cs) {
|
||
let s = this.config.page === "manager" ? '<span style="color: #37D5D3; background: black"> manager </span>' : '<span style="color: #\
|
||
1EA7FD; background: black"> preview </span>', c = Object.values(be).includes(a.type) ? `<span style="color: #FF4785">${a.type}</span>` : `<s\
|
||
pan style="color: #FFAE00">${a.type}</span>`;
|
||
if (i && (a.refId = i), a.source = this.config.page === "preview" ? e.origin : Os(e), !a.source) {
|
||
re.error(
|
||
`${s} received ${c} but was unable to determine the source of the event`
|
||
);
|
||
return;
|
||
}
|
||
let l = `${s} received ${c} (${t.length})`;
|
||
re.debug(
|
||
Ln.origin !== a.source ? l : `${l} <span style="color: gray">(on ${Ln.origin} from ${a.source})</span>`,
|
||
...a.args
|
||
), fe(this.handler, "ChannelHandler should be set"), this.handler(a);
|
||
}
|
||
} catch (t) {
|
||
C.error(t);
|
||
}
|
||
}
|
||
};
|
||
n(kn, "PostMessageTransport");
|
||
var or = kn;
|
||
|
||
// src/channels/websocket/index.ts
|
||
var { WebSocket: Ub } = T, Mn = class Mn {
|
||
buffer = [];
|
||
handler;
|
||
socket;
|
||
isReady = !1;
|
||
constructor({ url: e, onError: t, page: o }) {
|
||
this.socket = new Ub(e), this.socket.onopen = () => {
|
||
this.isReady = !0, this.flush();
|
||
}, this.socket.onmessage = ({ data: a }) => {
|
||
let i = typeof a == "string" && Vr(a) ? Yt(a) : a;
|
||
fe(this.handler, "WebsocketTransport handler should be set"), this.handler(i);
|
||
}, this.socket.onerror = (a) => {
|
||
t && t(a);
|
||
}, this.socket.onclose = () => {
|
||
fe(this.handler, "WebsocketTransport handler should be set"), this.handler({ type: en, args: [], from: o || "preview" });
|
||
};
|
||
}
|
||
setHandler(e) {
|
||
this.handler = e;
|
||
}
|
||
send(e) {
|
||
this.isReady ? this.sendNow(e) : this.sendLater(e);
|
||
}
|
||
sendLater(e) {
|
||
this.buffer.push(e);
|
||
}
|
||
sendNow(e) {
|
||
let t = zt(e, {
|
||
maxDepth: 15,
|
||
allowFunction: !1,
|
||
...T.CHANNEL_OPTIONS
|
||
});
|
||
this.socket.send(t);
|
||
}
|
||
flush() {
|
||
let { buffer: e } = this;
|
||
this.buffer = [], e.forEach((t) => this.send(t));
|
||
}
|
||
};
|
||
n(Mn, "WebsocketTransport");
|
||
var nr = Mn;
|
||
|
||
// src/channels/index.ts
|
||
var { CONFIG_TYPE: Gb } = T, Hb = ve;
|
||
function Vb({ page: r, extraTransports: e = [] }) {
|
||
let t = [new or({ page: r }), ...e];
|
||
if (Gb === "DEVELOPMENT") {
|
||
let o = window.location.protocol === "http:" ? "ws" : "wss", { hostname: a, port: i } = window.location, s = `${o}://${a}:${i}/storybook\
|
||
-server-channel`;
|
||
t.push(new nr({ url: s, onError: /* @__PURE__ */ n(() => {
|
||
}, "onError"), page: r }));
|
||
}
|
||
return new ve({ transports: t });
|
||
}
|
||
n(Vb, "createBrowserChannel");
|
||
|
||
// src/preview-errors.ts
|
||
var ot = {};
|
||
Ce(ot, {
|
||
CalledExtractOnStoreError: () => zr,
|
||
CalledPreviewMethodBeforeInitializationError: () => K,
|
||
Category: () => Fs,
|
||
EmptyIndexError: () => Jr,
|
||
ImplicitActionsDuringRendering: () => jn,
|
||
MdxFileWithNoCsfReferencesError: () => Xr,
|
||
MissingRenderToCanvasError: () => Yr,
|
||
MissingStoryAfterHmrError: () => Wr,
|
||
MissingStoryFromCsfFileError: () => Zr,
|
||
MountMustBeDestructuredError: () => Fe,
|
||
NextJsSharpError: () => Un,
|
||
NextjsRouterMocksNotAvailable: () => Gn,
|
||
NoRenderFunctionError: () => rt,
|
||
NoStoryMatchError: () => Qr,
|
||
NoStoryMountedError: () => tt,
|
||
StoryIndexFetchError: () => Kr,
|
||
StoryStoreAccessedBeforeInitializationError: () => et,
|
||
TestingLibraryMustBeConfiguredError: () => Bn,
|
||
UnknownArgTypesError: () => Hn
|
||
});
|
||
|
||
// ../node_modules/ts-dedent/esm/index.js
|
||
function _(r) {
|
||
for (var e = [], t = 1; t < arguments.length; t++)
|
||
e[t - 1] = arguments[t];
|
||
var o = Array.from(typeof r == "string" ? [r] : r);
|
||
o[o.length - 1] = o[o.length - 1].replace(/\r?\n([\t ]*)$/, "");
|
||
var a = o.reduce(function(c, l) {
|
||
var u = l.match(/\n([\t ]+|(?!\s).)/g);
|
||
return u ? c.concat(u.map(function(p) {
|
||
var h, y;
|
||
return (y = (h = p.match(/[\t ]/g)) === null || h === void 0 ? void 0 : h.length) !== null && y !== void 0 ? y : 0;
|
||
})) : c;
|
||
}, []);
|
||
if (a.length) {
|
||
var i = new RegExp(`
|
||
[ ]{` + Math.min.apply(Math, a) + "}", "g");
|
||
o = o.map(function(c) {
|
||
return c.replace(i, `
|
||
`);
|
||
});
|
||
}
|
||
o[0] = o[0].replace(/^\r?\n/, "");
|
||
var s = o[0];
|
||
return e.forEach(function(c, l) {
|
||
var u = s.match(/(?:^|\n)( *)$/), p = u ? u[1] : "", h = c;
|
||
typeof c == "string" && c.includes(`
|
||
`) && (h = String(c).split(`
|
||
`).map(function(y, g) {
|
||
return g === 0 ? y : "" + p + y;
|
||
}).join(`
|
||
`)), s += h + o[l + 1];
|
||
}), s;
|
||
}
|
||
n(_, "dedent");
|
||
|
||
// src/storybook-error.ts
|
||
function Is({
|
||
code: r,
|
||
category: e
|
||
}) {
|
||
let t = String(r).padStart(4, "0");
|
||
return `SB_${e}_${t}`;
|
||
}
|
||
n(Is, "parseErrorCode");
|
||
var Kt = class Kt extends Error {
|
||
/**
|
||
* Category of the error. Used to classify the type of error, e.g., 'PREVIEW_API'.
|
||
*/
|
||
category;
|
||
/**
|
||
* Code representing the error. Used to uniquely identify the error, e.g., 1.
|
||
*/
|
||
code;
|
||
/**
|
||
* Data associated with the error. Used to provide additional information in the error message or to be passed to telemetry.
|
||
*/
|
||
data = {};
|
||
/**
|
||
* Specifies the documentation for the error.
|
||
* - If `true`, links to a documentation page on the Storybook website (make sure it exists before enabling) – This is not implemented yet.
|
||
* - If a string, uses the provided URL for documentation (external or FAQ links).
|
||
* - If `false` (default), no documentation link is added.
|
||
*/
|
||
documentation;
|
||
/**
|
||
* Flag used to easily determine if the error originates from Storybook.
|
||
*/
|
||
fromStorybook = !0;
|
||
get fullErrorCode() {
|
||
return Is({ code: this.code, category: this.category });
|
||
}
|
||
/**
|
||
* Overrides the default `Error.name` property in the format: SB_<CATEGORY>_<CODE>.
|
||
*/
|
||
get name() {
|
||
let e = this.constructor.name;
|
||
return `${this.fullErrorCode} (${e})`;
|
||
}
|
||
constructor(e) {
|
||
super(Kt.getFullMessage(e)), this.category = e.category, this.documentation = e.documentation ?? !1, this.code = e.code;
|
||
}
|
||
/**
|
||
* Generates the error message along with additional documentation link (if applicable).
|
||
*/
|
||
static getFullMessage({
|
||
documentation: e,
|
||
code: t,
|
||
category: o,
|
||
message: a
|
||
}) {
|
||
let i;
|
||
return e === !0 ? i = `https://storybook.js.org/error/${Is({ code: t, category: o })}` : typeof e == "string" ? i = e : Array.isArray(e) &&
|
||
(i = `
|
||
${e.map((s) => ` - ${s}`).join(`
|
||
`)}`), `${a}${i != null ? `
|
||
|
||
More info: ${i}
|
||
` : ""}`;
|
||
}
|
||
};
|
||
n(Kt, "StorybookError");
|
||
var U = Kt;
|
||
|
||
// src/preview-errors.ts
|
||
var Fs = /* @__PURE__ */ ((v) => (v.BLOCKS = "BLOCKS", v.DOCS_TOOLS = "DOCS-TOOLS", v.PREVIEW_CLIENT_LOGGER = "PREVIEW_CLIENT-LOGGER", v.PREVIEW_CHANNELS =
|
||
"PREVIEW_CHANNELS", v.PREVIEW_CORE_EVENTS = "PREVIEW_CORE-EVENTS", v.PREVIEW_INSTRUMENTER = "PREVIEW_INSTRUMENTER", v.PREVIEW_API = "PREVIEW\
|
||
_API", v.PREVIEW_REACT_DOM_SHIM = "PREVIEW_REACT-DOM-SHIM", v.PREVIEW_ROUTER = "PREVIEW_ROUTER", v.PREVIEW_THEMING = "PREVIEW_THEMING", v.RENDERER_HTML =
|
||
"RENDERER_HTML", v.RENDERER_PREACT = "RENDERER_PREACT", v.RENDERER_REACT = "RENDERER_REACT", v.RENDERER_SERVER = "RENDERER_SERVER", v.RENDERER_SVELTE =
|
||
"RENDERER_SVELTE", v.RENDERER_VUE = "RENDERER_VUE", v.RENDERER_VUE3 = "RENDERER_VUE3", v.RENDERER_WEB_COMPONENTS = "RENDERER_WEB-COMPONENTS",
|
||
v.FRAMEWORK_NEXTJS = "FRAMEWORK_NEXTJS", v))(Fs || {}), Vn = class Vn extends U {
|
||
constructor(t) {
|
||
super({
|
||
category: "PREVIEW_API",
|
||
code: 1,
|
||
message: _`
|
||
Couldn't find story matching id '${t.storyId}' after HMR.
|
||
- Did you just rename a story?
|
||
- Did you remove it from your CSF file?
|
||
- Are you sure a story with the id '${t.storyId}' exists?
|
||
- Please check the values in the stories field of your main.js config and see if they would match your CSF File.
|
||
- Also check the browser console and terminal for potential error messages.`
|
||
});
|
||
this.data = t;
|
||
}
|
||
};
|
||
n(Vn, "MissingStoryAfterHmrError");
|
||
var Wr = Vn, $n = class $n extends U {
|
||
constructor(t) {
|
||
super({
|
||
category: "PREVIEW_API",
|
||
code: 2,
|
||
documentation: "https://github.com/storybookjs/storybook/blob/next/MIGRATION.md#using-implicit-actions-during-rendering-is-deprecated-\
|
||
for-example-in-the-play-function",
|
||
message: _`
|
||
We detected that you use an implicit action arg while ${t.phase} of your story.
|
||
${t.deprecated ? `
|
||
This is deprecated and won't work in Storybook 8 anymore.
|
||
` : ""}
|
||
Please provide an explicit spy to your args like this:
|
||
import { fn } from '@storybook/test';
|
||
...
|
||
args: {
|
||
${t.name}: fn()
|
||
}`
|
||
});
|
||
this.data = t;
|
||
}
|
||
};
|
||
n($n, "ImplicitActionsDuringRendering");
|
||
var jn = $n, Wn = class Wn extends U {
|
||
constructor() {
|
||
super({
|
||
category: "PREVIEW_API",
|
||
code: 3,
|
||
message: _`
|
||
Cannot call \`storyStore.extract()\` without calling \`storyStore.cacheAllCsfFiles()\` first.
|
||
|
||
You probably meant to call \`await preview.extract()\` which does the above for you.`
|
||
});
|
||
}
|
||
};
|
||
n(Wn, "CalledExtractOnStoreError");
|
||
var zr = Wn, zn = class zn extends U {
|
||
constructor() {
|
||
super({
|
||
category: "PREVIEW_API",
|
||
code: 4,
|
||
message: _`
|
||
Expected your framework's preset to export a \`renderToCanvas\` field.
|
||
|
||
Perhaps it needs to be upgraded for Storybook 7.0?`,
|
||
documentation: "https://github.com/storybookjs/storybook/blob/next/MIGRATION.md#mainjs-framework-field"
|
||
});
|
||
}
|
||
};
|
||
n(zn, "MissingRenderToCanvasError");
|
||
var Yr = zn, Yn = class Yn extends U {
|
||
constructor(t) {
|
||
super({
|
||
category: "PREVIEW_API",
|
||
code: 5,
|
||
message: _`
|
||
Called \`Preview.${t.methodName}()\` before initialization.
|
||
|
||
The preview needs to load the story index before most methods can be called. If you want
|
||
to call \`${t.methodName}\`, try \`await preview.initializationPromise;\` first.
|
||
|
||
If you didn't call the above code, then likely it was called by an addon that needs to
|
||
do the above.`
|
||
});
|
||
this.data = t;
|
||
}
|
||
};
|
||
n(Yn, "CalledPreviewMethodBeforeInitializationError");
|
||
var K = Yn, Kn = class Kn extends U {
|
||
constructor(t) {
|
||
super({
|
||
category: "PREVIEW_API",
|
||
code: 6,
|
||
message: _`
|
||
Error fetching \`/index.json\`:
|
||
|
||
${t.text}
|
||
|
||
If you are in development, this likely indicates a problem with your Storybook process,
|
||
check the terminal for errors.
|
||
|
||
If you are in a deployed Storybook, there may have been an issue deploying the full Storybook
|
||
build.`
|
||
});
|
||
this.data = t;
|
||
}
|
||
};
|
||
n(Kn, "StoryIndexFetchError");
|
||
var Kr = Kn, Xn = class Xn extends U {
|
||
constructor(t) {
|
||
super({
|
||
category: "PREVIEW_API",
|
||
code: 7,
|
||
message: _`
|
||
Tried to render docs entry ${t.storyId} but it is a MDX file that has no CSF
|
||
references, or autodocs for a CSF file that some doesn't refer to itself.
|
||
|
||
This likely is an internal error in Storybook's indexing, or you've attached the
|
||
\`attached-mdx\` tag to an MDX file that is not attached.`
|
||
});
|
||
this.data = t;
|
||
}
|
||
};
|
||
n(Xn, "MdxFileWithNoCsfReferencesError");
|
||
var Xr = Xn, Jn = class Jn extends U {
|
||
constructor() {
|
||
super({
|
||
category: "PREVIEW_API",
|
||
code: 8,
|
||
message: _`
|
||
Couldn't find any stories in your Storybook.
|
||
|
||
- Please check your stories field of your main.js config: does it match correctly?
|
||
- Also check the browser console and terminal for error messages.`
|
||
});
|
||
}
|
||
};
|
||
n(Jn, "EmptyIndexError");
|
||
var Jr = Jn, Qn = class Qn extends U {
|
||
constructor(t) {
|
||
super({
|
||
category: "PREVIEW_API",
|
||
code: 9,
|
||
message: _`
|
||
Couldn't find story matching '${t.storySpecifier}'.
|
||
|
||
- Are you sure a story with that id exists?
|
||
- Please check your stories field of your main.js config.
|
||
- Also check the browser console and terminal for error messages.`
|
||
});
|
||
this.data = t;
|
||
}
|
||
};
|
||
n(Qn, "NoStoryMatchError");
|
||
var Qr = Qn, Zn = class Zn extends U {
|
||
constructor(t) {
|
||
super({
|
||
category: "PREVIEW_API",
|
||
code: 10,
|
||
message: _`
|
||
Couldn't find story matching id '${t.storyId}' after importing a CSF file.
|
||
|
||
The file was indexed as if the story was there, but then after importing the file in the browser
|
||
we didn't find the story. Possible reasons:
|
||
- You are using a custom story indexer that is misbehaving.
|
||
- You have a custom file loader that is removing or renaming exports.
|
||
|
||
Please check your browser console and terminal for errors that may explain the issue.`
|
||
});
|
||
this.data = t;
|
||
}
|
||
};
|
||
n(Zn, "MissingStoryFromCsfFileError");
|
||
var Zr = Zn, ea = class ea extends U {
|
||
constructor() {
|
||
super({
|
||
category: "PREVIEW_API",
|
||
code: 11,
|
||
message: _`
|
||
Cannot access the Story Store until the index is ready.
|
||
|
||
It is not recommended to use methods directly on the Story Store anyway, in Storybook 9 we will
|
||
remove access to the store entirely`
|
||
});
|
||
}
|
||
};
|
||
n(ea, "StoryStoreAccessedBeforeInitializationError");
|
||
var et = ea, ra = class ra extends U {
|
||
constructor(t) {
|
||
super({
|
||
category: "PREVIEW_API",
|
||
code: 12,
|
||
message: _`
|
||
Incorrect use of mount in the play function.
|
||
|
||
To use mount in the play function, you must satisfy the following two requirements:
|
||
|
||
1. You *must* destructure the mount property from the \`context\` (the argument passed to your play function).
|
||
This makes sure that Storybook does not start rendering the story before the play function begins.
|
||
|
||
2. Your Storybook framework or builder must be configured to transpile to ES2017 or newer.
|
||
This is because destructuring statements and async/await usages are otherwise transpiled away,
|
||
which prevents Storybook from recognizing your usage of \`mount\`.
|
||
|
||
Note that Angular is not supported. As async/await is transpiled to support the zone.js polyfill.
|
||
|
||
More info: https://storybook.js.org/docs/writing-tests/interaction-testing#run-code-before-the-component-gets-rendered
|
||
|
||
Received the following play function:
|
||
${t.playFunction}`
|
||
});
|
||
this.data = t;
|
||
}
|
||
};
|
||
n(ra, "MountMustBeDestructuredError");
|
||
var Fe = ra, ta = class ta extends U {
|
||
constructor() {
|
||
super({
|
||
category: "PREVIEW_API",
|
||
code: 13,
|
||
message: _`
|
||
You must configure testingLibraryRender to use play in portable stories.
|
||
|
||
import { render } from '@testing-library/[renderer]';
|
||
|
||
setProjectAnnotations({
|
||
testingLibraryRender: render,
|
||
});
|
||
|
||
For other testing renderers, you can configure \`renderToCanvas\` like so:
|
||
|
||
import { render } from 'your-test-renderer';
|
||
|
||
setProjectAnnotations({
|
||
renderToCanvas: ({ storyFn }) => {
|
||
const Story = storyFn();
|
||
|
||
// Svelte
|
||
render(Story.Component, Story.props);
|
||
|
||
// Vue
|
||
render(Story);
|
||
|
||
// or for React
|
||
render(<Story/>);
|
||
},
|
||
});`
|
||
});
|
||
}
|
||
};
|
||
n(ta, "TestingLibraryMustBeConfiguredError");
|
||
var Bn = ta, oa = class oa extends U {
|
||
constructor(t) {
|
||
super({
|
||
category: "PREVIEW_API",
|
||
code: 14,
|
||
message: _`
|
||
No render function available for storyId '${t.id}'
|
||
`
|
||
});
|
||
this.data = t;
|
||
}
|
||
};
|
||
n(oa, "NoRenderFunctionError");
|
||
var rt = oa, na = class na extends U {
|
||
constructor() {
|
||
super({
|
||
category: "PREVIEW_API",
|
||
code: 15,
|
||
message: _`
|
||
No component is mounted in your story.
|
||
|
||
This usually occurs when you destructure mount in the play function, but forget to call it.
|
||
|
||
For example:
|
||
|
||
async play({ mount, canvasElement }) {
|
||
// 👈 mount should be called: await mount();
|
||
const canvas = within(canvasElement);
|
||
const button = await canvas.findByRole('button');
|
||
await userEvent.click(button);
|
||
};
|
||
|
||
Make sure to either remove it or call mount in your play function.
|
||
`
|
||
});
|
||
}
|
||
};
|
||
n(na, "NoStoryMountedError");
|
||
var tt = na, aa = class aa extends U {
|
||
constructor() {
|
||
super({
|
||
category: "FRAMEWORK_NEXTJS",
|
||
code: 1,
|
||
documentation: "https://storybook.js.org/docs/get-started/nextjs#faq",
|
||
message: _`
|
||
You are importing avif images, but you don't have sharp installed.
|
||
|
||
You have to install sharp in order to use image optimization features in Next.js.
|
||
`
|
||
});
|
||
}
|
||
};
|
||
n(aa, "NextJsSharpError");
|
||
var Un = aa, ia = class ia extends U {
|
||
constructor(t) {
|
||
super({
|
||
category: "FRAMEWORK_NEXTJS",
|
||
code: 2,
|
||
message: _`
|
||
Tried to access router mocks from "${t.importType}" but they were not created yet. You might be running code in an unsupported environment.
|
||
`
|
||
});
|
||
this.data = t;
|
||
}
|
||
};
|
||
n(ia, "NextjsRouterMocksNotAvailable");
|
||
var Gn = ia, sa = class sa extends U {
|
||
constructor(t) {
|
||
super({
|
||
category: "DOCS-TOOLS",
|
||
code: 1,
|
||
documentation: "https://github.com/storybookjs/storybook/issues/26606",
|
||
message: _`
|
||
There was a failure when generating detailed ArgTypes in ${t.language} for:
|
||
${JSON.stringify(t.type, null, 2)}
|
||
|
||
Storybook will fall back to use a generic type description instead.
|
||
|
||
This type is either not supported or it is a bug in the docgen generation in Storybook.
|
||
If you think this is a bug, please detail it as much as possible in the Github issue.
|
||
`
|
||
});
|
||
this.data = t;
|
||
}
|
||
};
|
||
n(sa, "UnknownArgTypesError");
|
||
var Hn = sa;
|
||
|
||
// src/preview-api/index.ts
|
||
var Ft = {};
|
||
Ce(Ft, {
|
||
DocsContext: () => ye,
|
||
HooksContext: () => Te,
|
||
Preview: () => Ue,
|
||
PreviewWeb: () => Ct,
|
||
PreviewWithSelection: () => Ge,
|
||
StoryStore: () => Be,
|
||
UrlStore: () => ze,
|
||
WebView: () => Ke,
|
||
addons: () => ne,
|
||
applyHooks: () => Jt,
|
||
combineArgs: () => Sr,
|
||
combineParameters: () => Q,
|
||
composeConfigs: () => vt,
|
||
composeStepRunners: () => wo,
|
||
composeStories: () => Cf,
|
||
composeStory: () => Of,
|
||
createPlaywrightTest: () => If,
|
||
decorateStory: () => oi,
|
||
defaultDecorateStory: () => Eo,
|
||
filterArgTypes: () => mt,
|
||
inferControls: () => Tr,
|
||
makeDecorator: () => $s,
|
||
mockChannel: () => Xt,
|
||
normalizeStory: () => vr,
|
||
prepareMeta: () => To,
|
||
prepareStory: () => Er,
|
||
sanitizeStoryContextUpdate: () => ni,
|
||
setProjectAnnotations: () => Pf,
|
||
simulateDOMContentLoaded: () => It,
|
||
simulatePageLoad: () => os,
|
||
sortStoriesV7: () => Mf,
|
||
useArgs: () => Hs,
|
||
useCallback: () => ar,
|
||
useChannel: () => Us,
|
||
useEffect: () => ya,
|
||
useGlobals: () => Vs,
|
||
useMemo: () => qs,
|
||
useParameter: () => Gs,
|
||
useReducer: () => Bs,
|
||
useRef: () => ks,
|
||
useState: () => js,
|
||
useStoryContext: () => nt,
|
||
userOrAutoTitle: () => qf,
|
||
userOrAutoTitleFromSpecifier: () => ui
|
||
});
|
||
|
||
// src/preview-api/modules/addons/storybook-channel-mock.ts
|
||
function Xt() {
|
||
let r = {
|
||
setHandler: /* @__PURE__ */ n(() => {
|
||
}, "setHandler"),
|
||
send: /* @__PURE__ */ n(() => {
|
||
}, "send")
|
||
};
|
||
return new ve({ transport: r });
|
||
}
|
||
n(Xt, "mockChannel");
|
||
|
||
// src/preview-api/modules/addons/main.ts
|
||
var ua = class ua {
|
||
constructor() {
|
||
this.promise = new Promise((e) => {
|
||
this.resolve = () => e(this.getChannel());
|
||
});
|
||
}
|
||
channel;
|
||
promise;
|
||
resolve;
|
||
getChannel = /* @__PURE__ */ n(() => {
|
||
if (!this.channel) {
|
||
let e = Xt();
|
||
return this.setChannel(e), e;
|
||
}
|
||
return this.channel;
|
||
}, "getChannel");
|
||
ready = /* @__PURE__ */ n(() => this.promise, "ready");
|
||
hasChannel = /* @__PURE__ */ n(() => !!this.channel, "hasChannel");
|
||
setChannel = /* @__PURE__ */ n((e) => {
|
||
this.channel = e, this.resolve();
|
||
}, "setChannel");
|
||
};
|
||
n(ua, "AddonStore");
|
||
var ca = ua, la = "__STORYBOOK_ADDONS_PREVIEW";
|
||
function $b() {
|
||
return T[la] || (T[la] = new ca()), T[la];
|
||
}
|
||
n($b, "getAddonsStore");
|
||
var ne = $b();
|
||
|
||
// src/preview-api/modules/addons/hooks.ts
|
||
var ha = class ha {
|
||
hookListsMap = void 0;
|
||
mountedDecorators = void 0;
|
||
prevMountedDecorators = void 0;
|
||
currentHooks = void 0;
|
||
nextHookIndex = void 0;
|
||
currentPhase = void 0;
|
||
currentEffects = void 0;
|
||
prevEffects = void 0;
|
||
currentDecoratorName = void 0;
|
||
hasUpdates = void 0;
|
||
currentContext = void 0;
|
||
renderListener = /* @__PURE__ */ n((e) => {
|
||
e === this.currentContext?.id && (this.triggerEffects(), this.currentContext = null, this.removeRenderListeners());
|
||
}, "renderListener");
|
||
constructor() {
|
||
this.init();
|
||
}
|
||
init() {
|
||
this.hookListsMap = /* @__PURE__ */ new WeakMap(), this.mountedDecorators = /* @__PURE__ */ new Set(), this.prevMountedDecorators = /* @__PURE__ */ new Set(),
|
||
this.currentHooks = [], this.nextHookIndex = 0, this.currentPhase = "NONE", this.currentEffects = [], this.prevEffects = [], this.currentDecoratorName =
|
||
null, this.hasUpdates = !1, this.currentContext = null;
|
||
}
|
||
clean() {
|
||
this.prevEffects.forEach((e) => {
|
||
e.destroy && e.destroy();
|
||
}), this.init(), this.removeRenderListeners();
|
||
}
|
||
getNextHook() {
|
||
let e = this.currentHooks[this.nextHookIndex];
|
||
return this.nextHookIndex += 1, e;
|
||
}
|
||
triggerEffects() {
|
||
this.prevEffects.forEach((e) => {
|
||
!this.currentEffects.includes(e) && e.destroy && e.destroy();
|
||
}), this.currentEffects.forEach((e) => {
|
||
this.prevEffects.includes(e) || (e.destroy = e.create());
|
||
}), this.prevEffects = this.currentEffects, this.currentEffects = [];
|
||
}
|
||
addRenderListeners() {
|
||
this.removeRenderListeners(), ne.getChannel().on(Je, this.renderListener);
|
||
}
|
||
removeRenderListeners() {
|
||
ne.getChannel().removeListener(Je, this.renderListener);
|
||
}
|
||
};
|
||
n(ha, "HooksContext");
|
||
var Te = ha;
|
||
function Ds(r) {
|
||
let e = /* @__PURE__ */ n((...t) => {
|
||
let { hooks: o } = typeof t[0] == "function" ? t[1] : t[0], a = o.currentPhase, i = o.currentHooks, s = o.nextHookIndex, c = o.currentDecoratorName;
|
||
o.currentDecoratorName = r.name, o.prevMountedDecorators.has(r) ? (o.currentPhase = "UPDATE", o.currentHooks = o.hookListsMap.get(r) || []) :
|
||
(o.currentPhase = "MOUNT", o.currentHooks = [], o.hookListsMap.set(r, o.currentHooks), o.prevMountedDecorators.add(r)), o.nextHookIndex =
|
||
0;
|
||
let l = T.STORYBOOK_HOOKS_CONTEXT;
|
||
T.STORYBOOK_HOOKS_CONTEXT = o;
|
||
let u = r(...t);
|
||
if (T.STORYBOOK_HOOKS_CONTEXT = l, o.currentPhase === "UPDATE" && o.getNextHook() != null)
|
||
throw new Error(
|
||
"Rendered fewer hooks than expected. This may be caused by an accidental early return statement."
|
||
);
|
||
return o.currentPhase = a, o.currentHooks = i, o.nextHookIndex = s, o.currentDecoratorName = c, u;
|
||
}, "hookified");
|
||
return e.originalFn = r, e;
|
||
}
|
||
n(Ds, "hookify");
|
||
var pa = 0, Wb = 25, Jt = /* @__PURE__ */ n((r) => (e, t) => {
|
||
let o = r(
|
||
Ds(e),
|
||
t.map((a) => Ds(a))
|
||
);
|
||
return (a) => {
|
||
let { hooks: i } = a;
|
||
i.prevMountedDecorators ??= /* @__PURE__ */ new Set(), i.mountedDecorators = /* @__PURE__ */ new Set([e, ...t]), i.currentContext = a, i.
|
||
hasUpdates = !1;
|
||
let s = o(a);
|
||
for (pa = 1; i.hasUpdates; )
|
||
if (i.hasUpdates = !1, i.currentEffects = [], s = o(a), pa += 1, pa > Wb)
|
||
throw new Error(
|
||
"Too many re-renders. Storybook limits the number of renders to prevent an infinite loop."
|
||
);
|
||
return i.addRenderListeners(), s;
|
||
};
|
||
}, "applyHooks"), zb = /* @__PURE__ */ n((r, e) => r.length === e.length && r.every((t, o) => t === e[o]), "areDepsEqual"), da = /* @__PURE__ */ n(
|
||
() => new Error("Storybook preview hooks can only be called inside decorators and story functions."), "invalidHooksError");
|
||
function Ns() {
|
||
return T.STORYBOOK_HOOKS_CONTEXT || null;
|
||
}
|
||
n(Ns, "getHooksContextOrNull");
|
||
function fa() {
|
||
let r = Ns();
|
||
if (r == null)
|
||
throw da();
|
||
return r;
|
||
}
|
||
n(fa, "getHooksContextOrThrow");
|
||
function Yb(r, e, t) {
|
||
let o = fa();
|
||
if (o.currentPhase === "MOUNT") {
|
||
t != null && !Array.isArray(t) && C.warn(
|
||
`${r} received a final argument that is not an array (instead, received ${t}). When specified, the final argument must be an array.`
|
||
);
|
||
let a = { name: r, deps: t };
|
||
return o.currentHooks.push(a), e(a), a;
|
||
}
|
||
if (o.currentPhase === "UPDATE") {
|
||
let a = o.getNextHook();
|
||
if (a == null)
|
||
throw new Error("Rendered more hooks than during the previous render.");
|
||
return a.name !== r && C.warn(
|
||
`Storybook has detected a change in the order of Hooks${o.currentDecoratorName ? ` called by ${o.currentDecoratorName}` : ""}. This wi\
|
||
ll lead to bugs and errors if not fixed.`
|
||
), t != null && a.deps == null && C.warn(
|
||
`${r} received a final argument during this render, but not during the previous render. Even though the final argument is optional, it\
|
||
s type cannot change between renders.`
|
||
), t != null && a.deps != null && t.length !== a.deps.length && C.warn(`The final argument passed to ${r} changed size between renders. \
|
||
The order and size of this array must remain constant.
|
||
Previous: ${a.deps}
|
||
Incoming: ${t}`), (t == null || a.deps == null || !zb(t, a.deps)) && (e(a), a.deps = t), a;
|
||
}
|
||
throw da();
|
||
}
|
||
n(Yb, "useHook");
|
||
function Qt(r, e, t) {
|
||
let { memoizedState: o } = Yb(
|
||
r,
|
||
(a) => {
|
||
a.memoizedState = e();
|
||
},
|
||
t
|
||
);
|
||
return o;
|
||
}
|
||
n(Qt, "useMemoLike");
|
||
function qs(r, e) {
|
||
return Qt("useMemo", r, e);
|
||
}
|
||
n(qs, "useMemo");
|
||
function ar(r, e) {
|
||
return Qt("useCallback", () => r, e);
|
||
}
|
||
n(ar, "useCallback");
|
||
function Ls(r, e) {
|
||
return Qt(r, () => ({ current: e }), []);
|
||
}
|
||
n(Ls, "useRefLike");
|
||
function ks(r) {
|
||
return Ls("useRef", r);
|
||
}
|
||
n(ks, "useRef");
|
||
function Kb() {
|
||
let r = Ns();
|
||
if (r != null && r.currentPhase !== "NONE")
|
||
r.hasUpdates = !0;
|
||
else
|
||
try {
|
||
ne.getChannel().emit(kr);
|
||
} catch {
|
||
C.warn("State updates of Storybook preview hooks work only in browser");
|
||
}
|
||
}
|
||
n(Kb, "triggerUpdate");
|
||
function Ms(r, e) {
|
||
let t = Ls(
|
||
r,
|
||
// @ts-expect-error S type should never be function, but there's no way to tell that to TypeScript
|
||
typeof e == "function" ? e() : e
|
||
), o = /* @__PURE__ */ n((a) => {
|
||
t.current = typeof a == "function" ? a(t.current) : a, Kb();
|
||
}, "setState");
|
||
return [t.current, o];
|
||
}
|
||
n(Ms, "useStateLike");
|
||
function js(r) {
|
||
return Ms("useState", r);
|
||
}
|
||
n(js, "useState");
|
||
function Bs(r, e, t) {
|
||
let o = t != null ? () => t(e) : e, [a, i] = Ms("useReducer", o);
|
||
return [a, /* @__PURE__ */ n((c) => i((l) => r(l, c)), "dispatch")];
|
||
}
|
||
n(Bs, "useReducer");
|
||
function ya(r, e) {
|
||
let t = fa(), o = Qt("useEffect", () => ({ create: r }), e);
|
||
t.currentEffects.includes(o) || t.currentEffects.push(o);
|
||
}
|
||
n(ya, "useEffect");
|
||
function Us(r, e = []) {
|
||
let t = ne.getChannel();
|
||
return ya(() => (Object.entries(r).forEach(([o, a]) => t.on(o, a)), () => {
|
||
Object.entries(r).forEach(
|
||
([o, a]) => t.removeListener(o, a)
|
||
);
|
||
}), [...Object.keys(r), ...e]), ar(t.emit.bind(t), [t]);
|
||
}
|
||
n(Us, "useChannel");
|
||
function nt() {
|
||
let { currentContext: r } = fa();
|
||
if (r == null)
|
||
throw da();
|
||
return r;
|
||
}
|
||
n(nt, "useStoryContext");
|
||
function Gs(r, e) {
|
||
let { parameters: t } = nt();
|
||
if (r)
|
||
return t[r] ?? e;
|
||
}
|
||
n(Gs, "useParameter");
|
||
function Hs() {
|
||
let r = ne.getChannel(), { id: e, args: t } = nt(), o = ar(
|
||
(i) => r.emit(Br, { storyId: e, updatedArgs: i }),
|
||
[r, e]
|
||
), a = ar(
|
||
(i) => r.emit(Mr, { storyId: e, argNames: i }),
|
||
[r, e]
|
||
);
|
||
return [t, o, a];
|
||
}
|
||
n(Hs, "useArgs");
|
||
function Vs() {
|
||
let r = ne.getChannel(), { globals: e } = nt(), t = ar(
|
||
(o) => r.emit(jr, { globals: o }),
|
||
[r]
|
||
);
|
||
return [e, t];
|
||
}
|
||
n(Vs, "useGlobals");
|
||
|
||
// src/preview-api/modules/addons/make-decorator.ts
|
||
var $s = /* @__PURE__ */ n(({
|
||
name: r,
|
||
parameterName: e,
|
||
wrapper: t,
|
||
skipIfNoParametersOrOptions: o = !1
|
||
}) => {
|
||
let a = /* @__PURE__ */ n((i) => (s, c) => {
|
||
let l = c.parameters && c.parameters[e];
|
||
return l && l.disable || o && !i && !l ? s(c) : t(s, c, {
|
||
options: i,
|
||
parameters: l
|
||
});
|
||
}, "decorator");
|
||
return (...i) => typeof i[0] == "function" ? a()(...i) : (...s) => {
|
||
if (s.length > 1)
|
||
return i.length > 1 ? a(i)(...s) : a(...i)(...s);
|
||
throw new Error(
|
||
`Passing stories directly into ${r}() is not allowed,
|
||
instead use addDecorator(${r}) and pass options with the '${e}' parameter`
|
||
);
|
||
};
|
||
}, "makeDecorator");
|
||
|
||
// src/preview-api/modules/store/StoryStore.ts
|
||
var _o = Y(Ht(), 1), Df = Y(yt(), 1), si = Y(Bd(), 1);
|
||
|
||
// src/preview-api/modules/store/StoryIndexStore.ts
|
||
var Ud = Y(Ht(), 1);
|
||
var Z_ = (0, Ud.default)(1)(
|
||
(r) => Object.values(r).reduce(
|
||
(e, t) => (e[t.importPath] = e[t.importPath] || t, e),
|
||
{}
|
||
)
|
||
), Xa = class Xa {
|
||
entries;
|
||
constructor({ entries: e } = { v: 5, entries: {} }) {
|
||
this.entries = e;
|
||
}
|
||
entryFromSpecifier(e) {
|
||
let t = Object.values(this.entries);
|
||
if (e === "*")
|
||
return t[0];
|
||
if (typeof e == "string")
|
||
return this.entries[e] ? this.entries[e] : t.find((i) => i.id.startsWith(e));
|
||
let { name: o, title: a } = e;
|
||
return t.find((i) => i.name === o && i.title === a);
|
||
}
|
||
storyIdToEntry(e) {
|
||
let t = this.entries[e];
|
||
if (!t)
|
||
throw new Wr({ storyId: e });
|
||
return t;
|
||
}
|
||
importPathToEntry(e) {
|
||
return Z_(this.entries)[e];
|
||
}
|
||
};
|
||
n(Xa, "StoryIndexStore");
|
||
var fo = Xa;
|
||
|
||
// ../node_modules/dequal/dist/index.mjs
|
||
var Gd = Object.prototype.hasOwnProperty;
|
||
function Hd(r, e, t) {
|
||
for (t of r.keys())
|
||
if (mr(t, e)) return t;
|
||
}
|
||
n(Hd, "find");
|
||
function mr(r, e) {
|
||
var t, o, a;
|
||
if (r === e) return !0;
|
||
if (r && e && (t = r.constructor) === e.constructor) {
|
||
if (t === Date) return r.getTime() === e.getTime();
|
||
if (t === RegExp) return r.toString() === e.toString();
|
||
if (t === Array) {
|
||
if ((o = r.length) === e.length)
|
||
for (; o-- && mr(r[o], e[o]); ) ;
|
||
return o === -1;
|
||
}
|
||
if (t === Set) {
|
||
if (r.size !== e.size)
|
||
return !1;
|
||
for (o of r)
|
||
if (a = o, a && typeof a == "object" && (a = Hd(e, a), !a) || !e.has(a)) return !1;
|
||
return !0;
|
||
}
|
||
if (t === Map) {
|
||
if (r.size !== e.size)
|
||
return !1;
|
||
for (o of r)
|
||
if (a = o[0], a && typeof a == "object" && (a = Hd(e, a), !a) || !mr(o[1], e.get(a)))
|
||
return !1;
|
||
return !0;
|
||
}
|
||
if (t === ArrayBuffer)
|
||
r = new Uint8Array(r), e = new Uint8Array(e);
|
||
else if (t === DataView) {
|
||
if ((o = r.byteLength) === e.byteLength)
|
||
for (; o-- && r.getInt8(o) === e.getInt8(o); ) ;
|
||
return o === -1;
|
||
}
|
||
if (ArrayBuffer.isView(r)) {
|
||
if ((o = r.byteLength) === e.byteLength)
|
||
for (; o-- && r[o] === e[o]; ) ;
|
||
return o === -1;
|
||
}
|
||
if (!t || typeof r == "object") {
|
||
o = 0;
|
||
for (t in r)
|
||
if (Gd.call(r, t) && ++o && !Gd.call(e, t) || !(t in e) || !mr(r[t], e[t])) return !1;
|
||
return Object.keys(e).length === o;
|
||
}
|
||
}
|
||
return r !== r && e !== e;
|
||
}
|
||
n(mr, "dequal");
|
||
|
||
// src/preview-api/modules/store/args.ts
|
||
var ht = Y(yo(), 1);
|
||
var gr = Symbol("incompatible"), Qa = /* @__PURE__ */ n((r, e) => {
|
||
let t = e.type;
|
||
if (r == null || !t || e.mapping)
|
||
return r;
|
||
switch (t.name) {
|
||
case "string":
|
||
return String(r);
|
||
case "enum":
|
||
return r;
|
||
case "number":
|
||
return Number(r);
|
||
case "boolean":
|
||
return String(r) === "true";
|
||
case "array":
|
||
return !t.value || !Array.isArray(r) ? gr : r.reduce((o, a, i) => {
|
||
let s = Qa(a, { type: t.value });
|
||
return s !== gr && (o[i] = s), o;
|
||
}, new Array(r.length));
|
||
case "object":
|
||
return typeof r == "string" || typeof r == "number" ? r : !t.value || typeof r != "object" ? gr : Object.entries(r).reduce((o, [a, i]) => {
|
||
let s = Qa(i, { type: t.value[a] });
|
||
return s === gr ? o : Object.assign(o, { [a]: s });
|
||
}, {});
|
||
default:
|
||
return gr;
|
||
}
|
||
}, "map"), zd = /* @__PURE__ */ n((r, e) => Object.entries(r).reduce((t, [o, a]) => {
|
||
if (!e[o]) return t;
|
||
let i = Qa(a, e[o]);
|
||
return i === gr ? t : Object.assign(t, { [o]: i });
|
||
}, {}), "mapArgsToTypes"), Sr = /* @__PURE__ */ n((r, e) => Array.isArray(r) && Array.isArray(e) ? e.reduce(
|
||
(t, o, a) => (t[a] = Sr(r[a], e[a]), t),
|
||
[...r]
|
||
).filter((t) => t !== void 0) : !(0, ht.default)(r) || !(0, ht.default)(e) ? e : Object.keys({ ...r, ...e }).reduce((t, o) => {
|
||
if (o in e) {
|
||
let a = Sr(r[o], e[o]);
|
||
a !== void 0 && (t[o] = a);
|
||
} else
|
||
t[o] = r[o];
|
||
return t;
|
||
}, {}), "combineArgs"), Yd = /* @__PURE__ */ n((r, e) => Object.entries(e).reduce((t, [o, { options: a }]) => {
|
||
function i() {
|
||
return o in r && (t[o] = r[o]), t;
|
||
}
|
||
if (n(i, "allowArg"), !a) return i();
|
||
if (!Array.isArray(a))
|
||
return M.error(_`
|
||
Invalid argType: '${o}.options' should be an array.
|
||
|
||
More info: https://storybook.js.org/docs/react/api/argtypes
|
||
`), i();
|
||
if (a.some((h) => h && ["object", "function"].includes(typeof h)))
|
||
return M.error(_`
|
||
Invalid argType: '${o}.options' should only contain primitives. Use a 'mapping' for complex values.
|
||
|
||
More info: https://storybook.js.org/docs/react/writing-stories/args#mapping-to-complex-arg-values
|
||
`), i();
|
||
let s = Array.isArray(r[o]), c = s && r[o].findIndex((h) => !a.includes(h)), l = s && c === -1;
|
||
if (r[o] === void 0 || a.includes(r[o]) || l)
|
||
return i();
|
||
let u = s ? `${o}[${c}]` : o, p = a.map((h) => typeof h == "string" ? `'${h}'` : String(h)).join(", ");
|
||
return M.warn(`Received illegal value for '${u}'. Supported options: ${p}`), t;
|
||
}, {}), "validateOptions"), Le = Symbol("Deeply equal"), br = /* @__PURE__ */ n((r, e) => {
|
||
if (typeof r != typeof e) return e;
|
||
if (mr(r, e)) return Le;
|
||
if (Array.isArray(r) && Array.isArray(e)) {
|
||
let t = e.reduce((o, a, i) => {
|
||
let s = br(r[i], a);
|
||
return s !== Le && (o[i] = s), o;
|
||
}, new Array(e.length));
|
||
return e.length >= r.length ? t : t.concat(new Array(r.length - e.length).fill(void 0));
|
||
}
|
||
return (0, ht.default)(r) && (0, ht.default)(e) ? Object.keys({ ...r, ...e }).reduce((t, o) => {
|
||
let a = br(r?.[o], e?.[o]);
|
||
return a === Le ? t : Object.assign(t, { [o]: a });
|
||
}, {}) : e;
|
||
}, "deepDiff"), Za = "UNTARGETED";
|
||
function Kd({
|
||
args: r,
|
||
argTypes: e
|
||
}) {
|
||
let t = {};
|
||
return Object.entries(r).forEach(([o, a]) => {
|
||
let { target: i = Za } = e[o] || {};
|
||
t[i] = t[i] || {}, t[i][o] = a;
|
||
}), t;
|
||
}
|
||
n(Kd, "groupArgsByTarget");
|
||
|
||
// src/preview-api/modules/store/ArgsStore.ts
|
||
function pP(r) {
|
||
return Object.keys(r).forEach((e) => r[e] === void 0 && delete r[e]), r;
|
||
}
|
||
n(pP, "deleteUndefined");
|
||
var ei = class ei {
|
||
initialArgsByStoryId = {};
|
||
argsByStoryId = {};
|
||
get(e) {
|
||
if (!(e in this.argsByStoryId))
|
||
throw new Error(`No args known for ${e} -- has it been rendered yet?`);
|
||
return this.argsByStoryId[e];
|
||
}
|
||
setInitial(e) {
|
||
if (!this.initialArgsByStoryId[e.id])
|
||
this.initialArgsByStoryId[e.id] = e.initialArgs, this.argsByStoryId[e.id] = e.initialArgs;
|
||
else if (this.initialArgsByStoryId[e.id] !== e.initialArgs) {
|
||
let t = br(this.initialArgsByStoryId[e.id], this.argsByStoryId[e.id]);
|
||
this.initialArgsByStoryId[e.id] = e.initialArgs, this.argsByStoryId[e.id] = e.initialArgs, t !== Le && this.updateFromDelta(e, t);
|
||
}
|
||
}
|
||
updateFromDelta(e, t) {
|
||
let o = Yd(t, e.argTypes);
|
||
this.argsByStoryId[e.id] = Sr(this.argsByStoryId[e.id], o);
|
||
}
|
||
updateFromPersisted(e, t) {
|
||
let o = zd(t, e.argTypes);
|
||
return this.updateFromDelta(e, o);
|
||
}
|
||
update(e, t) {
|
||
if (!(e in this.argsByStoryId))
|
||
throw new Error(`No args known for ${e} -- has it been rendered yet?`);
|
||
this.argsByStoryId[e] = pP({
|
||
...this.argsByStoryId[e],
|
||
...t
|
||
});
|
||
}
|
||
};
|
||
n(ei, "ArgsStore");
|
||
var ho = ei;
|
||
|
||
// src/preview-api/modules/store/csf/getValuesFromArgTypes.ts
|
||
var mo = /* @__PURE__ */ n((r = {}) => Object.entries(r).reduce((e, [t, { defaultValue: o }]) => (typeof o < "u" && (e[t] = o), e), {}), "ge\
|
||
tValuesFromArgTypes");
|
||
|
||
// src/preview-api/modules/store/GlobalsStore.ts
|
||
var ri = class ri {
|
||
// We use ! here because TS doesn't analyse the .set() function to see if it actually get set
|
||
allowedGlobalNames;
|
||
initialGlobals;
|
||
globals;
|
||
constructor({
|
||
globals: e = {},
|
||
globalTypes: t = {}
|
||
}) {
|
||
this.set({ globals: e, globalTypes: t });
|
||
}
|
||
set({ globals: e = {}, globalTypes: t = {} }) {
|
||
let o = this.initialGlobals && br(this.initialGlobals, this.globals);
|
||
this.allowedGlobalNames = /* @__PURE__ */ new Set([...Object.keys(e), ...Object.keys(t)]);
|
||
let a = mo(t);
|
||
this.initialGlobals = { ...a, ...e }, this.globals = this.initialGlobals, o && o !== Le && this.updateFromPersisted(o);
|
||
}
|
||
filterAllowedGlobals(e) {
|
||
return Object.entries(e).reduce((t, [o, a]) => (this.allowedGlobalNames.has(o) ? t[o] = a : C.warn(
|
||
`Attempted to set a global (${o}) that is not defined in initial globals or globalTypes`
|
||
), t), {});
|
||
}
|
||
updateFromPersisted(e) {
|
||
let t = this.filterAllowedGlobals(e);
|
||
this.globals = { ...this.globals, ...t };
|
||
}
|
||
get() {
|
||
return this.globals;
|
||
}
|
||
update(e) {
|
||
this.globals = { ...this.globals, ...this.filterAllowedGlobals(e) };
|
||
}
|
||
};
|
||
n(ri, "GlobalsStore");
|
||
var go = ri;
|
||
|
||
// src/preview-api/modules/store/csf/normalizeInputTypes.ts
|
||
var Xd = Y(yt(), 1);
|
||
var dP = /* @__PURE__ */ n((r) => typeof r == "string" ? { name: r } : r, "normalizeType"), fP = /* @__PURE__ */ n((r) => typeof r == "strin\
|
||
g" ? { type: r } : r, "normalizeControl"), yP = /* @__PURE__ */ n((r, e) => {
|
||
let { type: t, control: o, ...a } = r, i = {
|
||
name: e,
|
||
...a
|
||
};
|
||
return t && (i.type = dP(t)), o ? i.control = fP(o) : o === !1 && (i.control = { disable: !0 }), i;
|
||
}, "normalizeInputType"), ke = /* @__PURE__ */ n((r) => (0, Xd.default)(r, yP), "normalizeInputTypes");
|
||
|
||
// ../node_modules/@storybook/csf/dist/index.mjs
|
||
var hP = Object.create, ef = Object.defineProperty, mP = Object.getOwnPropertyDescriptor, gP = Object.getOwnPropertyNames, SP = Object.getPrototypeOf,
|
||
bP = Object.prototype.hasOwnProperty, vP = /* @__PURE__ */ n((r, e) => () => (e || r((e = { exports: {} }).exports, e), e.exports), "v"), EP = /* @__PURE__ */ n(
|
||
(r, e, t, o) => {
|
||
if (e && typeof e == "object" || typeof e == "function") for (let a of gP(e)) !bP.call(r, a) && a !== t && ef(r, a, { get: /* @__PURE__ */ n(
|
||
() => e[a], "get"), enumerable: !(o = mP(e, a)) || o.enumerable });
|
||
return r;
|
||
}, "E"), TP = /* @__PURE__ */ n((r, e, t) => (t = r != null ? hP(SP(r)) : {}, EP(e || !r || !r.__esModule ? ef(t, "default", { value: r, enumerable: !0 }) :
|
||
t, r)), "I"), RP = vP((r) => {
|
||
Object.defineProperty(r, "__esModule", { value: !0 }), r.isEqual = /* @__PURE__ */ function() {
|
||
var e = Object.prototype.toString, t = Object.getPrototypeOf, o = Object.getOwnPropertySymbols ? function(a) {
|
||
return Object.keys(a).concat(Object.getOwnPropertySymbols(a));
|
||
} : Object.keys;
|
||
return function(a, i) {
|
||
return (/* @__PURE__ */ n(function s(c, l, u) {
|
||
var p, h, y, g = e.call(c), m = e.call(l);
|
||
if (c === l) return !0;
|
||
if (c == null || l == null) return !1;
|
||
if (u.indexOf(c) > -1 && u.indexOf(l) > -1) return !0;
|
||
if (u.push(c, l), g != m || (p = o(c), h = o(l), p.length != h.length || p.some(function(b) {
|
||
return !s(c[b], l[b], u);
|
||
}))) return !1;
|
||
switch (g.slice(8, -1)) {
|
||
case "Symbol":
|
||
return c.valueOf() == l.valueOf();
|
||
case "Date":
|
||
case "Number":
|
||
return +c == +l || +c != +c && +l != +l;
|
||
case "RegExp":
|
||
case "Function":
|
||
case "String":
|
||
case "Boolean":
|
||
return "" + c == "" + l;
|
||
case "Set":
|
||
case "Map":
|
||
p = c.entries(), h = l.entries();
|
||
do
|
||
if (!s((y = p.next()).value, h.next().value, u)) return !1;
|
||
while (!y.done);
|
||
return !0;
|
||
case "ArrayBuffer":
|
||
c = new Uint8Array(c), l = new Uint8Array(l);
|
||
case "DataView":
|
||
c = new Uint8Array(c.buffer), l = new Uint8Array(l.buffer);
|
||
case "Float32Array":
|
||
case "Float64Array":
|
||
case "Int8Array":
|
||
case "Int16Array":
|
||
case "Int32Array":
|
||
case "Uint8Array":
|
||
case "Uint16Array":
|
||
case "Uint32Array":
|
||
case "Uint8ClampedArray":
|
||
case "Arguments":
|
||
case "Array":
|
||
if (c.length != l.length) return !1;
|
||
for (y = 0; y < c.length; y++) if ((y in c || y in l) && (y in c != y in l || !s(c[y], l[y], u))) return !1;
|
||
return !0;
|
||
case "Object":
|
||
return s(t(c), t(l), u);
|
||
default:
|
||
return !1;
|
||
}
|
||
}, "i"))(a, i, []);
|
||
};
|
||
}();
|
||
});
|
||
function AP(r) {
|
||
return r.replace(/_/g, " ").replace(/-/g, " ").replace(/\./g, " ").replace(/([^\n])([A-Z])([a-z])/g, (e, t, o, a) => `${t} ${o}${a}`).replace(
|
||
/([a-z])([A-Z])/g, (e, t, o) => `${t} ${o}`).replace(/([a-z])([0-9])/gi, (e, t, o) => `${t} ${o}`).replace(/([0-9])([a-z])/gi, (e, t, o) => `${t}\
|
||
${o}`).replace(/(\s|^)(\w)/g, (e, t, o) => `${t}${o.toUpperCase()}`).replace(/ +/g, " ").trim();
|
||
}
|
||
n(AP, "R");
|
||
var Jd = TP(RP()), rf = /* @__PURE__ */ n((r) => r.map((e) => typeof e < "u").filter(Boolean).length, "S"), wP = /* @__PURE__ */ n((r, e) => {
|
||
let { exists: t, eq: o, neq: a, truthy: i } = r;
|
||
if (rf([t, o, a, i]) > 1) throw new Error(`Invalid conditional test ${JSON.stringify({ exists: t, eq: o, neq: a })}`);
|
||
if (typeof o < "u") return (0, Jd.isEqual)(e, o);
|
||
if (typeof a < "u") return !(0, Jd.isEqual)(e, a);
|
||
if (typeof t < "u") {
|
||
let s = typeof e < "u";
|
||
return t ? s : !s;
|
||
}
|
||
return typeof i > "u" || i ? !!e : !e;
|
||
}, "k"), tf = /* @__PURE__ */ n((r, e, t) => {
|
||
if (!r.if) return !0;
|
||
let { arg: o, global: a } = r.if;
|
||
if (rf([o, a]) !== 1) throw new Error(`Invalid conditional value ${JSON.stringify({ arg: o, global: a })}`);
|
||
let i = o ? e[o] : t[a];
|
||
return wP(r.if, i);
|
||
}, "P"), ti = /* @__PURE__ */ n((r) => r.toLowerCase().replace(/[ ’–—―′¿'`~!@#$%^&*()_|+\-=?;:'",.<>\{\}\[\]\\\/]/gi, "-").replace(
|
||
/-+/g, "-").replace(/^-+/, "").replace(/-+$/, ""), "O"), Qd = /* @__PURE__ */ n((r, e) => {
|
||
let t = ti(r);
|
||
if (t === "") throw new Error(`Invalid ${e} '${r}', must include alphanumeric characters`);
|
||
return t;
|
||
}, "m"), of = /* @__PURE__ */ n((r, e) => `${Qd(r, "kind")}${e ? `--${Qd(e, "name")}` : ""}`, "G"), nf = /* @__PURE__ */ n((r) => AP(r), "N");
|
||
function Zd(r, e) {
|
||
return Array.isArray(e) ? e.includes(r) : r.match(e);
|
||
}
|
||
n(Zd, "f");
|
||
function So(r, { includeStories: e, excludeStories: t }) {
|
||
return r !== "__esModule" && (!e || Zd(r, e)) && (!t || !Zd(r, t));
|
||
}
|
||
n(So, "M");
|
||
var af = /* @__PURE__ */ n((...r) => {
|
||
let e = r.reduce((t, o) => (o.startsWith("!") ? t.delete(o.slice(1)) : t.add(o), t), /* @__PURE__ */ new Set());
|
||
return Array.from(e);
|
||
}, "z");
|
||
|
||
// src/preview-api/modules/store/csf/normalizeArrays.ts
|
||
var j = /* @__PURE__ */ n((r) => Array.isArray(r) ? r : r ? [r] : [], "normalizeArrays");
|
||
|
||
// src/preview-api/modules/store/csf/normalizeStory.ts
|
||
var xP = _`
|
||
CSF .story annotations deprecated; annotate story functions directly:
|
||
- StoryFn.story.name => StoryFn.storyName
|
||
- StoryFn.story.(parameters|decorators) => StoryFn.(parameters|decorators)
|
||
See https://github.com/storybookjs/storybook/blob/next/MIGRATION.md#hoisted-csf-annotations for details and codemod.
|
||
`;
|
||
function vr(r, e, t) {
|
||
let o = e, a = typeof e == "function" ? e : null, { story: i } = o;
|
||
i && (C.debug("deprecated story", i), ae(xP));
|
||
let s = nf(r), c = typeof o != "function" && o.name || o.storyName || i?.name || s, l = [
|
||
...j(o.decorators),
|
||
...j(i?.decorators)
|
||
], u = { ...i?.parameters, ...o.parameters }, p = { ...i?.args, ...o.args }, h = { ...i?.argTypes, ...o.argTypes }, y = [...j(o.loaders), ...j(
|
||
i?.loaders)], g = [
|
||
...j(o.beforeEach),
|
||
...j(i?.beforeEach)
|
||
], { render: m, play: b, tags: S = [] } = o, w = u.__id || of(t.id, s);
|
||
return {
|
||
moduleExport: e,
|
||
id: w,
|
||
name: c,
|
||
tags: S,
|
||
decorators: l,
|
||
parameters: u,
|
||
args: p,
|
||
argTypes: ke(h),
|
||
loaders: y,
|
||
beforeEach: g,
|
||
...m && { render: m },
|
||
...a && { userStoryFn: a },
|
||
...b && { play: b }
|
||
};
|
||
}
|
||
n(vr, "normalizeStory");
|
||
|
||
// src/preview-api/modules/store/csf/normalizeComponentAnnotations.ts
|
||
function bo(r, e = r.title, t) {
|
||
let { id: o, argTypes: a } = r;
|
||
return {
|
||
id: ti(o || e),
|
||
...r,
|
||
title: e,
|
||
...a && { argTypes: ke(a) },
|
||
parameters: {
|
||
fileName: t,
|
||
...r.parameters
|
||
}
|
||
};
|
||
}
|
||
n(bo, "normalizeComponentAnnotations");
|
||
|
||
// src/preview-api/modules/store/csf/processCSFFile.ts
|
||
var _P = /* @__PURE__ */ n((r) => {
|
||
let { globals: e, globalTypes: t } = r;
|
||
(e || t) && C.error(
|
||
"Global args/argTypes can only be set globally",
|
||
JSON.stringify({
|
||
globals: e,
|
||
globalTypes: t
|
||
})
|
||
);
|
||
}, "checkGlobals"), PP = /* @__PURE__ */ n((r) => {
|
||
let { options: e } = r;
|
||
e?.storySort && C.error("The storySort option parameter can only be set globally");
|
||
}, "checkStorySort"), sf = /* @__PURE__ */ n((r) => {
|
||
r && (_P(r), PP(r));
|
||
}, "checkDisallowedParameters");
|
||
function lf(r, e, t) {
|
||
let { default: o, __namedExportsOrder: a, ...i } = r, s = bo(
|
||
o,
|
||
t,
|
||
e
|
||
);
|
||
sf(s.parameters);
|
||
let c = { meta: s, stories: {}, moduleExports: r };
|
||
return Object.keys(i).forEach((l) => {
|
||
if (So(l, s)) {
|
||
let u = vr(l, i[l], s);
|
||
sf(u.parameters), c.stories[u.id] = u;
|
||
}
|
||
}), c;
|
||
}
|
||
n(lf, "processCSFFile");
|
||
|
||
// src/preview-api/modules/store/parameters.ts
|
||
var vo = Y(yo(), 1);
|
||
var Q = /* @__PURE__ */ n((...r) => {
|
||
let e = {}, t = r.filter(Boolean), o = t.reduce((a, i) => (Object.entries(i).forEach(([s, c]) => {
|
||
let l = a[s];
|
||
Array.isArray(c) || typeof l > "u" ? a[s] = c : (0, vo.default)(c) && (0, vo.default)(l) ? e[s] = !0 : typeof c < "u" && (a[s] = c);
|
||
}), a), {});
|
||
return Object.keys(e).forEach((a) => {
|
||
let i = t.filter(Boolean).map((s) => s[a]).filter((s) => typeof s < "u");
|
||
i.every((s) => (0, vo.default)(s)) ? o[a] = Q(...i) : o[a] = i[i.length - 1];
|
||
}), o;
|
||
}, "combineParameters");
|
||
|
||
// src/preview-api/modules/store/decorators.ts
|
||
function oi(r, e, t) {
|
||
let o = t(r);
|
||
return (a) => e(o, a);
|
||
}
|
||
n(oi, "decorateStory");
|
||
function ni({
|
||
componentId: r,
|
||
title: e,
|
||
kind: t,
|
||
id: o,
|
||
name: a,
|
||
story: i,
|
||
parameters: s,
|
||
initialArgs: c,
|
||
argTypes: l,
|
||
...u
|
||
} = {}) {
|
||
return u;
|
||
}
|
||
n(ni, "sanitizeStoryContextUpdate");
|
||
function Eo(r, e) {
|
||
let t = {}, o = /* @__PURE__ */ n((i) => (s) => {
|
||
if (!t.value) throw new Error("Decorated function called without init");
|
||
return t.value = {
|
||
...t.value,
|
||
...ni(s)
|
||
}, i(t.value);
|
||
}, "bindWithContext"), a = e.reduce(
|
||
(i, s) => oi(i, s, o),
|
||
r
|
||
);
|
||
return (i) => (t.value = i, a(i));
|
||
}
|
||
n(Eo, "defaultDecorateStory");
|
||
|
||
// src/preview-api/modules/preview-web/render/mount-utils.ts
|
||
function uf(r) {
|
||
return r != null && OP(r).includes("mount");
|
||
}
|
||
n(uf, "mountDestructured");
|
||
function OP(r) {
|
||
let e = r.toString().match(/[^(]*\(([^)]*)/);
|
||
if (!e) return [];
|
||
let t = cf(e[1]);
|
||
if (!t.length) return [];
|
||
let o = t[0];
|
||
return o.startsWith("{") && o.endsWith("}") ? cf(o.slice(1, -1).replace(/\s/g, "")).map((i) => i.replace(/:.*|=.*/g, "")) : [];
|
||
}
|
||
n(OP, "getUsedProps");
|
||
function cf(r) {
|
||
let e = [], t = [], o = 0;
|
||
for (let i = 0; i < r.length; i++)
|
||
if (r[i] === "{" || r[i] === "[")
|
||
t.push(r[i] === "{" ? "}" : "]");
|
||
else if (r[i] === t[t.length - 1])
|
||
t.pop();
|
||
else if (!t.length && r[i] === ",") {
|
||
let s = r.substring(o, i).trim();
|
||
s && e.push(s), o = i + 1;
|
||
}
|
||
let a = r.substring(o).trim();
|
||
return a && e.push(a), e;
|
||
}
|
||
n(cf, "splitByComma");
|
||
|
||
// src/preview-api/modules/store/csf/prepareStory.ts
|
||
function Er(r, e, t) {
|
||
let { moduleExport: o, id: a, name: i } = r || {}, s = pf(
|
||
r,
|
||
e,
|
||
t
|
||
), c = /* @__PURE__ */ n(async (R) => {
|
||
let P = {};
|
||
for (let k of [
|
||
..."__STORYBOOK_TEST_LOADERS__" in T && Array.isArray(T.__STORYBOOK_TEST_LOADERS__) ? [T.__STORYBOOK_TEST_LOADERS__] : [],
|
||
j(t.loaders),
|
||
j(e.loaders),
|
||
j(r.loaders)
|
||
]) {
|
||
if (R.abortSignal.aborted) return P;
|
||
let F = await Promise.all(k.map((H) => H(R)));
|
||
Object.assign(P, ...F);
|
||
}
|
||
return P;
|
||
}, "applyLoaders"), l = /* @__PURE__ */ n(async (R) => {
|
||
let P = new Array();
|
||
for (let k of [
|
||
...j(t.beforeEach),
|
||
...j(e.beforeEach),
|
||
...j(r.beforeEach)
|
||
]) {
|
||
if (R.abortSignal.aborted) return P;
|
||
let F = await k(R);
|
||
F && P.push(F);
|
||
}
|
||
return P;
|
||
}, "applyBeforeEach"), u = /* @__PURE__ */ n((R) => R.originalStoryFn(R.args, R), "undecoratedStoryFn"), { applyDecorators: p = Eo, runStep: h } = t,
|
||
y = [
|
||
...j(r?.decorators),
|
||
...j(e?.decorators),
|
||
...j(t?.decorators)
|
||
], g = r?.userStoryFn || r?.render || e.render || t.render, m = Jt(p)(u, y), b = /* @__PURE__ */ n((R) => m(R), "unboundStoryFn"), S = r?.
|
||
play ?? e?.play, w = uf(S);
|
||
if (!g && !w)
|
||
throw new rt({ id: a });
|
||
let E = /* @__PURE__ */ n((R) => async () => (await R.renderToCanvas(), R.canvas), "defaultMount"), v = r.mount ?? e.mount ?? t.mount ?? E,
|
||
x = t.testingLibraryRender;
|
||
return {
|
||
...s,
|
||
moduleExport: o,
|
||
id: a,
|
||
name: i,
|
||
story: i,
|
||
originalStoryFn: g,
|
||
undecoratedStoryFn: u,
|
||
unboundStoryFn: b,
|
||
applyLoaders: c,
|
||
applyBeforeEach: l,
|
||
playFunction: S,
|
||
runStep: h,
|
||
mount: v,
|
||
testingLibraryRender: x,
|
||
renderToCanvas: t.renderToCanvas,
|
||
usesMount: w
|
||
};
|
||
}
|
||
n(Er, "prepareStory");
|
||
function To(r, e, t) {
|
||
return {
|
||
...pf(void 0, r, e),
|
||
moduleExport: t
|
||
};
|
||
}
|
||
n(To, "prepareMeta");
|
||
function pf(r, e, t) {
|
||
let o = ["dev", "test"], a = T.DOCS_OPTIONS?.autodocs === !0 ? ["autodocs"] : [], i = af(
|
||
...o,
|
||
...a,
|
||
...t.tags ?? [],
|
||
...e.tags ?? [],
|
||
...r?.tags ?? []
|
||
), s = Q(
|
||
t.parameters,
|
||
e.parameters,
|
||
r?.parameters
|
||
), { argTypesEnhancers: c = [], argsEnhancers: l = [] } = t, u = Q(
|
||
t.argTypes,
|
||
e.argTypes,
|
||
r?.argTypes
|
||
);
|
||
if (r) {
|
||
let S = r?.userStoryFn || r?.render || e.render || t.render;
|
||
s.__isArgsStory = S && S.length > 0;
|
||
}
|
||
let p = {
|
||
...t.args,
|
||
...e.args,
|
||
...r?.args
|
||
}, h = {
|
||
componentId: e.id,
|
||
title: e.title,
|
||
kind: e.title,
|
||
// Back compat
|
||
id: r?.id || e.id,
|
||
// if there's no story name, we create a fake one since enhancers expect a name
|
||
name: r?.name || "__meta",
|
||
story: r?.name || "__meta",
|
||
// Back compat
|
||
component: e.component,
|
||
subcomponents: e.subcomponents,
|
||
tags: i,
|
||
parameters: s,
|
||
initialArgs: p,
|
||
argTypes: u
|
||
};
|
||
h.argTypes = c.reduce(
|
||
(S, w) => w({ ...h, argTypes: S }),
|
||
h.argTypes
|
||
);
|
||
let y = { ...p };
|
||
h.initialArgs = l.reduce(
|
||
(S, w) => ({
|
||
...S,
|
||
...w({
|
||
...h,
|
||
initialArgs: S
|
||
})
|
||
}),
|
||
y
|
||
);
|
||
let { name: g, story: m, ...b } = h;
|
||
return b;
|
||
}
|
||
n(pf, "preparePartialAnnotations");
|
||
function Ro(r) {
|
||
let { args: e } = r, t = {
|
||
...r,
|
||
allArgs: void 0,
|
||
argsByTarget: void 0
|
||
};
|
||
if (T.FEATURES?.argTypeTargetsV7) {
|
||
let i = Kd(r);
|
||
t = {
|
||
...r,
|
||
allArgs: r.args,
|
||
argsByTarget: i,
|
||
args: i[Za] || {}
|
||
};
|
||
}
|
||
let o = Object.entries(t.args).reduce((i, [s, c]) => {
|
||
if (!t.argTypes[s]?.mapping)
|
||
return i[s] = c, i;
|
||
let l = /* @__PURE__ */ n((u) => {
|
||
let p = t.argTypes[s].mapping;
|
||
return p && u in p ? p[u] : u;
|
||
}, "mappingFn");
|
||
return i[s] = Array.isArray(c) ? c.map(l) : l(c), i;
|
||
}, {}), a = Object.entries(o).reduce((i, [s, c]) => {
|
||
let l = t.argTypes[s] || {};
|
||
return tf(l, o, t.globals) && (i[s] = c), i;
|
||
}, {});
|
||
return { ...t, unmappedArgs: e, args: a };
|
||
}
|
||
n(Ro, "prepareContext");
|
||
|
||
// src/preview-api/modules/store/inferArgTypes.ts
|
||
var Ao = Y(yt(), 1);
|
||
var ai = /* @__PURE__ */ n((r, e, t) => {
|
||
let o = typeof r;
|
||
switch (o) {
|
||
case "boolean":
|
||
case "string":
|
||
case "number":
|
||
case "function":
|
||
case "symbol":
|
||
return { name: o };
|
||
default:
|
||
break;
|
||
}
|
||
return r ? t.has(r) ? (C.warn(_`
|
||
We've detected a cycle in arg '${e}'. Args should be JSON-serializable.
|
||
|
||
Consider using the mapping feature or fully custom args:
|
||
- Mapping: https://storybook.js.org/docs/react/writing-stories/args#mapping-to-complex-arg-values
|
||
- Custom args: https://storybook.js.org/docs/react/essentials/controls#fully-custom-args
|
||
`), { name: "other", value: "cyclic object" }) : (t.add(r), Array.isArray(r) ? { name: "array", value: r.length > 0 ? ai(r[0], e, new Set(
|
||
t)) : { name: "other", value: "unknown" } } : { name: "object", value: (0, Ao.default)(r, (i) => ai(i, e, new Set(t))) }) : { name: "objec\
|
||
t", value: {} };
|
||
}, "inferType"), ii = /* @__PURE__ */ n((r) => {
|
||
let { id: e, argTypes: t = {}, initialArgs: o = {} } = r, a = (0, Ao.default)(o, (s, c) => ({
|
||
name: c,
|
||
type: ai(s, `${e}.${c}`, /* @__PURE__ */ new Set())
|
||
})), i = (0, Ao.default)(t, (s, c) => ({
|
||
name: c
|
||
}));
|
||
return Q(a, i, t);
|
||
}, "inferArgTypes");
|
||
ii.secondPass = !0;
|
||
|
||
// src/preview-api/modules/store/inferControls.ts
|
||
var xf = Y(yt(), 1);
|
||
|
||
// src/preview-api/modules/store/filterArgTypes.ts
|
||
var wf = Y(Rf(), 1);
|
||
var Af = /* @__PURE__ */ n((r, e) => Array.isArray(e) ? e.includes(r) : r.match(e), "matches"), mt = /* @__PURE__ */ n((r, e, t) => !e && !t ?
|
||
r : r && (0, wf.default)(r, (o, a) => {
|
||
let i = o.name || a;
|
||
return (!e || Af(i, e)) && (!t || !Af(i, t));
|
||
}), "filterArgTypes");
|
||
|
||
// src/preview-api/modules/store/inferControls.ts
|
||
var tO = /* @__PURE__ */ n((r, e, t) => {
|
||
let { type: o, options: a } = r;
|
||
if (o) {
|
||
if (t.color && t.color.test(e)) {
|
||
let i = o.name;
|
||
if (i === "string")
|
||
return { control: { type: "color" } };
|
||
i !== "enum" && C.warn(
|
||
`Addon controls: Control of type color only supports string, received "${i}" instead`
|
||
);
|
||
}
|
||
if (t.date && t.date.test(e))
|
||
return { control: { type: "date" } };
|
||
switch (o.name) {
|
||
case "array":
|
||
return { control: { type: "object" } };
|
||
case "boolean":
|
||
return { control: { type: "boolean" } };
|
||
case "string":
|
||
return { control: { type: "text" } };
|
||
case "number":
|
||
return { control: { type: "number" } };
|
||
case "enum": {
|
||
let { value: i } = o;
|
||
return { control: { type: i?.length <= 5 ? "radio" : "select" }, options: i };
|
||
}
|
||
case "function":
|
||
case "symbol":
|
||
return null;
|
||
default:
|
||
return { control: { type: a ? "select" : "object" } };
|
||
}
|
||
}
|
||
}, "inferControl"), Tr = /* @__PURE__ */ n((r) => {
|
||
let {
|
||
argTypes: e,
|
||
// eslint-disable-next-line @typescript-eslint/naming-convention
|
||
parameters: { __isArgsStory: t, controls: { include: o = null, exclude: a = null, matchers: i = {} } = {} }
|
||
} = r;
|
||
if (!t) return e;
|
||
let s = mt(e, o, a), c = (0, xf.default)(s, (l, u) => l?.type && tO(l, u, i));
|
||
return Q(c, s);
|
||
}, "inferControls");
|
||
Tr.secondPass = !0;
|
||
|
||
// src/preview-api/modules/store/csf/normalizeProjectAnnotations.ts
|
||
function gt({
|
||
argTypes: r,
|
||
globalTypes: e,
|
||
argTypesEnhancers: t,
|
||
decorators: o,
|
||
loaders: a,
|
||
beforeEach: i,
|
||
globals: s,
|
||
initialGlobals: c,
|
||
...l
|
||
}) {
|
||
return s && Object.keys(s).length > 0 && ae(_`
|
||
The preview.js 'globals' field is deprecated and will be removed in Storybook 9.0.
|
||
Please use 'initialGlobals' instead. Learn more:
|
||
|
||
https://github.com/storybookjs/storybook/blob/next/MIGRATION.md#previewjs-globals-renamed-to-initialglobals
|
||
`), {
|
||
...r && { argTypes: ke(r) },
|
||
...e && { globalTypes: ke(e) },
|
||
decorators: j(o),
|
||
loaders: j(a),
|
||
beforeEach: j(i),
|
||
argTypesEnhancers: [
|
||
...t || [],
|
||
ii,
|
||
// inferControls technically should only run if the user is using the controls addon,
|
||
// and so should be added by a preset there. However, as it seems some code relies on controls
|
||
// annotations (in particular the angular implementation's `cleanArgsDecorator`), for backwards
|
||
// compatibility reasons, we will leave this in the store until 7.0
|
||
Tr
|
||
],
|
||
initialGlobals: Q(c, s),
|
||
...l
|
||
};
|
||
}
|
||
n(gt, "normalizeProjectAnnotations");
|
||
|
||
// src/preview-api/modules/store/csf/stepRunners.ts
|
||
function wo(r) {
|
||
return async (e, t, o) => {
|
||
await r.reduceRight(
|
||
(i, s) => async () => s(e, i, o),
|
||
async () => t(o)
|
||
)();
|
||
};
|
||
}
|
||
n(wo, "composeStepRunners");
|
||
|
||
// src/preview-api/modules/store/csf/beforeAll.ts
|
||
var _f = /* @__PURE__ */ n((r) => async () => {
|
||
let e = [];
|
||
for (let t of r) {
|
||
let o = await t();
|
||
o && e.unshift(o);
|
||
}
|
||
return async () => {
|
||
for (let t of e)
|
||
await t();
|
||
};
|
||
}, "composeBeforeAllHooks");
|
||
|
||
// src/preview-api/modules/store/csf/composeConfigs.ts
|
||
function bt(r, e) {
|
||
return r.map((t) => t.default?.[e] ?? t[e]).filter(Boolean);
|
||
}
|
||
n(bt, "getField");
|
||
function Me(r, e, t = {}) {
|
||
return bt(r, e).reduce((o, a) => {
|
||
let i = j(a);
|
||
return t.reverseFileOrder ? [...i, ...o] : [...o, ...i];
|
||
}, []);
|
||
}
|
||
n(Me, "getArrayField");
|
||
function St(r, e) {
|
||
return Object.assign({}, ...bt(r, e));
|
||
}
|
||
n(St, "getObjectField");
|
||
function Rr(r, e) {
|
||
return bt(r, e).pop();
|
||
}
|
||
n(Rr, "getSingletonField");
|
||
function vt(r) {
|
||
let e = Me(r, "argTypesEnhancers"), t = bt(r, "runStep"), o = Me(r, "beforeAll");
|
||
return {
|
||
parameters: Q(...bt(r, "parameters")),
|
||
decorators: Me(r, "decorators", {
|
||
reverseFileOrder: !(T.FEATURES?.legacyDecoratorFileOrder ?? !1)
|
||
}),
|
||
args: St(r, "args"),
|
||
argsEnhancers: Me(r, "argsEnhancers"),
|
||
argTypes: St(r, "argTypes"),
|
||
argTypesEnhancers: [
|
||
...e.filter((a) => !a.secondPass),
|
||
...e.filter((a) => a.secondPass)
|
||
],
|
||
globals: St(r, "globals"),
|
||
initialGlobals: St(r, "initialGlobals"),
|
||
globalTypes: St(r, "globalTypes"),
|
||
loaders: Me(r, "loaders"),
|
||
beforeAll: _f(o),
|
||
beforeEach: Me(r, "beforeEach"),
|
||
render: Rr(r, "render"),
|
||
renderToCanvas: Rr(r, "renderToCanvas"),
|
||
renderToDOM: Rr(r, "renderToDOM"),
|
||
// deprecated
|
||
applyDecorators: Rr(r, "applyDecorators"),
|
||
runStep: wo(t),
|
||
tags: Me(r, "tags"),
|
||
mount: Rr(r, "mount"),
|
||
testingLibraryRender: Rr(r, "testingLibraryRender")
|
||
};
|
||
}
|
||
n(vt, "composeConfigs");
|
||
|
||
// src/preview-api/modules/store/csf/portable-stories.ts
|
||
var xo = {}, oO = "ComposedStory", nO = "Unnamed Story";
|
||
function aO(r) {
|
||
return r ? "default" in r ? r.default : r : {};
|
||
}
|
||
n(aO, "extractAnnotation");
|
||
function Pf(r) {
|
||
let e = Array.isArray(r) ? r : [r];
|
||
return xo = vt(e.map(aO)), xo;
|
||
}
|
||
n(Pf, "setProjectAnnotations");
|
||
var je = [];
|
||
function Of(r, e, t, o, a) {
|
||
if (r === void 0)
|
||
throw new Error("Expected a story but received undefined.");
|
||
e.title = e.title ?? oO;
|
||
let i = bo(e), s = a || r.storyName || r.story?.name || r.name || nO, c = vr(
|
||
s,
|
||
r,
|
||
i
|
||
), l = o && !xo?.testingLibraryRender && !t?.testingLibraryRender, u = gt(
|
||
vt([
|
||
{
|
||
...o,
|
||
renderToCanvas: l ? void 0 : o?.renderToCanvas
|
||
},
|
||
xo,
|
||
t ?? {}
|
||
])
|
||
), p = Er(
|
||
c,
|
||
i,
|
||
u
|
||
), h = mo(u.globalTypes), y = /* @__PURE__ */ n(() => {
|
||
let E = Ro({
|
||
hooks: new Te(),
|
||
globals: {
|
||
...h,
|
||
...u.initialGlobals
|
||
},
|
||
args: { ...p.initialArgs },
|
||
viewMode: "story",
|
||
loaded: {},
|
||
abortSignal: new AbortController().signal,
|
||
step: /* @__PURE__ */ n((v, x) => p.runStep(v, x, E), "step"),
|
||
canvasElement: globalThis?.document?.body,
|
||
canvas: {},
|
||
...p,
|
||
context: null,
|
||
mount: null
|
||
});
|
||
return E.context = E, p.renderToCanvas && (E.renderToCanvas = async () => {
|
||
let v = await p.renderToCanvas?.(
|
||
{
|
||
componentId: p.componentId,
|
||
title: p.title,
|
||
id: p.id,
|
||
name: p.name,
|
||
tags: p.tags,
|
||
showError: /* @__PURE__ */ n((x) => {
|
||
}, "showError"),
|
||
showException: /* @__PURE__ */ n((x) => {
|
||
}, "showException"),
|
||
forceRemount: !0,
|
||
storyContext: E,
|
||
storyFn: /* @__PURE__ */ n(() => p.unboundStoryFn(E), "storyFn"),
|
||
unboundStoryFn: p.unboundStoryFn
|
||
},
|
||
E.canvasElement
|
||
);
|
||
v && je.push(v);
|
||
}), E.mount = p.mount(E), E;
|
||
}, "initializeContext"), g, m = /* @__PURE__ */ n(async (E) => {
|
||
let v = y();
|
||
return g && (v.loaded = g.loaded), Object.assign(v, E), p.playFunction(v);
|
||
}, "backwardsCompatiblePlay"), b = /* @__PURE__ */ n((E) => {
|
||
let v = y();
|
||
return Object.assign(v, E), iO(p, v);
|
||
}, "newPlay"), S = !p.renderToCanvas && p.playFunction ? m : !p.renderToCanvas && !p.playFunction ? void 0 : b;
|
||
return Object.assign(
|
||
/* @__PURE__ */ n(function(v) {
|
||
let x = y();
|
||
return g && (x.loaded = g.loaded), x.args = {
|
||
...x.initialArgs,
|
||
...v
|
||
}, p.unboundStoryFn(x);
|
||
}, "storyFn"),
|
||
{
|
||
id: p.id,
|
||
storyName: s,
|
||
load: /* @__PURE__ */ n(async () => {
|
||
for (let v of [...je].reverse()) await v();
|
||
je.length = 0;
|
||
let E = y();
|
||
E.loaded = await p.applyLoaders(E), je.push(...(await p.applyBeforeEach(E)).filter(Boolean)), g = E;
|
||
}, "load"),
|
||
args: p.initialArgs,
|
||
parameters: p.parameters,
|
||
argTypes: p.argTypes,
|
||
play: S,
|
||
tags: p.tags
|
||
}
|
||
);
|
||
}
|
||
n(Of, "composeStory");
|
||
function Cf(r, e, t) {
|
||
let { default: o, __esModule: a, __namedExportsOrder: i, ...s } = r;
|
||
return Object.entries(s).reduce((l, [u, p]) => So(u, o) ? Object.assign(l, {
|
||
[u]: t(
|
||
p,
|
||
o,
|
||
e,
|
||
u
|
||
)
|
||
}) : l, {});
|
||
}
|
||
n(Cf, "composeStories");
|
||
function If(r) {
|
||
return r.extend({
|
||
mount: /* @__PURE__ */ n(async ({ mount: e, page: t }, o) => {
|
||
await o(async (a, ...i) => {
|
||
if (!("__pw_type" in a) || "__pw_type" in a && a.__pw_type !== "jsx")
|
||
throw new Error(_`
|
||
Portable stories in Playwright CT only work when referencing JSX elements.
|
||
Please use JSX format for your components such as:
|
||
|
||
instead of:
|
||
await mount(MyComponent, { props: { foo: 'bar' } })
|
||
|
||
do:
|
||
await mount(<MyComponent foo="bar"/>)
|
||
|
||
More info: https://storybook.js.org/docs/api/portable-stories-playwright
|
||
`);
|
||
await t.evaluate(async (c) => {
|
||
let l = await globalThis.__pwUnwrapObject?.(c);
|
||
return ("__pw_type" in l ? l.type : l)?.load?.();
|
||
}, a);
|
||
let s = await e(a, ...i);
|
||
return await t.evaluate(async (c) => {
|
||
let l = await globalThis.__pwUnwrapObject?.(c), u = "__pw_type" in l ? l.type : l, p = document.querySelector("#root");
|
||
return u?.play?.({ canvasElement: p });
|
||
}, a), s;
|
||
});
|
||
}, "mount")
|
||
});
|
||
}
|
||
n(If, "createPlaywrightTest");
|
||
async function iO(r, e) {
|
||
for (let a of [...je].reverse()) await a();
|
||
if (je.length = 0, e.loaded = await r.applyLoaders(e), e.abortSignal.aborted) return;
|
||
je.push(...(await r.applyBeforeEach(e)).filter(Boolean));
|
||
let t = r.playFunction, o = r.usesMount;
|
||
o || await e.mount(), !e.abortSignal.aborted && t && (o || (e.mount = async () => {
|
||
throw new Fe({ playFunction: t.toString() });
|
||
}), await t(e));
|
||
}
|
||
n(iO, "playStory");
|
||
|
||
// src/preview-api/modules/store/StoryStore.ts
|
||
var Ff = 1e3, sO = 1e4, li = class li {
|
||
constructor(e, t, o) {
|
||
this.importFn = t;
|
||
this.storyIndex = new fo(e), this.projectAnnotations = gt(o);
|
||
let { initialGlobals: a, globalTypes: i } = this.projectAnnotations;
|
||
this.args = new ho(), this.globals = new go({ globals: a, globalTypes: i }), this.hooks = {}, this.cleanupCallbacks = {}, this.processCSFFileWithCache =
|
||
(0, _o.default)(Ff)(lf), this.prepareMetaWithCache = (0, _o.default)(Ff)(To), this.prepareStoryWithCache = (0, _o.default)(sO)(Er);
|
||
}
|
||
storyIndex;
|
||
projectAnnotations;
|
||
globals;
|
||
args;
|
||
hooks;
|
||
cleanupCallbacks;
|
||
cachedCSFFiles;
|
||
processCSFFileWithCache;
|
||
prepareMetaWithCache;
|
||
prepareStoryWithCache;
|
||
setProjectAnnotations(e) {
|
||
this.projectAnnotations = gt(e);
|
||
let { initialGlobals: t, globalTypes: o } = e;
|
||
this.globals.set({ globals: t, globalTypes: o });
|
||
}
|
||
// This means that one of the CSF files has changed.
|
||
// If the `importFn` has changed, we will invalidate both caches.
|
||
// If the `storyIndex` data has changed, we may or may not invalidate the caches, depending
|
||
// on whether we've loaded the relevant files yet.
|
||
async onStoriesChanged({
|
||
importFn: e,
|
||
storyIndex: t
|
||
}) {
|
||
e && (this.importFn = e), t && (this.storyIndex.entries = t.entries), this.cachedCSFFiles && await this.cacheAllCSFFiles();
|
||
}
|
||
// Get an entry from the index, waiting on initialization if necessary
|
||
async storyIdToEntry(e) {
|
||
return this.storyIndex.storyIdToEntry(e);
|
||
}
|
||
// To load a single CSF file to service a story we need to look up the importPath in the index
|
||
async loadCSFFileByStoryId(e) {
|
||
let { importPath: t, title: o } = this.storyIndex.storyIdToEntry(e), a = await this.importFn(t);
|
||
return this.processCSFFileWithCache(a, t, o);
|
||
}
|
||
async loadAllCSFFiles() {
|
||
let e = {};
|
||
return Object.entries(this.storyIndex.entries).forEach(([o, { importPath: a }]) => {
|
||
e[a] = o;
|
||
}), (await Promise.all(
|
||
Object.entries(e).map(async ([o, a]) => ({
|
||
importPath: o,
|
||
csfFile: await this.loadCSFFileByStoryId(a)
|
||
}))
|
||
)).reduce(
|
||
(o, { importPath: a, csfFile: i }) => (o[a] = i, o),
|
||
{}
|
||
);
|
||
}
|
||
async cacheAllCSFFiles() {
|
||
this.cachedCSFFiles = await this.loadAllCSFFiles();
|
||
}
|
||
preparedMetaFromCSFFile({ csfFile: e }) {
|
||
let t = e.meta;
|
||
return this.prepareMetaWithCache(
|
||
t,
|
||
this.projectAnnotations,
|
||
e.moduleExports.default
|
||
);
|
||
}
|
||
// Load the CSF file for a story and prepare the story from it and the project annotations.
|
||
async loadStory({ storyId: e }) {
|
||
let t = await this.loadCSFFileByStoryId(e);
|
||
return this.storyFromCSFFile({ storyId: e, csfFile: t });
|
||
}
|
||
// This function is synchronous for convenience -- often times if you have a CSF file already
|
||
// it is easier not to have to await `loadStory`.
|
||
storyFromCSFFile({
|
||
storyId: e,
|
||
csfFile: t
|
||
}) {
|
||
let o = t.stories[e];
|
||
if (!o) throw new Zr({ storyId: e });
|
||
let a = t.meta, i = this.prepareStoryWithCache(
|
||
o,
|
||
a,
|
||
this.projectAnnotations
|
||
);
|
||
return this.args.setInitial(i), this.hooks[i.id] = this.hooks[i.id] || new Te(), i;
|
||
}
|
||
// If we have a CSF file we can get all the stories from it synchronously
|
||
componentStoriesFromCSFFile({
|
||
csfFile: e
|
||
}) {
|
||
return Object.keys(this.storyIndex.entries).filter((t) => !!e.stories[t]).map((t) => this.storyFromCSFFile({ storyId: t, csfFile: e }));
|
||
}
|
||
async loadEntry(e) {
|
||
let t = await this.storyIdToEntry(e), o = t.type === "docs" ? t.storiesImports : [], [a, ...i] = await Promise.all([
|
||
this.importFn(t.importPath),
|
||
...o.map((s) => {
|
||
let c = this.storyIndex.importPathToEntry(s);
|
||
return this.loadCSFFileByStoryId(c.id);
|
||
})
|
||
]);
|
||
return { entryExports: a, csfFiles: i };
|
||
}
|
||
// A prepared story does not include args, globals or hooks. These are stored in the story store
|
||
// and updated separtely to the (immutable) story.
|
||
getStoryContext(e, { forceInitialArgs: t = !1 } = {}) {
|
||
return Ro({
|
||
...e,
|
||
args: t ? e.initialArgs : this.args.get(e.id),
|
||
globals: this.globals.get(),
|
||
hooks: this.hooks[e.id]
|
||
});
|
||
}
|
||
addCleanupCallbacks(e, t) {
|
||
this.cleanupCallbacks[e.id] = t;
|
||
}
|
||
async cleanupStory(e) {
|
||
this.hooks[e.id].clean();
|
||
let t = this.cleanupCallbacks[e.id];
|
||
if (t) for (let o of [...t].reverse()) await o();
|
||
delete this.cleanupCallbacks[e.id];
|
||
}
|
||
extract(e = { includeDocsOnly: !1 }) {
|
||
let { cachedCSFFiles: t } = this;
|
||
if (!t) throw new zr();
|
||
return Object.entries(this.storyIndex.entries).reduce(
|
||
(o, [a, { type: i, importPath: s }]) => {
|
||
if (i === "docs") return o;
|
||
let c = t[s], l = this.storyFromCSFFile({ storyId: a, csfFile: c });
|
||
return !e.includeDocsOnly && l.parameters.docsOnly || (o[a] = Object.entries(l).reduce(
|
||
(u, [p, h]) => p === "moduleExport" || typeof h == "function" ? u : Array.isArray(h) ? Object.assign(u, { [p]: h.slice().sort() }) :
|
||
Object.assign(u, { [p]: h }),
|
||
{ args: l.initialArgs }
|
||
)), o;
|
||
},
|
||
{}
|
||
);
|
||
}
|
||
getSetStoriesPayload() {
|
||
let e = this.extract({ includeDocsOnly: !0 }), t = Object.values(e).reduce(
|
||
(o, { title: a }) => (o[a] = {}, o),
|
||
{}
|
||
);
|
||
return {
|
||
v: 2,
|
||
globals: this.globals.get(),
|
||
globalParameters: {},
|
||
kindParameters: t,
|
||
stories: e
|
||
};
|
||
}
|
||
// NOTE: this is legacy `stories.json` data for the `extract` script.
|
||
// It is used to allow v7 Storybooks to be composed in v6 Storybooks, which expect a
|
||
// `stories.json` file with legacy fields (`kind` etc).
|
||
getStoriesJsonData = /* @__PURE__ */ n(() => {
|
||
let e = this.getSetStoriesPayload(), t = ["fileName", "docsOnly", "framework", "__id", "__isArgsStory"];
|
||
return {
|
||
v: 3,
|
||
stories: (0, Df.default)(e.stories, (a) => {
|
||
let { importPath: i } = this.storyIndex.entries[a.id];
|
||
return {
|
||
...(0, si.default)(a, ["id", "name", "title"]),
|
||
importPath: i,
|
||
// These 3 fields were going to be dropped in v7, but instead we will keep them for the
|
||
// 7.x cycle so that v7 Storybooks can be composed successfully in v6 Storybook.
|
||
// In v8 we will (likely) completely drop support for `extract` and `getStoriesJsonData`
|
||
kind: a.title,
|
||
story: a.name,
|
||
parameters: {
|
||
...(0, si.default)(a.parameters, t),
|
||
fileName: i
|
||
}
|
||
};
|
||
})
|
||
};
|
||
}, "getStoriesJsonData");
|
||
raw() {
|
||
return ae(
|
||
"StoryStore.raw() is deprecated and will be removed in 9.0, please use extract() instead"
|
||
), Object.values(this.extract()).map(({ id: e }) => this.fromId(e)).filter(Boolean);
|
||
}
|
||
fromId(e) {
|
||
if (ae(
|
||
"StoryStore.fromId() is deprecated and will be removed in 9.0, please use loadStory() instead"
|
||
), !this.cachedCSFFiles)
|
||
throw new Error("Cannot call fromId/raw() unless you call cacheAllCSFFiles() first.");
|
||
let t;
|
||
try {
|
||
({ importPath: t } = this.storyIndex.storyIdToEntry(e));
|
||
} catch {
|
||
return null;
|
||
}
|
||
let o = this.cachedCSFFiles[t], a = this.storyFromCSFFile({ storyId: e, csfFile: o });
|
||
return {
|
||
...a,
|
||
storyFn: /* @__PURE__ */ n((i) => {
|
||
let s = {
|
||
...this.getStoryContext(a),
|
||
abortSignal: new AbortController().signal,
|
||
canvasElement: null,
|
||
loaded: {},
|
||
step: /* @__PURE__ */ n((c, l) => a.runStep(c, l, s), "step"),
|
||
context: null,
|
||
mount: null,
|
||
canvas: {},
|
||
viewMode: "story"
|
||
};
|
||
return a.unboundStoryFn({ ...s, ...i });
|
||
}, "storyFn")
|
||
};
|
||
}
|
||
};
|
||
n(li, "StoryStore");
|
||
var Be = li;
|
||
|
||
// ../node_modules/slash/index.js
|
||
function ci(r) {
|
||
return r.startsWith("\\\\?\\") ? r : r.replace(/\\/g, "/");
|
||
}
|
||
n(ci, "slash");
|
||
|
||
// src/preview-api/modules/store/autoTitle.ts
|
||
var lO = /* @__PURE__ */ n((r) => {
|
||
if (r.length === 0) return r;
|
||
let e = r[r.length - 1], t = e?.replace(/(?:[.](?:story|stories))?([.][^.]+)$/i, "");
|
||
if (r.length === 1) return [t];
|
||
let o = r[r.length - 2];
|
||
return t && o && t.toLowerCase() === o.toLowerCase() ? [...r.slice(0, -2), t] : t && (/^(story|stories)([.][^.]+)$/i.test(e) || /^index$/i.
|
||
test(t)) ? r.slice(0, -1) : [...r.slice(0, -1), t];
|
||
}, "sanitize");
|
||
function Nf(r) {
|
||
return r.flatMap((e) => e.split("/")).filter(Boolean).join("/");
|
||
}
|
||
n(Nf, "pathJoin");
|
||
var ui = /* @__PURE__ */ n((r, e, t) => {
|
||
let { directory: o, importPathMatcher: a, titlePrefix: i = "" } = e || {};
|
||
typeof r == "number" && M.warn(_`
|
||
CSF Auto-title received a numeric fileName. This typically happens when
|
||
webpack is mis-configured in production mode. To force webpack to produce
|
||
filenames, set optimization.moduleIds = "named" in your webpack config.
|
||
`);
|
||
let s = ci(String(r));
|
||
if (a.exec(s)) {
|
||
if (!t) {
|
||
let c = s.replace(o, ""), l = Nf([i, c]).split("/");
|
||
return l = lO(l), l.join("/");
|
||
}
|
||
return i ? Nf([i, t]) : t;
|
||
}
|
||
}, "userOrAutoTitleFromSpecifier"), qf = /* @__PURE__ */ n((r, e, t) => {
|
||
for (let o = 0; o < e.length; o += 1) {
|
||
let a = ui(r, e[o], t);
|
||
if (a) return a;
|
||
}
|
||
return t || void 0;
|
||
}, "userOrAutoTitle");
|
||
|
||
// src/preview-api/modules/store/storySort.ts
|
||
var Lf = /\s*\/\s*/, kf = /* @__PURE__ */ n((r = {}) => (e, t) => {
|
||
if (e.title === t.title && !r.includeNames)
|
||
return 0;
|
||
let o = r.method || "configure", a = r.order || [], i = e.title.trim().split(Lf), s = t.title.trim().split(Lf);
|
||
r.includeNames && (i.push(e.name), s.push(t.name));
|
||
let c = 0;
|
||
for (; i[c] || s[c]; ) {
|
||
if (!i[c])
|
||
return -1;
|
||
if (!s[c])
|
||
return 1;
|
||
let l = i[c], u = s[c];
|
||
if (l !== u) {
|
||
let h = a.indexOf(l), y = a.indexOf(u), g = a.indexOf("*");
|
||
return h !== -1 || y !== -1 ? (h === -1 && (g !== -1 ? h = g : h = a.length), y === -1 && (g !== -1 ? y = g : y = a.length), h - y) : o ===
|
||
"configure" ? 0 : l.localeCompare(u, r.locales ? r.locales : void 0, {
|
||
numeric: !0,
|
||
sensitivity: "accent"
|
||
});
|
||
}
|
||
let p = a.indexOf(l);
|
||
p === -1 && (p = a.indexOf("*")), a = p !== -1 && Array.isArray(a[p + 1]) ? a[p + 1] : [], c += 1;
|
||
}
|
||
return 0;
|
||
}, "storySort");
|
||
|
||
// src/preview-api/modules/store/sortStories.ts
|
||
var cO = /* @__PURE__ */ n((r, e, t) => {
|
||
if (e) {
|
||
let o;
|
||
typeof e == "function" ? o = e : o = kf(e), r.sort(o);
|
||
} else
|
||
r.sort(
|
||
(o, a) => t.indexOf(o.importPath) - t.indexOf(a.importPath)
|
||
);
|
||
return r;
|
||
}, "sortStoriesCommon"), Mf = /* @__PURE__ */ n((r, e, t) => {
|
||
try {
|
||
return cO(r, e, t);
|
||
} catch (o) {
|
||
throw new Error(_`
|
||
Error sorting stories with sort parameter ${e}:
|
||
|
||
> ${o.message}
|
||
|
||
Are you using a V6-style sort function in V7 mode?
|
||
|
||
More info: https://github.com/storybookjs/storybook/blob/next/MIGRATION.md#v7-style-story-sort
|
||
`);
|
||
}
|
||
}, "sortStoriesV7");
|
||
|
||
// src/preview-api/modules/preview-web/render/Render.ts
|
||
var Ae = new Error("prepareAborted");
|
||
|
||
// src/preview-api/modules/preview-web/render/StoryRender.ts
|
||
var { AbortController: jf } = globalThis;
|
||
function Bf(r) {
|
||
try {
|
||
let { name: e = "Error", message: t = String(r), stack: o } = r;
|
||
return { name: e, message: t, stack: o };
|
||
} catch {
|
||
return { name: "Error", message: String(r) };
|
||
}
|
||
}
|
||
n(Bf, "serializeError");
|
||
var pi = class pi {
|
||
constructor(e, t, o, a, i, s, c = { autoplay: !0, forceInitialArgs: !1 }, l) {
|
||
this.channel = e;
|
||
this.store = t;
|
||
this.renderToScreen = o;
|
||
this.callbacks = a;
|
||
this.id = i;
|
||
this.viewMode = s;
|
||
this.renderOptions = c;
|
||
this.abortController = new jf(), l && (this.story = l, this.phase = "preparing");
|
||
}
|
||
type = "story";
|
||
story;
|
||
phase;
|
||
abortController;
|
||
canvasElement;
|
||
notYetRendered = !0;
|
||
rerenderEnqueued = !1;
|
||
disableKeyListeners = !1;
|
||
teardownRender = /* @__PURE__ */ n(() => {
|
||
}, "teardownRender");
|
||
torndown = !1;
|
||
async runPhase(e, t, o) {
|
||
this.phase = t, this.channel.emit(Ie, { newPhase: this.phase, storyId: this.id }), o && (await o(), this.checkIfAborted(e));
|
||
}
|
||
checkIfAborted(e) {
|
||
return e.aborted ? (this.phase = "aborted", this.channel.emit(Ie, { newPhase: this.phase, storyId: this.id }), !0) : !1;
|
||
}
|
||
async prepare() {
|
||
if (await this.runPhase(this.abortController.signal, "preparing", async () => {
|
||
this.story = await this.store.loadStory({ storyId: this.id });
|
||
}), this.abortController.signal.aborted)
|
||
throw await this.store.cleanupStory(this.story), Ae;
|
||
}
|
||
// The two story "renders" are equal and have both loaded the same story
|
||
isEqual(e) {
|
||
return !!(this.id === e.id && this.story && this.story === e.story);
|
||
}
|
||
isPreparing() {
|
||
return ["preparing"].includes(this.phase);
|
||
}
|
||
isPending() {
|
||
return ["loading", "beforeEach", "rendering", "playing"].includes(this.phase);
|
||
}
|
||
async renderToElement(e) {
|
||
return this.canvasElement = e, this.render({ initial: !0, forceRemount: !0 });
|
||
}
|
||
storyContext() {
|
||
if (!this.story) throw new Error("Cannot call storyContext before preparing");
|
||
let { forceInitialArgs: e } = this.renderOptions;
|
||
return this.store.getStoryContext(this.story, { forceInitialArgs: e });
|
||
}
|
||
async render({
|
||
initial: e = !1,
|
||
forceRemount: t = !1
|
||
} = {}) {
|
||
let { canvasElement: o } = this;
|
||
if (!this.story) throw new Error("cannot render when not prepared");
|
||
let a = this.story;
|
||
if (!o) throw new Error("cannot render when canvasElement is unset");
|
||
let {
|
||
id: i,
|
||
componentId: s,
|
||
title: c,
|
||
name: l,
|
||
tags: u,
|
||
applyLoaders: p,
|
||
applyBeforeEach: h,
|
||
unboundStoryFn: y,
|
||
playFunction: g,
|
||
runStep: m
|
||
} = a;
|
||
t && !e && (this.cancelRender(), this.abortController = new jf());
|
||
let b = this.abortController.signal, S = !1, w = a.usesMount;
|
||
try {
|
||
let E = {
|
||
...this.storyContext(),
|
||
viewMode: this.viewMode,
|
||
abortSignal: b,
|
||
canvasElement: o,
|
||
loaded: {},
|
||
step: /* @__PURE__ */ n((F, H) => m(F, H, E), "step"),
|
||
context: null,
|
||
canvas: {},
|
||
renderToCanvas: /* @__PURE__ */ n(async () => {
|
||
let F = await this.renderToScreen(v, o);
|
||
this.teardownRender = F || (() => {
|
||
}), S = !0;
|
||
}, "renderToCanvas"),
|
||
// The story provides (set in a renderer) a mount function that is a higher order function
|
||
// (context) => (...args) => Canvas
|
||
//
|
||
// Before assigning it to the context, we resolve the context dependency,
|
||
// so that a user can just call it as await mount(...args) in their play function.
|
||
mount: /* @__PURE__ */ n(async (...F) => {
|
||
this.callbacks.showStoryDuringRender?.();
|
||
let H = null;
|
||
return await this.runPhase(b, "rendering", async () => {
|
||
H = await a.mount(E)(...F);
|
||
}), w && await this.runPhase(b, "playing"), H;
|
||
}, "mount")
|
||
};
|
||
E.context = E;
|
||
let v = {
|
||
componentId: s,
|
||
title: c,
|
||
kind: c,
|
||
id: i,
|
||
name: l,
|
||
story: l,
|
||
tags: u,
|
||
...this.callbacks,
|
||
showError: /* @__PURE__ */ n((F) => (this.phase = "errored", this.callbacks.showError(F)), "showError"),
|
||
showException: /* @__PURE__ */ n((F) => (this.phase = "errored", this.callbacks.showException(F)), "showException"),
|
||
forceRemount: t || this.notYetRendered,
|
||
storyContext: E,
|
||
storyFn: /* @__PURE__ */ n(() => y(E), "storyFn"),
|
||
unboundStoryFn: y
|
||
};
|
||
if (await this.runPhase(b, "loading", async () => {
|
||
E.loaded = await p(E);
|
||
}), b.aborted) return;
|
||
let x = await h(E);
|
||
if (this.store.addCleanupCallbacks(a, x), this.checkIfAborted(b) || (!S && !w && await E.mount(), this.notYetRendered = !1, b.aborted))
|
||
return;
|
||
let R = this.story.parameters?.test?.dangerouslyIgnoreUnhandledErrors === !0, P = /* @__PURE__ */ new Set(), k = /* @__PURE__ */ n((F) => P.
|
||
add("error" in F ? F.error : F.reason), "onError");
|
||
if (this.renderOptions.autoplay && t && g && this.phase !== "errored") {
|
||
window.addEventListener("error", k), window.addEventListener("unhandledrejection", k), this.disableKeyListeners = !0;
|
||
try {
|
||
if (w ? await g(E) : (E.mount = async () => {
|
||
throw new Fe({ playFunction: g.toString() });
|
||
}, await this.runPhase(b, "playing", async () => g(E))), !S)
|
||
throw new tt();
|
||
this.checkIfAborted(b), !R && P.size > 0 ? await this.runPhase(b, "errored") : await this.runPhase(b, "played");
|
||
} catch (F) {
|
||
if (this.callbacks.showStoryDuringRender?.(), await this.runPhase(b, "errored", async () => {
|
||
this.channel.emit(an, Bf(F));
|
||
}), this.story.parameters.throwPlayFunctionExceptions !== !1) throw F;
|
||
console.error(F);
|
||
}
|
||
if (!R && P.size > 0 && this.channel.emit(
|
||
sn,
|
||
Array.from(P).map(Bf)
|
||
), this.disableKeyListeners = !1, window.removeEventListener("unhandledrejection", k), window.removeEventListener("error", k), b.aborted)
|
||
return;
|
||
}
|
||
await this.runPhase(
|
||
b,
|
||
"completed",
|
||
async () => this.channel.emit(Je, i)
|
||
);
|
||
} catch (E) {
|
||
this.phase = "errored", this.callbacks.showException(E);
|
||
}
|
||
this.rerenderEnqueued && (this.rerenderEnqueued = !1, this.render());
|
||
}
|
||
/**
|
||
* Rerender the story.
|
||
* If the story is currently pending (loading/rendering), the rerender will be enqueued,
|
||
* and will be executed after the current render is completed.
|
||
* Rerendering while playing will not be enqueued, and will be executed immediately, to support
|
||
* rendering args changes while playing.
|
||
*/
|
||
async rerender() {
|
||
if (this.isPending() && this.phase !== "playing")
|
||
this.rerenderEnqueued = !0;
|
||
else
|
||
return this.render();
|
||
}
|
||
async remount() {
|
||
return await this.teardown(), this.render({ forceRemount: !0 });
|
||
}
|
||
// If the story is torn down (either a new story is rendered or the docs page removes it)
|
||
// we need to consider the fact that the initial render may not be finished
|
||
// (possibly the loaders or the play function are still running). We use the controller
|
||
// as a method to abort them, ASAP, but this is not foolproof as we cannot control what
|
||
// happens inside the user's code.
|
||
cancelRender() {
|
||
this.abortController?.abort();
|
||
}
|
||
async teardown() {
|
||
this.torndown = !0, this.cancelRender(), this.story && await this.store.cleanupStory(this.story);
|
||
for (let e = 0; e < 3; e += 1) {
|
||
if (!this.isPending()) {
|
||
await this.teardownRender();
|
||
return;
|
||
}
|
||
await new Promise((t) => setTimeout(t, 0));
|
||
}
|
||
window.location.reload(), await new Promise(() => {
|
||
});
|
||
}
|
||
};
|
||
n(pi, "StoryRender");
|
||
var Ar = pi;
|
||
|
||
// src/preview-api/modules/preview-web/Preview.tsx
|
||
var { fetch: uO } = T, pO = "./index.json", di = class di {
|
||
constructor(e, t, o = ne.getChannel(), a = !0) {
|
||
this.importFn = e;
|
||
this.getProjectAnnotations = t;
|
||
this.channel = o;
|
||
this.storeInitializationPromise = new Promise((i, s) => {
|
||
this.resolveStoreInitializationPromise = i, this.rejectStoreInitializationPromise = s;
|
||
}), a && this.initialize();
|
||
}
|
||
/**
|
||
* @deprecated will be removed in 8.0, please use channel instead
|
||
*/
|
||
serverChannel;
|
||
storyStoreValue;
|
||
renderToCanvas;
|
||
storyRenders = [];
|
||
previewEntryError;
|
||
// While we wait for the index to load (note it may error for a while), we need to store the
|
||
// project annotations. Once the index loads, it is stored on the store and this will get unset.
|
||
projectAnnotationsBeforeInitialization;
|
||
beforeAllCleanup;
|
||
storeInitializationPromise;
|
||
resolveStoreInitializationPromise;
|
||
rejectStoreInitializationPromise;
|
||
// Create a proxy object for `__STORYBOOK_STORY_STORE__` and `__STORYBOOK_PREVIEW__.storyStore`
|
||
// That proxies through to the store once ready, and errors beforehand. This means we can set
|
||
// `__STORYBOOK_STORY_STORE__ = __STORYBOOK_PREVIEW__.storyStore` without having to wait, and
|
||
// simiarly integrators can access the `storyStore` on the preview at any time, although
|
||
// it is considered deprecated and we will no longer allow access in 9.0
|
||
get storyStore() {
|
||
return new Proxy(
|
||
{},
|
||
{
|
||
get: /* @__PURE__ */ n((e, t) => {
|
||
if (this.storyStoreValue)
|
||
return ae("Accessing the Story Store is deprecated and will be removed in 9.0"), this.storyStoreValue[t];
|
||
throw new et();
|
||
}, "get")
|
||
}
|
||
);
|
||
}
|
||
// INITIALIZATION
|
||
async initialize() {
|
||
this.setupListeners();
|
||
try {
|
||
let e = await this.getProjectAnnotationsOrRenderError();
|
||
await this.runBeforeAllHook(e), await this.initializeWithProjectAnnotations(e);
|
||
} catch (e) {
|
||
this.rejectStoreInitializationPromise(e);
|
||
}
|
||
}
|
||
ready() {
|
||
return this.storeInitializationPromise;
|
||
}
|
||
setupListeners() {
|
||
this.channel.on(hn, this.onStoryIndexChanged.bind(this)), this.channel.on(jr, this.onUpdateGlobals.bind(this)), this.channel.on(Br, this.
|
||
onUpdateArgs.bind(this)), this.channel.on(Tn, this.onRequestArgTypesInfo.bind(this)), this.channel.on(Mr, this.onResetArgs.bind(this)), this.
|
||
channel.on(kr, this.onForceReRender.bind(this)), this.channel.on(on, this.onForceRemount.bind(this));
|
||
}
|
||
async getProjectAnnotationsOrRenderError() {
|
||
try {
|
||
let e = await this.getProjectAnnotations();
|
||
if (this.renderToCanvas = e.renderToCanvas, !this.renderToCanvas) throw new Yr();
|
||
return e;
|
||
} catch (e) {
|
||
throw this.renderPreviewEntryError("Error reading preview.js:", e), e;
|
||
}
|
||
}
|
||
// If initialization gets as far as project annotations, this function runs.
|
||
async initializeWithProjectAnnotations(e) {
|
||
this.projectAnnotationsBeforeInitialization = e;
|
||
try {
|
||
let t = await this.getStoryIndexFromServer();
|
||
return this.initializeWithStoryIndex(t);
|
||
} catch (t) {
|
||
throw this.renderPreviewEntryError("Error loading story index:", t), t;
|
||
}
|
||
}
|
||
async runBeforeAllHook(e) {
|
||
try {
|
||
await this.beforeAllCleanup?.(), this.beforeAllCleanup = await e.beforeAll?.();
|
||
} catch (t) {
|
||
throw this.renderPreviewEntryError("Error in beforeAll hook:", t), t;
|
||
}
|
||
}
|
||
async getStoryIndexFromServer() {
|
||
let e = await uO(pO);
|
||
if (e.status === 200)
|
||
return e.json();
|
||
throw new Kr({ text: await e.text() });
|
||
}
|
||
// If initialization gets as far as the story index, this function runs.
|
||
initializeWithStoryIndex(e) {
|
||
if (!this.projectAnnotationsBeforeInitialization)
|
||
throw new Error("Cannot call initializeWithStoryIndex until project annotations resolve");
|
||
this.storyStoreValue = new Be(
|
||
e,
|
||
this.importFn,
|
||
this.projectAnnotationsBeforeInitialization
|
||
), delete this.projectAnnotationsBeforeInitialization, this.setInitialGlobals(), this.resolveStoreInitializationPromise();
|
||
}
|
||
async setInitialGlobals() {
|
||
this.emitGlobals();
|
||
}
|
||
emitGlobals() {
|
||
if (!this.storyStoreValue)
|
||
throw new K({ methodName: "emitGlobals" });
|
||
let e = {
|
||
globals: this.storyStoreValue.globals.get() || {},
|
||
globalTypes: this.storyStoreValue.projectAnnotations.globalTypes || {}
|
||
};
|
||
this.channel.emit(pn, e);
|
||
}
|
||
// EVENT HANDLERS
|
||
// This happens when a config file gets reloaded
|
||
async onGetProjectAnnotationsChanged({
|
||
getProjectAnnotations: e
|
||
}) {
|
||
delete this.previewEntryError, this.getProjectAnnotations = e;
|
||
let t = await this.getProjectAnnotationsOrRenderError();
|
||
if (await this.runBeforeAllHook(t), !this.storyStoreValue) {
|
||
await this.initializeWithProjectAnnotations(t);
|
||
return;
|
||
}
|
||
this.storyStoreValue.setProjectAnnotations(t), this.emitGlobals();
|
||
}
|
||
async onStoryIndexChanged() {
|
||
if (delete this.previewEntryError, !(!this.storyStoreValue && !this.projectAnnotationsBeforeInitialization))
|
||
try {
|
||
let e = await this.getStoryIndexFromServer();
|
||
if (this.projectAnnotationsBeforeInitialization) {
|
||
this.initializeWithStoryIndex(e);
|
||
return;
|
||
}
|
||
await this.onStoriesChanged({ storyIndex: e });
|
||
} catch (e) {
|
||
throw this.renderPreviewEntryError("Error loading story index:", e), e;
|
||
}
|
||
}
|
||
// This happens when a glob gets HMR-ed
|
||
async onStoriesChanged({
|
||
importFn: e,
|
||
storyIndex: t
|
||
}) {
|
||
if (!this.storyStoreValue)
|
||
throw new K({ methodName: "onStoriesChanged" });
|
||
await this.storyStoreValue.onStoriesChanged({ importFn: e, storyIndex: t });
|
||
}
|
||
async onUpdateGlobals({ globals: e }) {
|
||
if (!this.storyStoreValue)
|
||
throw new K({ methodName: "onUpdateGlobals" });
|
||
this.storyStoreValue.globals.update(e), await Promise.all(this.storyRenders.map((t) => t.rerender())), this.channel.emit(nn, {
|
||
globals: this.storyStoreValue.globals.get(),
|
||
initialGlobals: this.storyStoreValue.globals.initialGlobals
|
||
});
|
||
}
|
||
async onUpdateArgs({ storyId: e, updatedArgs: t }) {
|
||
if (!this.storyStoreValue)
|
||
throw new K({ methodName: "onUpdateArgs" });
|
||
this.storyStoreValue.args.update(e, t), await Promise.all(
|
||
this.storyRenders.filter((o) => o.id === e && !o.renderOptions.forceInitialArgs).map(
|
||
(o) => (
|
||
// We only run the play function, with in a force remount.
|
||
// But when mount is destructured, the rendering happens inside of the play function.
|
||
o.story && o.story.usesMount ? o.remount() : o.rerender()
|
||
)
|
||
)
|
||
), this.channel.emit(dn, {
|
||
storyId: e,
|
||
args: this.storyStoreValue.args.get(e)
|
||
});
|
||
}
|
||
async onRequestArgTypesInfo({ id: e, payload: t }) {
|
||
try {
|
||
await this.storeInitializationPromise;
|
||
let o = await this.storyStoreValue?.loadStory(t);
|
||
this.channel.emit(Ut, {
|
||
id: e,
|
||
success: !0,
|
||
payload: { argTypes: o?.argTypes || {} },
|
||
error: null
|
||
});
|
||
} catch (o) {
|
||
this.channel.emit(Ut, {
|
||
id: e,
|
||
success: !1,
|
||
error: o?.message
|
||
});
|
||
}
|
||
}
|
||
async onResetArgs({ storyId: e, argNames: t }) {
|
||
if (!this.storyStoreValue)
|
||
throw new K({ methodName: "onResetArgs" });
|
||
let a = this.storyRenders.find((c) => c.id === e)?.story || await this.storyStoreValue.loadStory({ storyId: e }), s = (t || [
|
||
.../* @__PURE__ */ new Set([
|
||
...Object.keys(a.initialArgs),
|
||
...Object.keys(this.storyStoreValue.args.get(e))
|
||
])
|
||
]).reduce((c, l) => (c[l] = a.initialArgs[l], c), {});
|
||
await this.onUpdateArgs({ storyId: e, updatedArgs: s });
|
||
}
|
||
// ForceReRender does not include a story id, so we simply must
|
||
// re-render all stories in case they are relevant
|
||
async onForceReRender() {
|
||
await Promise.all(this.storyRenders.map((e) => e.rerender()));
|
||
}
|
||
async onForceRemount({ storyId: e }) {
|
||
await Promise.all(this.storyRenders.filter((t) => t.id === e).map((t) => t.remount()));
|
||
}
|
||
// Used by docs to render a story to a given element
|
||
// Note this short-circuits the `prepare()` phase of the StoryRender,
|
||
// main to be consistent with the previous behaviour. In the future,
|
||
// we will change it to go ahead and load the story, which will end up being
|
||
// "instant", although async.
|
||
renderStoryToElement(e, t, o, a) {
|
||
if (!this.renderToCanvas || !this.storyStoreValue)
|
||
throw new K({
|
||
methodName: "renderStoryToElement"
|
||
});
|
||
let i = new Ar(
|
||
this.channel,
|
||
this.storyStoreValue,
|
||
this.renderToCanvas,
|
||
o,
|
||
e.id,
|
||
"docs",
|
||
a,
|
||
e
|
||
);
|
||
return i.renderToElement(t), this.storyRenders.push(i), async () => {
|
||
await this.teardownRender(i);
|
||
};
|
||
}
|
||
async teardownRender(e, { viewModeChanged: t } = {}) {
|
||
this.storyRenders = this.storyRenders.filter((o) => o !== e), await e?.teardown?.({ viewModeChanged: t });
|
||
}
|
||
// API
|
||
async loadStory({ storyId: e }) {
|
||
if (!this.storyStoreValue)
|
||
throw new K({ methodName: "loadStory" });
|
||
return this.storyStoreValue.loadStory({ storyId: e });
|
||
}
|
||
getStoryContext(e, { forceInitialArgs: t = !1 } = {}) {
|
||
if (!this.storyStoreValue)
|
||
throw new K({ methodName: "getStoryContext" });
|
||
return this.storyStoreValue.getStoryContext(e, { forceInitialArgs: t });
|
||
}
|
||
async extract(e) {
|
||
if (!this.storyStoreValue)
|
||
throw new K({ methodName: "extract" });
|
||
if (this.previewEntryError) throw this.previewEntryError;
|
||
return await this.storyStoreValue.cacheAllCSFFiles(), this.storyStoreValue.extract(e);
|
||
}
|
||
// UTILITIES
|
||
renderPreviewEntryError(e, t) {
|
||
this.previewEntryError = t, C.error(e), C.error(t), this.channel.emit(rn, t);
|
||
}
|
||
};
|
||
n(di, "Preview");
|
||
var Ue = di;
|
||
|
||
// src/preview-api/modules/preview-web/docs-context/DocsContext.ts
|
||
var fi = class fi {
|
||
constructor(e, t, o, a) {
|
||
this.channel = e;
|
||
this.store = t;
|
||
this.renderStoryToElement = o;
|
||
this.componentStoriesValue = [], this.storyIdToCSFFile = /* @__PURE__ */ new Map(), this.exportToStory = /* @__PURE__ */ new Map(), this.
|
||
exportsToCSFFile = /* @__PURE__ */ new Map(), this.nameToStoryId = /* @__PURE__ */ new Map(), this.attachedCSFFiles = /* @__PURE__ */ new Set(),
|
||
a.forEach((i, s) => {
|
||
this.referenceCSFFile(i);
|
||
});
|
||
}
|
||
componentStoriesValue;
|
||
storyIdToCSFFile;
|
||
exportToStory;
|
||
exportsToCSFFile;
|
||
nameToStoryId;
|
||
attachedCSFFiles;
|
||
primaryStory;
|
||
// This docs entry references this CSF file and can synchronously load the stories, as well
|
||
// as reference them by module export. If the CSF is part of the "component" stories, they
|
||
// can also be referenced by name and are in the componentStories list.
|
||
referenceCSFFile(e) {
|
||
this.exportsToCSFFile.set(e.moduleExports, e), this.exportsToCSFFile.set(e.moduleExports.default, e), this.store.componentStoriesFromCSFFile(
|
||
{ csfFile: e }).forEach((o) => {
|
||
let a = e.stories[o.id];
|
||
this.storyIdToCSFFile.set(a.id, e), this.exportToStory.set(a.moduleExport, o);
|
||
});
|
||
}
|
||
attachCSFFile(e) {
|
||
if (!this.exportsToCSFFile.has(e.moduleExports))
|
||
throw new Error("Cannot attach a CSF file that has not been referenced");
|
||
if (this.attachedCSFFiles.has(e))
|
||
return;
|
||
this.attachedCSFFiles.add(e), this.store.componentStoriesFromCSFFile({ csfFile: e }).forEach((o) => {
|
||
this.nameToStoryId.set(o.name, o.id), this.componentStoriesValue.push(o), this.primaryStory || (this.primaryStory = o);
|
||
});
|
||
}
|
||
referenceMeta(e, t) {
|
||
let o = this.resolveModuleExport(e);
|
||
if (o.type !== "meta")
|
||
throw new Error(
|
||
"<Meta of={} /> must reference a CSF file module export or meta export. Did you mistakenly reference your component instead of your \
|
||
CSF file?"
|
||
);
|
||
t && this.attachCSFFile(o.csfFile);
|
||
}
|
||
get projectAnnotations() {
|
||
let { projectAnnotations: e } = this.store;
|
||
if (!e)
|
||
throw new Error("Can't get projectAnnotations from DocsContext before they are initialized");
|
||
return e;
|
||
}
|
||
resolveAttachedModuleExportType(e) {
|
||
if (e === "story") {
|
||
if (!this.primaryStory)
|
||
throw new Error(
|
||
"No primary story attached to this docs file, did you forget to use <Meta of={} />?"
|
||
);
|
||
return { type: "story", story: this.primaryStory };
|
||
}
|
||
if (this.attachedCSFFiles.size === 0)
|
||
throw new Error(
|
||
"No CSF file attached to this docs file, did you forget to use <Meta of={} />?"
|
||
);
|
||
let t = Array.from(this.attachedCSFFiles)[0];
|
||
if (e === "meta")
|
||
return { type: "meta", csfFile: t };
|
||
let { component: o } = t.meta;
|
||
if (!o)
|
||
throw new Error(
|
||
"Attached CSF file does not defined a component, did you forget to export one?"
|
||
);
|
||
return { type: "component", component: o };
|
||
}
|
||
resolveModuleExport(e) {
|
||
let t = this.exportsToCSFFile.get(e);
|
||
if (t) return { type: "meta", csfFile: t };
|
||
let o = this.exportToStory.get(e);
|
||
return o ? { type: "story", story: o } : { type: "component", component: e };
|
||
}
|
||
resolveOf(e, t = []) {
|
||
let o;
|
||
if (["component", "meta", "story"].includes(e)) {
|
||
let a = e;
|
||
o = this.resolveAttachedModuleExportType(a);
|
||
} else
|
||
o = this.resolveModuleExport(e);
|
||
if (t.length && !t.includes(o.type)) {
|
||
let a = o.type === "component" ? "component or unknown" : o.type;
|
||
throw new Error(_`Invalid value passed to the 'of' prop. The value was resolved to a '${a}' type but the only types for this block are: ${t.
|
||
join(
|
||
", "
|
||
)}.
|
||
- Did you pass a component to the 'of' prop when the block only supports a story or a meta?
|
||
- ... or vice versa?
|
||
- Did you pass a story, CSF file or meta to the 'of' prop that is not indexed, ie. is not targeted by the 'stories' globs in the main configuration?`);
|
||
}
|
||
switch (o.type) {
|
||
case "component":
|
||
return {
|
||
...o,
|
||
projectAnnotations: this.projectAnnotations
|
||
};
|
||
case "meta":
|
||
return {
|
||
...o,
|
||
preparedMeta: this.store.preparedMetaFromCSFFile({ csfFile: o.csfFile })
|
||
};
|
||
case "story":
|
||
default:
|
||
return o;
|
||
}
|
||
}
|
||
storyIdByName = /* @__PURE__ */ n((e) => {
|
||
let t = this.nameToStoryId.get(e);
|
||
if (t) return t;
|
||
throw new Error(`No story found with that name: ${e}`);
|
||
}, "storyIdByName");
|
||
componentStories = /* @__PURE__ */ n(() => this.componentStoriesValue, "componentStories");
|
||
componentStoriesFromCSFFile = /* @__PURE__ */ n((e) => this.store.componentStoriesFromCSFFile({ csfFile: e }), "componentStoriesFromCSFFil\
|
||
e");
|
||
storyById = /* @__PURE__ */ n((e) => {
|
||
if (!e) {
|
||
if (!this.primaryStory)
|
||
throw new Error(
|
||
"No primary story defined for docs entry. Did you forget to use `<Meta>`?"
|
||
);
|
||
return this.primaryStory;
|
||
}
|
||
let t = this.storyIdToCSFFile.get(e);
|
||
if (!t)
|
||
throw new Error(`Called \`storyById\` for story that was never loaded: ${e}`);
|
||
return this.store.storyFromCSFFile({ storyId: e, csfFile: t });
|
||
}, "storyById");
|
||
getStoryContext = /* @__PURE__ */ n((e) => ({
|
||
...this.store.getStoryContext(e),
|
||
loaded: {},
|
||
viewMode: "docs"
|
||
}), "getStoryContext");
|
||
loadStory = /* @__PURE__ */ n((e) => this.store.loadStory({ storyId: e }), "loadStory");
|
||
};
|
||
n(fi, "DocsContext");
|
||
var ye = fi;
|
||
|
||
// src/preview-api/modules/preview-web/render/CsfDocsRender.ts
|
||
var yi = class yi {
|
||
constructor(e, t, o, a) {
|
||
this.channel = e;
|
||
this.store = t;
|
||
this.entry = o;
|
||
this.callbacks = a;
|
||
this.id = o.id;
|
||
}
|
||
type = "docs";
|
||
subtype = "csf";
|
||
id;
|
||
story;
|
||
rerender;
|
||
teardownRender;
|
||
torndown = !1;
|
||
disableKeyListeners = !1;
|
||
preparing = !1;
|
||
csfFiles;
|
||
isPreparing() {
|
||
return this.preparing;
|
||
}
|
||
async prepare() {
|
||
this.preparing = !0;
|
||
let { entryExports: e, csfFiles: t = [] } = await this.store.loadEntry(this.id);
|
||
if (this.torndown) throw Ae;
|
||
let { importPath: o, title: a } = this.entry, i = this.store.processCSFFileWithCache(
|
||
e,
|
||
o,
|
||
a
|
||
), s = Object.keys(i.stories)[0];
|
||
this.story = this.store.storyFromCSFFile({ storyId: s, csfFile: i }), this.csfFiles = [i, ...t], this.preparing = !1;
|
||
}
|
||
isEqual(e) {
|
||
return !!(this.id === e.id && this.story && this.story === e.story);
|
||
}
|
||
docsContext(e) {
|
||
if (!this.csfFiles) throw new Error("Cannot render docs before preparing");
|
||
let t = new ye(
|
||
this.channel,
|
||
this.store,
|
||
e,
|
||
this.csfFiles
|
||
);
|
||
return this.csfFiles.forEach((o) => t.attachCSFFile(o)), t;
|
||
}
|
||
async renderToElement(e, t) {
|
||
if (!this.story || !this.csfFiles) throw new Error("Cannot render docs before preparing");
|
||
let o = this.docsContext(t), { docs: a } = this.story.parameters || {};
|
||
if (!a)
|
||
throw new Error(
|
||
"Cannot render a story in viewMode=docs if `@storybook/addon-docs` is not installed"
|
||
);
|
||
let i = await a.renderer(), { render: s } = i, c = /* @__PURE__ */ n(async () => {
|
||
try {
|
||
await s(o, a, e), this.channel.emit(Lr, this.id);
|
||
} catch (l) {
|
||
this.callbacks.showException(l);
|
||
}
|
||
}, "renderDocs");
|
||
return this.rerender = async () => c(), this.teardownRender = async ({ viewModeChanged: l }) => {
|
||
!l || !e || i.unmount(e);
|
||
}, c();
|
||
}
|
||
async teardown({ viewModeChanged: e } = {}) {
|
||
this.teardownRender?.({ viewModeChanged: e }), this.torndown = !0;
|
||
}
|
||
};
|
||
n(yi, "CsfDocsRender");
|
||
var Et = yi;
|
||
|
||
// src/preview-api/modules/preview-web/render/MdxDocsRender.ts
|
||
var hi = class hi {
|
||
constructor(e, t, o, a) {
|
||
this.channel = e;
|
||
this.store = t;
|
||
this.entry = o;
|
||
this.callbacks = a;
|
||
this.id = o.id;
|
||
}
|
||
type = "docs";
|
||
subtype = "mdx";
|
||
id;
|
||
exports;
|
||
rerender;
|
||
teardownRender;
|
||
torndown = !1;
|
||
disableKeyListeners = !1;
|
||
preparing = !1;
|
||
csfFiles;
|
||
isPreparing() {
|
||
return this.preparing;
|
||
}
|
||
async prepare() {
|
||
this.preparing = !0;
|
||
let { entryExports: e, csfFiles: t = [] } = await this.store.loadEntry(this.id);
|
||
if (this.torndown) throw Ae;
|
||
this.csfFiles = t, this.exports = e, this.preparing = !1;
|
||
}
|
||
isEqual(e) {
|
||
return !!(this.id === e.id && this.exports && this.exports === e.exports);
|
||
}
|
||
docsContext(e) {
|
||
if (!this.csfFiles) throw new Error("Cannot render docs before preparing");
|
||
return new ye(
|
||
this.channel,
|
||
this.store,
|
||
e,
|
||
this.csfFiles
|
||
);
|
||
}
|
||
async renderToElement(e, t) {
|
||
if (!this.exports || !this.csfFiles || !this.store.projectAnnotations)
|
||
throw new Error("Cannot render docs before preparing");
|
||
let o = this.docsContext(t), { docs: a } = this.store.projectAnnotations.parameters || {};
|
||
if (!a)
|
||
throw new Error(
|
||
"Cannot render a story in viewMode=docs if `@storybook/addon-docs` is not installed"
|
||
);
|
||
let i = { ...a, page: this.exports.default }, s = await a.renderer(), { render: c } = s, l = /* @__PURE__ */ n(async () => {
|
||
try {
|
||
await c(o, i, e), this.channel.emit(Lr, this.id);
|
||
} catch (u) {
|
||
this.callbacks.showException(u);
|
||
}
|
||
}, "renderDocs");
|
||
return this.rerender = async () => l(), this.teardownRender = async ({ viewModeChanged: u } = {}) => {
|
||
!u || !e || (s.unmount(e), this.torndown = !0);
|
||
}, l();
|
||
}
|
||
async teardown({ viewModeChanged: e } = {}) {
|
||
this.teardownRender?.({ viewModeChanged: e }), this.torndown = !0;
|
||
}
|
||
};
|
||
n(hi, "MdxDocsRender");
|
||
var Tt = hi;
|
||
|
||
// src/preview-api/modules/preview-web/PreviewWithSelection.tsx
|
||
var dO = globalThis;
|
||
function fO(r) {
|
||
let e = r.composedPath && r.composedPath()[0] || r.target;
|
||
return /input|textarea/i.test(e.tagName) || e.getAttribute("contenteditable") !== null;
|
||
}
|
||
n(fO, "focusInInput");
|
||
var Uf = "attached-mdx", yO = "unattached-mdx";
|
||
function hO({ tags: r }) {
|
||
return r?.includes(yO) || r?.includes(Uf);
|
||
}
|
||
n(hO, "isMdxEntry");
|
||
function mi(r) {
|
||
return r.type === "story";
|
||
}
|
||
n(mi, "isStoryRender");
|
||
function mO(r) {
|
||
return r.type === "docs";
|
||
}
|
||
n(mO, "isDocsRender");
|
||
function gO(r) {
|
||
return mO(r) && r.subtype === "csf";
|
||
}
|
||
n(gO, "isCsfDocsRender");
|
||
var gi = class gi extends Ue {
|
||
constructor(t, o, a, i) {
|
||
super(t, o, void 0, !1);
|
||
this.importFn = t;
|
||
this.getProjectAnnotations = o;
|
||
this.selectionStore = a;
|
||
this.view = i;
|
||
this.initialize();
|
||
}
|
||
currentSelection;
|
||
currentRender;
|
||
setupListeners() {
|
||
super.setupListeners(), dO.onkeydown = this.onKeydown.bind(this), this.channel.on(un, this.onSetCurrentStory.bind(this)), this.channel.on(
|
||
vn, this.onUpdateQueryParams.bind(this)), this.channel.on(ln, this.onPreloadStories.bind(this));
|
||
}
|
||
async setInitialGlobals() {
|
||
if (!this.storyStoreValue)
|
||
throw new K({ methodName: "setInitialGlobals" });
|
||
let { globals: t } = this.selectionStore.selectionSpecifier || {};
|
||
t && this.storyStoreValue.globals.updateFromPersisted(t), this.emitGlobals();
|
||
}
|
||
// If initialization gets as far as the story index, this function runs.
|
||
async initializeWithStoryIndex(t) {
|
||
return await super.initializeWithStoryIndex(t), this.selectSpecifiedStory();
|
||
}
|
||
// Use the selection specifier to choose a story, then render it
|
||
async selectSpecifiedStory() {
|
||
if (!this.storyStoreValue)
|
||
throw new K({
|
||
methodName: "selectSpecifiedStory"
|
||
});
|
||
if (this.selectionStore.selection) {
|
||
await this.renderSelection();
|
||
return;
|
||
}
|
||
if (!this.selectionStore.selectionSpecifier) {
|
||
this.renderMissingStory();
|
||
return;
|
||
}
|
||
let { storySpecifier: t, args: o } = this.selectionStore.selectionSpecifier, a = this.storyStoreValue.storyIndex.entryFromSpecifier(t);
|
||
if (!a) {
|
||
t === "*" ? this.renderStoryLoadingException(t, new Jr()) : this.renderStoryLoadingException(
|
||
t,
|
||
new Qr({ storySpecifier: t.toString() })
|
||
);
|
||
return;
|
||
}
|
||
let { id: i, type: s } = a;
|
||
this.selectionStore.setSelection({ storyId: i, viewMode: s }), this.channel.emit(gn, this.selectionStore.selection), this.channel.emit(jt,
|
||
this.selectionStore.selection), await this.renderSelection({ persistedArgs: o });
|
||
}
|
||
// EVENT HANDLERS
|
||
// This happens when a config file gets reloaded
|
||
async onGetProjectAnnotationsChanged({
|
||
getProjectAnnotations: t
|
||
}) {
|
||
await super.onGetProjectAnnotationsChanged({ getProjectAnnotations: t }), this.selectionStore.selection && this.renderSelection();
|
||
}
|
||
// This happens when a glob gets HMR-ed
|
||
async onStoriesChanged({
|
||
importFn: t,
|
||
storyIndex: o
|
||
}) {
|
||
await super.onStoriesChanged({ importFn: t, storyIndex: o }), this.selectionStore.selection ? await this.renderSelection() : await this.
|
||
selectSpecifiedStory();
|
||
}
|
||
onKeydown(t) {
|
||
if (!this.storyRenders.find((o) => o.disableKeyListeners) && !fO(t)) {
|
||
let { altKey: o, ctrlKey: a, metaKey: i, shiftKey: s, key: c, code: l, keyCode: u } = t;
|
||
this.channel.emit(cn, {
|
||
event: { altKey: o, ctrlKey: a, metaKey: i, shiftKey: s, key: c, code: l, keyCode: u }
|
||
});
|
||
}
|
||
}
|
||
async onSetCurrentStory(t) {
|
||
this.selectionStore.setSelection({ viewMode: "story", ...t }), await this.storeInitializationPromise, this.channel.emit(jt, this.selectionStore.
|
||
selection), this.renderSelection();
|
||
}
|
||
onUpdateQueryParams(t) {
|
||
this.selectionStore.setQueryParams(t);
|
||
}
|
||
async onUpdateGlobals({ globals: t }) {
|
||
super.onUpdateGlobals({ globals: t }), (this.currentRender instanceof Tt || this.currentRender instanceof Et) && await this.currentRender.
|
||
rerender?.();
|
||
}
|
||
async onUpdateArgs({ storyId: t, updatedArgs: o }) {
|
||
super.onUpdateArgs({ storyId: t, updatedArgs: o });
|
||
}
|
||
async onPreloadStories({ ids: t }) {
|
||
await this.storeInitializationPromise, this.storyStoreValue && await Promise.allSettled(t.map((o) => this.storyStoreValue?.loadEntry(o)));
|
||
}
|
||
// RENDERING
|
||
// We can either have:
|
||
// - a story selected in "story" viewMode,
|
||
// in which case we render it to the root element, OR
|
||
// - a story selected in "docs" viewMode,
|
||
// in which case we render the docsPage for that story
|
||
async renderSelection({ persistedArgs: t } = {}) {
|
||
let { renderToCanvas: o } = this;
|
||
if (!this.storyStoreValue || !o)
|
||
throw new K({ methodName: "renderSelection" });
|
||
let { selection: a } = this.selectionStore;
|
||
if (!a) throw new Error("Cannot call renderSelection as no selection was made");
|
||
let { storyId: i } = a, s;
|
||
try {
|
||
s = await this.storyStoreValue.storyIdToEntry(i);
|
||
} catch (g) {
|
||
this.currentRender && await this.teardownRender(this.currentRender), this.renderStoryLoadingException(i, g);
|
||
return;
|
||
}
|
||
let c = this.currentSelection?.storyId !== i, l = this.currentRender?.type !== s.type;
|
||
s.type === "story" ? this.view.showPreparingStory({ immediate: l }) : this.view.showPreparingDocs({ immediate: l }), this.currentRender?.
|
||
isPreparing() && await this.teardownRender(this.currentRender);
|
||
let u;
|
||
s.type === "story" ? u = new Ar(
|
||
this.channel,
|
||
this.storyStoreValue,
|
||
o,
|
||
this.mainStoryCallbacks(i),
|
||
i,
|
||
"story"
|
||
) : hO(s) ? u = new Tt(
|
||
this.channel,
|
||
this.storyStoreValue,
|
||
s,
|
||
this.mainStoryCallbacks(i)
|
||
) : u = new Et(
|
||
this.channel,
|
||
this.storyStoreValue,
|
||
s,
|
||
this.mainStoryCallbacks(i)
|
||
);
|
||
let p = this.currentSelection;
|
||
this.currentSelection = a;
|
||
let h = this.currentRender;
|
||
this.currentRender = u;
|
||
try {
|
||
await u.prepare();
|
||
} catch (g) {
|
||
h && await this.teardownRender(h), g !== Ae && this.renderStoryLoadingException(i, g);
|
||
return;
|
||
}
|
||
let y = !c && h && !u.isEqual(h);
|
||
if (t && mi(u) && (fe(!!u.story), this.storyStoreValue.args.updateFromPersisted(u.story, t)), h && !h.torndown && !c && !y && !l) {
|
||
this.currentRender = h, this.channel.emit(bn, i), this.view.showMain();
|
||
return;
|
||
}
|
||
if (h && await this.teardownRender(h, { viewModeChanged: l }), p && (c || l) && this.channel.emit(fn, i), mi(u)) {
|
||
fe(!!u.story);
|
||
let { parameters: g, initialArgs: m, argTypes: b, unmappedArgs: S } = this.storyStoreValue.getStoryContext(u.story);
|
||
this.channel.emit(mn, {
|
||
id: i,
|
||
parameters: g,
|
||
initialArgs: m,
|
||
argTypes: b,
|
||
args: S
|
||
});
|
||
} else {
|
||
let { parameters: g } = this.storyStoreValue.projectAnnotations;
|
||
if (gO(u) || u.entry.tags?.includes(Uf)) {
|
||
if (!u.csfFiles) throw new Xr({ storyId: i });
|
||
({ parameters: g } = this.storyStoreValue.preparedMetaFromCSFFile({
|
||
csfFile: u.csfFiles[0]
|
||
}));
|
||
}
|
||
this.channel.emit(tn, {
|
||
id: i,
|
||
parameters: g
|
||
});
|
||
}
|
||
mi(u) ? (fe(!!u.story), this.storyRenders.push(u), this.currentRender.renderToElement(
|
||
this.view.prepareForStory(u.story)
|
||
)) : this.currentRender.renderToElement(
|
||
this.view.prepareForDocs(),
|
||
// This argument is used for docs, which is currently only compatible with HTMLElements
|
||
this.renderStoryToElement.bind(this)
|
||
);
|
||
}
|
||
async teardownRender(t, { viewModeChanged: o = !1 } = {}) {
|
||
this.storyRenders = this.storyRenders.filter((a) => a !== t), await t?.teardown?.({ viewModeChanged: o });
|
||
}
|
||
// UTILITIES
|
||
mainStoryCallbacks(t) {
|
||
return {
|
||
showStoryDuringRender: /* @__PURE__ */ n(() => this.view.showStoryDuringRender(), "showStoryDuringRender"),
|
||
showMain: /* @__PURE__ */ n(() => this.view.showMain(), "showMain"),
|
||
showError: /* @__PURE__ */ n((o) => this.renderError(t, o), "showError"),
|
||
showException: /* @__PURE__ */ n((o) => this.renderException(t, o), "showException")
|
||
};
|
||
}
|
||
renderPreviewEntryError(t, o) {
|
||
super.renderPreviewEntryError(t, o), this.view.showErrorDisplay(o);
|
||
}
|
||
renderMissingStory() {
|
||
this.view.showNoPreview(), this.channel.emit(Bt);
|
||
}
|
||
renderStoryLoadingException(t, o) {
|
||
C.error(o), this.view.showErrorDisplay(o), this.channel.emit(Bt, t);
|
||
}
|
||
// renderException is used if we fail to render the story and it is uncaught by the app layer
|
||
renderException(t, o) {
|
||
let { name: a = "Error", message: i = String(o), stack: s } = o;
|
||
this.channel.emit(Sn, { name: a, message: i, stack: s }), this.channel.emit(Ie, { newPhase: "errored", storyId: t }), this.view.showErrorDisplay(
|
||
o), C.error(`Error rendering story '${t}':`), C.error(o);
|
||
}
|
||
// renderError is used by the various app layers to inform the user they have done something
|
||
// wrong -- for instance returned the wrong thing from a story
|
||
renderError(t, { title: o, description: a }) {
|
||
C.error(`Error rendering story ${o}: ${a}`), this.channel.emit(yn, { title: o, description: a }), this.channel.emit(Ie, { newPhase: "err\
|
||
ored", storyId: t }), this.view.showErrorDisplay({
|
||
message: o,
|
||
stack: a
|
||
});
|
||
}
|
||
};
|
||
n(gi, "PreviewWithSelection");
|
||
var Ge = gi;
|
||
|
||
// src/preview-api/modules/preview-web/UrlStore.ts
|
||
var Vo = Y(Ho(), 1);
|
||
|
||
// src/preview-api/modules/preview-web/parseArgsParam.ts
|
||
var xh = Y(Ho(), 1);
|
||
var _h = Y(yo(), 1);
|
||
var wh = /^[a-zA-Z0-9 _-]*$/, Ph = /^-?[0-9]+(\.[0-9]+)?$/, mI = /^#([a-f0-9]{3,4}|[a-f0-9]{6}|[a-f0-9]{8})$/i, Oh = /^(rgba?|hsla?)\(([0-9]{1,3}),\s?([0-9]{1,3})%?,\s?([0-9]{1,3})%?,?\s?([0-9](\.[0-9]{1,2})?)?\)$/i,
|
||
Vi = /* @__PURE__ */ n((r = "", e) => r === null || r === "" || !wh.test(r) ? !1 : e == null || e instanceof Date || typeof e == "number" ||
|
||
typeof e == "boolean" ? !0 : typeof e == "string" ? wh.test(e) || Ph.test(e) || mI.test(e) || Oh.test(e) : Array.isArray(e) ? e.every((t) => Vi(
|
||
r, t)) : (0, _h.default)(e) ? Object.entries(e).every(([t, o]) => Vi(t, o)) : !1, "validateArgs"), gI = {
|
||
delimiter: ";",
|
||
// we're parsing a single query param
|
||
allowDots: !0,
|
||
// objects are encoded using dot notation
|
||
allowSparse: !0,
|
||
// arrays will be merged on top of their initial value
|
||
decoder(r, e, t, o) {
|
||
if (o === "value" && r.startsWith("!")) {
|
||
if (r === "!undefined") return;
|
||
if (r === "!null") return null;
|
||
if (r === "!true") return !0;
|
||
if (r === "!false") return !1;
|
||
if (r.startsWith("!date(") && r.endsWith(")")) return new Date(r.slice(6, -1));
|
||
if (r.startsWith("!hex(") && r.endsWith(")")) return `#${r.slice(5, -1)}`;
|
||
let a = r.slice(1).match(Oh);
|
||
if (a)
|
||
return r.startsWith("!rgba") ? `${a[1]}(${a[2]}, ${a[3]}, ${a[4]}, ${a[5]})` : r.startsWith("!hsla") ? `${a[1]}(${a[2]}, ${a[3]}%, ${a[4]}\
|
||
%, ${a[5]})` : r.startsWith("!rgb") ? `${a[1]}(${a[2]}, ${a[3]}, ${a[4]})` : `${a[1]}(${a[2]}, ${a[3]}%, ${a[4]}%)`;
|
||
}
|
||
return o === "value" && Ph.test(r) ? Number(r) : e(r, e, t);
|
||
}
|
||
}, $i = /* @__PURE__ */ n((r) => {
|
||
let e = r.split(";").map((t) => t.replace("=", "~").replace(":", "="));
|
||
return Object.entries(xh.default.parse(e.join(";"), gI)).reduce((t, [o, a]) => Vi(o, a) ? Object.assign(t, { [o]: a }) : (M.warn(_`
|
||
Omitted potentially unsafe URL args.
|
||
|
||
More info: https://storybook.js.org/docs/react/writing-stories/args#setting-args-through-the-url
|
||
`), t), {});
|
||
}, "parseArgsParam");
|
||
|
||
// src/preview-api/modules/preview-web/UrlStore.ts
|
||
var { history: Ch, document: he } = T;
|
||
function SI(r) {
|
||
let e = (r || "").match(/^\/story\/(.+)/);
|
||
if (!e)
|
||
throw new Error(`Invalid path '${r}', must start with '/story/'`);
|
||
return e[1];
|
||
}
|
||
n(SI, "pathToId");
|
||
var Ih = /* @__PURE__ */ n(({
|
||
selection: r,
|
||
extraParams: e
|
||
}) => {
|
||
let t = typeof he < "u" ? he.location.search : "", { path: o, selectedKind: a, selectedStory: i, ...s } = Vo.default.parse(t, {
|
||
ignoreQueryPrefix: !0
|
||
});
|
||
return Vo.default.stringify(
|
||
{
|
||
...s,
|
||
...e,
|
||
...r && { id: r.storyId, viewMode: r.viewMode }
|
||
},
|
||
{ encode: !1, addQueryPrefix: !0 }
|
||
);
|
||
}, "getQueryString"), bI = /* @__PURE__ */ n((r) => {
|
||
if (!r) return;
|
||
let e = Ih({ selection: r }), { hash: t = "" } = he.location;
|
||
he.title = r.storyId, Ch.replaceState({}, "", `${he.location.pathname}${e}${t}`);
|
||
}, "setPath"), vI = /* @__PURE__ */ n((r) => r != null && typeof r == "object" && Array.isArray(r) === !1, "isObject"), Pt = /* @__PURE__ */ n(
|
||
(r) => {
|
||
if (r !== void 0) {
|
||
if (typeof r == "string")
|
||
return r;
|
||
if (Array.isArray(r))
|
||
return Pt(r[0]);
|
||
if (vI(r))
|
||
return Pt(Object.values(r).filter(Boolean));
|
||
}
|
||
}, "getFirstString"), EI = /* @__PURE__ */ n(() => {
|
||
if (typeof he < "u") {
|
||
let r = Vo.default.parse(he.location.search, { ignoreQueryPrefix: !0 }), e = typeof r.args == "string" ? $i(r.args) : void 0, t = typeof r.
|
||
globals == "string" ? $i(r.globals) : void 0, o = Pt(r.viewMode);
|
||
(typeof o != "string" || !o.match(/docs|story/)) && (o = "story");
|
||
let a = Pt(r.path), i = a ? SI(a) : Pt(r.id);
|
||
if (i)
|
||
return { storySpecifier: i, args: e, globals: t, viewMode: o };
|
||
}
|
||
return null;
|
||
}, "getSelectionSpecifierFromPath"), Wi = class Wi {
|
||
selectionSpecifier;
|
||
selection;
|
||
constructor() {
|
||
this.selectionSpecifier = EI();
|
||
}
|
||
setSelection(e) {
|
||
this.selection = e, bI(this.selection);
|
||
}
|
||
setQueryParams(e) {
|
||
let t = Ih({ extraParams: e }), { hash: o = "" } = he.location;
|
||
Ch.replaceState({}, "", `${he.location.pathname}${t}${o}`);
|
||
}
|
||
};
|
||
n(Wi, "UrlStore");
|
||
var ze = Wi;
|
||
|
||
// src/preview-api/modules/preview-web/WebView.ts
|
||
var cm = Y(im(), 1);
|
||
var um = Y(Ho(), 1);
|
||
var { document: J } = T, sm = 100, pm = /* @__PURE__ */ ((i) => (i.MAIN = "MAIN", i.NOPREVIEW = "NOPREVIEW", i.PREPARING_STORY = "PREPARING_\
|
||
STORY", i.PREPARING_DOCS = "PREPARING_DOCS", i.ERROR = "ERROR", i))(pm || {}), Zi = {
|
||
PREPARING_STORY: "sb-show-preparing-story",
|
||
PREPARING_DOCS: "sb-show-preparing-docs",
|
||
MAIN: "sb-show-main",
|
||
NOPREVIEW: "sb-show-nopreview",
|
||
ERROR: "sb-show-errordisplay"
|
||
}, es = {
|
||
centered: "sb-main-centered",
|
||
fullscreen: "sb-main-fullscreen",
|
||
padded: "sb-main-padded"
|
||
}, lm = new cm.default({
|
||
escapeXML: !0
|
||
}), rs = class rs {
|
||
currentLayoutClass;
|
||
testing = !1;
|
||
preparingTimeout;
|
||
constructor() {
|
||
if (typeof J < "u") {
|
||
let { __SPECIAL_TEST_PARAMETER__: e } = um.default.parse(J.location.search, {
|
||
ignoreQueryPrefix: !0
|
||
});
|
||
switch (e) {
|
||
case "preparing-story": {
|
||
this.showPreparingStory(), this.testing = !0;
|
||
break;
|
||
}
|
||
case "preparing-docs": {
|
||
this.showPreparingDocs(), this.testing = !0;
|
||
break;
|
||
}
|
||
default:
|
||
}
|
||
}
|
||
}
|
||
// Get ready to render a story, returning the element to render to
|
||
prepareForStory(e) {
|
||
return this.showStory(), this.applyLayout(e.parameters.layout), J.documentElement.scrollTop = 0, J.documentElement.scrollLeft = 0, this.
|
||
storyRoot();
|
||
}
|
||
storyRoot() {
|
||
return J.getElementById("storybook-root");
|
||
}
|
||
prepareForDocs() {
|
||
return this.showMain(), this.showDocs(), this.applyLayout("fullscreen"), J.documentElement.scrollTop = 0, J.documentElement.scrollLeft =
|
||
0, this.docsRoot();
|
||
}
|
||
docsRoot() {
|
||
return J.getElementById("storybook-docs");
|
||
}
|
||
applyLayout(e = "padded") {
|
||
if (e === "none") {
|
||
J.body.classList.remove(this.currentLayoutClass), this.currentLayoutClass = null;
|
||
return;
|
||
}
|
||
this.checkIfLayoutExists(e);
|
||
let t = es[e];
|
||
J.body.classList.remove(this.currentLayoutClass), J.body.classList.add(t), this.currentLayoutClass = t;
|
||
}
|
||
checkIfLayoutExists(e) {
|
||
es[e] || C.warn(
|
||
_`
|
||
The desired layout: ${e} is not a valid option.
|
||
The possible options are: ${Object.keys(es).join(", ")}, none.
|
||
`
|
||
);
|
||
}
|
||
showMode(e) {
|
||
clearTimeout(this.preparingTimeout), Object.keys(pm).forEach((t) => {
|
||
t === e ? J.body.classList.add(Zi[t]) : J.body.classList.remove(Zi[t]);
|
||
});
|
||
}
|
||
showErrorDisplay({ message: e = "", stack: t = "" }) {
|
||
let o = e, a = t, i = e.split(`
|
||
`);
|
||
i.length > 1 && ([o] = i, a = i.slice(1).join(`
|
||
`).replace(/^\n/, "")), J.getElementById("error-message").innerHTML = lm.toHtml(o), J.getElementById("error-stack").innerHTML = lm.toHtml(a),
|
||
this.showMode("ERROR");
|
||
}
|
||
showNoPreview() {
|
||
this.testing || (this.showMode("NOPREVIEW"), this.storyRoot()?.setAttribute("hidden", "true"), this.docsRoot()?.setAttribute("hidden", "\
|
||
true"));
|
||
}
|
||
showPreparingStory({ immediate: e = !1 } = {}) {
|
||
clearTimeout(this.preparingTimeout), e ? this.showMode("PREPARING_STORY") : this.preparingTimeout = setTimeout(
|
||
() => this.showMode("PREPARING_STORY"),
|
||
sm
|
||
);
|
||
}
|
||
showPreparingDocs({ immediate: e = !1 } = {}) {
|
||
clearTimeout(this.preparingTimeout), e ? this.showMode("PREPARING_DOCS") : this.preparingTimeout = setTimeout(() => this.showMode("PREPA\
|
||
RING_DOCS"), sm);
|
||
}
|
||
showMain() {
|
||
this.showMode("MAIN");
|
||
}
|
||
showDocs() {
|
||
this.storyRoot().setAttribute("hidden", "true"), this.docsRoot().removeAttribute("hidden");
|
||
}
|
||
showStory() {
|
||
this.docsRoot().setAttribute("hidden", "true"), this.storyRoot().removeAttribute("hidden");
|
||
}
|
||
showStoryDuringRender() {
|
||
J.body.classList.add(Zi.MAIN);
|
||
}
|
||
};
|
||
n(rs, "WebView");
|
||
var Ke = rs;
|
||
|
||
// src/preview-api/modules/preview-web/PreviewWeb.tsx
|
||
var ts = class ts extends Ge {
|
||
constructor(t, o) {
|
||
super(t, o, new ze(), new Ke());
|
||
this.importFn = t;
|
||
this.getProjectAnnotations = o;
|
||
T.__STORYBOOK_PREVIEW__ = this;
|
||
}
|
||
};
|
||
n(ts, "PreviewWeb");
|
||
var Ct = ts;
|
||
|
||
// src/preview-api/modules/preview-web/simulate-pageload.ts
|
||
var { document: Xe } = T, tF = [
|
||
"application/javascript",
|
||
"application/ecmascript",
|
||
"application/x-ecmascript",
|
||
"application/x-javascript",
|
||
"text/ecmascript",
|
||
"text/javascript",
|
||
"text/javascript1.0",
|
||
"text/javascript1.1",
|
||
"text/javascript1.2",
|
||
"text/javascript1.3",
|
||
"text/javascript1.4",
|
||
"text/javascript1.5",
|
||
"text/jscript",
|
||
"text/livescript",
|
||
"text/x-ecmascript",
|
||
"text/x-javascript",
|
||
// Support modern javascript
|
||
"module"
|
||
], oF = "script", dm = "scripts-root";
|
||
function It() {
|
||
let r = Xe.createEvent("Event");
|
||
r.initEvent("DOMContentLoaded", !0, !0), Xe.dispatchEvent(r);
|
||
}
|
||
n(It, "simulateDOMContentLoaded");
|
||
function nF(r, e, t) {
|
||
let o = Xe.createElement("script");
|
||
o.type = r.type === "module" ? "module" : "text/javascript", r.src ? (o.onload = e, o.onerror = e, o.src = r.src) : o.textContent = r.innerText,
|
||
t ? t.appendChild(o) : Xe.head.appendChild(o), r.parentNode.removeChild(r), r.src || e();
|
||
}
|
||
n(nF, "insertScript");
|
||
function fm(r, e, t = 0) {
|
||
r[t](() => {
|
||
t++, t === r.length ? e() : fm(r, e, t);
|
||
});
|
||
}
|
||
n(fm, "insertScriptsSequentially");
|
||
function os(r) {
|
||
let e = Xe.getElementById(dm);
|
||
e ? e.innerHTML = "" : (e = Xe.createElement("div"), e.id = dm, Xe.body.appendChild(e));
|
||
let t = Array.from(r.querySelectorAll(oF));
|
||
if (t.length) {
|
||
let o = [];
|
||
t.forEach((a) => {
|
||
let i = a.getAttribute("type");
|
||
(!i || tF.includes(i)) && o.push((s) => nF(a, s, e));
|
||
}), o.length && fm(o, It, void 0);
|
||
} else
|
||
It();
|
||
}
|
||
n(os, "simulatePageLoad");
|
||
|
||
// src/types/index.ts
|
||
var Dt = {};
|
||
Ce(Dt, {
|
||
Addon_TypesEnum: () => ym
|
||
});
|
||
|
||
// src/types/modules/addons.ts
|
||
var ym = /* @__PURE__ */ ((l) => (l.TAB = "tab", l.PANEL = "panel", l.TOOL = "tool", l.TOOLEXTRA = "toolextra", l.PREVIEW = "preview", l.experimental_PAGE =
|
||
"page", l.experimental_SIDEBAR_BOTTOM = "sidebar-bottom", l.experimental_SIDEBAR_TOP = "sidebar-top", l))(ym || {});
|
||
|
||
// src/preview/globals/runtime.ts
|
||
var hm = {
|
||
"@storybook/global": Rn,
|
||
"storybook/internal/channels": $r,
|
||
"@storybook/channels": $r,
|
||
"@storybook/core/channels": $r,
|
||
"storybook/internal/client-logger": Ur,
|
||
"@storybook/client-logger": Ur,
|
||
"@storybook/core/client-logger": Ur,
|
||
"storybook/internal/core-events": be,
|
||
"@storybook/core-events": be,
|
||
"@storybook/core/core-events": be,
|
||
"storybook/internal/preview-errors": ot,
|
||
"@storybook/core-events/preview-errors": ot,
|
||
"@storybook/core/preview-errors": ot,
|
||
"storybook/internal/preview-api": Ft,
|
||
"@storybook/preview-api": Ft,
|
||
"@storybook/core/preview-api": Ft,
|
||
"storybook/internal/types": Dt,
|
||
"@storybook/types": Dt,
|
||
"@storybook/core/types": Dt
|
||
};
|
||
|
||
// src/preview/utils.ts
|
||
var gm = Y(mm(), 1);
|
||
var is;
|
||
function aF() {
|
||
return is || (is = new gm.default(T.navigator?.userAgent).getBrowserInfo()), is;
|
||
}
|
||
n(aF, "getBrowserInfo");
|
||
function Sm(r) {
|
||
return r.browserInfo = aF(), r;
|
||
}
|
||
n(Sm, "prepareForTelemetry");
|
||
|
||
// src/preview/runtime.ts
|
||
ss.forEach((r) => {
|
||
T[An[r]] = hm[r];
|
||
});
|
||
T.sendTelemetryError = (r) => {
|
||
T.__STORYBOOK_ADDONS_CHANNEL__.emit(En, Sm(r));
|
||
};
|
||
T.addEventListener("error", (r) => {
|
||
let e = r.error || r;
|
||
e.fromStorybook && T.sendTelemetryError(e);
|
||
});
|
||
T.addEventListener("unhandledrejection", ({ reason: r }) => {
|
||
r.fromStorybook && T.sendTelemetryError(r);
|
||
});
|