diff --git a/frontend/resources/plugins-runtime/index.mjs b/frontend/resources/plugins-runtime/index.mjs new file mode 100644 index 000000000..59c2daa7c --- /dev/null +++ b/frontend/resources/plugins-runtime/index.mjs @@ -0,0 +1,7664 @@ +const E = globalThis, { + Array: bs, + Date: ws, + FinalizationRegistry: gt, + Float32Array: xs, + JSON: Ss, + Map: Ie, + Math: Es, + Number: ro, + Object: nn, + Promise: Ps, + Proxy: br, + Reflect: ks, + RegExp: ze, + Set: wt, + String: ie, + Symbol: At, + WeakMap: Pe, + WeakSet: xt +} = globalThis, { + // The feral Error constructor is safe for internal use, but must not be + // revealed to post-lockdown code in any compartment including the start + // compartment since in V8 at least it bears stack inspection capabilities. + Error: le, + RangeError: Ts, + ReferenceError: et, + SyntaxError: Gt, + TypeError: v +} = globalThis, { + assign: wr, + create: H, + defineProperties: F, + entries: te, + freeze: y, + getOwnPropertyDescriptor: ue, + getOwnPropertyDescriptors: Ke, + getOwnPropertyNames: Nt, + getPrototypeOf: G, + is: xr, + isFrozen: Xc, + isSealed: Qc, + isExtensible: el, + keys: no, + prototype: oo, + seal: tl, + preventExtensions: Is, + setPrototypeOf: so, + values: ao, + fromEntries: St +} = nn, { + species: Pn, + toStringTag: Be, + iterator: Ht, + matchAll: io, + unscopables: As, + keyFor: Cs, + for: rl +} = At, { isInteger: Ns } = ro, { stringify: co } = Ss, { defineProperty: $s } = nn, L = (t, e, r) => { + const n = $s(t, e, r); + if (n !== t) + throw v( + `Please report that the original defineProperty silently failed to set ${co( + ie(e) + )}. (SES_DEFINE_PROPERTY_FAILED_SILENTLY)` + ); + return n; +}, { + apply: oe, + construct: sr, + get: Os, + getOwnPropertyDescriptor: Rs, + has: lo, + isExtensible: Ms, + ownKeys: nt, + preventExtensions: Ls, + set: uo +} = ks, { isArray: mt, prototype: ke } = bs, { prototype: Et } = Ie, { prototype: Sr } = RegExp, { prototype: Vt } = wt, { prototype: $e } = ie, { prototype: Er } = Pe, { prototype: fo } = xt, { prototype: on } = Function, { prototype: po } = Ps, Fs = G(Uint8Array.prototype), { bind: kn } = on, k = kn.bind(kn.call), se = k(oo.hasOwnProperty), Ge = k(ke.filter), tt = k(ke.forEach), Pr = k(ke.includes), Pt = k(ke.join), de = ( + /** @type {any} */ + k(ke.map) +), jr = k(ke.pop), ae = k(ke.push), Ds = k(ke.slice), js = k(ke.some), mo = k(ke.sort), Us = k(ke[Ht]), Ae = k(Et.set), Le = k(Et.get), kr = k(Et.has), Zs = k(Et.delete), zs = k(Et.entries), Bs = k(Et[Ht]), Tr = k(Vt.add); +k(Vt.delete); +const Tn = k(Vt.forEach), sn = k(Vt.has), Gs = k(Vt[Ht]), an = k(Sr.test), cn = k(Sr.exec), Hs = k(Sr[io]), ho = k($e.endsWith), Vs = k($e.includes), Ws = k($e.indexOf); +k($e.match); +const ar = ( + /** @type {any} */ + k($e.replace) +), qs = k($e.search), ln = k($e.slice), go = k($e.split), yo = k($e.startsWith), Ks = k($e[Ht]), Js = k(Er.delete), M = k(Er.get), un = k(Er.has), ee = k(Er.set), Ir = k(fo.add), Wt = k(fo.has), Ys = k(on.toString), Xs = k(po.catch), dn = ( + /** @type {any} */ + k(po.then) +), Qs = gt && k(gt.prototype.register); +gt && k(gt.prototype.unregister); +const fn = y(H(null)), He = (t) => nn(t) === t, pn = (t) => t instanceof le, vo = eval, ye = Function, ea = () => { + throw v('Cannot eval with evalTaming set to "noEval" (SES_NO_EVAL)'); +}; +function ta() { + return this; +} +if (ta()) + throw v("SES failed to initialize, sloppy mode (SES_NO_SLOPPY)"); +const { freeze: Xe } = Object, { apply: ra } = Reflect, mn = (t) => (e, ...r) => ra(t, e, r), na = mn(Array.prototype.push), In = mn(Array.prototype.includes), oa = mn(String.prototype.split), Ye = JSON.stringify, Jt = (t, ...e) => { + let r = t[0]; + for (let n = 0; n < e.length; n += 1) + r = `${r}${e[n]}${t[n + 1]}`; + throw Error(r); +}, _o = (t, e = !1) => { + const r = [], n = (c, u, l = void 0) => { + typeof c == "string" || Jt`Environment option name ${Ye(c)} must be a string.`, typeof u == "string" || Jt`Environment option default setting ${Ye( + u + )} must be a string.`; + let d = u; + const f = t.process || void 0, m = typeof f == "object" && f.env || void 0; + if (typeof m == "object" && c in m) { + e || na(r, c); + const p = m[c]; + typeof p == "string" || Jt`Environment option named ${Ye( + c + )}, if present, must have a corresponding string value, got ${Ye( + p + )}`, d = p; + } + return l === void 0 || d === u || In(l, d) || Jt`Unrecognized ${Ye(c)} value ${Ye( + d + )}. Expected one of ${Ye([u, ...l])}`, d; + }; + Xe(n); + const a = (c) => { + const u = n(c, ""); + return Xe(u === "" ? [] : oa(u, ",")); + }; + Xe(a); + const s = (c, u) => In(a(c), u), i = () => Xe([...r]); + return Xe(i), Xe({ + getEnvironmentOption: n, + getEnvironmentOptionsList: a, + environmentOptionsListHas: s, + getCapturedEnvironmentOptionNames: i + }); +}; +Xe(_o); +const { + getEnvironmentOption: me, + getEnvironmentOptionsList: nl, + environmentOptionsListHas: ol +} = _o(globalThis, !0), ir = (t) => (t = `${t}`, t.length >= 1 && Vs("aeiouAEIOU", t[0]) ? `an ${t}` : `a ${t}`); +y(ir); +const bo = (t, e = void 0) => { + const r = new wt(), n = (a, s) => { + switch (typeof s) { + case "object": { + if (s === null) + return null; + if (sn(r, s)) + return "[Seen]"; + if (Tr(r, s), pn(s)) + return `[${s.name}: ${s.message}]`; + if (Be in s) + return `[${s[Be]}]`; + if (mt(s)) + return s; + const i = no(s); + if (i.length < 2) + return s; + let c = !0; + for (let l = 1; l < i.length; l += 1) + if (i[l - 1] >= i[l]) { + c = !1; + break; + } + if (c) + return s; + mo(i); + const u = de(i, (l) => [l, s[l]]); + return St(u); + } + case "function": + return `[Function ${s.name || ""}]`; + case "string": + return yo(s, "[") ? `[${s}]` : s; + case "undefined": + case "symbol": + return `[${ie(s)}]`; + case "bigint": + return `[${s}n]`; + case "number": + return xr(s, NaN) ? "[NaN]" : s === 1 / 0 ? "[Infinity]" : s === -1 / 0 ? "[-Infinity]" : s; + default: + return s; + } + }; + try { + return co(t, n, e); + } catch { + return "[Something that failed to stringify]"; + } +}; +y(bo); +const { isSafeInteger: sa } = Number, { freeze: ft } = Object, { toStringTag: aa } = Symbol, An = (t) => { + const r = { + next: void 0, + prev: void 0, + data: t + }; + return r.next = r, r.prev = r, r; +}, Cn = (t, e) => { + if (t === e) + throw TypeError("Cannot splice a cell into itself"); + if (e.next !== e || e.prev !== e) + throw TypeError("Expected self-linked cell"); + const r = e, n = t.next; + return r.prev = t, r.next = n, t.next = r, n.prev = r, r; +}, Or = (t) => { + const { prev: e, next: r } = t; + e.next = r, r.prev = e, t.prev = t, t.next = t; +}, wo = (t) => { + if (!sa(t) || t < 0) + throw TypeError("keysBudget must be a safe non-negative integer number"); + const e = /* @__PURE__ */ new WeakMap(); + let r = 0; + const n = An(void 0), a = (d) => { + const f = e.get(d); + if (!(f === void 0 || f.data === void 0)) + return Or(f), Cn(n, f), f; + }, s = (d) => a(d) !== void 0; + ft(s); + const i = (d) => { + const f = a(d); + return f && f.data && f.data.get(d); + }; + ft(i); + const c = (d, f) => { + if (t < 1) + return l; + let m = a(d); + if (m === void 0 && (m = An(void 0), Cn(n, m)), !m.data) + for (r += 1, m.data = /* @__PURE__ */ new WeakMap(), e.set(d, m); r > t; ) { + const p = n.prev; + Or(p), p.data = void 0, r -= 1; + } + return m.data.set(d, f), l; + }; + ft(c); + const u = (d) => { + const f = e.get(d); + return f === void 0 || (Or(f), e.delete(d), f.data === void 0) ? !1 : (f.data = void 0, r -= 1, !0); + }; + ft(u); + const l = ft({ + has: s, + get: i, + set: c, + delete: u, + // eslint-disable-next-line jsdoc/check-types + [ + /** @type {typeof Symbol.toStringTag} */ + aa + ]: "LRUCacheMap" + }); + return l; +}; +ft(wo); +const { freeze: rr } = Object, { isSafeInteger: ia } = Number, ca = 1e3, la = 100, xo = (t = ca, e = la) => { + if (!ia(e) || e < 1) + throw TypeError( + "argsPerErrorBudget must be a safe positive integer number" + ); + const r = wo(t), n = (s, i) => { + const c = r.get(s); + c !== void 0 ? (c.length >= e && c.shift(), c.push(i)) : r.set(s, [i]); + }; + rr(n); + const a = (s) => { + const i = r.get(s); + return r.delete(s), i; + }; + return rr(a), rr({ + addLogArgs: n, + takeLogArgsArray: a + }); +}; +rr(xo); +const yt = new Pe(), ot = (t, e = void 0) => { + const r = y({ + toString: y(() => bo(t, e)) + }); + return ee(yt, r, t), r; +}; +y(ot); +const ua = y(/^[\w:-]( ?[\w:-])*$/), Ur = (t, e = void 0) => { + if (typeof t != "string" || !an(ua, t)) + return ot(t, e); + const r = y({ + toString: y(() => t) + }); + return ee(yt, r, t), r; +}; +y(Ur); +const Ar = new Pe(), So = ({ template: t, args: e }) => { + const r = [t[0]]; + for (let n = 0; n < e.length; n += 1) { + const a = e[n]; + let s; + un(yt, a) ? s = `${a}` : pn(a) ? s = `(${ir(a.name)})` : s = `(${ir(typeof a)})`, ae(r, s, t[n + 1]); + } + return Pt(r, ""); +}, Eo = y({ + toString() { + const t = M(Ar, this); + return t === void 0 ? "[Not a DetailsToken]" : So(t); + } +}); +y(Eo.toString); +const vt = (t, ...e) => { + const r = y({ __proto__: Eo }); + return ee(Ar, r, { template: t, args: e }), r; +}; +y(vt); +const Po = (t, ...e) => (e = de( + e, + (r) => un(yt, r) ? r : ot(r) +), vt(t, ...e)); +y(Po); +const ko = ({ template: t, args: e }) => { + const r = [t[0]]; + for (let n = 0; n < e.length; n += 1) { + let a = e[n]; + un(yt, a) && (a = M(yt, a)); + const s = ar(jr(r) || "", / $/, ""); + s !== "" && ae(r, s); + const i = ar(t[n + 1], /^ /, ""); + ae(r, a, i); + } + return r[r.length - 1] === "" && jr(r), r; +}, nr = new Pe(); +let Zr = 0; +const Nn = new Pe(), To = (t, e = t.name) => { + let r = M(Nn, t); + return r !== void 0 || (Zr += 1, r = `${e}#${Zr}`, ee(Nn, t, r)), r; +}, zr = (t = vt`Assert failed`, e = E.Error, { errorName: r = void 0 } = {}) => { + typeof t == "string" && (t = vt([t])); + const n = M(Ar, t); + if (n === void 0) + throw v(`unrecognized details ${ot(t)}`); + const a = So(n), s = new e(a); + return ee(nr, s, ko(n)), r !== void 0 && To(s, r), s; +}; +y(zr); +const { addLogArgs: da, takeLogArgsArray: fa } = xo(), Br = new Pe(), Io = (t, e) => { + typeof e == "string" && (e = vt([e])); + const r = M(Ar, e); + if (r === void 0) + throw v(`unrecognized details ${ot(e)}`); + const n = ko(r), a = M(Br, t); + if (a !== void 0) + for (const s of a) + s(t, n); + else + da(t, n); +}; +y(Io); +const pa = (t) => { + if (!("stack" in t)) + return ""; + const e = `${t.stack}`, r = Ws(e, ` +`); + return yo(e, " ") || r === -1 ? e : ln(e, r + 1); +}, Gr = { + getStackString: E.getStackString || pa, + tagError: (t) => To(t), + resetErrorTagNum: () => { + Zr = 0; + }, + getMessageLogArgs: (t) => M(nr, t), + takeMessageLogArgs: (t) => { + const e = M(nr, t); + return Js(nr, t), e; + }, + takeNoteLogArgsArray: (t, e) => { + const r = fa(t); + if (e !== void 0) { + const n = M(Br, t); + n ? ae(n, e) : ee(Br, t, [e]); + } + return r || []; + } +}; +y(Gr); +const Cr = (t = void 0, e = !1) => { + const r = e ? Po : vt, n = r`Check failed`, a = (f = n, m = E.Error) => { + const p = zr(f, m); + throw t !== void 0 && t(p), p; + }; + y(a); + const s = (f, ...m) => a(r(f, ...m)); + function i(f, m = void 0, p = void 0) { + f || a(m, p); + } + const c = (f, m, p = void 0, h = void 0) => { + xr(f, m) || a( + p || r`Expected ${f} is same as ${m}`, + h || Ts + ); + }; + y(c); + const u = (f, m, p) => { + if (typeof f !== m) { + if (typeof m == "string" || s`${ot(m)} must be a string`, p === void 0) { + const h = ir(m); + p = r`${f} must be ${Ur(h)}`; + } + a(p, v); + } + }; + y(u); + const d = wr(i, { + error: zr, + fail: a, + equal: c, + typeof: u, + string: (f, m = void 0) => u(f, "string", m), + note: Io, + details: r, + Fail: s, + quote: ot, + bare: Ur, + makeAssert: Cr + }); + return y(d); +}; +y(Cr); +const Z = Cr(), Ao = ue( + Fs, + Be +); +Z(Ao); +const Co = Ao.get; +Z(Co); +const ma = (t) => oe(Co, t, []) !== void 0, ha = (t) => { + const e = +ie(t); + return Ns(e) && ie(e) === t; +}, ga = (t) => { + Is(t), tt(nt(t), (e) => { + const r = ue(t, e); + Z(r), ha(e) || L(t, e, { + ...r, + writable: !1, + configurable: !1 + }); + }); +}, ya = () => { + if (typeof E.harden == "function") + return E.harden; + const t = new xt(), { harden: e } = { + /** + * @template T + * @param {T} root + * @returns {T} + */ + harden(r) { + const n = new wt(), a = new Pe(); + function s(d, f = void 0) { + if (!He(d)) + return; + const m = typeof d; + if (m !== "object" && m !== "function") + throw v(`Unexpected typeof: ${m}`); + Wt(t, d) || sn(n, d) || (Tr(n, d), ee(a, d, f)); + } + function i(d) { + ma(d) ? ga(d) : y(d); + const f = M(a, d) || "unknown", m = Ke(d), p = G(d); + s(p, `${f}.__proto__`), tt(nt(m), (h) => { + const _ = `${f}.${ie(h)}`, w = m[ + /** @type {string} */ + h + ]; + se(w, "value") ? s(w.value, `${_}`) : (s(w.get, `${_}(get)`), s(w.set, `${_}(set)`)); + }); + } + function c() { + Tn(n, i); + } + function u(d) { + Ir(t, d); + } + function l() { + Tn(n, u); + } + return s(r), c(), l(), r; + } + }; + return e; +}, No = { + // *** Value Properties of the Global Object + Infinity: 1 / 0, + NaN: NaN, + undefined: void 0 +}, $o = { + // *** Function Properties of the Global Object + isFinite: "isFinite", + isNaN: "isNaN", + parseFloat: "parseFloat", + parseInt: "parseInt", + decodeURI: "decodeURI", + decodeURIComponent: "decodeURIComponent", + encodeURI: "encodeURI", + encodeURIComponent: "encodeURIComponent", + // *** Constructor Properties of the Global Object + Array: "Array", + ArrayBuffer: "ArrayBuffer", + BigInt: "BigInt", + BigInt64Array: "BigInt64Array", + BigUint64Array: "BigUint64Array", + Boolean: "Boolean", + DataView: "DataView", + EvalError: "EvalError", + // https://github.com/tc39/proposal-float16array + Float16Array: "Float16Array", + Float32Array: "Float32Array", + Float64Array: "Float64Array", + Int8Array: "Int8Array", + Int16Array: "Int16Array", + Int32Array: "Int32Array", + Map: "Map", + Number: "Number", + Object: "Object", + Promise: "Promise", + Proxy: "Proxy", + RangeError: "RangeError", + ReferenceError: "ReferenceError", + Set: "Set", + String: "String", + SyntaxError: "SyntaxError", + TypeError: "TypeError", + Uint8Array: "Uint8Array", + Uint8ClampedArray: "Uint8ClampedArray", + Uint16Array: "Uint16Array", + Uint32Array: "Uint32Array", + URIError: "URIError", + WeakMap: "WeakMap", + WeakSet: "WeakSet", + // https://github.com/tc39/proposal-iterator-helpers + Iterator: "Iterator", + // https://github.com/tc39/proposal-async-iterator-helpers + AsyncIterator: "AsyncIterator", + // *** Other Properties of the Global Object + JSON: "JSON", + Reflect: "Reflect", + // *** Annex B + escape: "escape", + unescape: "unescape", + // ESNext + lockdown: "lockdown", + harden: "harden", + HandledPromise: "HandledPromise" + // TODO: Until Promise.delegate (see below). +}, $n = { + // *** Constructor Properties of the Global Object + Date: "%InitialDate%", + Error: "%InitialError%", + RegExp: "%InitialRegExp%", + // Omit `Symbol`, because we want the original to appear on the + // start compartment without passing through the whitelist mechanism, since + // we want to preserve all its properties, even if we never heard of them. + // Symbol: '%InitialSymbol%', + // *** Other Properties of the Global Object + Math: "%InitialMath%", + // ESNext + // From Error-stack proposal + // Only on initial global. No corresponding + // powerless form for other globals. + getStackString: "%InitialGetStackString%" + // TODO https://github.com/Agoric/SES-shim/issues/551 + // Need initial WeakRef and FinalizationGroup in + // start compartment only. +}, Oo = { + // *** Constructor Properties of the Global Object + Date: "%SharedDate%", + Error: "%SharedError%", + RegExp: "%SharedRegExp%", + Symbol: "%SharedSymbol%", + // *** Other Properties of the Global Object + Math: "%SharedMath%" +}, va = [ + EvalError, + RangeError, + ReferenceError, + SyntaxError, + TypeError, + URIError +], Hr = { + "[[Proto]]": "%FunctionPrototype%", + length: "number", + name: "string" + // Do not specify "prototype" here, since only Function instances that can + // be used as a constructor have a prototype property. For constructors, + // since prototype properties are instance-specific, we define it there. +}, _a = { + // This property is not mentioned in ECMA 262, but is present in V8 and + // necessary for lockdown to succeed. + "[[Proto]]": "%AsyncFunctionPrototype%" +}, o = Hr, On = _a, O = { + get: o, + set: "undefined" +}, Te = { + get: o, + set: o +}, Rn = (t) => t === O || t === Te; +function lt(t) { + return { + // Properties of the NativeError Constructors + "[[Proto]]": "%SharedError%", + // NativeError.prototype + prototype: t + }; +} +function ut(t) { + return { + // Properties of the NativeError Prototype Objects + "[[Proto]]": "%ErrorPrototype%", + constructor: t, + message: "string", + name: "string", + // Redundantly present only on v8. Safe to remove. + toString: !1, + // Superfluously present in some versions of V8. + // https://github.com/tc39/notes/blob/master/meetings/2021-10/oct-26.md#:~:text=However%2C%20Chrome%2093,and%20node%2016.11. + cause: !1 + }; +} +function he(t) { + return { + // Properties of the TypedArray Constructors + "[[Proto]]": "%TypedArray%", + BYTES_PER_ELEMENT: "number", + prototype: t + }; +} +function ge(t) { + return { + // Properties of the TypedArray Prototype Objects + "[[Proto]]": "%TypedArrayPrototype%", + BYTES_PER_ELEMENT: "number", + constructor: t + }; +} +const Mn = { + E: "number", + LN10: "number", + LN2: "number", + LOG10E: "number", + LOG2E: "number", + PI: "number", + SQRT1_2: "number", + SQRT2: "number", + "@@toStringTag": "string", + abs: o, + acos: o, + acosh: o, + asin: o, + asinh: o, + atan: o, + atanh: o, + atan2: o, + cbrt: o, + ceil: o, + clz32: o, + cos: o, + cosh: o, + exp: o, + expm1: o, + floor: o, + fround: o, + hypot: o, + imul: o, + log: o, + log1p: o, + log10: o, + log2: o, + max: o, + min: o, + pow: o, + round: o, + sign: o, + sin: o, + sinh: o, + sqrt: o, + tan: o, + tanh: o, + trunc: o, + // See https://github.com/Moddable-OpenSource/moddable/issues/523 + idiv: !1, + // See https://github.com/Moddable-OpenSource/moddable/issues/523 + idivmod: !1, + // See https://github.com/Moddable-OpenSource/moddable/issues/523 + imod: !1, + // See https://github.com/Moddable-OpenSource/moddable/issues/523 + imuldiv: !1, + // See https://github.com/Moddable-OpenSource/moddable/issues/523 + irem: !1, + // See https://github.com/Moddable-OpenSource/moddable/issues/523 + mod: !1, + // See https://github.com/Moddable-OpenSource/moddable/issues/523#issuecomment-1942904505 + irandom: !1 +}, cr = { + // ECMA https://tc39.es/ecma262 + // The intrinsics object has no prototype to avoid conflicts. + "[[Proto]]": null, + // %ThrowTypeError% + "%ThrowTypeError%": o, + // *** The Global Object + // *** Value Properties of the Global Object + Infinity: "number", + NaN: "number", + undefined: "undefined", + // *** Function Properties of the Global Object + // eval + "%UniqueEval%": o, + isFinite: o, + isNaN: o, + parseFloat: o, + parseInt: o, + decodeURI: o, + decodeURIComponent: o, + encodeURI: o, + encodeURIComponent: o, + // *** Fundamental Objects + Object: { + // Properties of the Object Constructor + "[[Proto]]": "%FunctionPrototype%", + assign: o, + create: o, + defineProperties: o, + defineProperty: o, + entries: o, + freeze: o, + fromEntries: o, + getOwnPropertyDescriptor: o, + getOwnPropertyDescriptors: o, + getOwnPropertyNames: o, + getOwnPropertySymbols: o, + getPrototypeOf: o, + hasOwn: o, + is: o, + isExtensible: o, + isFrozen: o, + isSealed: o, + keys: o, + preventExtensions: o, + prototype: "%ObjectPrototype%", + seal: o, + setPrototypeOf: o, + values: o, + // https://github.com/tc39/proposal-array-grouping + groupBy: o, + // Seen on QuickJS + __getClass: !1 + }, + "%ObjectPrototype%": { + // Properties of the Object Prototype Object + "[[Proto]]": null, + constructor: "Object", + hasOwnProperty: o, + isPrototypeOf: o, + propertyIsEnumerable: o, + toLocaleString: o, + toString: o, + valueOf: o, + // Annex B: Additional Properties of the Object.prototype Object + // See note in header about the difference between [[Proto]] and --proto-- + // special notations. + "--proto--": Te, + __defineGetter__: o, + __defineSetter__: o, + __lookupGetter__: o, + __lookupSetter__: o + }, + "%UniqueFunction%": { + // Properties of the Function Constructor + "[[Proto]]": "%FunctionPrototype%", + prototype: "%FunctionPrototype%" + }, + "%InertFunction%": { + "[[Proto]]": "%FunctionPrototype%", + prototype: "%FunctionPrototype%" + }, + "%FunctionPrototype%": { + apply: o, + bind: o, + call: o, + constructor: "%InertFunction%", + toString: o, + "@@hasInstance": o, + // proposed but not yet std. To be removed if there + caller: !1, + // proposed but not yet std. To be removed if there + arguments: !1, + // Seen on QuickJS. TODO grab getter for use by console + fileName: !1, + // Seen on QuickJS. TODO grab getter for use by console + lineNumber: !1 + }, + Boolean: { + // Properties of the Boolean Constructor + "[[Proto]]": "%FunctionPrototype%", + prototype: "%BooleanPrototype%" + }, + "%BooleanPrototype%": { + constructor: "Boolean", + toString: o, + valueOf: o + }, + "%SharedSymbol%": { + // Properties of the Symbol Constructor + "[[Proto]]": "%FunctionPrototype%", + asyncDispose: "symbol", + asyncIterator: "symbol", + dispose: "symbol", + for: o, + hasInstance: "symbol", + isConcatSpreadable: "symbol", + iterator: "symbol", + keyFor: o, + match: "symbol", + matchAll: "symbol", + prototype: "%SymbolPrototype%", + replace: "symbol", + search: "symbol", + species: "symbol", + split: "symbol", + toPrimitive: "symbol", + toStringTag: "symbol", + unscopables: "symbol", + // Seen at core-js https://github.com/zloirock/core-js#ecmascript-symbol + useSimple: !1, + // Seen at core-js https://github.com/zloirock/core-js#ecmascript-symbol + useSetter: !1, + // Seen on QuickJS + operatorSet: !1 + }, + "%SymbolPrototype%": { + // Properties of the Symbol Prototype Object + constructor: "%SharedSymbol%", + description: O, + toString: o, + valueOf: o, + "@@toPrimitive": o, + "@@toStringTag": "string" + }, + "%InitialError%": { + // Properties of the Error Constructor + "[[Proto]]": "%FunctionPrototype%", + prototype: "%ErrorPrototype%", + // Non standard, v8 only, used by tap + captureStackTrace: o, + // Non standard, v8 only, used by tap, tamed to accessor + stackTraceLimit: Te, + // Non standard, v8 only, used by several, tamed to accessor + prepareStackTrace: Te + }, + "%SharedError%": { + // Properties of the Error Constructor + "[[Proto]]": "%FunctionPrototype%", + prototype: "%ErrorPrototype%", + // Non standard, v8 only, used by tap + captureStackTrace: o, + // Non standard, v8 only, used by tap, tamed to accessor + stackTraceLimit: Te, + // Non standard, v8 only, used by several, tamed to accessor + prepareStackTrace: Te + }, + "%ErrorPrototype%": { + constructor: "%SharedError%", + message: "string", + name: "string", + toString: o, + // proposed de-facto, assumed TODO + // Seen on FF Nightly 88.0a1 + at: !1, + // Seen on FF and XS + stack: Te, + // Superfluously present in some versions of V8. + // https://github.com/tc39/notes/blob/master/meetings/2021-10/oct-26.md#:~:text=However%2C%20Chrome%2093,and%20node%2016.11. + cause: !1 + }, + // NativeError + EvalError: lt("%EvalErrorPrototype%"), + RangeError: lt("%RangeErrorPrototype%"), + ReferenceError: lt("%ReferenceErrorPrototype%"), + SyntaxError: lt("%SyntaxErrorPrototype%"), + TypeError: lt("%TypeErrorPrototype%"), + URIError: lt("%URIErrorPrototype%"), + "%EvalErrorPrototype%": ut("EvalError"), + "%RangeErrorPrototype%": ut("RangeError"), + "%ReferenceErrorPrototype%": ut("ReferenceError"), + "%SyntaxErrorPrototype%": ut("SyntaxError"), + "%TypeErrorPrototype%": ut("TypeError"), + "%URIErrorPrototype%": ut("URIError"), + // *** Numbers and Dates + Number: { + // Properties of the Number Constructor + "[[Proto]]": "%FunctionPrototype%", + EPSILON: "number", + isFinite: o, + isInteger: o, + isNaN: o, + isSafeInteger: o, + MAX_SAFE_INTEGER: "number", + MAX_VALUE: "number", + MIN_SAFE_INTEGER: "number", + MIN_VALUE: "number", + NaN: "number", + NEGATIVE_INFINITY: "number", + parseFloat: o, + parseInt: o, + POSITIVE_INFINITY: "number", + prototype: "%NumberPrototype%" + }, + "%NumberPrototype%": { + // Properties of the Number Prototype Object + constructor: "Number", + toExponential: o, + toFixed: o, + toLocaleString: o, + toPrecision: o, + toString: o, + valueOf: o + }, + BigInt: { + // Properties of the BigInt Constructor + "[[Proto]]": "%FunctionPrototype%", + asIntN: o, + asUintN: o, + prototype: "%BigIntPrototype%", + // See https://github.com/Moddable-OpenSource/moddable/issues/523 + bitLength: !1, + // See https://github.com/Moddable-OpenSource/moddable/issues/523 + fromArrayBuffer: !1, + // Seen on QuickJS + tdiv: !1, + // Seen on QuickJS + fdiv: !1, + // Seen on QuickJS + cdiv: !1, + // Seen on QuickJS + ediv: !1, + // Seen on QuickJS + tdivrem: !1, + // Seen on QuickJS + fdivrem: !1, + // Seen on QuickJS + cdivrem: !1, + // Seen on QuickJS + edivrem: !1, + // Seen on QuickJS + sqrt: !1, + // Seen on QuickJS + sqrtrem: !1, + // Seen on QuickJS + floorLog2: !1, + // Seen on QuickJS + ctz: !1 + }, + "%BigIntPrototype%": { + constructor: "BigInt", + toLocaleString: o, + toString: o, + valueOf: o, + "@@toStringTag": "string" + }, + "%InitialMath%": { + ...Mn, + // `%InitialMath%.random()` has the standard unsafe behavior + random: o + }, + "%SharedMath%": { + ...Mn, + // `%SharedMath%.random()` is tamed to always throw + random: o + }, + "%InitialDate%": { + // Properties of the Date Constructor + "[[Proto]]": "%FunctionPrototype%", + now: o, + parse: o, + prototype: "%DatePrototype%", + UTC: o + }, + "%SharedDate%": { + // Properties of the Date Constructor + "[[Proto]]": "%FunctionPrototype%", + // `%SharedDate%.now()` is tamed to always throw + now: o, + parse: o, + prototype: "%DatePrototype%", + UTC: o + }, + "%DatePrototype%": { + constructor: "%SharedDate%", + getDate: o, + getDay: o, + getFullYear: o, + getHours: o, + getMilliseconds: o, + getMinutes: o, + getMonth: o, + getSeconds: o, + getTime: o, + getTimezoneOffset: o, + getUTCDate: o, + getUTCDay: o, + getUTCFullYear: o, + getUTCHours: o, + getUTCMilliseconds: o, + getUTCMinutes: o, + getUTCMonth: o, + getUTCSeconds: o, + setDate: o, + setFullYear: o, + setHours: o, + setMilliseconds: o, + setMinutes: o, + setMonth: o, + setSeconds: o, + setTime: o, + setUTCDate: o, + setUTCFullYear: o, + setUTCHours: o, + setUTCMilliseconds: o, + setUTCMinutes: o, + setUTCMonth: o, + setUTCSeconds: o, + toDateString: o, + toISOString: o, + toJSON: o, + toLocaleDateString: o, + toLocaleString: o, + toLocaleTimeString: o, + toString: o, + toTimeString: o, + toUTCString: o, + valueOf: o, + "@@toPrimitive": o, + // Annex B: Additional Properties of the Date.prototype Object + getYear: o, + setYear: o, + toGMTString: o + }, + // Text Processing + String: { + // Properties of the String Constructor + "[[Proto]]": "%FunctionPrototype%", + fromCharCode: o, + fromCodePoint: o, + prototype: "%StringPrototype%", + raw: o, + // See https://github.com/Moddable-OpenSource/moddable/issues/523 + fromArrayBuffer: !1 + }, + "%StringPrototype%": { + // Properties of the String Prototype Object + length: "number", + at: o, + charAt: o, + charCodeAt: o, + codePointAt: o, + concat: o, + constructor: "String", + endsWith: o, + includes: o, + indexOf: o, + lastIndexOf: o, + localeCompare: o, + match: o, + matchAll: o, + normalize: o, + padEnd: o, + padStart: o, + repeat: o, + replace: o, + replaceAll: o, + // ES2021 + search: o, + slice: o, + split: o, + startsWith: o, + substring: o, + toLocaleLowerCase: o, + toLocaleUpperCase: o, + toLowerCase: o, + toString: o, + toUpperCase: o, + trim: o, + trimEnd: o, + trimStart: o, + valueOf: o, + "@@iterator": o, + // Annex B: Additional Properties of the String.prototype Object + substr: o, + anchor: o, + big: o, + blink: o, + bold: o, + fixed: o, + fontcolor: o, + fontsize: o, + italics: o, + link: o, + small: o, + strike: o, + sub: o, + sup: o, + trimLeft: o, + trimRight: o, + // See https://github.com/Moddable-OpenSource/moddable/issues/523 + compare: !1, + // https://github.com/tc39/proposal-is-usv-string + isWellFormed: o, + toWellFormed: o, + unicodeSets: o, + // Seen on QuickJS + __quote: !1 + }, + "%StringIteratorPrototype%": { + "[[Proto]]": "%IteratorPrototype%", + next: o, + "@@toStringTag": "string" + }, + "%InitialRegExp%": { + // Properties of the RegExp Constructor + "[[Proto]]": "%FunctionPrototype%", + prototype: "%RegExpPrototype%", + "@@species": O, + // The https://github.com/tc39/proposal-regexp-legacy-features + // are all optional, unsafe, and omitted + input: !1, + $_: !1, + lastMatch: !1, + "$&": !1, + lastParen: !1, + "$+": !1, + leftContext: !1, + "$`": !1, + rightContext: !1, + "$'": !1, + $1: !1, + $2: !1, + $3: !1, + $4: !1, + $5: !1, + $6: !1, + $7: !1, + $8: !1, + $9: !1 + }, + "%SharedRegExp%": { + // Properties of the RegExp Constructor + "[[Proto]]": "%FunctionPrototype%", + prototype: "%RegExpPrototype%", + "@@species": O + }, + "%RegExpPrototype%": { + // Properties of the RegExp Prototype Object + constructor: "%SharedRegExp%", + exec: o, + dotAll: O, + flags: O, + global: O, + hasIndices: O, + ignoreCase: O, + "@@match": o, + "@@matchAll": o, + multiline: O, + "@@replace": o, + "@@search": o, + source: O, + "@@split": o, + sticky: O, + test: o, + toString: o, + unicode: O, + unicodeSets: O, + // Annex B: Additional Properties of the RegExp.prototype Object + compile: !1 + // UNSAFE and suppressed. + }, + "%RegExpStringIteratorPrototype%": { + // The %RegExpStringIteratorPrototype% Object + "[[Proto]]": "%IteratorPrototype%", + next: o, + "@@toStringTag": "string" + }, + // Indexed Collections + Array: { + // Properties of the Array Constructor + "[[Proto]]": "%FunctionPrototype%", + from: o, + isArray: o, + of: o, + prototype: "%ArrayPrototype%", + "@@species": O, + // Stage 3: + // https://tc39.es/proposal-relative-indexing-method/ + at: o, + // https://tc39.es/proposal-array-from-async/ + fromAsync: o + }, + "%ArrayPrototype%": { + // Properties of the Array Prototype Object + at: o, + length: "number", + concat: o, + constructor: "Array", + copyWithin: o, + entries: o, + every: o, + fill: o, + filter: o, + find: o, + findIndex: o, + flat: o, + flatMap: o, + forEach: o, + includes: o, + indexOf: o, + join: o, + keys: o, + lastIndexOf: o, + map: o, + pop: o, + push: o, + reduce: o, + reduceRight: o, + reverse: o, + shift: o, + slice: o, + some: o, + sort: o, + splice: o, + toLocaleString: o, + toString: o, + unshift: o, + values: o, + "@@iterator": o, + "@@unscopables": { + "[[Proto]]": null, + copyWithin: "boolean", + entries: "boolean", + fill: "boolean", + find: "boolean", + findIndex: "boolean", + flat: "boolean", + flatMap: "boolean", + includes: "boolean", + keys: "boolean", + values: "boolean", + // Failed tc39 proposal + // Seen on FF Nightly 88.0a1 + at: "boolean", + // See https://github.com/tc39/proposal-array-find-from-last + findLast: "boolean", + findLastIndex: "boolean", + // https://github.com/tc39/proposal-change-array-by-copy + toReversed: "boolean", + toSorted: "boolean", + toSpliced: "boolean", + with: "boolean", + // https://github.com/tc39/proposal-array-grouping + group: "boolean", + groupToMap: "boolean", + groupBy: "boolean" + }, + // See https://github.com/tc39/proposal-array-find-from-last + findLast: o, + findLastIndex: o, + // https://github.com/tc39/proposal-change-array-by-copy + toReversed: o, + toSorted: o, + toSpliced: o, + with: o, + // https://github.com/tc39/proposal-array-grouping + group: o, + // Not in proposal? Where? + groupToMap: o, + // Not in proposal? Where? + groupBy: o + }, + "%ArrayIteratorPrototype%": { + // The %ArrayIteratorPrototype% Object + "[[Proto]]": "%IteratorPrototype%", + next: o, + "@@toStringTag": "string" + }, + // *** TypedArray Objects + "%TypedArray%": { + // Properties of the %TypedArray% Intrinsic Object + "[[Proto]]": "%FunctionPrototype%", + from: o, + of: o, + prototype: "%TypedArrayPrototype%", + "@@species": O + }, + "%TypedArrayPrototype%": { + at: o, + buffer: O, + byteLength: O, + byteOffset: O, + constructor: "%TypedArray%", + copyWithin: o, + entries: o, + every: o, + fill: o, + filter: o, + find: o, + findIndex: o, + forEach: o, + includes: o, + indexOf: o, + join: o, + keys: o, + lastIndexOf: o, + length: O, + map: o, + reduce: o, + reduceRight: o, + reverse: o, + set: o, + slice: o, + some: o, + sort: o, + subarray: o, + toLocaleString: o, + toString: o, + values: o, + "@@iterator": o, + "@@toStringTag": O, + // See https://github.com/tc39/proposal-array-find-from-last + findLast: o, + findLastIndex: o, + // https://github.com/tc39/proposal-change-array-by-copy + toReversed: o, + toSorted: o, + with: o + }, + // The TypedArray Constructors + BigInt64Array: he("%BigInt64ArrayPrototype%"), + BigUint64Array: he("%BigUint64ArrayPrototype%"), + // https://github.com/tc39/proposal-float16array + Float16Array: he("%Float16ArrayPrototype%"), + Float32Array: he("%Float32ArrayPrototype%"), + Float64Array: he("%Float64ArrayPrototype%"), + Int16Array: he("%Int16ArrayPrototype%"), + Int32Array: he("%Int32ArrayPrototype%"), + Int8Array: he("%Int8ArrayPrototype%"), + Uint16Array: he("%Uint16ArrayPrototype%"), + Uint32Array: he("%Uint32ArrayPrototype%"), + Uint8Array: he("%Uint8ArrayPrototype%"), + Uint8ClampedArray: he("%Uint8ClampedArrayPrototype%"), + "%BigInt64ArrayPrototype%": ge("BigInt64Array"), + "%BigUint64ArrayPrototype%": ge("BigUint64Array"), + // https://github.com/tc39/proposal-float16array + "%Float16ArrayPrototype%": ge("Float16Array"), + "%Float32ArrayPrototype%": ge("Float32Array"), + "%Float64ArrayPrototype%": ge("Float64Array"), + "%Int16ArrayPrototype%": ge("Int16Array"), + "%Int32ArrayPrototype%": ge("Int32Array"), + "%Int8ArrayPrototype%": ge("Int8Array"), + "%Uint16ArrayPrototype%": ge("Uint16Array"), + "%Uint32ArrayPrototype%": ge("Uint32Array"), + "%Uint8ArrayPrototype%": ge("Uint8Array"), + "%Uint8ClampedArrayPrototype%": ge("Uint8ClampedArray"), + // *** Keyed Collections + Map: { + // Properties of the Map Constructor + "[[Proto]]": "%FunctionPrototype%", + "@@species": O, + prototype: "%MapPrototype%", + // https://github.com/tc39/proposal-array-grouping + groupBy: o + }, + "%MapPrototype%": { + clear: o, + constructor: "Map", + delete: o, + entries: o, + forEach: o, + get: o, + has: o, + keys: o, + set: o, + size: O, + values: o, + "@@iterator": o, + "@@toStringTag": "string" + }, + "%MapIteratorPrototype%": { + // The %MapIteratorPrototype% Object + "[[Proto]]": "%IteratorPrototype%", + next: o, + "@@toStringTag": "string" + }, + Set: { + // Properties of the Set Constructor + "[[Proto]]": "%FunctionPrototype%", + prototype: "%SetPrototype%", + "@@species": O, + // Seen on QuickJS + groupBy: !1 + }, + "%SetPrototype%": { + add: o, + clear: o, + constructor: "Set", + delete: o, + entries: o, + forEach: o, + has: o, + keys: o, + size: O, + values: o, + "@@iterator": o, + "@@toStringTag": "string", + // See https://github.com/tc39/proposal-set-methods + intersection: o, + // See https://github.com/tc39/proposal-set-methods + union: o, + // See https://github.com/tc39/proposal-set-methods + difference: o, + // See https://github.com/tc39/proposal-set-methods + symmetricDifference: o, + // See https://github.com/tc39/proposal-set-methods + isSubsetOf: o, + // See https://github.com/tc39/proposal-set-methods + isSupersetOf: o, + // See https://github.com/tc39/proposal-set-methods + isDisjointFrom: o + }, + "%SetIteratorPrototype%": { + // The %SetIteratorPrototype% Object + "[[Proto]]": "%IteratorPrototype%", + next: o, + "@@toStringTag": "string" + }, + WeakMap: { + // Properties of the WeakMap Constructor + "[[Proto]]": "%FunctionPrototype%", + prototype: "%WeakMapPrototype%" + }, + "%WeakMapPrototype%": { + constructor: "WeakMap", + delete: o, + get: o, + has: o, + set: o, + "@@toStringTag": "string" + }, + WeakSet: { + // Properties of the WeakSet Constructor + "[[Proto]]": "%FunctionPrototype%", + prototype: "%WeakSetPrototype%" + }, + "%WeakSetPrototype%": { + add: o, + constructor: "WeakSet", + delete: o, + has: o, + "@@toStringTag": "string" + }, + // *** Structured Data + ArrayBuffer: { + // Properties of the ArrayBuffer Constructor + "[[Proto]]": "%FunctionPrototype%", + isView: o, + prototype: "%ArrayBufferPrototype%", + "@@species": O, + // See https://github.com/Moddable-OpenSource/moddable/issues/523 + fromString: !1, + // See https://github.com/Moddable-OpenSource/moddable/issues/523 + fromBigInt: !1 + }, + "%ArrayBufferPrototype%": { + byteLength: O, + constructor: "ArrayBuffer", + slice: o, + "@@toStringTag": "string", + // See https://github.com/Moddable-OpenSource/moddable/issues/523 + concat: !1, + // See https://github.com/tc39/proposal-resizablearraybuffer + transfer: o, + resize: o, + resizable: O, + maxByteLength: O, + // https://github.com/tc39/proposal-arraybuffer-transfer + transferToFixedLength: o, + detached: O + }, + // SharedArrayBuffer Objects + SharedArrayBuffer: !1, + // UNSAFE and purposely suppressed. + "%SharedArrayBufferPrototype%": !1, + // UNSAFE and purposely suppressed. + DataView: { + // Properties of the DataView Constructor + "[[Proto]]": "%FunctionPrototype%", + BYTES_PER_ELEMENT: "number", + // Non std but undeletable on Safari. + prototype: "%DataViewPrototype%" + }, + "%DataViewPrototype%": { + buffer: O, + byteLength: O, + byteOffset: O, + constructor: "DataView", + getBigInt64: o, + getBigUint64: o, + // https://github.com/tc39/proposal-float16array + getFloat16: o, + getFloat32: o, + getFloat64: o, + getInt8: o, + getInt16: o, + getInt32: o, + getUint8: o, + getUint16: o, + getUint32: o, + setBigInt64: o, + setBigUint64: o, + // https://github.com/tc39/proposal-float16array + setFloat16: o, + setFloat32: o, + setFloat64: o, + setInt8: o, + setInt16: o, + setInt32: o, + setUint8: o, + setUint16: o, + setUint32: o, + "@@toStringTag": "string" + }, + // Atomics + Atomics: !1, + // UNSAFE and suppressed. + JSON: { + parse: o, + stringify: o, + "@@toStringTag": "string", + // https://github.com/tc39/proposal-json-parse-with-source/ + rawJSON: o, + isRawJSON: o + }, + // *** Control Abstraction Objects + // https://github.com/tc39/proposal-iterator-helpers + Iterator: { + // Properties of the Iterator Constructor + "[[Proto]]": "%FunctionPrototype%", + prototype: "%IteratorPrototype%", + from: o + }, + "%IteratorPrototype%": { + // The %IteratorPrototype% Object + "@@iterator": o, + // https://github.com/tc39/proposal-iterator-helpers + constructor: "Iterator", + map: o, + filter: o, + take: o, + drop: o, + flatMap: o, + reduce: o, + toArray: o, + forEach: o, + some: o, + every: o, + find: o, + "@@toStringTag": "string", + // https://github.com/tc39/proposal-async-iterator-helpers + toAsync: o, + // See https://github.com/Moddable-OpenSource/moddable/issues/523#issuecomment-1942904505 + "@@dispose": !1 + }, + // https://github.com/tc39/proposal-iterator-helpers + "%WrapForValidIteratorPrototype%": { + "[[Proto]]": "%IteratorPrototype%", + next: o, + return: o + }, + // https://github.com/tc39/proposal-iterator-helpers + "%IteratorHelperPrototype%": { + "[[Proto]]": "%IteratorPrototype%", + next: o, + return: o, + "@@toStringTag": "string" + }, + // https://github.com/tc39/proposal-async-iterator-helpers + AsyncIterator: { + // Properties of the Iterator Constructor + "[[Proto]]": "%FunctionPrototype%", + prototype: "%AsyncIteratorPrototype%", + from: o + }, + "%AsyncIteratorPrototype%": { + // The %AsyncIteratorPrototype% Object + "@@asyncIterator": o, + // https://github.com/tc39/proposal-async-iterator-helpers + constructor: "AsyncIterator", + map: o, + filter: o, + take: o, + drop: o, + flatMap: o, + reduce: o, + toArray: o, + forEach: o, + some: o, + every: o, + find: o, + "@@toStringTag": "string", + // See https://github.com/Moddable-OpenSource/moddable/issues/523#issuecomment-1942904505 + "@@asyncDispose": !1 + }, + // https://github.com/tc39/proposal-async-iterator-helpers + "%WrapForValidAsyncIteratorPrototype%": { + "[[Proto]]": "%AsyncIteratorPrototype%", + next: o, + return: o + }, + // https://github.com/tc39/proposal-async-iterator-helpers + "%AsyncIteratorHelperPrototype%": { + "[[Proto]]": "%AsyncIteratorPrototype%", + next: o, + return: o, + "@@toStringTag": "string" + }, + "%InertGeneratorFunction%": { + // Properties of the GeneratorFunction Constructor + "[[Proto]]": "%InertFunction%", + prototype: "%Generator%" + }, + "%Generator%": { + // Properties of the GeneratorFunction Prototype Object + "[[Proto]]": "%FunctionPrototype%", + constructor: "%InertGeneratorFunction%", + prototype: "%GeneratorPrototype%", + "@@toStringTag": "string" + }, + "%InertAsyncGeneratorFunction%": { + // Properties of the AsyncGeneratorFunction Constructor + "[[Proto]]": "%InertFunction%", + prototype: "%AsyncGenerator%" + }, + "%AsyncGenerator%": { + // Properties of the AsyncGeneratorFunction Prototype Object + "[[Proto]]": "%FunctionPrototype%", + constructor: "%InertAsyncGeneratorFunction%", + prototype: "%AsyncGeneratorPrototype%", + // length prop added here for React Native jsc-android + // https://github.com/endojs/endo/issues/660 + // https://github.com/react-native-community/jsc-android-buildscripts/issues/181 + length: "number", + "@@toStringTag": "string" + }, + "%GeneratorPrototype%": { + // Properties of the Generator Prototype Object + "[[Proto]]": "%IteratorPrototype%", + constructor: "%Generator%", + next: o, + return: o, + throw: o, + "@@toStringTag": "string" + }, + "%AsyncGeneratorPrototype%": { + // Properties of the AsyncGenerator Prototype Object + "[[Proto]]": "%AsyncIteratorPrototype%", + constructor: "%AsyncGenerator%", + next: o, + return: o, + throw: o, + "@@toStringTag": "string" + }, + // TODO: To be replaced with Promise.delegate + // + // The HandledPromise global variable shimmed by `@agoric/eventual-send/shim` + // implements an initial version of the eventual send specification at: + // https://github.com/tc39/proposal-eventual-send + // + // We will likely change this to add a property to Promise called + // Promise.delegate and put static methods on it, which will necessitate + // another whitelist change to update to the current proposed standard. + HandledPromise: { + "[[Proto]]": "Promise", + applyFunction: o, + applyFunctionSendOnly: o, + applyMethod: o, + applyMethodSendOnly: o, + get: o, + getSendOnly: o, + prototype: "%PromisePrototype%", + resolve: o + }, + Promise: { + // Properties of the Promise Constructor + "[[Proto]]": "%FunctionPrototype%", + all: o, + allSettled: o, + // To transition from `false` to `fn` once we also have `AggregateError` + // TODO https://github.com/Agoric/SES-shim/issues/550 + any: !1, + // ES2021 + prototype: "%PromisePrototype%", + race: o, + reject: o, + resolve: o, + // https://github.com/tc39/proposal-promise-with-resolvers + withResolvers: o, + "@@species": O + }, + "%PromisePrototype%": { + // Properties of the Promise Prototype Object + catch: o, + constructor: "Promise", + finally: o, + then: o, + "@@toStringTag": "string", + // Non-standard, used in node to prevent async_hooks from breaking + "UniqueSymbol(async_id_symbol)": Te, + "UniqueSymbol(trigger_async_id_symbol)": Te, + "UniqueSymbol(destroyed)": Te + }, + "%InertAsyncFunction%": { + // Properties of the AsyncFunction Constructor + "[[Proto]]": "%InertFunction%", + prototype: "%AsyncFunctionPrototype%" + }, + "%AsyncFunctionPrototype%": { + // Properties of the AsyncFunction Prototype Object + "[[Proto]]": "%FunctionPrototype%", + constructor: "%InertAsyncFunction%", + // length prop added here for React Native jsc-android + // https://github.com/endojs/endo/issues/660 + // https://github.com/react-native-community/jsc-android-buildscripts/issues/181 + length: "number", + "@@toStringTag": "string" + }, + // Reflection + Reflect: { + // The Reflect Object + // Not a function object. + apply: o, + construct: o, + defineProperty: o, + deleteProperty: o, + get: o, + getOwnPropertyDescriptor: o, + getPrototypeOf: o, + has: o, + isExtensible: o, + ownKeys: o, + preventExtensions: o, + set: o, + setPrototypeOf: o, + "@@toStringTag": "string" + }, + Proxy: { + // Properties of the Proxy Constructor + "[[Proto]]": "%FunctionPrototype%", + revocable: o + }, + // Appendix B + // Annex B: Additional Properties of the Global Object + escape: o, + unescape: o, + // Proposed + "%UniqueCompartment%": { + "[[Proto]]": "%FunctionPrototype%", + prototype: "%CompartmentPrototype%", + toString: o + }, + "%InertCompartment%": { + "[[Proto]]": "%FunctionPrototype%", + prototype: "%CompartmentPrototype%", + toString: o + }, + "%CompartmentPrototype%": { + constructor: "%InertCompartment%", + evaluate: o, + globalThis: O, + name: O, + import: On, + load: On, + importNow: o, + module: o, + "@@toStringTag": "string" + }, + lockdown: o, + harden: { ...o, isFake: "boolean" }, + "%InitialGetStackString%": o +}, ba = (t) => typeof t == "function"; +function wa(t, e, r) { + if (se(t, e)) { + const n = ue(t, e); + if (!n || !xr(n.value, r.value) || n.get !== r.get || n.set !== r.set || n.writable !== r.writable || n.enumerable !== r.enumerable || n.configurable !== r.configurable) + throw v(`Conflicting definitions of ${e}`); + } + L(t, e, r); +} +function xa(t, e) { + for (const [r, n] of te(e)) + wa(t, r, n); +} +function Ro(t, e) { + const r = { __proto__: null }; + for (const [n, a] of te(e)) + se(t, n) && (r[a] = t[n]); + return r; +} +const Mo = () => { + const t = H(null); + let e; + const r = (c) => { + xa(t, Ke(c)); + }; + y(r); + const n = () => { + for (const [c, u] of te(t)) { + if (!He(u) || !se(u, "prototype")) + continue; + const l = cr[c]; + if (typeof l != "object") + throw v(`Expected permit object at whitelist.${c}`); + const d = l.prototype; + if (!d) + throw v(`${c}.prototype property not whitelisted`); + if (typeof d != "string" || !se(cr, d)) + throw v(`Unrecognized ${c}.prototype whitelist entry`); + const f = u.prototype; + if (se(t, d)) { + if (t[d] !== f) + throw v(`Conflicting bindings of ${d}`); + continue; + } + t[d] = f; + } + }; + y(n); + const a = () => (y(t), e = new xt(Ge(ao(t), ba)), t); + y(a); + const s = (c) => { + if (!e) + throw v( + "isPseudoNative can only be called after finalIntrinsics" + ); + return Wt(e, c); + }; + y(s); + const i = { + addIntrinsics: r, + completePrototypes: n, + finalIntrinsics: a, + isPseudoNative: s + }; + return y(i), r(No), r(Ro(E, $o)), i; +}, Sa = (t) => { + const { addIntrinsics: e, finalIntrinsics: r } = Mo(); + return e(Ro(t, Oo)), r(); +}; +function Ea(t, e) { + let r = !1; + const n = (m, ...p) => (r || (console.groupCollapsed("Removing unpermitted intrinsics"), r = !0), console[m](...p)), a = ["undefined", "boolean", "number", "string", "symbol"], s = new Ie( + At ? de( + Ge( + te(cr["%SharedSymbol%"]), + ([m, p]) => p === "symbol" && typeof At[m] == "symbol" + ), + ([m]) => [At[m], `@@${m}`] + ) : [] + ); + function i(m, p) { + if (typeof p == "string") + return p; + const h = Le(s, p); + if (typeof p == "symbol") { + if (h) + return h; + { + const _ = Cs(p); + return _ !== void 0 ? `RegisteredSymbol(${_})` : `Unique${ie(p)}`; + } + } + throw v(`Unexpected property name type ${m} ${p}`); + } + function c(m, p, h) { + if (!He(p)) + throw v(`Object expected: ${m}, ${p}, ${h}`); + const _ = G(p); + if (!(_ === null && h === null)) { + if (h !== void 0 && typeof h != "string") + throw v(`Malformed whitelist permit ${m}.__proto__`); + if (_ !== t[h || "%ObjectPrototype%"]) + throw v(`Unexpected intrinsic ${m}.__proto__ at ${h}`); + } + } + function u(m, p, h, _) { + if (typeof _ == "object") + return f(m, p, _), !0; + if (_ === !1) + return !1; + if (typeof _ == "string") { + if (h === "prototype" || h === "constructor") { + if (se(t, _)) { + if (p !== t[_]) + throw v(`Does not match whitelist ${m}`); + return !0; + } + } else if (Pr(a, _)) { + if (typeof p !== _) + throw v( + `At ${m} expected ${_} not ${typeof p}` + ); + return !0; + } + } + throw v(`Unexpected whitelist permit ${_} at ${m}`); + } + function l(m, p, h, _) { + const w = ue(p, h); + if (!w) + throw v(`Property ${h} not found at ${m}`); + if (se(w, "value")) { + if (Rn(_)) + throw v(`Accessor expected at ${m}`); + return u(m, w.value, h, _); + } + if (!Rn(_)) + throw v(`Accessor not expected at ${m}`); + return u(`${m}`, w.get, h, _.get) && u(`${m}`, w.set, h, _.set); + } + function d(m, p, h) { + const _ = h === "__proto__" ? "--proto--" : h; + if (se(p, _)) + return p[_]; + if (typeof m == "function" && se(Hr, _)) + return Hr[_]; + } + function f(m, p, h) { + if (p == null) + return; + const _ = h["[[Proto]]"]; + c(m, p, _), typeof p == "function" && e(p); + for (const w of nt(p)) { + const I = i(m, w), N = `${m}.${I}`, T = d(p, h, I); + if (!T || !l(N, p, w, T)) { + T !== !1 && n("warn", `Removing ${N}`); + try { + delete p[w]; + } catch (D) { + if (w in p) { + if (typeof p == "function" && w === "prototype" && (p.prototype = void 0, p.prototype === void 0)) { + n( + "warn", + `Tolerating undeletable ${N} === undefined` + ); + continue; + } + n("error", `failed to delete ${N}`, D); + } else + n("error", `deleting ${N} threw`, D); + throw D; + } + } + } + } + try { + f("intrinsics", t, cr); + } finally { + r && console.groupEnd(); + } +} +function Pa() { + try { + ye.prototype.constructor("return 1"); + } catch { + return y({}); + } + const t = {}; + function e(r, n, a) { + let s; + try { + s = (0, eval)(a); + } catch (u) { + if (u instanceof Gt) + return; + throw u; + } + const i = G(s), c = function() { + throw v( + "Function.prototype.constructor is not a valid constructor." + ); + }; + F(c, { + prototype: { value: i }, + name: { + value: r, + writable: !1, + enumerable: !1, + configurable: !0 + } + }), F(i, { + constructor: { value: c } + }), c !== ye.prototype.constructor && so(c, ye.prototype.constructor), t[n] = c; + } + return e("Function", "%InertFunction%", "(function(){})"), e( + "GeneratorFunction", + "%InertGeneratorFunction%", + "(function*(){})" + ), e( + "AsyncFunction", + "%InertAsyncFunction%", + "(async function(){})" + ), e( + "AsyncGeneratorFunction", + "%InertAsyncGeneratorFunction%", + "(async function*(){})" + ), t; +} +function ka(t = "safe") { + if (t !== "safe" && t !== "unsafe") + throw v(`unrecognized dateTaming ${t}`); + const e = ws, r = e.prototype, n = { + /** + * `%SharedDate%.now()` throw a `TypeError` starting with "secure mode". + * See https://github.com/endojs/endo/issues/910#issuecomment-1581855420 + */ + now() { + throw v("secure mode Calling %SharedDate%.now() throws"); + } + }, a = ({ powers: c = "none" } = {}) => { + let u; + return c === "original" ? u = function(...d) { + return new.target === void 0 ? oe(e, void 0, d) : sr(e, d, new.target); + } : u = function(...d) { + if (new.target === void 0) + throw v( + "secure mode Calling %SharedDate% constructor as a function throws" + ); + if (d.length === 0) + throw v( + "secure mode Calling new %SharedDate%() with no arguments throws" + ); + return sr(e, d, new.target); + }, F(u, { + length: { value: 7 }, + prototype: { + value: r, + writable: !1, + enumerable: !1, + configurable: !1 + }, + parse: { + value: e.parse, + writable: !0, + enumerable: !1, + configurable: !0 + }, + UTC: { + value: e.UTC, + writable: !0, + enumerable: !1, + configurable: !0 + } + }), u; + }, s = a({ powers: "original" }), i = a({ powers: "none" }); + return F(s, { + now: { + value: e.now, + writable: !0, + enumerable: !1, + configurable: !0 + } + }), F(i, { + now: { + value: n.now, + writable: !0, + enumerable: !1, + configurable: !0 + } + }), F(r, { + constructor: { value: i } + }), { + "%InitialDate%": s, + "%SharedDate%": i + }; +} +function Ta(t = "safe") { + if (t !== "safe" && t !== "unsafe") + throw v(`unrecognized mathTaming ${t}`); + const e = Es, r = e, { random: n, ...a } = Ke(e), i = H(oo, { + ...a, + random: { + value: { + /** + * `%SharedMath%.random()` throws a TypeError starting with "secure mode". + * See https://github.com/endojs/endo/issues/910#issuecomment-1581855420 + */ + random() { + throw v("secure mode %SharedMath%.random() throws"); + } + }.random, + writable: !0, + enumerable: !1, + configurable: !0 + } + }); + return { + "%InitialMath%": r, + "%SharedMath%": i + }; +} +function Ia(t = "safe") { + if (t !== "safe" && t !== "unsafe") + throw v(`unrecognized regExpTaming ${t}`); + const e = ze.prototype, r = (s = {}) => { + const i = function(...l) { + return new.target === void 0 ? ze(...l) : sr(ze, l, new.target); + }, c = ue(ze, Pn); + if (!c) + throw v("no RegExp[Symbol.species] descriptor"); + return F(i, { + length: { value: 2 }, + prototype: { + value: e, + writable: !1, + enumerable: !1, + configurable: !1 + }, + [Pn]: c + }), i; + }, n = r(), a = r(); + return t !== "unsafe" && delete e.compile, F(e, { + constructor: { value: a } + }), { + "%InitialRegExp%": n, + "%SharedRegExp%": a + }; +} +const Aa = { + "%ObjectPrototype%": { + toString: !0 + }, + "%FunctionPrototype%": { + toString: !0 + // set by "rollup" + }, + "%ErrorPrototype%": { + name: !0 + // set by "precond", "ava", "node-fetch" + }, + "%IteratorPrototype%": { + toString: !0, + // https://github.com/tc39/proposal-iterator-helpers + constructor: !0, + // https://github.com/tc39/proposal-iterator-helpers + [Be]: !0 + } +}, Lo = { + "%ObjectPrototype%": { + toString: !0, + valueOf: !0 + }, + "%ArrayPrototype%": { + toString: !0, + push: !0, + // set by "Google Analytics" + concat: !0, + // set by mobx generated code (old TS compiler?) + [Ht]: !0 + // set by mobx generated code (old TS compiler?) + }, + // Function.prototype has no 'prototype' property to enable. + // Function instances have their own 'name' and 'length' properties + // which are configurable and non-writable. Thus, they are already + // non-assignable anyway. + "%FunctionPrototype%": { + constructor: !0, + // set by "regenerator-runtime" + bind: !0, + // set by "underscore", "express" + toString: !0 + // set by "rollup" + }, + "%ErrorPrototype%": { + constructor: !0, + // set by "fast-json-patch", "node-fetch" + message: !0, + name: !0, + // set by "precond", "ava", "node-fetch", "node 14" + toString: !0 + // set by "bluebird" + }, + "%TypeErrorPrototype%": { + constructor: !0, + // set by "readable-stream" + message: !0, + // set by "tape" + name: !0 + // set by "readable-stream", "node 14" + }, + "%SyntaxErrorPrototype%": { + message: !0, + // to match TypeErrorPrototype.message + name: !0 + // set by "node 14" + }, + "%RangeErrorPrototype%": { + message: !0, + // to match TypeErrorPrototype.message + name: !0 + // set by "node 14" + }, + "%URIErrorPrototype%": { + message: !0, + // to match TypeErrorPrototype.message + name: !0 + // set by "node 14" + }, + "%EvalErrorPrototype%": { + message: !0, + // to match TypeErrorPrototype.message + name: !0 + // set by "node 14" + }, + "%ReferenceErrorPrototype%": { + message: !0, + // to match TypeErrorPrototype.message + name: !0 + // set by "node 14" + }, + "%PromisePrototype%": { + constructor: !0 + // set by "core-js" + }, + "%TypedArrayPrototype%": "*", + // set by https://github.com/feross/buffer + "%Generator%": { + constructor: !0, + name: !0, + toString: !0 + }, + "%IteratorPrototype%": { + toString: !0, + // https://github.com/tc39/proposal-iterator-helpers + constructor: !0, + // https://github.com/tc39/proposal-iterator-helpers + [Be]: !0 + } +}, Ca = { + ...Lo, + /** + * Rollup (as used at least by vega) and webpack + * (as used at least by regenerator) both turn exports into assignments + * to a big `exports` object that inherits directly from + * `Object.prototype`. Some of the exported names we've seen include + * `hasOwnProperty`, `constructor`, and `toString`. But the strategy used + * by rollup and webpack potentionally turns any exported name + * into an assignment rejected by the override mistake. That's why + * the `severe` enablements takes the extreme step of enabling + * everything on `Object.prototype`. + * + * In addition, code doing inheritance manually will often override + * the `constructor` property on the new prototype by assignment. We've + * seen this several times. + * + * The cost of enabling all these is that they create a miserable debugging + * experience specifically on Node. + * https://github.com/Agoric/agoric-sdk/issues/2324 + * explains how it confused the Node console. + * + * (TODO Reexamine the vscode situation. I think it may have improved + * since the following paragraph was written.) + * + * The vscode debugger's object inspector shows the own data properties of + * an object, which is typically what you want, but also shows both getter + * and setter for every accessor property whether inherited or own. + * With the `'*'` setting here, all the properties inherited from + * `Object.prototype` are accessors, creating an unusable display as seen + * at As explained at + * https://github.com/endojs/endo/blob/master/packages/ses/docs/lockdown.md#overridetaming-options + * Open the triangles at the bottom of that section. + */ + "%ObjectPrototype%": "*", + /** + * The widely used Buffer defined at https://github.com/feross/buffer + * on initialization, manually creates the equivalent of a subclass of + * `TypedArray`, which it then initializes by assignment. These assignments + * include enough of the `TypeArray` methods that here, the `severe` + * enablements just enable them all. + */ + "%TypedArrayPrototype%": "*", + /** + * Needed to work with Immer before https://github.com/immerjs/immer/pull/914 + * is accepted. + */ + "%MapPrototype%": "*", + /** + * Needed to work with Immer before https://github.com/immerjs/immer/pull/914 + * is accepted. + */ + "%SetPrototype%": "*" +}; +function Na(t, e, r = []) { + const n = new wt(r); + function a(l, d, f, m) { + if ("value" in m && m.configurable) { + const { value: p } = m, h = sn(n, f), { get: _, set: w } = ue( + { + get [f]() { + return p; + }, + set [f](I) { + if (d === this) + throw v( + `Cannot assign to read only property '${ie( + f + )}' of '${l}'` + ); + se(this, f) ? this[f] = I : (h && console.error(v(`Override property ${f}`)), L(this, f, { + value: I, + writable: !0, + enumerable: !0, + configurable: !0 + })); + } + }, + f + ); + L(_, "originalValue", { + value: p, + writable: !1, + enumerable: !1, + configurable: !1 + }), L(d, f, { + get: _, + set: w, + enumerable: m.enumerable, + configurable: m.configurable + }); + } + } + function s(l, d, f) { + const m = ue(d, f); + m && a(l, d, f, m); + } + function i(l, d) { + const f = Ke(d); + f && tt(nt(f), (m) => a(l, d, m, f[m])); + } + function c(l, d, f) { + for (const m of nt(f)) { + const p = ue(d, m); + if (!p || p.get || p.set) + continue; + const h = `${l}.${ie(m)}`, _ = f[m]; + if (_ === !0) + s(h, d, m); + else if (_ === "*") + i(h, p.value); + else if (He(_)) + c(h, p.value, _); + else + throw v(`Unexpected override enablement plan ${h}`); + } + } + let u; + switch (e) { + case "min": { + u = Aa; + break; + } + case "moderate": { + u = Lo; + break; + } + case "severe": { + u = Ca; + break; + } + default: + throw v(`unrecognized overrideTaming ${e}`); + } + c("root", t, u); +} +const { Fail: Vr, quote: lr } = Z, $a = /^(\w*[a-z])Locale([A-Z]\w*)$/, Fo = { + // See https://tc39.es/ecma262/#sec-string.prototype.localecompare + localeCompare(t) { + if (this === null || this === void 0) + throw v( + 'Cannot localeCompare with null or undefined "this" value' + ); + const e = `${this}`, r = `${t}`; + return e < r ? -1 : e > r ? 1 : (e === r || Vr`expected ${lr(e)} and ${lr(r)} to compare`, 0); + }, + toString() { + return `${this}`; + } +}, Oa = Fo.localeCompare, Ra = Fo.toString; +function Ma(t, e = "safe") { + if (e !== "safe" && e !== "unsafe") + throw v(`unrecognized localeTaming ${e}`); + if (e !== "unsafe") { + L(ie.prototype, "localeCompare", { + value: Oa + }); + for (const r of Nt(t)) { + const n = t[r]; + if (He(n)) + for (const a of Nt(n)) { + const s = cn($a, a); + if (s) { + typeof n[a] == "function" || Vr`expected ${lr(a)} to be a function`; + const i = `${s[1]}${s[2]}`, c = n[i]; + typeof c == "function" || Vr`function ${lr(i)} not found`, L(n, a, { value: c }); + } + } + } + L(ro.prototype, "toLocaleString", { + value: Ra + }); + } +} +const La = (t) => ({ + eval(r) { + return typeof r != "string" ? r : t(r); + } +}).eval, { Fail: Ln } = Z, Fa = (t) => { + const e = function(n) { + const a = `${jr(arguments) || ""}`, s = `${Pt(arguments, ",")}`; + new ye(s, ""), new ye(a); + const i = `(function anonymous(${s} +) { +${a} +})`; + return t(i); + }; + return F(e, { + // Ensure that any function created in any evaluator in a realm is an + // instance of Function in any evaluator of the same realm. + prototype: { + value: ye.prototype, + writable: !1, + enumerable: !1, + configurable: !1 + } + }), G(ye) === ye.prototype || Ln`Function prototype is the same accross compartments`, G(e) === ye.prototype || Ln`Function constructor prototype is the same accross compartments`, e; +}, Da = (t) => { + L( + t, + As, + y( + wr(H(null), { + set: y(() => { + throw v( + "Cannot set Symbol.unscopables of a Compartment's globalThis" + ); + }), + enumerable: !1, + configurable: !1 + }) + ) + ); +}, Do = (t) => { + for (const [e, r] of te(No)) + L(t, e, { + value: r, + writable: !1, + enumerable: !1, + configurable: !1 + }); +}, jo = (t, { + intrinsics: e, + newGlobalPropertyNames: r, + makeCompartmentConstructor: n, + markVirtualizedNativeFunction: a +}) => { + for (const [i, c] of te($o)) + se(e, c) && L(t, i, { + value: e[c], + writable: !0, + enumerable: !1, + configurable: !0 + }); + for (const [i, c] of te(r)) + se(e, c) && L(t, i, { + value: e[c], + writable: !0, + enumerable: !1, + configurable: !0 + }); + const s = { + globalThis: t + }; + s.Compartment = y( + n( + n, + e, + a + ) + ); + for (const [i, c] of te(s)) + L(t, i, { + value: c, + writable: !0, + enumerable: !1, + configurable: !0 + }), typeof c == "function" && a(c); +}, Wr = (t, e, r) => { + { + const n = y(La(e)); + r(n), L(t, "eval", { + value: n, + writable: !0, + enumerable: !1, + configurable: !0 + }); + } + { + const n = y(Fa(e)); + r(n), L(t, "Function", { + value: n, + writable: !0, + enumerable: !1, + configurable: !0 + }); + } +}, { Fail: ja, quote: Uo } = Z, Zo = new br( + fn, + y({ + get(t, e) { + ja`Please report unexpected scope handler trap: ${Uo(ie(e))}`; + } + }) +), Ua = { + get(t, e) { + }, + set(t, e, r) { + throw et(`${ie(e)} is not defined`); + }, + has(t, e) { + return e in E; + }, + // note: this is likely a bug of safari + // https://bugs.webkit.org/show_bug.cgi?id=195534 + getPrototypeOf(t) { + return null; + }, + // See https://github.com/endojs/endo/issues/1510 + // TODO: report as bug to v8 or Chrome, and record issue link here. + getOwnPropertyDescriptor(t, e) { + const r = Uo(ie(e)); + console.warn( + `getOwnPropertyDescriptor trap on scopeTerminatorHandler for ${r}`, + v().stack + ); + }, + // See https://github.com/endojs/endo/issues/1490 + // TODO Report bug to JSC or Safari + ownKeys(t) { + return []; + } +}, zo = y( + H( + Zo, + Ke(Ua) + ) +), Za = new br( + fn, + zo +), Bo = (t) => { + const e = { + // inherit scopeTerminator behavior + ...zo, + // Redirect set properties to the globalObject. + set(a, s, i) { + return uo(t, s, i); + }, + // Always claim to have a potential property in order to be the recipient of a set + has(a, s) { + return !0; + } + }, r = y( + H( + Zo, + Ke(e) + ) + ); + return new br( + fn, + r + ); +}; +y(Bo); +const { Fail: za } = Z, Ba = () => { + const t = H(null), e = y({ + eval: { + get() { + return delete t.eval, vo; + }, + enumerable: !1, + configurable: !0 + } + }), r = { + evalScope: t, + allowNextEvalToBeUnsafe() { + const { revoked: n } = r; + n !== null && za`a handler did not reset allowNextEvalToBeUnsafe ${n.err}`, F(t, e); + }, + /** @type {null | { err: any }} */ + revoked: null + }; + return r; +}, Fn = "\\s*[@#]\\s*([a-zA-Z][a-zA-Z0-9]*)\\s*=\\s*([^\\s\\*]*)", Ga = new ze( + `(?:\\s*//${Fn}|/\\*${Fn}\\s*\\*/)\\s*$` +), hn = (t) => { + let e = ""; + for (; t.length > 0; ) { + const r = cn(Ga, t); + if (r === null) + break; + t = ln(t, 0, t.length - r[0].length), r[3] === "sourceURL" ? e = r[4] : r[1] === "sourceURL" && (e = r[2]); + } + return e; +}; +function gn(t, e) { + const r = qs(t, e); + if (r < 0) + return -1; + const n = t[r] === ` +` ? 1 : 0; + return go(ln(t, 0, r), ` +`).length + n; +} +const Go = new ze("(?:)", "g"), Ho = (t) => { + const e = gn(t, Go); + if (e < 0) + return t; + const r = hn(t); + throw Gt( + `Possible HTML comment rejected at ${r}:${e}. (SES_HTML_COMMENT_REJECTED)` + ); +}, Vo = (t) => ar(t, Go, (r) => r[0] === "<" ? "< ! --" : "-- >"), Wo = new ze( + "(^|[^.]|\\.\\.\\.)\\bimport(\\s*(?:\\(|/[/*]))", + "g" +), qo = (t) => { + const e = gn(t, Wo); + if (e < 0) + return t; + const r = hn(t); + throw Gt( + `Possible import expression rejected at ${r}:${e}. (SES_IMPORT_REJECTED)` + ); +}, Ko = (t) => ar(t, Wo, (r, n, a) => `${n}__import__${a}`), Ha = new ze( + "(^|[^.])\\beval(\\s*\\()", + "g" +), Jo = (t) => { + const e = gn(t, Ha); + if (e < 0) + return t; + const r = hn(t); + throw Gt( + `Possible direct eval expression rejected at ${r}:${e}. (SES_EVAL_REJECTED)` + ); +}, Yo = (t) => (t = Ho(t), t = qo(t), t), Xo = (t, e) => { + for (const r of e) + t = r(t); + return t; +}; +y({ + rejectHtmlComments: y(Ho), + evadeHtmlCommentTest: y(Vo), + rejectImportExpressions: y(qo), + evadeImportExpressionTest: y(Ko), + rejectSomeDirectEvalExpressions: y(Jo), + mandatoryTransforms: y(Yo), + applyTransforms: y(Xo) +}); +const Va = [ + // 11.6.2.1 Keywords + "await", + "break", + "case", + "catch", + "class", + "const", + "continue", + "debugger", + "default", + "delete", + "do", + "else", + "export", + "extends", + "finally", + "for", + "function", + "if", + "import", + "in", + "instanceof", + "new", + "return", + "super", + "switch", + "this", + "throw", + "try", + "typeof", + "var", + "void", + "while", + "with", + "yield", + // Also reserved when parsing strict mode code + "let", + "static", + // 11.6.2.2 Future Reserved Words + "enum", + // Also reserved when parsing strict mode code + "implements", + "package", + "protected", + "interface", + "private", + "public", + // Reserved but not mentioned in specs + "await", + "null", + "true", + "false", + "this", + "arguments" +], Wa = /^[a-zA-Z_$][\w$]*$/, Dn = (t) => t !== "eval" && !Pr(Va, t) && an(Wa, t); +function jn(t, e) { + const r = ue(t, e); + return r && // + // The getters will not have .writable, don't let the falsyness of + // 'undefined' trick us: test with === false, not ! . However descriptors + // inherit from the (potentially poisoned) global object, so we might see + // extra properties which weren't really there. Accessor properties have + // 'get/set/enumerable/configurable', while data properties have + // 'value/writable/enumerable/configurable'. + r.configurable === !1 && r.writable === !1 && // + // Checks for data properties because they're the only ones we can + // optimize (accessors are most likely non-constant). Descriptors can't + // can't have accessors and value properties at the same time, therefore + // this check is sufficient. Using explicit own property deal with the + // case where Object.prototype has been poisoned. + se(r, "value"); +} +const qa = (t, e = {}) => { + const r = Nt(t), n = Nt(e), a = Ge( + n, + (i) => Dn(i) && jn(e, i) + ); + return { + globalObjectConstants: Ge( + r, + (i) => ( + // Can't define a constant: it would prevent a + // lookup on the endowments. + !Pr(n, i) && Dn(i) && jn(t, i) + ) + ), + moduleLexicalConstants: a + }; +}; +function Un(t, e) { + return t.length === 0 ? "" : `const {${Pt(t, ",")}} = this.${e};`; +} +const Ka = (t) => { + const { globalObjectConstants: e, moduleLexicalConstants: r } = qa( + t.globalObject, + t.moduleLexicals + ), n = Un( + e, + "globalObject" + ), a = Un( + r, + "moduleLexicals" + ), s = ye(` + with (this.scopeTerminator) { + with (this.globalObject) { + with (this.moduleLexicals) { + with (this.evalScope) { + ${n} + ${a} + return function() { + 'use strict'; + return eval(arguments[0]); + }; + } + } + } + } + `); + return oe(s, t, []); +}, { Fail: Ja } = Z, yn = ({ + globalObject: t, + moduleLexicals: e = {}, + globalTransforms: r = [], + sloppyGlobalsMode: n = !1 +}) => { + const a = n ? Bo(t) : Za, s = Ba(), { evalScope: i } = s, c = y({ + evalScope: i, + moduleLexicals: e, + globalObject: t, + scopeTerminator: a + }); + let u; + const l = () => { + u || (u = Ka(c)); + }; + return { safeEvaluate: (f, m) => { + const { localTransforms: p = [] } = m || {}; + l(), f = Xo(f, [ + ...p, + ...r, + Yo + ]); + let h; + try { + return s.allowNextEvalToBeUnsafe(), oe(u, t, [f]); + } catch (_) { + throw h = _, _; + } finally { + const _ = "eval" in i; + delete i.eval, _ && (s.revoked = { err: h }, Ja`handler did not reset allowNextEvalToBeUnsafe ${h}`); + } + } }; +}, Ya = ") { [native code] }"; +let Rr; +const Qo = () => { + if (Rr === void 0) { + const t = new xt(); + L(on, "toString", { + value: { + toString() { + const r = Ys(this); + return ho(r, Ya) || !Wt(t, this) ? r : `function ${this.name}() { [native code] }`; + } + }.toString + }), Rr = y( + (r) => Ir(t, r) + ); + } + return Rr; +}; +function Xa(t = "safe") { + if (t !== "safe" && t !== "unsafe") + throw v(`unrecognized domainTaming ${t}`); + if (t === "unsafe") + return; + const e = E.process || void 0; + if (typeof e == "object") { + const r = ue(e, "domain"); + if (r !== void 0 && r.get !== void 0) + throw v( + "SES failed to lockdown, Node.js domains have been initialized (SES_NO_DOMAINS)" + ); + L(e, "domain", { + value: null, + configurable: !1, + writable: !1, + enumerable: !1 + }); + } +} +const es = y([ + ["debug", "debug"], + // (fmt?, ...args) verbose level on Chrome + ["log", "log"], + // (fmt?, ...args) info level on Chrome + ["info", "info"], + // (fmt?, ...args) + ["warn", "warn"], + // (fmt?, ...args) + ["error", "error"], + // (fmt?, ...args) + ["trace", "log"], + // (fmt?, ...args) + ["dirxml", "log"], + // (fmt?, ...args) + ["group", "log"], + // (fmt?, ...args) + ["groupCollapsed", "log"] + // (fmt?, ...args) +]), ts = y([ + ["assert", "error"], + // (value, fmt?, ...args) + ["timeLog", "log"], + // (label?, ...args) no fmt string + // Insensitive to whether any argument is an error. All arguments can pass + // thru to baseConsole as is. + ["clear", void 0], + // () + ["count", "info"], + // (label?) + ["countReset", void 0], + // (label?) + ["dir", "log"], + // (item, options?) + ["groupEnd", "log"], + // () + // In theory tabular data may be or contain an error. However, we currently + // do not detect these and may never. + ["table", "log"], + // (tabularData, properties?) + ["time", "info"], + // (label?) + ["timeEnd", "info"], + // (label?) + // Node Inspector only, MDN, and TypeScript, but not whatwg + ["profile", void 0], + // (label?) + ["profileEnd", void 0], + // (label?) + ["timeStamp", void 0] + // (label?) +]), rs = y([ + ...es, + ...ts +]), Qa = (t, { shouldResetForDebugging: e = !1 } = {}) => { + e && t.resetErrorTagNum(); + let r = []; + const n = St( + de(rs, ([i, c]) => { + const u = (...l) => { + ae(r, [i, ...l]); + }; + return L(u, "name", { value: i }), [i, y(u)]; + }) + ); + y(n); + const a = () => { + const i = y(r); + return r = [], i; + }; + return y(a), y({ loggingConsole: ( + /** @type {VirtualConsole} */ + n + ), takeLog: a }); +}; +y(Qa); +const Tt = { + NOTE: "ERROR_NOTE:", + MESSAGE: "ERROR_MESSAGE:" +}; +y(Tt); +const ns = (t, e) => { + if (!t) + return; + const { getStackString: r, tagError: n, takeMessageLogArgs: a, takeNoteLogArgsArray: s } = e, i = (w, I) => de(w, (T) => pn(T) ? (ae(I, T), `(${n(T)})`) : T), c = (w, I, N, T, D) => { + const U = n(I), q = N === Tt.MESSAGE ? `${U}:` : `${U} ${N}`, K = i(T, D); + t[w](q, ...K); + }, u = (w, I, N = void 0) => { + if (I.length === 0) + return; + if (I.length === 1 && N === void 0) { + f(w, I[0]); + return; + } + let T; + I.length === 1 ? T = "Nested error" : T = `Nested ${I.length} errors`, N !== void 0 && (T = `${T} under ${N}`), t.group(T); + try { + for (const D of I) + f(w, D); + } finally { + t.groupEnd(); + } + }, l = new xt(), d = (w) => (I, N) => { + const T = []; + c(w, I, Tt.NOTE, N, T), u(w, T, n(I)); + }, f = (w, I) => { + if (Wt(l, I)) + return; + const N = n(I); + Ir(l, I); + const T = [], D = a(I), U = s( + I, + d(w) + ); + D === void 0 ? t[w](`${N}:`, I.message) : c( + w, + I, + Tt.MESSAGE, + D, + T + ); + let q = r(I); + typeof q == "string" && q.length >= 1 && !ho(q, ` +`) && (q += ` +`), t[w](q); + for (const K of U) + c(w, I, Tt.NOTE, K, T); + u(w, T, N); + }, m = de(es, ([w, I]) => { + const N = (...T) => { + const D = [], U = i(T, D); + t[w](...U), u(w, D); + }; + return L(N, "name", { value: w }), [w, y(N)]; + }), p = Ge( + ts, + ([w, I]) => w in t + ), h = de(p, ([w, I]) => { + const N = (...T) => { + t[w](...T); + }; + return L(N, "name", { value: w }), [w, y(N)]; + }), _ = St([...m, ...h]); + return ( + /** @type {VirtualConsole} */ + y(_) + ); +}; +y(ns); +const ei = (t, e, r = void 0) => { + const n = Ge( + rs, + ([i, c]) => i in t + ), a = de(n, ([i, c]) => [i, y((...l) => { + (c === void 0 || e.canLog(c)) && t[i](...l); + })]), s = St(a); + return ( + /** @type {VirtualConsole} */ + y(s) + ); +}; +y(ei); +const Zn = (t) => { + if (gt === void 0) + return; + let e = 0; + const r = new Ie(), n = (d) => { + Zs(r, d); + }, a = new Pe(), s = (d) => { + if (kr(r, d)) { + const f = Le(r, d); + n(d), t(f); + } + }, i = new gt(s); + return { + rejectionHandledHandler: (d) => { + const f = M(a, d); + n(f); + }, + unhandledRejectionHandler: (d, f) => { + e += 1; + const m = e; + Ae(r, m, d), ee(a, f, m), Qs(i, f, m, f); + }, + processTerminationHandler: () => { + for (const [d, f] of zs(r)) + n(d), t(f); + } + }; +}, Mr = (t) => { + throw v(t); +}, zn = (t, e) => y((...r) => oe(t, e, r)), ti = (t = "safe", e = "platform", r = "report", n = void 0) => { + t === "safe" || t === "unsafe" || Mr(`unrecognized consoleTaming ${t}`); + let a; + n === void 0 ? a = Gr : a = { + ...Gr, + getStackString: n + }; + const s = ( + /** @type {VirtualConsole} */ + // eslint-disable-next-line no-nested-ternary + typeof E.console < "u" ? E.console : typeof E.print == "function" ? ( + // Make a good-enough console for eshost (including only functions that + // log at a specific level with no special argument interpretation). + // https://console.spec.whatwg.org/#logging + ((l) => y({ debug: l, log: l, info: l, warn: l, error: l }))( + // eslint-disable-next-line no-undef + zn(E.print) + ) + ) : void 0 + ); + if (s && s.log) + for (const l of ["warn", "error"]) + s[l] || L(s, l, { + value: zn(s.log, s) + }); + const i = ( + /** @type {VirtualConsole} */ + t === "unsafe" ? s : ns(s, a) + ), c = E.process || void 0; + if (e !== "none" && typeof c == "object" && typeof c.on == "function") { + let l; + if (e === "platform" || e === "exit") { + const { exit: d } = c; + typeof d == "function" || Mr("missing process.exit"), l = () => d(c.exitCode || -1); + } else + e === "abort" && (l = c.abort, typeof l == "function" || Mr("missing process.abort")); + c.on("uncaughtException", (d) => { + i.error(d), l && l(); + }); + } + if (r !== "none" && typeof c == "object" && typeof c.on == "function") { + const d = Zn((f) => { + i.error("SES_UNHANDLED_REJECTION:", f); + }); + d && (c.on("unhandledRejection", d.unhandledRejectionHandler), c.on("rejectionHandled", d.rejectionHandledHandler), c.on("exit", d.processTerminationHandler)); + } + const u = E.window || void 0; + if (e !== "none" && typeof u == "object" && typeof u.addEventListener == "function" && u.addEventListener("error", (l) => { + l.preventDefault(), i.error(l.error), (e === "exit" || e === "abort") && (u.location.href = "about:blank"); + }), r !== "none" && typeof u == "object" && typeof u.addEventListener == "function") { + const d = Zn((f) => { + i.error("SES_UNHANDLED_REJECTION:", f); + }); + d && (u.addEventListener("unhandledrejection", (f) => { + f.preventDefault(), d.unhandledRejectionHandler(f.reason, f.promise); + }), u.addEventListener("rejectionhandled", (f) => { + f.preventDefault(), d.rejectionHandledHandler(f.promise); + }), u.addEventListener("beforeunload", (f) => { + d.processTerminationHandler(); + })); + } + return { console: i }; +}, ri = [ + // suppress 'getThis' definitely + "getTypeName", + // suppress 'getFunction' definitely + "getFunctionName", + "getMethodName", + "getFileName", + "getLineNumber", + "getColumnNumber", + "getEvalOrigin", + "isToplevel", + "isEval", + "isNative", + "isConstructor", + "isAsync", + // suppress 'isPromiseAll' for now + // suppress 'getPromiseIndex' for now + // Additional names found by experiment, absent from + // https://v8.dev/docs/stack-trace-api + "getPosition", + "getScriptNameOrSourceURL", + "toString" + // TODO replace to use only whitelisted info +], ni = (t) => { + const r = St(de(ri, (n) => { + const a = t[n]; + return [n, () => oe(a, t, [])]; + })); + return H(r, {}); +}, oi = (t) => de(t, ni), si = /\/node_modules\//, ai = /^(?:node:)?internal\//, ii = /\/packages\/ses\/src\/error\/assert.js$/, ci = /\/packages\/eventual-send\/src\//, li = [ + si, + ai, + ii, + ci +], ui = (t) => { + if (!t) + return !0; + for (const e of li) + if (an(e, t)) + return !1; + return !0; +}, di = /^((?:.*[( ])?)[:/\w_-]*\/\.\.\.\/(.+)$/, fi = /^((?:.*[( ])?)[:/\w_-]*\/(packages\/.+)$/, pi = [ + di, + fi +], mi = (t) => { + for (const e of pi) { + const r = cn(e, t); + if (r) + return Pt(Ds(r, 1), ""); + } + return t; +}, hi = (t, e, r, n) => { + const a = t.captureStackTrace, s = (p) => n === "verbose" ? !0 : ui(p.getFileName()), i = (p) => { + let h = `${p}`; + return n === "concise" && (h = mi(h)), ` + at ${h}`; + }, c = (p, h) => Pt( + de(Ge(h, s), i), + "" + ), u = new Pe(), l = { + // The optional `optFn` argument is for cutting off the bottom of + // the stack --- for capturing the stack only above the topmost + // call to that function. Since this isn't the "real" captureStackTrace + // but instead calls the real one, if no other cutoff is provided, + // we cut this one off. + captureStackTrace(p, h = l.captureStackTrace) { + if (typeof a == "function") { + oe(a, t, [p, h]); + return; + } + uo(p, "stack", ""); + }, + // Shim of proposed special power, to reside by default only + // in the start compartment, for getting the stack traceback + // string associated with an error. + // See https://tc39.es/proposal-error-stacks/ + getStackString(p) { + let h = M(u, p); + if (h === void 0 && (p.stack, h = M(u, p), h || (h = { stackString: "" }, ee(u, p, h))), h.stackString !== void 0) + return h.stackString; + const _ = c(p, h.callSites); + return ee(u, p, { stackString: _ }), _; + }, + prepareStackTrace(p, h) { + if (r === "unsafe") { + const _ = c(p, h); + return ee(u, p, { stackString: _ }), `${p}${_}`; + } else + return ee(u, p, { callSites: h }), ""; + } + }, d = l.prepareStackTrace; + t.prepareStackTrace = d; + const f = new xt([d]), m = (p) => { + if (Wt(f, p)) + return p; + const h = { + prepareStackTrace(_, w) { + return ee(u, _, { callSites: w }), p(_, oi(w)); + } + }; + return Ir(f, h.prepareStackTrace), h.prepareStackTrace; + }; + return F(e, { + captureStackTrace: { + value: l.captureStackTrace, + writable: !0, + enumerable: !1, + configurable: !0 + }, + prepareStackTrace: { + get() { + return t.prepareStackTrace; + }, + set(p) { + if (typeof p == "function") { + const h = m(p); + t.prepareStackTrace = h; + } else + t.prepareStackTrace = d; + }, + enumerable: !1, + configurable: !0 + } + }), l.getStackString; +}, Bn = ue(le.prototype, "stack"), Gn = Bn && Bn.get, gi = { + getStackString(t) { + return typeof Gn == "function" ? oe(Gn, t, []) : "stack" in t ? `${t.stack}` : ""; + } +}; +function yi(t = "safe", e = "concise") { + if (t !== "safe" && t !== "unsafe") + throw v(`unrecognized errorTaming ${t}`); + if (e !== "concise" && e !== "verbose") + throw v(`unrecognized stackFiltering ${e}`); + const r = le.prototype, n = typeof le.captureStackTrace == "function" ? "v8" : "unknown", { captureStackTrace: a } = le, s = (l = {}) => { + const d = function(...m) { + let p; + return new.target === void 0 ? p = oe(le, this, m) : p = sr(le, m, new.target), n === "v8" && oe(a, le, [p, d]), p; + }; + return F(d, { + length: { value: 1 }, + prototype: { + value: r, + writable: !1, + enumerable: !1, + configurable: !1 + } + }), d; + }, i = s({ powers: "original" }), c = s({ powers: "none" }); + F(r, { + constructor: { value: c } + }); + for (const l of va) + so(l, c); + F(i, { + stackTraceLimit: { + get() { + if (typeof le.stackTraceLimit == "number") + return le.stackTraceLimit; + }, + set(l) { + if (typeof l == "number" && typeof le.stackTraceLimit == "number") { + le.stackTraceLimit = l; + return; + } + }, + // WTF on v8 stackTraceLimit is enumerable + enumerable: !1, + configurable: !0 + } + }), F(c, { + stackTraceLimit: { + get() { + }, + set(l) { + }, + enumerable: !1, + configurable: !0 + } + }), n === "v8" && F(c, { + prepareStackTrace: { + get() { + return () => ""; + }, + set(l) { + }, + enumerable: !1, + configurable: !0 + }, + captureStackTrace: { + value: (l, d) => { + L(l, "stack", { + value: "" + }); + }, + writable: !1, + enumerable: !1, + configurable: !0 + } + }); + let u = gi.getStackString; + return n === "v8" ? u = hi( + le, + i, + t, + e + ) : t === "unsafe" ? F(r, { + stack: { + get() { + return u(this); + }, + set(l) { + F(this, { + stack: { + value: l, + writable: !0, + enumerable: !0, + configurable: !0 + } + }); + } + } + }) : F(r, { + stack: { + get() { + return `${this}`; + }, + set(l) { + F(this, { + stack: { + value: l, + writable: !0, + enumerable: !0, + configurable: !0 + } + }); + } + } + }), { + "%InitialGetStackString%": u, + "%InitialError%": i, + "%SharedError%": c + }; +} +const { Fail: vi, details: qr, quote: Re } = Z, os = () => { +}, _i = (t, e) => y({ + compartment: t, + specifier: e +}), bi = (t, e, r) => { + const n = H(null); + for (const a of t) { + const s = e(a, r); + n[a] = s; + } + return y(n); +}, Hn = (t, e, r, n, a, s, i, c, u) => { + const { resolveHook: l, moduleRecords: d } = M( + t, + r + ), f = bi( + a.imports, + l, + n + ), m = y({ + compartment: r, + staticModuleRecord: a, + moduleSpecifier: n, + resolvedImports: f, + importMeta: u + }); + for (const p of ao(f)) { + const h = ur( + t, + e, + r, + p, + s, + i, + c + ); + Tr( + s, + dn(h, os, (_) => { + ae(c, _); + }) + ); + } + return Ae(d, n, m), m; +}, wi = async (t, e, r, n, a, s, i) => { + const { importHook: c, moduleMap: u, moduleMapHook: l, moduleRecords: d } = M( + t, + r + ); + let f = u[n]; + if (f === void 0 && l !== void 0 && (f = l(n)), typeof f == "string") + Z.fail( + qr`Cannot map module ${Re(n)} to ${Re( + f + )} in parent compartment, not yet implemented`, + v + ); + else if (f !== void 0) { + const p = M(e, f); + p === void 0 && Z.fail( + qr`Cannot map module ${Re( + n + )} because the value is not a module exports namespace, or is from another realm`, + et + ); + const h = await ur( + t, + e, + p.compartment, + p.specifier, + a, + s, + i + ); + return Ae(d, n, h), h; + } + if (kr(d, n)) + return Le(d, n); + const m = await c(n); + if ((m === null || typeof m != "object") && vi`importHook must return a promise for an object, for module ${Re( + n + )} in compartment ${Re(r.name)}`, m.specifier !== void 0) { + if (m.record !== void 0) { + if (m.compartment !== void 0) + throw v( + "Cannot redirect to an explicit record with a specified compartment" + ); + const { + compartment: p = r, + specifier: h = n, + record: _, + importMeta: w + } = m, I = Hn( + t, + e, + p, + h, + _, + a, + s, + i, + w + ); + return Ae(d, n, I), I; + } + if (m.compartment !== void 0) { + if (m.importMeta !== void 0) + throw v( + "Cannot redirect to an implicit record with a specified importMeta" + ); + const p = await ur( + t, + e, + m.compartment, + m.specifier, + a, + s, + i + ); + return Ae(d, n, p), p; + } + throw v("Unnexpected RedirectStaticModuleInterface record shape"); + } + return Hn( + t, + e, + r, + n, + m, + a, + s, + i + ); +}, ur = async (t, e, r, n, a, s, i) => { + const { name: c } = M( + t, + r + ); + let u = Le(s, r); + u === void 0 && (u = new Ie(), Ae(s, r, u)); + let l = Le(u, n); + return l !== void 0 || (l = Xs( + wi( + t, + e, + r, + n, + a, + s, + i + ), + (d) => { + throw Z.note( + d, + qr`${d.message}, loading ${Re(n)} in compartment ${Re( + c + )}` + ), d; + } + ), Ae(u, n, l)), l; +}, Vn = async (t, e, r, n) => { + const { name: a } = M( + t, + r + ), s = new wt(), i = new Ie(), c = [], u = ur( + t, + e, + r, + n, + s, + i, + c + ); + Tr( + s, + dn(u, os, (l) => { + ae(c, l); + }) + ); + for (const l of s) + await l; + if (c.length > 0) + throw v( + `Failed to load module ${Re(n)} in package ${Re( + a + )} (${c.length} underlying failures: ${Pt( + de(c, (l) => l.message), + ", " + )}` + ); +}, { quote: dt } = Z, xi = () => { + let t = !1; + const e = H(null, { + // Make this appear like an ESM module namespace object. + [Be]: { + value: "Module", + writable: !1, + enumerable: !1, + configurable: !1 + } + }); + return y({ + activate() { + t = !0; + }, + exportsTarget: e, + exportsProxy: new br(e, { + get(r, n, a) { + if (!t) + throw v( + `Cannot get property ${dt( + n + )} of module exports namespace, the module has not yet begun to execute` + ); + return Os(e, n, a); + }, + set(r, n, a) { + throw v( + `Cannot set property ${dt(n)} of module exports namespace` + ); + }, + has(r, n) { + if (!t) + throw v( + `Cannot check property ${dt( + n + )}, the module has not yet begun to execute` + ); + return lo(e, n); + }, + deleteProperty(r, n) { + throw v( + `Cannot delete property ${dt(n)}s of module exports namespace` + ); + }, + ownKeys(r) { + if (!t) + throw v( + "Cannot enumerate keys, the module has not yet begun to execute" + ); + return nt(e); + }, + getOwnPropertyDescriptor(r, n) { + if (!t) + throw v( + `Cannot get own property descriptor ${dt( + n + )}, the module has not yet begun to execute` + ); + return Rs(e, n); + }, + preventExtensions(r) { + if (!t) + throw v( + "Cannot prevent extensions of module exports namespace, the module has not yet begun to execute" + ); + return Ls(e); + }, + isExtensible() { + if (!t) + throw v( + "Cannot check extensibility of module exports namespace, the module has not yet begun to execute" + ); + return Ms(e); + }, + getPrototypeOf(r) { + return null; + }, + setPrototypeOf(r, n) { + throw v("Cannot set prototype of module exports namespace"); + }, + defineProperty(r, n, a) { + throw v( + `Cannot define property ${dt(n)} of module exports namespace` + ); + }, + apply(r, n, a) { + throw v( + "Cannot call module exports namespace, it is not a function" + ); + }, + construct(r, n) { + throw v( + "Cannot construct module exports namespace, it is not a constructor" + ); + } + }) + }); +}, vn = (t, e, r, n) => { + const { deferredExports: a } = e; + if (!kr(a, n)) { + const s = xi(); + ee( + r, + s.exportsProxy, + _i(t, n) + ), Ae(a, n, s); + } + return Le(a, n); +}, Si = (t, e) => { + const { sloppyGlobalsMode: r = !1, __moduleShimLexicals__: n = void 0 } = e; + let a; + if (n === void 0 && !r) + ({ safeEvaluate: a } = t); + else { + let { globalTransforms: s } = t; + const { globalObject: i } = t; + let c; + n !== void 0 && (s = void 0, c = H( + null, + Ke(n) + )), { safeEvaluate: a } = yn({ + globalObject: i, + moduleLexicals: c, + globalTransforms: s, + sloppyGlobalsMode: r + }); + } + return { safeEvaluate: a }; +}, ss = (t, e, r) => { + if (typeof e != "string") + throw v("first argument of evaluate() must be a string"); + const { + transforms: n = [], + __evadeHtmlCommentTest__: a = !1, + __evadeImportExpressionTest__: s = !1, + __rejectSomeDirectEvalExpressions__: i = !0 + // Note default on + } = r, c = [...n]; + a === !0 && ae(c, Vo), s === !0 && ae(c, Ko), i === !0 && ae(c, Jo); + const { safeEvaluate: u } = Si( + t, + r + ); + return u(e, { + localTransforms: c + }); +}, { quote: Yt } = Z, Ei = (t, e, r, n, a, s) => { + const { exportsProxy: i, exportsTarget: c, activate: u } = vn( + r, + M(t, r), + n, + a + ), l = H(null); + if (e.exports) { + if (!mt(e.exports) || js(e.exports, (f) => typeof f != "string")) + throw v( + `SES third-party static module record "exports" property must be an array of strings for module ${a}` + ); + tt(e.exports, (f) => { + let m = c[f]; + const p = []; + L(c, f, { + get: () => m, + set: (w) => { + m = w; + for (const I of p) + I(w); + }, + enumerable: !0, + configurable: !1 + }), l[f] = (w) => { + ae(p, w), w(m); + }; + }), l["*"] = (f) => { + f(c); + }; + } + const d = { + activated: !1 + }; + return y({ + notifiers: l, + exportsProxy: i, + execute() { + if (lo(d, "errorFromExecute")) + throw d.errorFromExecute; + if (!d.activated) { + u(), d.activated = !0; + try { + e.execute( + c, + r, + s + ); + } catch (f) { + throw d.errorFromExecute = f, f; + } + } + } + }); +}, Pi = (t, e, r, n) => { + const { + compartment: a, + moduleSpecifier: s, + staticModuleRecord: i, + importMeta: c + } = r, { + reexports: u = [], + __syncModuleProgram__: l, + __fixedExportMap__: d = {}, + __liveExportMap__: f = {}, + __reexportMap__: m = {}, + __needsImportMeta__: p = !1, + __syncModuleFunctor__: h + } = i, _ = M(t, a), { __shimTransforms__: w, importMetaHook: I } = _, { exportsProxy: N, exportsTarget: T, activate: D } = vn( + a, + _, + e, + s + ), U = H(null), q = H(null), K = H(null), De = H(null), fe = H(null); + c && wr(fe, c), p && I && I(s, fe); + const je = H(null), Je = H(null); + tt(te(d), ([pe, [z]]) => { + let B = je[z]; + if (!B) { + let X, Q = !0, ce = []; + const J = () => { + if (Q) + throw et(`binding ${Yt(z)} not yet initialized`); + return X; + }, ve = y((_e) => { + if (!Q) + throw v( + `Internal: binding ${Yt(z)} already initialized` + ); + X = _e; + const En = ce; + ce = null, Q = !1; + for (const be of En || []) + be(_e); + return _e; + }); + B = { + get: J, + notify: (_e) => { + _e !== ve && (Q ? ae(ce || [], _e) : _e(X)); + } + }, je[z] = B, K[z] = ve; + } + U[pe] = { + get: B.get, + set: void 0, + enumerable: !0, + configurable: !1 + }, Je[pe] = B.notify; + }), tt( + te(f), + ([pe, [z, B]]) => { + let X = je[z]; + if (!X) { + let Q, ce = !0; + const J = [], ve = () => { + if (ce) + throw et( + `binding ${Yt(pe)} not yet initialized` + ); + return Q; + }, ct = y((be) => { + Q = be, ce = !1; + for (const $r of J) + $r(be); + }), _e = (be) => { + if (ce) + throw et(`binding ${Yt(z)} not yet initialized`); + Q = be; + for (const $r of J) + $r(be); + }; + X = { + get: ve, + notify: (be) => { + be !== ct && (ae(J, be), ce || be(Q)); + } + }, je[z] = X, B && L(q, z, { + get: ve, + set: _e, + enumerable: !0, + configurable: !1 + }), De[z] = ct; + } + U[pe] = { + get: X.get, + set: void 0, + enumerable: !0, + configurable: !1 + }, Je[pe] = X.notify; + } + ); + const Ue = (pe) => { + pe(T); + }; + Je["*"] = Ue; + function Kt(pe) { + const z = H(null); + z.default = !1; + for (const [B, X] of pe) { + const Q = Le(n, B); + Q.execute(); + const { notifiers: ce } = Q; + for (const [J, ve] of X) { + const ct = ce[J]; + if (!ct) + throw Gt( + `The requested module '${B}' does not provide an export named '${J}'` + ); + for (const _e of ve) + ct(_e); + } + if (Pr(u, B)) + for (const [J, ve] of te( + ce + )) + z[J] === void 0 ? z[J] = ve : z[J] = !1; + if (m[B]) + for (const [J, ve] of m[B]) + z[ve] = ce[J]; + } + for (const [B, X] of te(z)) + if (!Je[B] && X !== !1) { + Je[B] = X; + let Q; + X((J) => Q = J), U[B] = { + get() { + return Q; + }, + set: void 0, + enumerable: !0, + configurable: !1 + }; + } + tt( + mo(no(U)), + (B) => L(T, B, U[B]) + ), y(T), D(); + } + let kt; + h !== void 0 ? kt = h : kt = ss(_, l, { + globalObject: a.globalThis, + transforms: w, + __moduleShimLexicals__: q + }); + let xn = !1, Sn; + function _s() { + if (kt) { + const pe = kt; + kt = null; + try { + pe( + y({ + imports: y(Kt), + onceVar: y(K), + liveVar: y(De), + importMeta: fe + }) + ); + } catch (z) { + xn = !0, Sn = z; + } + } + if (xn) + throw Sn; + } + return y({ + notifiers: Je, + exportsProxy: N, + execute: _s + }); +}, { Fail: Qe, quote: W } = Z, as = (t, e, r, n) => { + const { name: a, moduleRecords: s } = M( + t, + r + ), i = Le(s, n); + if (i === void 0) + throw et( + `Missing link to module ${W(n)} from compartment ${W( + a + )}` + ); + return Ni(t, e, i); +}; +function ki(t) { + return typeof t.__syncModuleProgram__ == "string"; +} +function Ti(t, e) { + const { __fixedExportMap__: r, __liveExportMap__: n } = t; + He(r) || Qe`Property '__fixedExportMap__' of a precompiled module record must be an object, got ${W( + r + )}, for module ${W(e)}`, He(n) || Qe`Property '__liveExportMap__' of a precompiled module record must be an object, got ${W( + n + )}, for module ${W(e)}`; +} +function Ii(t) { + return typeof t.execute == "function"; +} +function Ai(t, e) { + const { exports: r } = t; + mt(r) || Qe`Property 'exports' of a third-party static module record must be an array, got ${W( + r + )}, for module ${W(e)}`; +} +function Ci(t, e) { + He(t) || Qe`Static module records must be of type object, got ${W( + t + )}, for module ${W(e)}`; + const { imports: r, exports: n, reexports: a = [] } = t; + mt(r) || Qe`Property 'imports' of a static module record must be an array, got ${W( + r + )}, for module ${W(e)}`, mt(n) || Qe`Property 'exports' of a precompiled module record must be an array, got ${W( + n + )}, for module ${W(e)}`, mt(a) || Qe`Property 'reexports' of a precompiled module record must be an array if present, got ${W( + a + )}, for module ${W(e)}`; +} +const Ni = (t, e, r) => { + const { compartment: n, moduleSpecifier: a, resolvedImports: s, staticModuleRecord: i } = r, { instances: c } = M(t, n); + if (kr(c, a)) + return Le(c, a); + Ci(i, a); + const u = new Ie(); + let l; + if (ki(i)) + Ti(i, a), l = Pi( + t, + e, + r, + u + ); + else if (Ii(i)) + Ai(i, a), l = Ei( + t, + i, + n, + e, + a, + s + ); + else + throw v( + `importHook must return a static module record, got ${W( + i + )}` + ); + Ae(c, a, l); + for (const [d, f] of te(s)) { + const m = as( + t, + e, + n, + f + ); + Ae(u, d, m); + } + return l; +}, { quote: Lr } = Z, Ct = new Pe(), Oe = new Pe(), Xt = (t) => { + const { importHook: e, resolveHook: r } = M(Oe, t); + if (typeof e != "function" || typeof r != "function") + throw v( + "Compartment must be constructed with an importHook and a resolveHook for it to be able to load modules" + ); +}, _n = function(e = {}, r = {}, n = {}) { + throw v( + "Compartment.prototype.constructor is not a valid constructor." + ); +}, Wn = (t, e) => { + const { execute: r, exportsProxy: n } = as( + Oe, + Ct, + t, + e + ); + return r(), n; +}, bn = { + constructor: _n, + get globalThis() { + return M(Oe, this).globalObject; + }, + get name() { + return M(Oe, this).name; + }, + /** + * @param {string} source is a JavaScript program grammar construction. + * @param {object} [options] + * @param {Array} [options.transforms] + * @param {boolean} [options.sloppyGlobalsMode] + * @param {object} [options.__moduleShimLexicals__] + * @param {boolean} [options.__evadeHtmlCommentTest__] + * @param {boolean} [options.__evadeImportExpressionTest__] + * @param {boolean} [options.__rejectSomeDirectEvalExpressions__] + */ + evaluate(t, e = {}) { + const r = M(Oe, this); + return ss(r, t, e); + }, + module(t) { + if (typeof t != "string") + throw v("first argument of module() must be a string"); + Xt(this); + const { exportsProxy: e } = vn( + this, + M(Oe, this), + Ct, + t + ); + return e; + }, + async import(t) { + if (typeof t != "string") + throw v("first argument of import() must be a string"); + return Xt(this), dn( + Vn(Oe, Ct, this, t), + () => ({ namespace: Wn( + /** @type {Compartment} */ + this, + t + ) }) + ); + }, + async load(t) { + if (typeof t != "string") + throw v("first argument of load() must be a string"); + return Xt(this), Vn(Oe, Ct, this, t); + }, + importNow(t) { + if (typeof t != "string") + throw v("first argument of importNow() must be a string"); + return Xt(this), Wn( + /** @type {Compartment} */ + this, + t + ); + } +}; +F(bn, { + [Be]: { + value: "Compartment", + writable: !1, + enumerable: !1, + configurable: !0 + } +}); +F(_n, { + prototype: { value: bn } +}); +const Kr = (t, e, r) => { + function n(a = {}, s = {}, i = {}) { + if (new.target === void 0) + throw v( + "Class constructor Compartment cannot be invoked without 'new'" + ); + const { + name: c = "", + transforms: u = [], + __shimTransforms__: l = [], + resolveHook: d, + importHook: f, + moduleMapHook: m, + importMetaHook: p + } = i, h = [...u, ...l], _ = new Ie(), w = new Ie(), I = new Ie(); + for (const [D, U] of te(s || {})) { + if (typeof U == "string") + throw v( + `Cannot map module ${Lr(D)} to ${Lr( + U + )} in parent compartment` + ); + if (M(Ct, U) === void 0) + throw et( + `Cannot map module ${Lr( + D + )} because it has no known compartment in this realm` + ); + } + const N = {}; + Da(N), Do(N); + const { safeEvaluate: T } = yn({ + globalObject: N, + globalTransforms: h, + sloppyGlobalsMode: !1 + }); + jo(N, { + intrinsics: e, + newGlobalPropertyNames: Oo, + makeCompartmentConstructor: t, + markVirtualizedNativeFunction: r + }), Wr( + N, + T, + r + ), wr(N, a), ee(Oe, this, { + name: `${c}`, + globalTransforms: h, + globalObject: N, + safeEvaluate: T, + resolveHook: d, + importHook: f, + moduleMap: s, + moduleMapHook: m, + importMetaHook: p, + moduleRecords: _, + __shimTransforms__: l, + deferredExports: I, + instances: w + }); + } + return n.prototype = bn, n; +}; +function Fr(t) { + return G(t).constructor; +} +function $i() { + return arguments; +} +const Oi = () => { + const t = ye.prototype.constructor, e = ue($i(), "callee"), r = e && e.get, n = Ks(new ie()), a = G(n), s = Sr[io] && Hs(/./), i = s && G(s), c = Us([]), u = G(c), l = G(xs), d = Bs(new Ie()), f = G(d), m = Gs(new wt()), p = G(m), h = G(u); + function* _() { + } + const w = Fr(_), I = w.prototype; + async function* N() { + } + const T = Fr( + N + ), D = T.prototype, U = D.prototype, q = G(U); + async function K() { + } + const De = Fr(K), fe = { + "%InertFunction%": t, + "%ArrayIteratorPrototype%": u, + "%InertAsyncFunction%": De, + "%AsyncGenerator%": D, + "%InertAsyncGeneratorFunction%": T, + "%AsyncGeneratorPrototype%": U, + "%AsyncIteratorPrototype%": q, + "%Generator%": I, + "%InertGeneratorFunction%": w, + "%IteratorPrototype%": h, + "%MapIteratorPrototype%": f, + "%RegExpStringIteratorPrototype%": i, + "%SetIteratorPrototype%": p, + "%StringIteratorPrototype%": a, + "%ThrowTypeError%": r, + "%TypedArray%": l, + "%InertCompartment%": _n + }; + return E.Iterator && (fe["%IteratorHelperPrototype%"] = G( + // eslint-disable-next-line @endo/no-polymorphic-call + E.Iterator.from([]).take(0) + ), fe["%WrapForValidIteratorPrototype%"] = G( + // eslint-disable-next-line @endo/no-polymorphic-call + E.Iterator.from({ next() { + } }) + )), E.AsyncIterator && (fe["%AsyncIteratorHelperPrototype%"] = G( + // eslint-disable-next-line @endo/no-polymorphic-call + E.AsyncIterator.from([]).take(0) + ), fe["%WrapForValidAsyncIteratorPrototype%"] = G( + // eslint-disable-next-line @endo/no-polymorphic-call + E.AsyncIterator.from({ next() { + } }) + )), fe; +}, is = (t, e) => { + if (e !== "safe" && e !== "unsafe") + throw v(`unrecognized fakeHardenOption ${e}`); + if (e === "safe" || (Object.isExtensible = () => !1, Object.isFrozen = () => !0, Object.isSealed = () => !0, Reflect.isExtensible = () => !1, t.isFake)) + return t; + const r = (n) => n; + return r.isFake = !0, y(r); +}; +y(is); +const Ri = () => { + const t = At, e = t.prototype, r = { + Symbol(s) { + return t(s); + } + }.Symbol; + F(e, { + constructor: { + value: r + // leave other `constructor` attributes as is + } + }); + const n = te( + Ke(t) + ), a = St( + de(n, ([s, i]) => [ + s, + { ...i, configurable: !0 } + ]) + ); + return F(r, a), { "%SharedSymbol%": r }; +}, Mi = (t) => { + try { + return t(), !1; + } catch { + return !0; + } +}, qn = (t, e, r) => { + if (t === void 0) + return !1; + const n = ue(t, e); + if (!n || "value" in n) + return !1; + const { get: a, set: s } = n; + if (typeof a != "function" || typeof s != "function" || a() !== r || oe(a, t, []) !== r) + return !1; + const i = "Seems to be a setter", c = { __proto__: null }; + if (oe(s, c, [i]), c[e] !== i) + return !1; + const u = { __proto__: t }; + return oe(s, u, [i]), u[e] !== i || !Mi(() => oe(s, t, [r])) || "originalValue" in a || n.configurable === !1 ? !1 : (L(t, e, { + value: r, + writable: !0, + enumerable: n.enumerable, + configurable: !0 + }), !0); +}, Li = (t) => { + qn( + t["%IteratorPrototype%"], + "constructor", + t.Iterator + ), qn( + t["%IteratorPrototype%"], + Be, + "Iterator" + ); +}, { Fail: Kn, details: Jn, quote: Yn } = Z; +let Qt, er; +const Fi = ya(), Di = () => { + let t = !1; + try { + t = ye( + "eval", + "SES_changed", + ` eval("SES_changed = true"); + return SES_changed; + ` + )(vo, !1), t || delete E.SES_changed; + } catch { + t = !0; + } + if (!t) + throw v( + "SES cannot initialize unless 'eval' is the original intrinsic 'eval', suitable for direct-eval (dynamically scoped eval) (SES_DIRECT_EVAL)" + ); +}, cs = (t = {}) => { + const { + errorTaming: e = me("LOCKDOWN_ERROR_TAMING", "safe"), + errorTrapping: r = ( + /** @type {"platform" | "none" | "report" | "abort" | "exit" | undefined} */ + me("LOCKDOWN_ERROR_TRAPPING", "platform") + ), + unhandledRejectionTrapping: n = ( + /** @type {"none" | "report" | undefined} */ + me("LOCKDOWN_UNHANDLED_REJECTION_TRAPPING", "report") + ), + regExpTaming: a = me("LOCKDOWN_REGEXP_TAMING", "safe"), + localeTaming: s = me("LOCKDOWN_LOCALE_TAMING", "safe"), + consoleTaming: i = ( + /** @type {'unsafe' | 'safe' | undefined} */ + me("LOCKDOWN_CONSOLE_TAMING", "safe") + ), + overrideTaming: c = me("LOCKDOWN_OVERRIDE_TAMING", "moderate"), + stackFiltering: u = me("LOCKDOWN_STACK_FILTERING", "concise"), + domainTaming: l = me("LOCKDOWN_DOMAIN_TAMING", "safe"), + evalTaming: d = me("LOCKDOWN_EVAL_TAMING", "safeEval"), + overrideDebug: f = Ge( + go(me("LOCKDOWN_OVERRIDE_DEBUG", ""), ","), + /** @param {string} debugName */ + (Ue) => Ue !== "" + ), + __hardenTaming__: m = me("LOCKDOWN_HARDEN_TAMING", "safe"), + dateTaming: p = "safe", + // deprecated + mathTaming: h = "safe", + // deprecated + ..._ + } = t; + d === "unsafeEval" || d === "safeEval" || d === "noEval" || Kn`lockdown(): non supported option evalTaming: ${Yn(d)}`; + const w = nt(_); + if (w.length === 0 || Kn`lockdown(): non supported option ${Yn(w)}`, Qt === void 0 || // eslint-disable-next-line @endo/no-polymorphic-call + Z.fail( + Jn`Already locked down at ${Qt} (SES_ALREADY_LOCKED_DOWN)`, + v + ), Qt = v("Prior lockdown (SES_ALREADY_LOCKED_DOWN)"), Qt.stack, Di(), E.Function.prototype.constructor !== E.Function && // @ts-ignore harden is absent on globalThis type def. + typeof E.harden == "function" && // @ts-ignore lockdown is absent on globalThis type def. + typeof E.lockdown == "function" && E.Date.prototype.constructor !== E.Date && typeof E.Date.now == "function" && // @ts-ignore does not recognize that Date constructor is a special + // Function. + // eslint-disable-next-line @endo/no-polymorphic-call + xr(E.Date.prototype.constructor.now(), NaN)) + throw v( + "Already locked down but not by this SES instance (SES_MULTIPLE_INSTANCES)" + ); + Xa(l); + const N = Qo(), { addIntrinsics: T, completePrototypes: D, finalIntrinsics: U } = Mo(), q = is(Fi, m); + T({ harden: q }), T(Pa()), T(ka(p)), T(yi(e, u)), T(Ta(h)), T(Ia(a)), T(Ri()), T(Oi()), D(); + const K = U(), De = { __proto__: null }; + typeof E.Buffer == "function" && (De.Buffer = E.Buffer); + let fe; + e !== "unsafe" && (fe = K["%InitialGetStackString%"]); + const je = ti( + i, + r, + n, + fe + ); + if (E.console = /** @type {Console} */ + je.console, typeof /** @type {any} */ + je.console._times == "object" && (De.SafeMap = G( + // eslint-disable-next-line no-underscore-dangle + /** @type {any} */ + je.console._times + )), e === "unsafe" && E.assert === Z && (E.assert = Cr(void 0, !0)), Ma(K, s), Li(K), Ea(K, N), Do(E), jo(E, { + intrinsics: K, + newGlobalPropertyNames: $n, + makeCompartmentConstructor: Kr, + markVirtualizedNativeFunction: N + }), d === "noEval") + Wr( + E, + ea, + N + ); + else if (d === "safeEval") { + const { safeEvaluate: Ue } = yn({ globalObject: E }); + Wr( + E, + Ue, + N + ); + } + return () => { + er === void 0 || // eslint-disable-next-line @endo/no-polymorphic-call + Z.fail( + Jn`Already locked down at ${er} (SES_ALREADY_LOCKED_DOWN)`, + v + ), er = v( + "Prior lockdown (SES_ALREADY_LOCKED_DOWN)" + ), er.stack, Na(K, c, f); + const Ue = { + intrinsics: K, + hostIntrinsics: De, + globals: { + // Harden evaluators + Function: E.Function, + eval: E.eval, + // @ts-ignore Compartment does exist on globalThis + Compartment: E.Compartment, + // Harden Symbol + Symbol: E.Symbol + } + }; + for (const Kt of Nt($n)) + Ue.globals[Kt] = E[Kt]; + return q(Ue), q; + }; +}; +E.lockdown = (t) => { + const e = cs(t); + E.harden = e(); +}; +E.repairIntrinsics = (t) => { + const e = cs(t); + E.hardenIntrinsics = () => { + E.harden = e(); + }; +}; +const ji = Qo(); +E.Compartment = Kr( + Kr, + Sa(E), + ji +); +E.assert = Z; +const Ui = ` +`; +class Zi extends HTMLElement { + constructor() { + super(), this.attachShadow({ mode: "open" }); + } + connectedCallback() { + const e = this.getAttribute("title"), r = this.getAttribute("iframe-src"), n = Number(this.getAttribute("width") || "300"), a = Number(this.getAttribute("height") || "400"); + if (!e || !r) + throw new Error("title and iframe-src attributes are required"); + if (!this.shadowRoot) + throw new Error("Error creating shadow root"); + const s = document.createElement("div"); + s.classList.add("header"); + const i = document.createElement("h1"); + i.textContent = e, s.appendChild(i); + const c = document.createElement("button"); + c.setAttribute("type", "button"), c.innerHTML = `
${Ui}
`, c.addEventListener("click", () => { + this.shadowRoot && this.shadowRoot.dispatchEvent( + new CustomEvent("close", { + composed: !0, + bubbles: !0 + }) + ); + }), s.appendChild(c); + const u = document.createElement("iframe"); + u.src = r, u.allow = "", u.sandbox.add( + "allow-scripts", + "allow-forms", + "allow-modals", + "allow-popups", + "allow-popups-to-escape-sandbox", + "allow-storage-access-by-user-activation" + ), this.addEventListener("message", (d) => { + u.contentWindow && u.contentWindow.postMessage(d.detail, "*"); + }), this.shadowRoot.appendChild(s), this.shadowRoot.appendChild(u); + const l = document.createElement("style"); + l.textContent = ` + :host { + display: flex; + flex-direction: column; + position: fixed; + inset-block-end: 10px; + inset-inline-start: 10px; + z-index: 1000; + padding: 20px; + border-radius: 20px; + box-shadow: 0 4px 8px rgba(0,0,0,0.1); + inline-size: ${n}px; + block-size: ${a}px; + } + + :host([data-theme="dark"]) { + background: #2e3434; + border: 1px solid #2e3434; + color: #ffffff; + } + + :host([data-theme="light"]) { + background: #ffffff; + border: 1px solid #eef0f2; + color: #18181a; + } + + .header { + display: flex; + justify-content: space-between; + } + + button { + background: transparent; + border: 0; + cursor: pointer; + } + + h1 { + font-family: Arial, sans-serif; + margin: 0; + margin-block-end: 10px; + } + + iframe { + border: none; + inline-size: 100%; + block-size: 100%; + } + `, this.shadowRoot.appendChild(l); + } +} +customElements.define("plugin-modal", Zi); +var R; +(function(t) { + t.assertEqual = (a) => a; + function e(a) { + } + t.assertIs = e; + function r(a) { + throw new Error(); + } + t.assertNever = r, t.arrayToEnum = (a) => { + const s = {}; + for (const i of a) + s[i] = i; + return s; + }, t.getValidEnumValues = (a) => { + const s = t.objectKeys(a).filter((c) => typeof a[a[c]] != "number"), i = {}; + for (const c of s) + i[c] = a[c]; + return t.objectValues(i); + }, t.objectValues = (a) => t.objectKeys(a).map(function(s) { + return a[s]; + }), t.objectKeys = typeof Object.keys == "function" ? (a) => Object.keys(a) : (a) => { + const s = []; + for (const i in a) + Object.prototype.hasOwnProperty.call(a, i) && s.push(i); + return s; + }, t.find = (a, s) => { + for (const i of a) + if (s(i)) + return i; + }, t.isInteger = typeof Number.isInteger == "function" ? (a) => Number.isInteger(a) : (a) => typeof a == "number" && isFinite(a) && Math.floor(a) === a; + function n(a, s = " | ") { + return a.map((i) => typeof i == "string" ? `'${i}'` : i).join(s); + } + t.joinValues = n, t.jsonStringifyReplacer = (a, s) => typeof s == "bigint" ? s.toString() : s; +})(R || (R = {})); +var Jr; +(function(t) { + t.mergeShapes = (e, r) => ({ + ...e, + ...r + // second overwrites first + }); +})(Jr || (Jr = {})); +const b = R.arrayToEnum([ + "string", + "nan", + "number", + "integer", + "float", + "boolean", + "date", + "bigint", + "symbol", + "function", + "undefined", + "null", + "array", + "object", + "unknown", + "promise", + "void", + "never", + "map", + "set" +]), Ze = (t) => { + switch (typeof t) { + case "undefined": + return b.undefined; + case "string": + return b.string; + case "number": + return isNaN(t) ? b.nan : b.number; + case "boolean": + return b.boolean; + case "function": + return b.function; + case "bigint": + return b.bigint; + case "symbol": + return b.symbol; + case "object": + return Array.isArray(t) ? b.array : t === null ? b.null : t.then && typeof t.then == "function" && t.catch && typeof t.catch == "function" ? b.promise : typeof Map < "u" && t instanceof Map ? b.map : typeof Set < "u" && t instanceof Set ? b.set : typeof Date < "u" && t instanceof Date ? b.date : b.object; + default: + return b.unknown; + } +}, g = R.arrayToEnum([ + "invalid_type", + "invalid_literal", + "custom", + "invalid_union", + "invalid_union_discriminator", + "invalid_enum_value", + "unrecognized_keys", + "invalid_arguments", + "invalid_return_type", + "invalid_date", + "invalid_string", + "too_small", + "too_big", + "invalid_intersection_types", + "not_multiple_of", + "not_finite" +]), zi = (t) => JSON.stringify(t, null, 2).replace(/"([^"]+)":/g, "$1:"); +class xe extends Error { + constructor(e) { + super(), this.issues = [], this.addIssue = (n) => { + this.issues = [...this.issues, n]; + }, this.addIssues = (n = []) => { + this.issues = [...this.issues, ...n]; + }; + const r = new.target.prototype; + Object.setPrototypeOf ? Object.setPrototypeOf(this, r) : this.__proto__ = r, this.name = "ZodError", this.issues = e; + } + get errors() { + return this.issues; + } + format(e) { + const r = e || function(s) { + return s.message; + }, n = { _errors: [] }, a = (s) => { + for (const i of s.issues) + if (i.code === "invalid_union") + i.unionErrors.map(a); + else if (i.code === "invalid_return_type") + a(i.returnTypeError); + else if (i.code === "invalid_arguments") + a(i.argumentsError); + else if (i.path.length === 0) + n._errors.push(r(i)); + else { + let c = n, u = 0; + for (; u < i.path.length; ) { + const l = i.path[u]; + u === i.path.length - 1 ? (c[l] = c[l] || { _errors: [] }, c[l]._errors.push(r(i))) : c[l] = c[l] || { _errors: [] }, c = c[l], u++; + } + } + }; + return a(this), n; + } + toString() { + return this.message; + } + get message() { + return JSON.stringify(this.issues, R.jsonStringifyReplacer, 2); + } + get isEmpty() { + return this.issues.length === 0; + } + flatten(e = (r) => r.message) { + const r = {}, n = []; + for (const a of this.issues) + a.path.length > 0 ? (r[a.path[0]] = r[a.path[0]] || [], r[a.path[0]].push(e(a))) : n.push(e(a)); + return { formErrors: n, fieldErrors: r }; + } + get formErrors() { + return this.flatten(); + } +} +xe.create = (t) => new xe(t); +const $t = (t, e) => { + let r; + switch (t.code) { + case g.invalid_type: + t.received === b.undefined ? r = "Required" : r = `Expected ${t.expected}, received ${t.received}`; + break; + case g.invalid_literal: + r = `Invalid literal value, expected ${JSON.stringify(t.expected, R.jsonStringifyReplacer)}`; + break; + case g.unrecognized_keys: + r = `Unrecognized key(s) in object: ${R.joinValues(t.keys, ", ")}`; + break; + case g.invalid_union: + r = "Invalid input"; + break; + case g.invalid_union_discriminator: + r = `Invalid discriminator value. Expected ${R.joinValues(t.options)}`; + break; + case g.invalid_enum_value: + r = `Invalid enum value. Expected ${R.joinValues(t.options)}, received '${t.received}'`; + break; + case g.invalid_arguments: + r = "Invalid function arguments"; + break; + case g.invalid_return_type: + r = "Invalid function return type"; + break; + case g.invalid_date: + r = "Invalid date"; + break; + case g.invalid_string: + typeof t.validation == "object" ? "includes" in t.validation ? (r = `Invalid input: must include "${t.validation.includes}"`, typeof t.validation.position == "number" && (r = `${r} at one or more positions greater than or equal to ${t.validation.position}`)) : "startsWith" in t.validation ? r = `Invalid input: must start with "${t.validation.startsWith}"` : "endsWith" in t.validation ? r = `Invalid input: must end with "${t.validation.endsWith}"` : R.assertNever(t.validation) : t.validation !== "regex" ? r = `Invalid ${t.validation}` : r = "Invalid"; + break; + case g.too_small: + t.type === "array" ? r = `Array must contain ${t.exact ? "exactly" : t.inclusive ? "at least" : "more than"} ${t.minimum} element(s)` : t.type === "string" ? r = `String must contain ${t.exact ? "exactly" : t.inclusive ? "at least" : "over"} ${t.minimum} character(s)` : t.type === "number" ? r = `Number must be ${t.exact ? "exactly equal to " : t.inclusive ? "greater than or equal to " : "greater than "}${t.minimum}` : t.type === "date" ? r = `Date must be ${t.exact ? "exactly equal to " : t.inclusive ? "greater than or equal to " : "greater than "}${new Date(Number(t.minimum))}` : r = "Invalid input"; + break; + case g.too_big: + t.type === "array" ? r = `Array must contain ${t.exact ? "exactly" : t.inclusive ? "at most" : "less than"} ${t.maximum} element(s)` : t.type === "string" ? r = `String must contain ${t.exact ? "exactly" : t.inclusive ? "at most" : "under"} ${t.maximum} character(s)` : t.type === "number" ? r = `Number must be ${t.exact ? "exactly" : t.inclusive ? "less than or equal to" : "less than"} ${t.maximum}` : t.type === "bigint" ? r = `BigInt must be ${t.exact ? "exactly" : t.inclusive ? "less than or equal to" : "less than"} ${t.maximum}` : t.type === "date" ? r = `Date must be ${t.exact ? "exactly" : t.inclusive ? "smaller than or equal to" : "smaller than"} ${new Date(Number(t.maximum))}` : r = "Invalid input"; + break; + case g.custom: + r = "Invalid input"; + break; + case g.invalid_intersection_types: + r = "Intersection results could not be merged"; + break; + case g.not_multiple_of: + r = `Number must be a multiple of ${t.multipleOf}`; + break; + case g.not_finite: + r = "Number must be finite"; + break; + default: + r = e.defaultError, R.assertNever(t); + } + return { message: r }; +}; +let ls = $t; +function Bi(t) { + ls = t; +} +function dr() { + return ls; +} +const fr = (t) => { + const { data: e, path: r, errorMaps: n, issueData: a } = t, s = [...r, ...a.path || []], i = { + ...a, + path: s + }; + let c = ""; + const u = n.filter((l) => !!l).slice().reverse(); + for (const l of u) + c = l(i, { data: e, defaultError: c }).message; + return { + ...a, + path: s, + message: a.message || c + }; +}, Gi = []; +function x(t, e) { + const r = fr({ + issueData: e, + data: t.data, + path: t.path, + errorMaps: [ + t.common.contextualErrorMap, + t.schemaErrorMap, + dr(), + $t + // then global default map + ].filter((n) => !!n) + }); + t.common.issues.push(r); +} +class Y { + constructor() { + this.value = "valid"; + } + dirty() { + this.value === "valid" && (this.value = "dirty"); + } + abort() { + this.value !== "aborted" && (this.value = "aborted"); + } + static mergeArray(e, r) { + const n = []; + for (const a of r) { + if (a.status === "aborted") + return A; + a.status === "dirty" && e.dirty(), n.push(a.value); + } + return { status: e.value, value: n }; + } + static async mergeObjectAsync(e, r) { + const n = []; + for (const a of r) + n.push({ + key: await a.key, + value: await a.value + }); + return Y.mergeObjectSync(e, n); + } + static mergeObjectSync(e, r) { + const n = {}; + for (const a of r) { + const { key: s, value: i } = a; + if (s.status === "aborted" || i.status === "aborted") + return A; + s.status === "dirty" && e.dirty(), i.status === "dirty" && e.dirty(), s.value !== "__proto__" && (typeof i.value < "u" || a.alwaysSet) && (n[s.value] = i.value); + } + return { status: e.value, value: n }; + } +} +const A = Object.freeze({ + status: "aborted" +}), us = (t) => ({ status: "dirty", value: t }), re = (t) => ({ status: "valid", value: t }), Yr = (t) => t.status === "aborted", Xr = (t) => t.status === "dirty", Ot = (t) => t.status === "valid", pr = (t) => typeof Promise < "u" && t instanceof Promise; +var S; +(function(t) { + t.errToObj = (e) => typeof e == "string" ? { message: e } : e || {}, t.toString = (e) => typeof e == "string" ? e : e == null ? void 0 : e.message; +})(S || (S = {})); +class Ce { + constructor(e, r, n, a) { + this._cachedPath = [], this.parent = e, this.data = r, this._path = n, this._key = a; + } + get path() { + return this._cachedPath.length || (this._key instanceof Array ? this._cachedPath.push(...this._path, ...this._key) : this._cachedPath.push(...this._path, this._key)), this._cachedPath; + } +} +const Xn = (t, e) => { + if (Ot(e)) + return { success: !0, data: e.value }; + if (!t.common.issues.length) + throw new Error("Validation failed but no issues detected."); + return { + success: !1, + get error() { + if (this._error) + return this._error; + const r = new xe(t.common.issues); + return this._error = r, this._error; + } + }; +}; +function C(t) { + if (!t) + return {}; + const { errorMap: e, invalid_type_error: r, required_error: n, description: a } = t; + if (e && (r || n)) + throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`); + return e ? { errorMap: e, description: a } : { errorMap: (i, c) => i.code !== "invalid_type" ? { message: c.defaultError } : typeof c.data > "u" ? { message: n ?? c.defaultError } : { message: r ?? c.defaultError }, description: a }; +} +class $ { + constructor(e) { + this.spa = this.safeParseAsync, this._def = e, this.parse = this.parse.bind(this), this.safeParse = this.safeParse.bind(this), this.parseAsync = this.parseAsync.bind(this), this.safeParseAsync = this.safeParseAsync.bind(this), this.spa = this.spa.bind(this), this.refine = this.refine.bind(this), this.refinement = this.refinement.bind(this), this.superRefine = this.superRefine.bind(this), this.optional = this.optional.bind(this), this.nullable = this.nullable.bind(this), this.nullish = this.nullish.bind(this), this.array = this.array.bind(this), this.promise = this.promise.bind(this), this.or = this.or.bind(this), this.and = this.and.bind(this), this.transform = this.transform.bind(this), this.brand = this.brand.bind(this), this.default = this.default.bind(this), this.catch = this.catch.bind(this), this.describe = this.describe.bind(this), this.pipe = this.pipe.bind(this), this.readonly = this.readonly.bind(this), this.isNullable = this.isNullable.bind(this), this.isOptional = this.isOptional.bind(this); + } + get description() { + return this._def.description; + } + _getType(e) { + return Ze(e.data); + } + _getOrReturnCtx(e, r) { + return r || { + common: e.parent.common, + data: e.data, + parsedType: Ze(e.data), + schemaErrorMap: this._def.errorMap, + path: e.path, + parent: e.parent + }; + } + _processInputParams(e) { + return { + status: new Y(), + ctx: { + common: e.parent.common, + data: e.data, + parsedType: Ze(e.data), + schemaErrorMap: this._def.errorMap, + path: e.path, + parent: e.parent + } + }; + } + _parseSync(e) { + const r = this._parse(e); + if (pr(r)) + throw new Error("Synchronous parse encountered promise."); + return r; + } + _parseAsync(e) { + const r = this._parse(e); + return Promise.resolve(r); + } + parse(e, r) { + const n = this.safeParse(e, r); + if (n.success) + return n.data; + throw n.error; + } + safeParse(e, r) { + var n; + const a = { + common: { + issues: [], + async: (n = r == null ? void 0 : r.async) !== null && n !== void 0 ? n : !1, + contextualErrorMap: r == null ? void 0 : r.errorMap + }, + path: (r == null ? void 0 : r.path) || [], + schemaErrorMap: this._def.errorMap, + parent: null, + data: e, + parsedType: Ze(e) + }, s = this._parseSync({ data: e, path: a.path, parent: a }); + return Xn(a, s); + } + async parseAsync(e, r) { + const n = await this.safeParseAsync(e, r); + if (n.success) + return n.data; + throw n.error; + } + async safeParseAsync(e, r) { + const n = { + common: { + issues: [], + contextualErrorMap: r == null ? void 0 : r.errorMap, + async: !0 + }, + path: (r == null ? void 0 : r.path) || [], + schemaErrorMap: this._def.errorMap, + parent: null, + data: e, + parsedType: Ze(e) + }, a = this._parse({ data: e, path: n.path, parent: n }), s = await (pr(a) ? a : Promise.resolve(a)); + return Xn(n, s); + } + refine(e, r) { + const n = (a) => typeof r == "string" || typeof r > "u" ? { message: r } : typeof r == "function" ? r(a) : r; + return this._refinement((a, s) => { + const i = e(a), c = () => s.addIssue({ + code: g.custom, + ...n(a) + }); + return typeof Promise < "u" && i instanceof Promise ? i.then((u) => u ? !0 : (c(), !1)) : i ? !0 : (c(), !1); + }); + } + refinement(e, r) { + return this._refinement((n, a) => e(n) ? !0 : (a.addIssue(typeof r == "function" ? r(n, a) : r), !1)); + } + _refinement(e) { + return new Ee({ + schema: this, + typeName: P.ZodEffects, + effect: { type: "refinement", refinement: e } + }); + } + superRefine(e) { + return this._refinement(e); + } + optional() { + return Me.create(this, this._def); + } + nullable() { + return it.create(this, this._def); + } + nullish() { + return this.nullable().optional(); + } + array() { + return Se.create(this, this._def); + } + promise() { + return bt.create(this, this._def); + } + or(e) { + return Ft.create([this, e], this._def); + } + and(e) { + return Dt.create(this, e, this._def); + } + transform(e) { + return new Ee({ + ...C(this._def), + schema: this, + typeName: P.ZodEffects, + effect: { type: "transform", transform: e } + }); + } + default(e) { + const r = typeof e == "function" ? e : () => e; + return new Bt({ + ...C(this._def), + innerType: this, + defaultValue: r, + typeName: P.ZodDefault + }); + } + brand() { + return new fs({ + typeName: P.ZodBranded, + type: this, + ...C(this._def) + }); + } + catch(e) { + const r = typeof e == "function" ? e : () => e; + return new yr({ + ...C(this._def), + innerType: this, + catchValue: r, + typeName: P.ZodCatch + }); + } + describe(e) { + const r = this.constructor; + return new r({ + ...this._def, + description: e + }); + } + pipe(e) { + return qt.create(this, e); + } + readonly() { + return _r.create(this); + } + isOptional() { + return this.safeParse(void 0).success; + } + isNullable() { + return this.safeParse(null).success; + } +} +const Hi = /^c[^\s-]{8,}$/i, Vi = /^[a-z][a-z0-9]*$/, Wi = /^[0-9A-HJKMNP-TV-Z]{26}$/, qi = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/i, Ki = /^(?!\.)(?!.*\.\.)([A-Z0-9_+-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i, Ji = "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$"; +let Dr; +const Yi = /^(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))$/, Xi = /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/, Qi = (t) => t.precision ? t.offset ? new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{${t.precision}}(([+-]\\d{2}(:?\\d{2})?)|Z)$`) : new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{${t.precision}}Z$`) : t.precision === 0 ? t.offset ? new RegExp("^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(([+-]\\d{2}(:?\\d{2})?)|Z)$") : new RegExp("^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}Z$") : t.offset ? new RegExp("^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(([+-]\\d{2}(:?\\d{2})?)|Z)$") : new RegExp("^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?Z$"); +function ec(t, e) { + return !!((e === "v4" || !e) && Yi.test(t) || (e === "v6" || !e) && Xi.test(t)); +} +class we extends $ { + _parse(e) { + if (this._def.coerce && (e.data = String(e.data)), this._getType(e) !== b.string) { + const s = this._getOrReturnCtx(e); + return x( + s, + { + code: g.invalid_type, + expected: b.string, + received: s.parsedType + } + // + ), A; + } + const n = new Y(); + let a; + for (const s of this._def.checks) + if (s.kind === "min") + e.data.length < s.value && (a = this._getOrReturnCtx(e, a), x(a, { + code: g.too_small, + minimum: s.value, + type: "string", + inclusive: !0, + exact: !1, + message: s.message + }), n.dirty()); + else if (s.kind === "max") + e.data.length > s.value && (a = this._getOrReturnCtx(e, a), x(a, { + code: g.too_big, + maximum: s.value, + type: "string", + inclusive: !0, + exact: !1, + message: s.message + }), n.dirty()); + else if (s.kind === "length") { + const i = e.data.length > s.value, c = e.data.length < s.value; + (i || c) && (a = this._getOrReturnCtx(e, a), i ? x(a, { + code: g.too_big, + maximum: s.value, + type: "string", + inclusive: !0, + exact: !0, + message: s.message + }) : c && x(a, { + code: g.too_small, + minimum: s.value, + type: "string", + inclusive: !0, + exact: !0, + message: s.message + }), n.dirty()); + } else if (s.kind === "email") + Ki.test(e.data) || (a = this._getOrReturnCtx(e, a), x(a, { + validation: "email", + code: g.invalid_string, + message: s.message + }), n.dirty()); + else if (s.kind === "emoji") + Dr || (Dr = new RegExp(Ji, "u")), Dr.test(e.data) || (a = this._getOrReturnCtx(e, a), x(a, { + validation: "emoji", + code: g.invalid_string, + message: s.message + }), n.dirty()); + else if (s.kind === "uuid") + qi.test(e.data) || (a = this._getOrReturnCtx(e, a), x(a, { + validation: "uuid", + code: g.invalid_string, + message: s.message + }), n.dirty()); + else if (s.kind === "cuid") + Hi.test(e.data) || (a = this._getOrReturnCtx(e, a), x(a, { + validation: "cuid", + code: g.invalid_string, + message: s.message + }), n.dirty()); + else if (s.kind === "cuid2") + Vi.test(e.data) || (a = this._getOrReturnCtx(e, a), x(a, { + validation: "cuid2", + code: g.invalid_string, + message: s.message + }), n.dirty()); + else if (s.kind === "ulid") + Wi.test(e.data) || (a = this._getOrReturnCtx(e, a), x(a, { + validation: "ulid", + code: g.invalid_string, + message: s.message + }), n.dirty()); + else if (s.kind === "url") + try { + new URL(e.data); + } catch { + a = this._getOrReturnCtx(e, a), x(a, { + validation: "url", + code: g.invalid_string, + message: s.message + }), n.dirty(); + } + else + s.kind === "regex" ? (s.regex.lastIndex = 0, s.regex.test(e.data) || (a = this._getOrReturnCtx(e, a), x(a, { + validation: "regex", + code: g.invalid_string, + message: s.message + }), n.dirty())) : s.kind === "trim" ? e.data = e.data.trim() : s.kind === "includes" ? e.data.includes(s.value, s.position) || (a = this._getOrReturnCtx(e, a), x(a, { + code: g.invalid_string, + validation: { includes: s.value, position: s.position }, + message: s.message + }), n.dirty()) : s.kind === "toLowerCase" ? e.data = e.data.toLowerCase() : s.kind === "toUpperCase" ? e.data = e.data.toUpperCase() : s.kind === "startsWith" ? e.data.startsWith(s.value) || (a = this._getOrReturnCtx(e, a), x(a, { + code: g.invalid_string, + validation: { startsWith: s.value }, + message: s.message + }), n.dirty()) : s.kind === "endsWith" ? e.data.endsWith(s.value) || (a = this._getOrReturnCtx(e, a), x(a, { + code: g.invalid_string, + validation: { endsWith: s.value }, + message: s.message + }), n.dirty()) : s.kind === "datetime" ? Qi(s).test(e.data) || (a = this._getOrReturnCtx(e, a), x(a, { + code: g.invalid_string, + validation: "datetime", + message: s.message + }), n.dirty()) : s.kind === "ip" ? ec(e.data, s.version) || (a = this._getOrReturnCtx(e, a), x(a, { + validation: "ip", + code: g.invalid_string, + message: s.message + }), n.dirty()) : R.assertNever(s); + return { status: n.value, value: e.data }; + } + _regex(e, r, n) { + return this.refinement((a) => e.test(a), { + validation: r, + code: g.invalid_string, + ...S.errToObj(n) + }); + } + _addCheck(e) { + return new we({ + ...this._def, + checks: [...this._def.checks, e] + }); + } + email(e) { + return this._addCheck({ kind: "email", ...S.errToObj(e) }); + } + url(e) { + return this._addCheck({ kind: "url", ...S.errToObj(e) }); + } + emoji(e) { + return this._addCheck({ kind: "emoji", ...S.errToObj(e) }); + } + uuid(e) { + return this._addCheck({ kind: "uuid", ...S.errToObj(e) }); + } + cuid(e) { + return this._addCheck({ kind: "cuid", ...S.errToObj(e) }); + } + cuid2(e) { + return this._addCheck({ kind: "cuid2", ...S.errToObj(e) }); + } + ulid(e) { + return this._addCheck({ kind: "ulid", ...S.errToObj(e) }); + } + ip(e) { + return this._addCheck({ kind: "ip", ...S.errToObj(e) }); + } + datetime(e) { + var r; + return typeof e == "string" ? this._addCheck({ + kind: "datetime", + precision: null, + offset: !1, + message: e + }) : this._addCheck({ + kind: "datetime", + precision: typeof (e == null ? void 0 : e.precision) > "u" ? null : e == null ? void 0 : e.precision, + offset: (r = e == null ? void 0 : e.offset) !== null && r !== void 0 ? r : !1, + ...S.errToObj(e == null ? void 0 : e.message) + }); + } + regex(e, r) { + return this._addCheck({ + kind: "regex", + regex: e, + ...S.errToObj(r) + }); + } + includes(e, r) { + return this._addCheck({ + kind: "includes", + value: e, + position: r == null ? void 0 : r.position, + ...S.errToObj(r == null ? void 0 : r.message) + }); + } + startsWith(e, r) { + return this._addCheck({ + kind: "startsWith", + value: e, + ...S.errToObj(r) + }); + } + endsWith(e, r) { + return this._addCheck({ + kind: "endsWith", + value: e, + ...S.errToObj(r) + }); + } + min(e, r) { + return this._addCheck({ + kind: "min", + value: e, + ...S.errToObj(r) + }); + } + max(e, r) { + return this._addCheck({ + kind: "max", + value: e, + ...S.errToObj(r) + }); + } + length(e, r) { + return this._addCheck({ + kind: "length", + value: e, + ...S.errToObj(r) + }); + } + /** + * @deprecated Use z.string().min(1) instead. + * @see {@link ZodString.min} + */ + nonempty(e) { + return this.min(1, S.errToObj(e)); + } + trim() { + return new we({ + ...this._def, + checks: [...this._def.checks, { kind: "trim" }] + }); + } + toLowerCase() { + return new we({ + ...this._def, + checks: [...this._def.checks, { kind: "toLowerCase" }] + }); + } + toUpperCase() { + return new we({ + ...this._def, + checks: [...this._def.checks, { kind: "toUpperCase" }] + }); + } + get isDatetime() { + return !!this._def.checks.find((e) => e.kind === "datetime"); + } + get isEmail() { + return !!this._def.checks.find((e) => e.kind === "email"); + } + get isURL() { + return !!this._def.checks.find((e) => e.kind === "url"); + } + get isEmoji() { + return !!this._def.checks.find((e) => e.kind === "emoji"); + } + get isUUID() { + return !!this._def.checks.find((e) => e.kind === "uuid"); + } + get isCUID() { + return !!this._def.checks.find((e) => e.kind === "cuid"); + } + get isCUID2() { + return !!this._def.checks.find((e) => e.kind === "cuid2"); + } + get isULID() { + return !!this._def.checks.find((e) => e.kind === "ulid"); + } + get isIP() { + return !!this._def.checks.find((e) => e.kind === "ip"); + } + get minLength() { + let e = null; + for (const r of this._def.checks) + r.kind === "min" && (e === null || r.value > e) && (e = r.value); + return e; + } + get maxLength() { + let e = null; + for (const r of this._def.checks) + r.kind === "max" && (e === null || r.value < e) && (e = r.value); + return e; + } +} +we.create = (t) => { + var e; + return new we({ + checks: [], + typeName: P.ZodString, + coerce: (e = t == null ? void 0 : t.coerce) !== null && e !== void 0 ? e : !1, + ...C(t) + }); +}; +function tc(t, e) { + const r = (t.toString().split(".")[1] || "").length, n = (e.toString().split(".")[1] || "").length, a = r > n ? r : n, s = parseInt(t.toFixed(a).replace(".", "")), i = parseInt(e.toFixed(a).replace(".", "")); + return s % i / Math.pow(10, a); +} +class Ve extends $ { + constructor() { + super(...arguments), this.min = this.gte, this.max = this.lte, this.step = this.multipleOf; + } + _parse(e) { + if (this._def.coerce && (e.data = Number(e.data)), this._getType(e) !== b.number) { + const s = this._getOrReturnCtx(e); + return x(s, { + code: g.invalid_type, + expected: b.number, + received: s.parsedType + }), A; + } + let n; + const a = new Y(); + for (const s of this._def.checks) + s.kind === "int" ? R.isInteger(e.data) || (n = this._getOrReturnCtx(e, n), x(n, { + code: g.invalid_type, + expected: "integer", + received: "float", + message: s.message + }), a.dirty()) : s.kind === "min" ? (s.inclusive ? e.data < s.value : e.data <= s.value) && (n = this._getOrReturnCtx(e, n), x(n, { + code: g.too_small, + minimum: s.value, + type: "number", + inclusive: s.inclusive, + exact: !1, + message: s.message + }), a.dirty()) : s.kind === "max" ? (s.inclusive ? e.data > s.value : e.data >= s.value) && (n = this._getOrReturnCtx(e, n), x(n, { + code: g.too_big, + maximum: s.value, + type: "number", + inclusive: s.inclusive, + exact: !1, + message: s.message + }), a.dirty()) : s.kind === "multipleOf" ? tc(e.data, s.value) !== 0 && (n = this._getOrReturnCtx(e, n), x(n, { + code: g.not_multiple_of, + multipleOf: s.value, + message: s.message + }), a.dirty()) : s.kind === "finite" ? Number.isFinite(e.data) || (n = this._getOrReturnCtx(e, n), x(n, { + code: g.not_finite, + message: s.message + }), a.dirty()) : R.assertNever(s); + return { status: a.value, value: e.data }; + } + gte(e, r) { + return this.setLimit("min", e, !0, S.toString(r)); + } + gt(e, r) { + return this.setLimit("min", e, !1, S.toString(r)); + } + lte(e, r) { + return this.setLimit("max", e, !0, S.toString(r)); + } + lt(e, r) { + return this.setLimit("max", e, !1, S.toString(r)); + } + setLimit(e, r, n, a) { + return new Ve({ + ...this._def, + checks: [ + ...this._def.checks, + { + kind: e, + value: r, + inclusive: n, + message: S.toString(a) + } + ] + }); + } + _addCheck(e) { + return new Ve({ + ...this._def, + checks: [...this._def.checks, e] + }); + } + int(e) { + return this._addCheck({ + kind: "int", + message: S.toString(e) + }); + } + positive(e) { + return this._addCheck({ + kind: "min", + value: 0, + inclusive: !1, + message: S.toString(e) + }); + } + negative(e) { + return this._addCheck({ + kind: "max", + value: 0, + inclusive: !1, + message: S.toString(e) + }); + } + nonpositive(e) { + return this._addCheck({ + kind: "max", + value: 0, + inclusive: !0, + message: S.toString(e) + }); + } + nonnegative(e) { + return this._addCheck({ + kind: "min", + value: 0, + inclusive: !0, + message: S.toString(e) + }); + } + multipleOf(e, r) { + return this._addCheck({ + kind: "multipleOf", + value: e, + message: S.toString(r) + }); + } + finite(e) { + return this._addCheck({ + kind: "finite", + message: S.toString(e) + }); + } + safe(e) { + return this._addCheck({ + kind: "min", + inclusive: !0, + value: Number.MIN_SAFE_INTEGER, + message: S.toString(e) + })._addCheck({ + kind: "max", + inclusive: !0, + value: Number.MAX_SAFE_INTEGER, + message: S.toString(e) + }); + } + get minValue() { + let e = null; + for (const r of this._def.checks) + r.kind === "min" && (e === null || r.value > e) && (e = r.value); + return e; + } + get maxValue() { + let e = null; + for (const r of this._def.checks) + r.kind === "max" && (e === null || r.value < e) && (e = r.value); + return e; + } + get isInt() { + return !!this._def.checks.find((e) => e.kind === "int" || e.kind === "multipleOf" && R.isInteger(e.value)); + } + get isFinite() { + let e = null, r = null; + for (const n of this._def.checks) { + if (n.kind === "finite" || n.kind === "int" || n.kind === "multipleOf") + return !0; + n.kind === "min" ? (r === null || n.value > r) && (r = n.value) : n.kind === "max" && (e === null || n.value < e) && (e = n.value); + } + return Number.isFinite(r) && Number.isFinite(e); + } +} +Ve.create = (t) => new Ve({ + checks: [], + typeName: P.ZodNumber, + coerce: (t == null ? void 0 : t.coerce) || !1, + ...C(t) +}); +class We extends $ { + constructor() { + super(...arguments), this.min = this.gte, this.max = this.lte; + } + _parse(e) { + if (this._def.coerce && (e.data = BigInt(e.data)), this._getType(e) !== b.bigint) { + const s = this._getOrReturnCtx(e); + return x(s, { + code: g.invalid_type, + expected: b.bigint, + received: s.parsedType + }), A; + } + let n; + const a = new Y(); + for (const s of this._def.checks) + s.kind === "min" ? (s.inclusive ? e.data < s.value : e.data <= s.value) && (n = this._getOrReturnCtx(e, n), x(n, { + code: g.too_small, + type: "bigint", + minimum: s.value, + inclusive: s.inclusive, + message: s.message + }), a.dirty()) : s.kind === "max" ? (s.inclusive ? e.data > s.value : e.data >= s.value) && (n = this._getOrReturnCtx(e, n), x(n, { + code: g.too_big, + type: "bigint", + maximum: s.value, + inclusive: s.inclusive, + message: s.message + }), a.dirty()) : s.kind === "multipleOf" ? e.data % s.value !== BigInt(0) && (n = this._getOrReturnCtx(e, n), x(n, { + code: g.not_multiple_of, + multipleOf: s.value, + message: s.message + }), a.dirty()) : R.assertNever(s); + return { status: a.value, value: e.data }; + } + gte(e, r) { + return this.setLimit("min", e, !0, S.toString(r)); + } + gt(e, r) { + return this.setLimit("min", e, !1, S.toString(r)); + } + lte(e, r) { + return this.setLimit("max", e, !0, S.toString(r)); + } + lt(e, r) { + return this.setLimit("max", e, !1, S.toString(r)); + } + setLimit(e, r, n, a) { + return new We({ + ...this._def, + checks: [ + ...this._def.checks, + { + kind: e, + value: r, + inclusive: n, + message: S.toString(a) + } + ] + }); + } + _addCheck(e) { + return new We({ + ...this._def, + checks: [...this._def.checks, e] + }); + } + positive(e) { + return this._addCheck({ + kind: "min", + value: BigInt(0), + inclusive: !1, + message: S.toString(e) + }); + } + negative(e) { + return this._addCheck({ + kind: "max", + value: BigInt(0), + inclusive: !1, + message: S.toString(e) + }); + } + nonpositive(e) { + return this._addCheck({ + kind: "max", + value: BigInt(0), + inclusive: !0, + message: S.toString(e) + }); + } + nonnegative(e) { + return this._addCheck({ + kind: "min", + value: BigInt(0), + inclusive: !0, + message: S.toString(e) + }); + } + multipleOf(e, r) { + return this._addCheck({ + kind: "multipleOf", + value: e, + message: S.toString(r) + }); + } + get minValue() { + let e = null; + for (const r of this._def.checks) + r.kind === "min" && (e === null || r.value > e) && (e = r.value); + return e; + } + get maxValue() { + let e = null; + for (const r of this._def.checks) + r.kind === "max" && (e === null || r.value < e) && (e = r.value); + return e; + } +} +We.create = (t) => { + var e; + return new We({ + checks: [], + typeName: P.ZodBigInt, + coerce: (e = t == null ? void 0 : t.coerce) !== null && e !== void 0 ? e : !1, + ...C(t) + }); +}; +class Rt extends $ { + _parse(e) { + if (this._def.coerce && (e.data = !!e.data), this._getType(e) !== b.boolean) { + const n = this._getOrReturnCtx(e); + return x(n, { + code: g.invalid_type, + expected: b.boolean, + received: n.parsedType + }), A; + } + return re(e.data); + } +} +Rt.create = (t) => new Rt({ + typeName: P.ZodBoolean, + coerce: (t == null ? void 0 : t.coerce) || !1, + ...C(t) +}); +class st extends $ { + _parse(e) { + if (this._def.coerce && (e.data = new Date(e.data)), this._getType(e) !== b.date) { + const s = this._getOrReturnCtx(e); + return x(s, { + code: g.invalid_type, + expected: b.date, + received: s.parsedType + }), A; + } + if (isNaN(e.data.getTime())) { + const s = this._getOrReturnCtx(e); + return x(s, { + code: g.invalid_date + }), A; + } + const n = new Y(); + let a; + for (const s of this._def.checks) + s.kind === "min" ? e.data.getTime() < s.value && (a = this._getOrReturnCtx(e, a), x(a, { + code: g.too_small, + message: s.message, + inclusive: !0, + exact: !1, + minimum: s.value, + type: "date" + }), n.dirty()) : s.kind === "max" ? e.data.getTime() > s.value && (a = this._getOrReturnCtx(e, a), x(a, { + code: g.too_big, + message: s.message, + inclusive: !0, + exact: !1, + maximum: s.value, + type: "date" + }), n.dirty()) : R.assertNever(s); + return { + status: n.value, + value: new Date(e.data.getTime()) + }; + } + _addCheck(e) { + return new st({ + ...this._def, + checks: [...this._def.checks, e] + }); + } + min(e, r) { + return this._addCheck({ + kind: "min", + value: e.getTime(), + message: S.toString(r) + }); + } + max(e, r) { + return this._addCheck({ + kind: "max", + value: e.getTime(), + message: S.toString(r) + }); + } + get minDate() { + let e = null; + for (const r of this._def.checks) + r.kind === "min" && (e === null || r.value > e) && (e = r.value); + return e != null ? new Date(e) : null; + } + get maxDate() { + let e = null; + for (const r of this._def.checks) + r.kind === "max" && (e === null || r.value < e) && (e = r.value); + return e != null ? new Date(e) : null; + } +} +st.create = (t) => new st({ + checks: [], + coerce: (t == null ? void 0 : t.coerce) || !1, + typeName: P.ZodDate, + ...C(t) +}); +class mr extends $ { + _parse(e) { + if (this._getType(e) !== b.symbol) { + const n = this._getOrReturnCtx(e); + return x(n, { + code: g.invalid_type, + expected: b.symbol, + received: n.parsedType + }), A; + } + return re(e.data); + } +} +mr.create = (t) => new mr({ + typeName: P.ZodSymbol, + ...C(t) +}); +class Mt extends $ { + _parse(e) { + if (this._getType(e) !== b.undefined) { + const n = this._getOrReturnCtx(e); + return x(n, { + code: g.invalid_type, + expected: b.undefined, + received: n.parsedType + }), A; + } + return re(e.data); + } +} +Mt.create = (t) => new Mt({ + typeName: P.ZodUndefined, + ...C(t) +}); +class Lt extends $ { + _parse(e) { + if (this._getType(e) !== b.null) { + const n = this._getOrReturnCtx(e); + return x(n, { + code: g.invalid_type, + expected: b.null, + received: n.parsedType + }), A; + } + return re(e.data); + } +} +Lt.create = (t) => new Lt({ + typeName: P.ZodNull, + ...C(t) +}); +class _t extends $ { + constructor() { + super(...arguments), this._any = !0; + } + _parse(e) { + return re(e.data); + } +} +_t.create = (t) => new _t({ + typeName: P.ZodAny, + ...C(t) +}); +class rt extends $ { + constructor() { + super(...arguments), this._unknown = !0; + } + _parse(e) { + return re(e.data); + } +} +rt.create = (t) => new rt({ + typeName: P.ZodUnknown, + ...C(t) +}); +class Fe extends $ { + _parse(e) { + const r = this._getOrReturnCtx(e); + return x(r, { + code: g.invalid_type, + expected: b.never, + received: r.parsedType + }), A; + } +} +Fe.create = (t) => new Fe({ + typeName: P.ZodNever, + ...C(t) +}); +class hr extends $ { + _parse(e) { + if (this._getType(e) !== b.undefined) { + const n = this._getOrReturnCtx(e); + return x(n, { + code: g.invalid_type, + expected: b.void, + received: n.parsedType + }), A; + } + return re(e.data); + } +} +hr.create = (t) => new hr({ + typeName: P.ZodVoid, + ...C(t) +}); +class Se extends $ { + _parse(e) { + const { ctx: r, status: n } = this._processInputParams(e), a = this._def; + if (r.parsedType !== b.array) + return x(r, { + code: g.invalid_type, + expected: b.array, + received: r.parsedType + }), A; + if (a.exactLength !== null) { + const i = r.data.length > a.exactLength.value, c = r.data.length < a.exactLength.value; + (i || c) && (x(r, { + code: i ? g.too_big : g.too_small, + minimum: c ? a.exactLength.value : void 0, + maximum: i ? a.exactLength.value : void 0, + type: "array", + inclusive: !0, + exact: !0, + message: a.exactLength.message + }), n.dirty()); + } + if (a.minLength !== null && r.data.length < a.minLength.value && (x(r, { + code: g.too_small, + minimum: a.minLength.value, + type: "array", + inclusive: !0, + exact: !1, + message: a.minLength.message + }), n.dirty()), a.maxLength !== null && r.data.length > a.maxLength.value && (x(r, { + code: g.too_big, + maximum: a.maxLength.value, + type: "array", + inclusive: !0, + exact: !1, + message: a.maxLength.message + }), n.dirty()), r.common.async) + return Promise.all([...r.data].map((i, c) => a.type._parseAsync(new Ce(r, i, r.path, c)))).then((i) => Y.mergeArray(n, i)); + const s = [...r.data].map((i, c) => a.type._parseSync(new Ce(r, i, r.path, c))); + return Y.mergeArray(n, s); + } + get element() { + return this._def.type; + } + min(e, r) { + return new Se({ + ...this._def, + minLength: { value: e, message: S.toString(r) } + }); + } + max(e, r) { + return new Se({ + ...this._def, + maxLength: { value: e, message: S.toString(r) } + }); + } + length(e, r) { + return new Se({ + ...this._def, + exactLength: { value: e, message: S.toString(r) } + }); + } + nonempty(e) { + return this.min(1, e); + } +} +Se.create = (t, e) => new Se({ + type: t, + minLength: null, + maxLength: null, + exactLength: null, + typeName: P.ZodArray, + ...C(e) +}); +function pt(t) { + if (t instanceof j) { + const e = {}; + for (const r in t.shape) { + const n = t.shape[r]; + e[r] = Me.create(pt(n)); + } + return new j({ + ...t._def, + shape: () => e + }); + } else + return t instanceof Se ? new Se({ + ...t._def, + type: pt(t.element) + }) : t instanceof Me ? Me.create(pt(t.unwrap())) : t instanceof it ? it.create(pt(t.unwrap())) : t instanceof Ne ? Ne.create(t.items.map((e) => pt(e))) : t; +} +class j extends $ { + constructor() { + super(...arguments), this._cached = null, this.nonstrict = this.passthrough, this.augment = this.extend; + } + _getCached() { + if (this._cached !== null) + return this._cached; + const e = this._def.shape(), r = R.objectKeys(e); + return this._cached = { shape: e, keys: r }; + } + _parse(e) { + if (this._getType(e) !== b.object) { + const l = this._getOrReturnCtx(e); + return x(l, { + code: g.invalid_type, + expected: b.object, + received: l.parsedType + }), A; + } + const { status: n, ctx: a } = this._processInputParams(e), { shape: s, keys: i } = this._getCached(), c = []; + if (!(this._def.catchall instanceof Fe && this._def.unknownKeys === "strip")) + for (const l in a.data) + i.includes(l) || c.push(l); + const u = []; + for (const l of i) { + const d = s[l], f = a.data[l]; + u.push({ + key: { status: "valid", value: l }, + value: d._parse(new Ce(a, f, a.path, l)), + alwaysSet: l in a.data + }); + } + if (this._def.catchall instanceof Fe) { + const l = this._def.unknownKeys; + if (l === "passthrough") + for (const d of c) + u.push({ + key: { status: "valid", value: d }, + value: { status: "valid", value: a.data[d] } + }); + else if (l === "strict") + c.length > 0 && (x(a, { + code: g.unrecognized_keys, + keys: c + }), n.dirty()); + else if (l !== "strip") + throw new Error("Internal ZodObject error: invalid unknownKeys value."); + } else { + const l = this._def.catchall; + for (const d of c) { + const f = a.data[d]; + u.push({ + key: { status: "valid", value: d }, + value: l._parse( + new Ce(a, f, a.path, d) + //, ctx.child(key), value, getParsedType(value) + ), + alwaysSet: d in a.data + }); + } + } + return a.common.async ? Promise.resolve().then(async () => { + const l = []; + for (const d of u) { + const f = await d.key; + l.push({ + key: f, + value: await d.value, + alwaysSet: d.alwaysSet + }); + } + return l; + }).then((l) => Y.mergeObjectSync(n, l)) : Y.mergeObjectSync(n, u); + } + get shape() { + return this._def.shape(); + } + strict(e) { + return S.errToObj, new j({ + ...this._def, + unknownKeys: "strict", + ...e !== void 0 ? { + errorMap: (r, n) => { + var a, s, i, c; + const u = (i = (s = (a = this._def).errorMap) === null || s === void 0 ? void 0 : s.call(a, r, n).message) !== null && i !== void 0 ? i : n.defaultError; + return r.code === "unrecognized_keys" ? { + message: (c = S.errToObj(e).message) !== null && c !== void 0 ? c : u + } : { + message: u + }; + } + } : {} + }); + } + strip() { + return new j({ + ...this._def, + unknownKeys: "strip" + }); + } + passthrough() { + return new j({ + ...this._def, + unknownKeys: "passthrough" + }); + } + // const AugmentFactory = + // (def: Def) => + // ( + // augmentation: Augmentation + // ): ZodObject< + // extendShape, Augmentation>, + // Def["unknownKeys"], + // Def["catchall"] + // > => { + // return new ZodObject({ + // ...def, + // shape: () => ({ + // ...def.shape(), + // ...augmentation, + // }), + // }) as any; + // }; + extend(e) { + return new j({ + ...this._def, + shape: () => ({ + ...this._def.shape(), + ...e + }) + }); + } + /** + * Prior to zod@1.0.12 there was a bug in the + * inferred type of merged objects. Please + * upgrade if you are experiencing issues. + */ + merge(e) { + return new j({ + unknownKeys: e._def.unknownKeys, + catchall: e._def.catchall, + shape: () => ({ + ...this._def.shape(), + ...e._def.shape() + }), + typeName: P.ZodObject + }); + } + // merge< + // Incoming extends AnyZodObject, + // Augmentation extends Incoming["shape"], + // NewOutput extends { + // [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation + // ? Augmentation[k]["_output"] + // : k extends keyof Output + // ? Output[k] + // : never; + // }, + // NewInput extends { + // [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation + // ? Augmentation[k]["_input"] + // : k extends keyof Input + // ? Input[k] + // : never; + // } + // >( + // merging: Incoming + // ): ZodObject< + // extendShape>, + // Incoming["_def"]["unknownKeys"], + // Incoming["_def"]["catchall"], + // NewOutput, + // NewInput + // > { + // const merged: any = new ZodObject({ + // unknownKeys: merging._def.unknownKeys, + // catchall: merging._def.catchall, + // shape: () => + // objectUtil.mergeShapes(this._def.shape(), merging._def.shape()), + // typeName: ZodFirstPartyTypeKind.ZodObject, + // }) as any; + // return merged; + // } + setKey(e, r) { + return this.augment({ [e]: r }); + } + // merge( + // merging: Incoming + // ): //ZodObject = (merging) => { + // ZodObject< + // extendShape>, + // Incoming["_def"]["unknownKeys"], + // Incoming["_def"]["catchall"] + // > { + // // const mergedShape = objectUtil.mergeShapes( + // // this._def.shape(), + // // merging._def.shape() + // // ); + // const merged: any = new ZodObject({ + // unknownKeys: merging._def.unknownKeys, + // catchall: merging._def.catchall, + // shape: () => + // objectUtil.mergeShapes(this._def.shape(), merging._def.shape()), + // typeName: ZodFirstPartyTypeKind.ZodObject, + // }) as any; + // return merged; + // } + catchall(e) { + return new j({ + ...this._def, + catchall: e + }); + } + pick(e) { + const r = {}; + return R.objectKeys(e).forEach((n) => { + e[n] && this.shape[n] && (r[n] = this.shape[n]); + }), new j({ + ...this._def, + shape: () => r + }); + } + omit(e) { + const r = {}; + return R.objectKeys(this.shape).forEach((n) => { + e[n] || (r[n] = this.shape[n]); + }), new j({ + ...this._def, + shape: () => r + }); + } + /** + * @deprecated + */ + deepPartial() { + return pt(this); + } + partial(e) { + const r = {}; + return R.objectKeys(this.shape).forEach((n) => { + const a = this.shape[n]; + e && !e[n] ? r[n] = a : r[n] = a.optional(); + }), new j({ + ...this._def, + shape: () => r + }); + } + required(e) { + const r = {}; + return R.objectKeys(this.shape).forEach((n) => { + if (e && !e[n]) + r[n] = this.shape[n]; + else { + let s = this.shape[n]; + for (; s instanceof Me; ) + s = s._def.innerType; + r[n] = s; + } + }), new j({ + ...this._def, + shape: () => r + }); + } + keyof() { + return ds(R.objectKeys(this.shape)); + } +} +j.create = (t, e) => new j({ + shape: () => t, + unknownKeys: "strip", + catchall: Fe.create(), + typeName: P.ZodObject, + ...C(e) +}); +j.strictCreate = (t, e) => new j({ + shape: () => t, + unknownKeys: "strict", + catchall: Fe.create(), + typeName: P.ZodObject, + ...C(e) +}); +j.lazycreate = (t, e) => new j({ + shape: t, + unknownKeys: "strip", + catchall: Fe.create(), + typeName: P.ZodObject, + ...C(e) +}); +class Ft extends $ { + _parse(e) { + const { ctx: r } = this._processInputParams(e), n = this._def.options; + function a(s) { + for (const c of s) + if (c.result.status === "valid") + return c.result; + for (const c of s) + if (c.result.status === "dirty") + return r.common.issues.push(...c.ctx.common.issues), c.result; + const i = s.map((c) => new xe(c.ctx.common.issues)); + return x(r, { + code: g.invalid_union, + unionErrors: i + }), A; + } + if (r.common.async) + return Promise.all(n.map(async (s) => { + const i = { + ...r, + common: { + ...r.common, + issues: [] + }, + parent: null + }; + return { + result: await s._parseAsync({ + data: r.data, + path: r.path, + parent: i + }), + ctx: i + }; + })).then(a); + { + let s; + const i = []; + for (const u of n) { + const l = { + ...r, + common: { + ...r.common, + issues: [] + }, + parent: null + }, d = u._parseSync({ + data: r.data, + path: r.path, + parent: l + }); + if (d.status === "valid") + return d; + d.status === "dirty" && !s && (s = { result: d, ctx: l }), l.common.issues.length && i.push(l.common.issues); + } + if (s) + return r.common.issues.push(...s.ctx.common.issues), s.result; + const c = i.map((u) => new xe(u)); + return x(r, { + code: g.invalid_union, + unionErrors: c + }), A; + } + } + get options() { + return this._def.options; + } +} +Ft.create = (t, e) => new Ft({ + options: t, + typeName: P.ZodUnion, + ...C(e) +}); +const or = (t) => t instanceof Ut ? or(t.schema) : t instanceof Ee ? or(t.innerType()) : t instanceof Zt ? [t.value] : t instanceof qe ? t.options : t instanceof zt ? Object.keys(t.enum) : t instanceof Bt ? or(t._def.innerType) : t instanceof Mt ? [void 0] : t instanceof Lt ? [null] : null; +class Nr extends $ { + _parse(e) { + const { ctx: r } = this._processInputParams(e); + if (r.parsedType !== b.object) + return x(r, { + code: g.invalid_type, + expected: b.object, + received: r.parsedType + }), A; + const n = this.discriminator, a = r.data[n], s = this.optionsMap.get(a); + return s ? r.common.async ? s._parseAsync({ + data: r.data, + path: r.path, + parent: r + }) : s._parseSync({ + data: r.data, + path: r.path, + parent: r + }) : (x(r, { + code: g.invalid_union_discriminator, + options: Array.from(this.optionsMap.keys()), + path: [n] + }), A); + } + get discriminator() { + return this._def.discriminator; + } + get options() { + return this._def.options; + } + get optionsMap() { + return this._def.optionsMap; + } + /** + * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor. + * However, it only allows a union of objects, all of which need to share a discriminator property. This property must + * have a different value for each object in the union. + * @param discriminator the name of the discriminator property + * @param types an array of object schemas + * @param params + */ + static create(e, r, n) { + const a = /* @__PURE__ */ new Map(); + for (const s of r) { + const i = or(s.shape[e]); + if (!i) + throw new Error(`A discriminator value for key \`${e}\` could not be extracted from all schema options`); + for (const c of i) { + if (a.has(c)) + throw new Error(`Discriminator property ${String(e)} has duplicate value ${String(c)}`); + a.set(c, s); + } + } + return new Nr({ + typeName: P.ZodDiscriminatedUnion, + discriminator: e, + options: r, + optionsMap: a, + ...C(n) + }); + } +} +function Qr(t, e) { + const r = Ze(t), n = Ze(e); + if (t === e) + return { valid: !0, data: t }; + if (r === b.object && n === b.object) { + const a = R.objectKeys(e), s = R.objectKeys(t).filter((c) => a.indexOf(c) !== -1), i = { ...t, ...e }; + for (const c of s) { + const u = Qr(t[c], e[c]); + if (!u.valid) + return { valid: !1 }; + i[c] = u.data; + } + return { valid: !0, data: i }; + } else if (r === b.array && n === b.array) { + if (t.length !== e.length) + return { valid: !1 }; + const a = []; + for (let s = 0; s < t.length; s++) { + const i = t[s], c = e[s], u = Qr(i, c); + if (!u.valid) + return { valid: !1 }; + a.push(u.data); + } + return { valid: !0, data: a }; + } else + return r === b.date && n === b.date && +t == +e ? { valid: !0, data: t } : { valid: !1 }; +} +class Dt extends $ { + _parse(e) { + const { status: r, ctx: n } = this._processInputParams(e), a = (s, i) => { + if (Yr(s) || Yr(i)) + return A; + const c = Qr(s.value, i.value); + return c.valid ? ((Xr(s) || Xr(i)) && r.dirty(), { status: r.value, value: c.data }) : (x(n, { + code: g.invalid_intersection_types + }), A); + }; + return n.common.async ? Promise.all([ + this._def.left._parseAsync({ + data: n.data, + path: n.path, + parent: n + }), + this._def.right._parseAsync({ + data: n.data, + path: n.path, + parent: n + }) + ]).then(([s, i]) => a(s, i)) : a(this._def.left._parseSync({ + data: n.data, + path: n.path, + parent: n + }), this._def.right._parseSync({ + data: n.data, + path: n.path, + parent: n + })); + } +} +Dt.create = (t, e, r) => new Dt({ + left: t, + right: e, + typeName: P.ZodIntersection, + ...C(r) +}); +class Ne extends $ { + _parse(e) { + const { status: r, ctx: n } = this._processInputParams(e); + if (n.parsedType !== b.array) + return x(n, { + code: g.invalid_type, + expected: b.array, + received: n.parsedType + }), A; + if (n.data.length < this._def.items.length) + return x(n, { + code: g.too_small, + minimum: this._def.items.length, + inclusive: !0, + exact: !1, + type: "array" + }), A; + !this._def.rest && n.data.length > this._def.items.length && (x(n, { + code: g.too_big, + maximum: this._def.items.length, + inclusive: !0, + exact: !1, + type: "array" + }), r.dirty()); + const s = [...n.data].map((i, c) => { + const u = this._def.items[c] || this._def.rest; + return u ? u._parse(new Ce(n, i, n.path, c)) : null; + }).filter((i) => !!i); + return n.common.async ? Promise.all(s).then((i) => Y.mergeArray(r, i)) : Y.mergeArray(r, s); + } + get items() { + return this._def.items; + } + rest(e) { + return new Ne({ + ...this._def, + rest: e + }); + } +} +Ne.create = (t, e) => { + if (!Array.isArray(t)) + throw new Error("You must pass an array of schemas to z.tuple([ ... ])"); + return new Ne({ + items: t, + typeName: P.ZodTuple, + rest: null, + ...C(e) + }); +}; +class jt extends $ { + get keySchema() { + return this._def.keyType; + } + get valueSchema() { + return this._def.valueType; + } + _parse(e) { + const { status: r, ctx: n } = this._processInputParams(e); + if (n.parsedType !== b.object) + return x(n, { + code: g.invalid_type, + expected: b.object, + received: n.parsedType + }), A; + const a = [], s = this._def.keyType, i = this._def.valueType; + for (const c in n.data) + a.push({ + key: s._parse(new Ce(n, c, n.path, c)), + value: i._parse(new Ce(n, n.data[c], n.path, c)) + }); + return n.common.async ? Y.mergeObjectAsync(r, a) : Y.mergeObjectSync(r, a); + } + get element() { + return this._def.valueType; + } + static create(e, r, n) { + return r instanceof $ ? new jt({ + keyType: e, + valueType: r, + typeName: P.ZodRecord, + ...C(n) + }) : new jt({ + keyType: we.create(), + valueType: e, + typeName: P.ZodRecord, + ...C(r) + }); + } +} +class gr extends $ { + get keySchema() { + return this._def.keyType; + } + get valueSchema() { + return this._def.valueType; + } + _parse(e) { + const { status: r, ctx: n } = this._processInputParams(e); + if (n.parsedType !== b.map) + return x(n, { + code: g.invalid_type, + expected: b.map, + received: n.parsedType + }), A; + const a = this._def.keyType, s = this._def.valueType, i = [...n.data.entries()].map(([c, u], l) => ({ + key: a._parse(new Ce(n, c, n.path, [l, "key"])), + value: s._parse(new Ce(n, u, n.path, [l, "value"])) + })); + if (n.common.async) { + const c = /* @__PURE__ */ new Map(); + return Promise.resolve().then(async () => { + for (const u of i) { + const l = await u.key, d = await u.value; + if (l.status === "aborted" || d.status === "aborted") + return A; + (l.status === "dirty" || d.status === "dirty") && r.dirty(), c.set(l.value, d.value); + } + return { status: r.value, value: c }; + }); + } else { + const c = /* @__PURE__ */ new Map(); + for (const u of i) { + const l = u.key, d = u.value; + if (l.status === "aborted" || d.status === "aborted") + return A; + (l.status === "dirty" || d.status === "dirty") && r.dirty(), c.set(l.value, d.value); + } + return { status: r.value, value: c }; + } + } +} +gr.create = (t, e, r) => new gr({ + valueType: e, + keyType: t, + typeName: P.ZodMap, + ...C(r) +}); +class at extends $ { + _parse(e) { + const { status: r, ctx: n } = this._processInputParams(e); + if (n.parsedType !== b.set) + return x(n, { + code: g.invalid_type, + expected: b.set, + received: n.parsedType + }), A; + const a = this._def; + a.minSize !== null && n.data.size < a.minSize.value && (x(n, { + code: g.too_small, + minimum: a.minSize.value, + type: "set", + inclusive: !0, + exact: !1, + message: a.minSize.message + }), r.dirty()), a.maxSize !== null && n.data.size > a.maxSize.value && (x(n, { + code: g.too_big, + maximum: a.maxSize.value, + type: "set", + inclusive: !0, + exact: !1, + message: a.maxSize.message + }), r.dirty()); + const s = this._def.valueType; + function i(u) { + const l = /* @__PURE__ */ new Set(); + for (const d of u) { + if (d.status === "aborted") + return A; + d.status === "dirty" && r.dirty(), l.add(d.value); + } + return { status: r.value, value: l }; + } + const c = [...n.data.values()].map((u, l) => s._parse(new Ce(n, u, n.path, l))); + return n.common.async ? Promise.all(c).then((u) => i(u)) : i(c); + } + min(e, r) { + return new at({ + ...this._def, + minSize: { value: e, message: S.toString(r) } + }); + } + max(e, r) { + return new at({ + ...this._def, + maxSize: { value: e, message: S.toString(r) } + }); + } + size(e, r) { + return this.min(e, r).max(e, r); + } + nonempty(e) { + return this.min(1, e); + } +} +at.create = (t, e) => new at({ + valueType: t, + minSize: null, + maxSize: null, + typeName: P.ZodSet, + ...C(e) +}); +class ht extends $ { + constructor() { + super(...arguments), this.validate = this.implement; + } + _parse(e) { + const { ctx: r } = this._processInputParams(e); + if (r.parsedType !== b.function) + return x(r, { + code: g.invalid_type, + expected: b.function, + received: r.parsedType + }), A; + function n(c, u) { + return fr({ + data: c, + path: r.path, + errorMaps: [ + r.common.contextualErrorMap, + r.schemaErrorMap, + dr(), + $t + ].filter((l) => !!l), + issueData: { + code: g.invalid_arguments, + argumentsError: u + } + }); + } + function a(c, u) { + return fr({ + data: c, + path: r.path, + errorMaps: [ + r.common.contextualErrorMap, + r.schemaErrorMap, + dr(), + $t + ].filter((l) => !!l), + issueData: { + code: g.invalid_return_type, + returnTypeError: u + } + }); + } + const s = { errorMap: r.common.contextualErrorMap }, i = r.data; + if (this._def.returns instanceof bt) { + const c = this; + return re(async function(...u) { + const l = new xe([]), d = await c._def.args.parseAsync(u, s).catch((p) => { + throw l.addIssue(n(u, p)), l; + }), f = await Reflect.apply(i, this, d); + return await c._def.returns._def.type.parseAsync(f, s).catch((p) => { + throw l.addIssue(a(f, p)), l; + }); + }); + } else { + const c = this; + return re(function(...u) { + const l = c._def.args.safeParse(u, s); + if (!l.success) + throw new xe([n(u, l.error)]); + const d = Reflect.apply(i, this, l.data), f = c._def.returns.safeParse(d, s); + if (!f.success) + throw new xe([a(d, f.error)]); + return f.data; + }); + } + } + parameters() { + return this._def.args; + } + returnType() { + return this._def.returns; + } + args(...e) { + return new ht({ + ...this._def, + args: Ne.create(e).rest(rt.create()) + }); + } + returns(e) { + return new ht({ + ...this._def, + returns: e + }); + } + implement(e) { + return this.parse(e); + } + strictImplement(e) { + return this.parse(e); + } + static create(e, r, n) { + return new ht({ + args: e || Ne.create([]).rest(rt.create()), + returns: r || rt.create(), + typeName: P.ZodFunction, + ...C(n) + }); + } +} +class Ut extends $ { + get schema() { + return this._def.getter(); + } + _parse(e) { + const { ctx: r } = this._processInputParams(e); + return this._def.getter()._parse({ data: r.data, path: r.path, parent: r }); + } +} +Ut.create = (t, e) => new Ut({ + getter: t, + typeName: P.ZodLazy, + ...C(e) +}); +class Zt extends $ { + _parse(e) { + if (e.data !== this._def.value) { + const r = this._getOrReturnCtx(e); + return x(r, { + received: r.data, + code: g.invalid_literal, + expected: this._def.value + }), A; + } + return { status: "valid", value: e.data }; + } + get value() { + return this._def.value; + } +} +Zt.create = (t, e) => new Zt({ + value: t, + typeName: P.ZodLiteral, + ...C(e) +}); +function ds(t, e) { + return new qe({ + values: t, + typeName: P.ZodEnum, + ...C(e) + }); +} +class qe extends $ { + _parse(e) { + if (typeof e.data != "string") { + const r = this._getOrReturnCtx(e), n = this._def.values; + return x(r, { + expected: R.joinValues(n), + received: r.parsedType, + code: g.invalid_type + }), A; + } + if (this._def.values.indexOf(e.data) === -1) { + const r = this._getOrReturnCtx(e), n = this._def.values; + return x(r, { + received: r.data, + code: g.invalid_enum_value, + options: n + }), A; + } + return re(e.data); + } + get options() { + return this._def.values; + } + get enum() { + const e = {}; + for (const r of this._def.values) + e[r] = r; + return e; + } + get Values() { + const e = {}; + for (const r of this._def.values) + e[r] = r; + return e; + } + get Enum() { + const e = {}; + for (const r of this._def.values) + e[r] = r; + return e; + } + extract(e) { + return qe.create(e); + } + exclude(e) { + return qe.create(this.options.filter((r) => !e.includes(r))); + } +} +qe.create = ds; +class zt extends $ { + _parse(e) { + const r = R.getValidEnumValues(this._def.values), n = this._getOrReturnCtx(e); + if (n.parsedType !== b.string && n.parsedType !== b.number) { + const a = R.objectValues(r); + return x(n, { + expected: R.joinValues(a), + received: n.parsedType, + code: g.invalid_type + }), A; + } + if (r.indexOf(e.data) === -1) { + const a = R.objectValues(r); + return x(n, { + received: n.data, + code: g.invalid_enum_value, + options: a + }), A; + } + return re(e.data); + } + get enum() { + return this._def.values; + } +} +zt.create = (t, e) => new zt({ + values: t, + typeName: P.ZodNativeEnum, + ...C(e) +}); +class bt extends $ { + unwrap() { + return this._def.type; + } + _parse(e) { + const { ctx: r } = this._processInputParams(e); + if (r.parsedType !== b.promise && r.common.async === !1) + return x(r, { + code: g.invalid_type, + expected: b.promise, + received: r.parsedType + }), A; + const n = r.parsedType === b.promise ? r.data : Promise.resolve(r.data); + return re(n.then((a) => this._def.type.parseAsync(a, { + path: r.path, + errorMap: r.common.contextualErrorMap + }))); + } +} +bt.create = (t, e) => new bt({ + type: t, + typeName: P.ZodPromise, + ...C(e) +}); +class Ee extends $ { + innerType() { + return this._def.schema; + } + sourceType() { + return this._def.schema._def.typeName === P.ZodEffects ? this._def.schema.sourceType() : this._def.schema; + } + _parse(e) { + const { status: r, ctx: n } = this._processInputParams(e), a = this._def.effect || null, s = { + addIssue: (i) => { + x(n, i), i.fatal ? r.abort() : r.dirty(); + }, + get path() { + return n.path; + } + }; + if (s.addIssue = s.addIssue.bind(s), a.type === "preprocess") { + const i = a.transform(n.data, s); + return n.common.issues.length ? { + status: "dirty", + value: n.data + } : n.common.async ? Promise.resolve(i).then((c) => this._def.schema._parseAsync({ + data: c, + path: n.path, + parent: n + })) : this._def.schema._parseSync({ + data: i, + path: n.path, + parent: n + }); + } + if (a.type === "refinement") { + const i = (c) => { + const u = a.refinement(c, s); + if (n.common.async) + return Promise.resolve(u); + if (u instanceof Promise) + throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead."); + return c; + }; + if (n.common.async === !1) { + const c = this._def.schema._parseSync({ + data: n.data, + path: n.path, + parent: n + }); + return c.status === "aborted" ? A : (c.status === "dirty" && r.dirty(), i(c.value), { status: r.value, value: c.value }); + } else + return this._def.schema._parseAsync({ data: n.data, path: n.path, parent: n }).then((c) => c.status === "aborted" ? A : (c.status === "dirty" && r.dirty(), i(c.value).then(() => ({ status: r.value, value: c.value })))); + } + if (a.type === "transform") + if (n.common.async === !1) { + const i = this._def.schema._parseSync({ + data: n.data, + path: n.path, + parent: n + }); + if (!Ot(i)) + return i; + const c = a.transform(i.value, s); + if (c instanceof Promise) + throw new Error("Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead."); + return { status: r.value, value: c }; + } else + return this._def.schema._parseAsync({ data: n.data, path: n.path, parent: n }).then((i) => Ot(i) ? Promise.resolve(a.transform(i.value, s)).then((c) => ({ status: r.value, value: c })) : i); + R.assertNever(a); + } +} +Ee.create = (t, e, r) => new Ee({ + schema: t, + typeName: P.ZodEffects, + effect: e, + ...C(r) +}); +Ee.createWithPreprocess = (t, e, r) => new Ee({ + schema: e, + effect: { type: "preprocess", transform: t }, + typeName: P.ZodEffects, + ...C(r) +}); +class Me extends $ { + _parse(e) { + return this._getType(e) === b.undefined ? re(void 0) : this._def.innerType._parse(e); + } + unwrap() { + return this._def.innerType; + } +} +Me.create = (t, e) => new Me({ + innerType: t, + typeName: P.ZodOptional, + ...C(e) +}); +class it extends $ { + _parse(e) { + return this._getType(e) === b.null ? re(null) : this._def.innerType._parse(e); + } + unwrap() { + return this._def.innerType; + } +} +it.create = (t, e) => new it({ + innerType: t, + typeName: P.ZodNullable, + ...C(e) +}); +class Bt extends $ { + _parse(e) { + const { ctx: r } = this._processInputParams(e); + let n = r.data; + return r.parsedType === b.undefined && (n = this._def.defaultValue()), this._def.innerType._parse({ + data: n, + path: r.path, + parent: r + }); + } + removeDefault() { + return this._def.innerType; + } +} +Bt.create = (t, e) => new Bt({ + innerType: t, + typeName: P.ZodDefault, + defaultValue: typeof e.default == "function" ? e.default : () => e.default, + ...C(e) +}); +class yr extends $ { + _parse(e) { + const { ctx: r } = this._processInputParams(e), n = { + ...r, + common: { + ...r.common, + issues: [] + } + }, a = this._def.innerType._parse({ + data: n.data, + path: n.path, + parent: { + ...n + } + }); + return pr(a) ? a.then((s) => ({ + status: "valid", + value: s.status === "valid" ? s.value : this._def.catchValue({ + get error() { + return new xe(n.common.issues); + }, + input: n.data + }) + })) : { + status: "valid", + value: a.status === "valid" ? a.value : this._def.catchValue({ + get error() { + return new xe(n.common.issues); + }, + input: n.data + }) + }; + } + removeCatch() { + return this._def.innerType; + } +} +yr.create = (t, e) => new yr({ + innerType: t, + typeName: P.ZodCatch, + catchValue: typeof e.catch == "function" ? e.catch : () => e.catch, + ...C(e) +}); +class vr extends $ { + _parse(e) { + if (this._getType(e) !== b.nan) { + const n = this._getOrReturnCtx(e); + return x(n, { + code: g.invalid_type, + expected: b.nan, + received: n.parsedType + }), A; + } + return { status: "valid", value: e.data }; + } +} +vr.create = (t) => new vr({ + typeName: P.ZodNaN, + ...C(t) +}); +const rc = Symbol("zod_brand"); +class fs extends $ { + _parse(e) { + const { ctx: r } = this._processInputParams(e), n = r.data; + return this._def.type._parse({ + data: n, + path: r.path, + parent: r + }); + } + unwrap() { + return this._def.type; + } +} +class qt extends $ { + _parse(e) { + const { status: r, ctx: n } = this._processInputParams(e); + if (n.common.async) + return (async () => { + const s = await this._def.in._parseAsync({ + data: n.data, + path: n.path, + parent: n + }); + return s.status === "aborted" ? A : s.status === "dirty" ? (r.dirty(), us(s.value)) : this._def.out._parseAsync({ + data: s.value, + path: n.path, + parent: n + }); + })(); + { + const a = this._def.in._parseSync({ + data: n.data, + path: n.path, + parent: n + }); + return a.status === "aborted" ? A : a.status === "dirty" ? (r.dirty(), { + status: "dirty", + value: a.value + }) : this._def.out._parseSync({ + data: a.value, + path: n.path, + parent: n + }); + } + } + static create(e, r) { + return new qt({ + in: e, + out: r, + typeName: P.ZodPipeline + }); + } +} +class _r extends $ { + _parse(e) { + const r = this._def.innerType._parse(e); + return Ot(r) && (r.value = Object.freeze(r.value)), r; + } +} +_r.create = (t, e) => new _r({ + innerType: t, + typeName: P.ZodReadonly, + ...C(e) +}); +const ps = (t, e = {}, r) => t ? _t.create().superRefine((n, a) => { + var s, i; + if (!t(n)) { + const c = typeof e == "function" ? e(n) : typeof e == "string" ? { message: e } : e, u = (i = (s = c.fatal) !== null && s !== void 0 ? s : r) !== null && i !== void 0 ? i : !0, l = typeof c == "string" ? { message: c } : c; + a.addIssue({ code: "custom", ...l, fatal: u }); + } +}) : _t.create(), nc = { + object: j.lazycreate +}; +var P; +(function(t) { + t.ZodString = "ZodString", t.ZodNumber = "ZodNumber", t.ZodNaN = "ZodNaN", t.ZodBigInt = "ZodBigInt", t.ZodBoolean = "ZodBoolean", t.ZodDate = "ZodDate", t.ZodSymbol = "ZodSymbol", t.ZodUndefined = "ZodUndefined", t.ZodNull = "ZodNull", t.ZodAny = "ZodAny", t.ZodUnknown = "ZodUnknown", t.ZodNever = "ZodNever", t.ZodVoid = "ZodVoid", t.ZodArray = "ZodArray", t.ZodObject = "ZodObject", t.ZodUnion = "ZodUnion", t.ZodDiscriminatedUnion = "ZodDiscriminatedUnion", t.ZodIntersection = "ZodIntersection", t.ZodTuple = "ZodTuple", t.ZodRecord = "ZodRecord", t.ZodMap = "ZodMap", t.ZodSet = "ZodSet", t.ZodFunction = "ZodFunction", t.ZodLazy = "ZodLazy", t.ZodLiteral = "ZodLiteral", t.ZodEnum = "ZodEnum", t.ZodEffects = "ZodEffects", t.ZodNativeEnum = "ZodNativeEnum", t.ZodOptional = "ZodOptional", t.ZodNullable = "ZodNullable", t.ZodDefault = "ZodDefault", t.ZodCatch = "ZodCatch", t.ZodPromise = "ZodPromise", t.ZodBranded = "ZodBranded", t.ZodPipeline = "ZodPipeline", t.ZodReadonly = "ZodReadonly"; +})(P || (P = {})); +const oc = (t, e = { + message: `Input not instance of ${t.name}` +}) => ps((r) => r instanceof t, e), ms = we.create, hs = Ve.create, sc = vr.create, ac = We.create, gs = Rt.create, ic = st.create, cc = mr.create, lc = Mt.create, uc = Lt.create, dc = _t.create, fc = rt.create, pc = Fe.create, mc = hr.create, hc = Se.create, gc = j.create, yc = j.strictCreate, vc = Ft.create, _c = Nr.create, bc = Dt.create, wc = Ne.create, xc = jt.create, Sc = gr.create, Ec = at.create, Pc = ht.create, kc = Ut.create, Tc = Zt.create, Ic = qe.create, Ac = zt.create, Cc = bt.create, Qn = Ee.create, Nc = Me.create, $c = it.create, Oc = Ee.createWithPreprocess, Rc = qt.create, Mc = () => ms().optional(), Lc = () => hs().optional(), Fc = () => gs().optional(), Dc = { + string: (t) => we.create({ ...t, coerce: !0 }), + number: (t) => Ve.create({ ...t, coerce: !0 }), + boolean: (t) => Rt.create({ + ...t, + coerce: !0 + }), + bigint: (t) => We.create({ ...t, coerce: !0 }), + date: (t) => st.create({ ...t, coerce: !0 }) +}, jc = A; +var V = /* @__PURE__ */ Object.freeze({ + __proto__: null, + defaultErrorMap: $t, + setErrorMap: Bi, + getErrorMap: dr, + makeIssue: fr, + EMPTY_PATH: Gi, + addIssueToContext: x, + ParseStatus: Y, + INVALID: A, + DIRTY: us, + OK: re, + isAborted: Yr, + isDirty: Xr, + isValid: Ot, + isAsync: pr, + get util() { + return R; + }, + get objectUtil() { + return Jr; + }, + ZodParsedType: b, + getParsedType: Ze, + ZodType: $, + ZodString: we, + ZodNumber: Ve, + ZodBigInt: We, + ZodBoolean: Rt, + ZodDate: st, + ZodSymbol: mr, + ZodUndefined: Mt, + ZodNull: Lt, + ZodAny: _t, + ZodUnknown: rt, + ZodNever: Fe, + ZodVoid: hr, + ZodArray: Se, + ZodObject: j, + ZodUnion: Ft, + ZodDiscriminatedUnion: Nr, + ZodIntersection: Dt, + ZodTuple: Ne, + ZodRecord: jt, + ZodMap: gr, + ZodSet: at, + ZodFunction: ht, + ZodLazy: Ut, + ZodLiteral: Zt, + ZodEnum: qe, + ZodNativeEnum: zt, + ZodPromise: bt, + ZodEffects: Ee, + ZodTransformer: Ee, + ZodOptional: Me, + ZodNullable: it, + ZodDefault: Bt, + ZodCatch: yr, + ZodNaN: vr, + BRAND: rc, + ZodBranded: fs, + ZodPipeline: qt, + ZodReadonly: _r, + custom: ps, + Schema: $, + ZodSchema: $, + late: nc, + get ZodFirstPartyTypeKind() { + return P; + }, + coerce: Dc, + any: dc, + array: hc, + bigint: ac, + boolean: gs, + date: ic, + discriminatedUnion: _c, + effect: Qn, + enum: Ic, + function: Pc, + instanceof: oc, + intersection: bc, + lazy: kc, + literal: Tc, + map: Sc, + nan: sc, + nativeEnum: Ac, + never: pc, + null: uc, + nullable: $c, + number: hs, + object: gc, + oboolean: Fc, + onumber: Lc, + optional: Nc, + ostring: Mc, + pipeline: Rc, + preprocess: Oc, + promise: Cc, + record: xc, + set: Ec, + strictObject: yc, + string: ms, + symbol: cc, + transformer: Qn, + tuple: wc, + undefined: lc, + union: vc, + unknown: fc, + void: mc, + NEVER: jc, + ZodIssueCode: g, + quotelessJson: zi, + ZodError: xe +}); +const Uc = V.object({ + name: V.string(), + code: V.string().url(), + permissions: V.array( + V.enum([ + "page:read", + "page:write", + "file:read", + "file:write", + "selection:read" + ]) + ) +}); +function ys(t) { + return fetch(t).then((e) => e.json()).then((e) => { + if (!Uc.safeParse(e).success) + throw new Error("Invalid plugin manifest"); + return e; + }).catch((e) => { + throw console.error(e), e; + }); +} +function Zc(t) { + return fetch(t).then((e) => e.text()); +} +async function zc(t) { + const e = await ys(t.manifest), r = await Zc(e.code); + return { + manifest: e, + code: r + }; +} +function wn(t, e) { + t.setAttribute("data-theme", e); +} +function Bc(t, e, r, n) { + const a = document.createElement("plugin-modal"); + return wn(a, r), a.setAttribute("title", t), a.setAttribute("iframe-src", e), a.setAttribute("width", String(n.width || 300)), a.setAttribute("height", String(n.height || 400)), document.body.appendChild(a), a; +} +const Gc = V.object({ + width: V.number().positive(), + height: V.number().positive() +}), Hc = V.function().args(V.string(), V.string(), V.enum(["dark", "light"]), Gc).implement((t, e, r, n) => Bc(t, e, r, n)), en = [ + "pagechange", + "filechange", + "selectionchange", + "themechange" +]; +let tn = [], ne = null; +const It = /* @__PURE__ */ new Map(); +window.addEventListener("message", (t) => { + for (const e of tn) + e(t.data); +}); +function Vc(t, e) { + t === "themechange" && ne && wn(ne, e), (It.get(t) || []).forEach((n) => n(e)); +} +function Wc(t, e) { + const r = () => { + ne == null || ne.removeEventListener("close", r), ne && ne.remove(), tn = [], ne = null; + }, n = (s) => { + if (!e.permissions.includes(s)) + throw new Error(`Permission ${s} is not granted`); + }; + return { + ui: { + open: (s, i, c) => { + const u = t.getTheme(); + ne = Hc(s, i, u, c), wn(ne, u), ne.addEventListener("close", r, { + once: !0 + }); + }, + sendMessage(s) { + const i = new CustomEvent("message", { + detail: s + }); + ne == null || ne.dispatchEvent(i); + }, + onMessage: (s) => { + V.function().parse(s), tn.push(s); + } + }, + log: console.log, + setTimeout: V.function().args(V.function(), V.number()).implement((s, i) => { + setTimeout(s, i); + }), + closePlugin: r, + on(s, i) { + V.enum(en).parse(s), V.function().parse(i), s === "pagechange" ? n("page:read") : s === "filechange" ? n("file:read") : s === "selectionchange" && n("selection:read"); + const c = It.get(s) || []; + c.push(i), It.set(s, c); + }, + off(s, i) { + V.enum(en).parse(s), V.function().parse(i); + const c = It.get(s) || []; + It.set( + s, + c.filter((u) => u !== i) + ); + }, + // Penpot State API + getFile() { + return n("file:read"), t.getFile(); + }, + getCurrentPage() { + return n("page:read"), t.getCurrentPage(); + }, + getPage() { + return n("page:read"), t.getPage(); + }, + getSelected() { + return n("selection:read"), t.getSelected(); + }, + getSelectedShapes() { + return n("selection:read"), t.getSelectedShapes(); + }, + getTheme() { + return t.getTheme(); + }, + fetch + }; +} +let eo = !1, tr, rn = null; +function qc(t) { + rn = t; +} +const vs = async function(t) { + const { code: e, manifest: r } = await zc(t); + try { + eo || (eo = !0, hardenIntrinsics()), tr && tr.closePlugin(), rn ? (tr = Wc(rn, r), new Compartment({ + penpot: harden(tr) + }).evaluate(e)) : console.error("Cannot find Penpot Context"); + } catch (n) { + console.error(n); + } +}, Kc = ` +`, to = (t) => { + t.target.tagName === "INSTALLER-MODAL" && t.stopImmediatePropagation(); +}; +class Jc extends HTMLElement { + constructor() { + super(), this.dialog = null, this.attachShadow({ mode: "open" }); + } + createPlugin(e, r) { + var c, u; + const n = document.createElement("li"); + n.classList.add("plugin"), n.textContent = e; + const a = document.createElement("div"); + a.classList.add("actions"); + const s = document.createElement("button"); + s.classList.add("button"), s.textContent = "Open", s.type = "button", s.addEventListener("click", () => { + this.closeModal(), vs({ + manifest: r + }); + }), a.appendChild(s); + const i = document.createElement("button"); + i.classList.add("button", "remove"), i.textContent = "Remove", i.type = "button", i.addEventListener("click", () => { + n.remove(); + const d = this.getPlugins().filter((f) => f.url !== r); + this.savePlugins(d); + }), a.appendChild(i), n.appendChild(a), (u = (c = this.dialog) == null ? void 0 : c.querySelector(".plugins-list")) == null || u.prepend(n); + } + loadPluginList() { + const e = this.getPlugins(); + for (const r of e) + this.createPlugin(r.name, r.url); + } + getPlugins() { + const e = localStorage.getItem("plugins"); + return e ? JSON.parse(e) : []; + } + savePlugins(e) { + localStorage.setItem("plugins", JSON.stringify(e)); + } + submitNewPlugin(e) { + e.preventDefault(); + const n = e.target.querySelector("input"); + if (!n) + return; + const a = n.value; + n.value = "", ys(a).then((s) => { + if (this.createPlugin(s.name, a), !localStorage.getItem("plugins")) + localStorage.setItem( + "plugins", + JSON.stringify([{ name: s.name, url: a }]) + ); + else { + const c = this.getPlugins(); + c.push({ name: s.name, url: a }), this.savePlugins(c); + } + this.error(!1); + }).catch((s) => { + console.error(s), this.error(!0); + }); + } + error(e) { + var r, n; + (n = (r = this.dialog) == null ? void 0 : r.querySelector(".error")) == null || n.classList.toggle("show", e); + } + connectedCallback() { + var r; + if (!this.shadowRoot) + throw new Error("Error creating shadow root"); + this.dialog = document.createElement("dialog"), this.dialog.innerHTML = ` +
+

Plugins

+ +
+
+ + +
+
+ Error instaling plugin +
+ +
    + `, (r = this.dialog.querySelector(".close")) == null || r.addEventListener("click", () => { + this.closeModal(); + }), this.shadowRoot.appendChild(this.dialog), this.dialog.addEventListener("submit", (n) => { + this.submitNewPlugin(n); + }), this.loadPluginList(); + const e = document.createElement("style"); + e.textContent = ` + * { + font-family worksans, sans-serif + } + + ::backdrop { + background-color: rgba(0, 0, 0, 0.8); + } + + dialog { + border: 0; + width: 700px; + height: 500px; + padding: 20px; + background-color: white; + border-radius: 10px; + flex-direction: column; + display: none; + } + + dialog[open] { + display: flex; + } + + .header { + display: flex; + justify-content: space-between; + } + + h1 { + margin: 0; + margin-block-end: 10px; + } + + ul { + padding: 0; + } + + li { + list-style: none; + } + + .input { + display: flex; + border: 1px solid; + border-radius: calc( 0.25rem * 2); + font-size: 12px; + font-weight: 400; + line-height: 1.4; + outline: none; + padding-block: calc( 0.25rem * 2); + padding-inline: calc( 0.25rem * 2); + background-color: #f3f4f6; + border-color: #f3f4f6; + color: #000; + + &:hover { + background-color: #eef0f2; + border-color: #eef0f2; + } + + &:focus { + background-color: #ffffff + border-color: ##6911d4; + } + } + + button { + background: transparent; + border: 0; + cursor: pointer; + } + + .button { + border: 1px solid transparent; + font-weight: 500; + font-size: 12px; + border-radius: 8px; + line-height: 1.2; + padding: 8px 24px 8px 24px; + text-transform: uppercase; + background-color: #7EFFF5; + border: 1px solid 7EFFF5; + outline: 2px solid transparent; + + &:hover:not(:disabled) { + cursor: pointer; + } + + &:focus-visible { + outline: none; + } + } + + .remove { + background-color: #ff3277; + border: 1px solid #ff3277; + outline: 2px solid transparent; + } + + form { + display: flex; + gap: 10px; + margin-block-end: 20px; + } + + .url-input { + inline-size: 400px; + } + + .plugins-list { + display: flex; + flex-direction: column; + gap: 10px; + } + + .plugin { + display: flex; + justify-content: space-between; + } + + .actions { + display: flex; + gap: 10px; + } + + .error { + display: none; + color: red; + + &.show { + display: block; + } + } + `, this.shadowRoot.appendChild(e); + } + closeModal() { + var e, r; + (r = (e = this.shadowRoot) == null ? void 0 : e.querySelector("dialog")) == null || r.close(), window.removeEventListener("paste", to, !0); + } + openModal() { + var e, r; + (r = (e = this.shadowRoot) == null ? void 0 : e.querySelector("dialog")) == null || r.showModal(), window.addEventListener("paste", to, !0); + } +} +function Yc() { + customElements.define("installer-modal", Jc); + const t = document.createElement("installer-modal"); + document.body.appendChild(t), document.addEventListener("keydown", (e) => { + var r; + e.key.toUpperCase() === "I" && e.ctrlKey && ((r = document.querySelector("installer-modal")) == null || r.openModal()); + }); +} +console.log("Loading plugin system"); +repairIntrinsics({ + evalTaming: "unsafeEval" +}); +globalThis.initPluginsRuntime = (t) => { + if (t) { + console.log("Initialize context"), globalThis.ɵcontext = t, globalThis.ɵloadPlugin = vs, Yc(), qc(t); + for (const e of en) + t.addListener(e, Vc.bind(null, e)); + } +}; +//# sourceMappingURL=index.mjs.map