@metapages/metapage 1.8.12 → 1.8.15

package/dist/index.js

@@ -1,80 +1,3636 @@
-import { METAFRAME_JSON_FILE as a, METAPAGE_KEY_DEFINITION as t, METAPAGE_KEY_STATE as o, VERSION_METAFRAME as i, VERSION_METAPAGE as n } from "./metapage/Constants.js";
-import { convertMetapageDefinitionToCurrentVersion as m, convertMetapageDefinitionToVersion as p, getMatchingMetapageVersion as M } from "./metapage/conversions-metapage.js";
-import { convertMetaframeDefinitionToCurrentVersion as g, convertMetaframeDefinitionToVersion as E, convertMetaframeJsonToCurrentVersion as l, getMatchingMetaframeVersion as T } from "./metapage/conversions-metaframe.js";
-import { deserializeInputs as A, possiblyDeserializeDatarefToFile as D, possiblyDeserializeDatarefToValue as R, possiblySerializeValueToDataref as V, serializeInputs as _, valueToFile as d } from "./metapage/data.js";
-import { MetapageEvents as h } from "./metapage/events.js";
-import { JsonRpcMethodsFromChild as c, JsonRpcMethodsFromParent as F } from "./metapage/jsonrpc.js";
-import { INTERNAL_ERROR as u, INVALID_PARAMS as S, INVALID_REQUEST as L, METHOD_NOT_FOUND as O, PARSE_ERROR as v, isJsonRpcId as C } from "./metapage/jsonrpc2.js";
-import { Metaframe as b, MetaframeEvents as y, MetaframeLoadingState as z } from "./metapage/Metaframe.js";
-import { Metapage as J, getLibraryVersionMatching as H, matchPipe as K } from "./metapage/Metapage.js";
-import { MetapageIFrameRpcClient as B } from "./metapage/MetapageIFrameRpcClient.js";
-import { generateId as j, generateMetaframeId as k, generateMetapageId as q, generateNonce as w, getUrlParam as W, getUrlParamDebug as X, hashCode as Z, intToRGB as $, isDebugFromUrlsParams as ee, isPageLoaded as re, log as ae, merge as te, metapageAllSha256Hash as oe, metapageOnlyEssentailSha256Hash as ie, pageLoaded as ne, stringToRgb as se } from "./metapage/MetapageTools.js";
-import { INITIAL_NULL_METAPAGE_DEFINITION as pe, MetapageHashParams as Me, MetapageShared as fe, isIframe as ge } from "./metapage/Shared.js";
-import { MetaframeVersionCurrent as le, MetaframeVersionsAll as Te, MetapageVersionCurrent as Ie, MetapageVersionsAll as Ae } from "./metapage/versions.js";
-import { getMetaframeDefinitionFromUrl as Re, getMetapageDefinitionFromUrl as Ve, isEmptyMetaframeDefinition as _e } from "./metapage/util.js";
-import { renderMetapage as Ne } from "./metapage/metapageRenderer.js";
+const Ct = ["0.3", "0.4", "0.5", "0.6", "1", "2"], $t = ["0.2", "0.3", "1", "2"], We = "2", Le = "2", Mi = "metaframe.json", Ii = "metapage/definition", Ci = "metapage/state", Wt = $t[$t.length - 1], En = Ct[Ct.length - 1], Mn = /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([\da-z\-]+(?:\.[\da-z\-]+)*))?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i, xt = (t) => {
+  if (typeof t != "string")
+    throw new TypeError("Invalid argument expected string");
+  const e = t.match(Mn);
+  if (!e)
+    throw new Error(`Invalid argument not valid semver ('${t}' received)`);
+  return e.shift(), e;
+}, Lt = (t) => t === "*" || t === "x" || t === "X", Tt = (t) => {
+  const e = parseInt(t, 10);
+  return isNaN(e) ? t : e;
+}, In = (t, e) => typeof t != typeof e ? [String(t), String(e)] : [t, e], Cn = (t, e) => {
+  if (Lt(t) || Lt(e))
+    return 0;
+  const [n, s] = In(Tt(t), Tt(e));
+  return n > s ? 1 : n < s ? -1 : 0;
+}, Pt = (t, e) => {
+  for (let n = 0; n < Math.max(t.length, e.length); n++) {
+    const s = Cn(t[n] || "0", e[n] || "0");
+    if (s !== 0)
+      return s;
+  }
+  return 0;
+}, j = (t, e) => {
+  const n = xt(t), s = xt(e), i = n.pop(), o = s.pop(), r = Pt(n, s);
+  return r !== 0 ? r : i && o ? Pt(i.split("."), o.split(".")) : i || o ? i ? -1 : 1 : 0;
+};
+var $n = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
+function yt(t) {
+  return t && t.__esModule && Object.prototype.hasOwnProperty.call(t, "default") ? t.default : t;
+}
+var Kt = { exports: {} };
+(function(t, e) {
+  (function(n, s) {
+    t.exports = s();
+  })($n, function() {
+    var n = function(o, r) {
+      if (r = r || {}, typeof o != "function")
+        throw new i("fetch must be a function");
+      if (typeof r != "object")
+        throw new i("defaults must be an object");
+      if (r.retries !== void 0 && !s(r.retries))
+        throw new i("retries must be a positive integer");
+      if (r.retryDelay !== void 0 && !s(r.retryDelay) && typeof r.retryDelay != "function")
+        throw new i("retryDelay must be a positive integer or a function returning a positive integer");
+      if (r.retryOn !== void 0 && !Array.isArray(r.retryOn) && typeof r.retryOn != "function")
+        throw new i("retryOn property expects an array or function");
+      var a = {
+        retries: 3,
+        retryDelay: 1e3,
+        retryOn: []
+      };
+      return r = Object.assign(a, r), function(l, c) {
+        var d = r.retries, g = r.retryDelay, v = r.retryOn;
+        if (c && c.retries !== void 0)
+          if (s(c.retries))
+            d = c.retries;
+          else
+            throw new i("retries must be a positive integer");
+        if (c && c.retryDelay !== void 0)
+          if (s(c.retryDelay) || typeof c.retryDelay == "function")
+            g = c.retryDelay;
+          else
+            throw new i("retryDelay must be a positive integer or a function returning a positive integer");
+        if (c && c.retryOn)
+          if (Array.isArray(c.retryOn) || typeof c.retryOn == "function")
+            v = c.retryOn;
+          else
+            throw new i("retryOn property expects an array or function");
+        return new Promise(function(y, R) {
+          var w = function(b) {
+            var A = typeof Request < "u" && l instanceof Request ? l.clone() : l;
+            o(A, c).then(function(E) {
+              if (Array.isArray(v) && v.indexOf(E.status) === -1)
+                y(E);
+              else if (typeof v == "function")
+                try {
+                  return Promise.resolve(v(b, null, E)).then(function(O) {
+                    O ? $(b, null, E) : y(E);
+                  }).catch(R);
+                } catch (O) {
+                  R(O);
+                }
+              else
+                b < d ? $(b, null, E) : y(E);
+            }).catch(function(E) {
+              if (typeof v == "function")
+                try {
+                  Promise.resolve(v(b, E, null)).then(function(O) {
+                    O ? $(b, E, null) : R(E);
+                  }).catch(function(O) {
+                    R(O);
+                  });
+                } catch (O) {
+                  R(O);
+                }
+              else
+                b < d ? $(b, E, null) : R(E);
+            });
+          };
+          function $(b, A, E) {
+            var O = typeof g == "function" ? g(b, A, E) : g;
+            setTimeout(function() {
+              w(++b);
+            }, O);
+          }
+          w(0);
+        });
+      };
+    };
+    function s(o) {
+      return Number.isInteger(o) && o >= 0;
+    }
+    function i(o) {
+      this.name = "ArgumentError", this.message = o;
+    }
+    return n;
+  });
+})(Kt);
+var xn = Kt.exports;
+const gt = /* @__PURE__ */ yt(xn), G = {
+  Remove: "remove",
+  Replace: "replace",
+  Add: "add"
+}, Xt = Symbol.for("__MUTATIVE_PROXY_DRAFT__"), Ln = Symbol("__MUTATIVE_RAW_RETURN_SYMBOL__"), Be = Symbol.iterator, Z = {
+  mutable: "mutable",
+  immutable: "immutable"
+}, _t = {};
+function Ie(t, e) {
+  return t instanceof Map ? t.has(e) : Object.prototype.hasOwnProperty.call(t, e);
+}
+function Dt(t, e) {
+  if (e in t) {
+    let n = Reflect.getPrototypeOf(t);
+    for (; n; ) {
+      const s = Reflect.getOwnPropertyDescriptor(n, e);
+      if (s)
+        return s;
+      n = Reflect.getPrototypeOf(n);
+    }
+  }
+}
+function Y(t) {
+  var e;
+  return (e = t.copy) !== null && e !== void 0 ? e : t.original;
+}
+function be(t) {
+  return !!P(t);
+}
+function P(t) {
+  return typeof t != "object" ? null : t == null ? void 0 : t[Xt];
+}
+function bt(t) {
+  var e;
+  const n = P(t);
+  return n ? (e = n.copy) !== null && e !== void 0 ? e : n.original : t;
+}
+function se(t, e) {
+  if (!t || typeof t != "object")
+    return !1;
+  let n;
+  return Object.getPrototypeOf(t) === Object.prototype || Array.isArray(t) || t instanceof Map || t instanceof Set || !!(e != null && e.mark) && ((n = e.mark(t, Z)) === Z.immutable || typeof n == "function");
+}
+function qt(t, e = []) {
+  if (Object.hasOwnProperty.call(t, "key")) {
+    const n = t.parent.copy, s = P(he(n, t.key));
+    if (s !== null && (s == null ? void 0 : s.original) !== t.original)
+      return null;
+    const i = t.parent.type === 3, o = i ? Array.from(t.parent.setMap.keys()).indexOf(t.key) : t.key;
+    if (!(i && n.size > o || Ie(n, o)))
+      return null;
+    e.push(o);
+  }
+  if (t.parent)
+    return qt(t.parent, e);
+  e.reverse();
+  try {
+    Tn(t.copy, e);
+  } catch {
+    return null;
+  }
+  return e;
+}
+function we(t) {
+  return Array.isArray(t) ? 1 : t instanceof Map ? 2 : t instanceof Set ? 3 : 0;
+}
+function he(t, e) {
+  return we(t) === 2 ? t.get(e) : t[e];
+}
+function Te(t, e, n) {
+  we(t) === 2 ? t.set(e, n) : t[e] = n;
+}
+function et(t, e) {
+  const n = P(t);
+  return (n ? Y(n) : t)[e];
+}
+function pe(t, e) {
+  return t === e ? t !== 0 || 1 / t === 1 / e : t !== t && e !== e;
+}
+function ot(t) {
+  if (t)
+    for (; t.finalities.revoke.length > 0; )
+      t.finalities.revoke.pop()();
+}
+function _e(t, e) {
+  return e ? t : [""].concat(t).map((n) => {
+    const s = `${n}`;
+    return s.indexOf("/") === -1 && s.indexOf("~") === -1 ? s : s.replace(/~/g, "~0").replace(/\//g, "~1");
+  }).join("/");
+}
+function Tn(t, e) {
+  for (let n = 0; n < e.length - 1; n += 1) {
+    const s = e[n];
+    if (t = he(we(t) === 3 ? Array.from(t) : t, s), typeof t != "object")
+      throw new Error(`Cannot resolve patch at '${e.join("/")}'.`);
+  }
+  return t;
+}
+function Pn(t) {
+  const e = Object.create(Object.getPrototypeOf(t));
+  return Reflect.ownKeys(t).forEach((n) => {
+    let s = Reflect.getOwnPropertyDescriptor(t, n);
+    if (s.enumerable && s.configurable && s.writable) {
+      e[n] = t[n];
+      return;
+    }
+    s.writable || (s.writable = !0, s.configurable = !0), (s.get || s.set) && (s = {
+      configurable: !0,
+      writable: !0,
+      enumerable: s.enumerable,
+      value: t[n]
+    }), Reflect.defineProperty(e, n, s);
+  }), e;
+}
+const Dn = Object.prototype.propertyIsEnumerable;
+function Qt(t, e) {
+  let n;
+  if (Array.isArray(t))
+    return Array.prototype.concat.call(t);
+  if (t instanceof Set)
+    return new Set(t.values());
+  if (t instanceof Map)
+    return new Map(t);
+  if (e != null && e.mark && (n = e.mark(t, Z), n !== void 0) && n !== Z.mutable) {
+    if (n === Z.immutable)
+      return Pn(t);
+    if (typeof n == "function") {
+      if (e.enablePatches || e.enableAutoFreeze)
+        throw new Error("You can't use mark and patches or auto freeze together.");
+      return n();
+    }
+    throw new Error(`Unsupported mark result: ${n}`);
+  } else if (typeof t == "object" && Object.getPrototypeOf(t) === Object.prototype) {
+    const s = {};
+    return Object.keys(t).forEach((i) => {
+      s[i] = t[i];
+    }), Object.getOwnPropertySymbols(t).forEach((i) => {
+      Dn.call(t, i) && (s[i] = t[i]);
+    }), s;
+  } else
+    throw new Error("Please check mark() to ensure that it is a stable marker draftable function.");
+}
+function X(t) {
+  t.copy || (t.copy = Qt(t.original, t.options));
+}
+function Ae(t) {
+  if (!se(t))
+    return bt(t);
+  if (Array.isArray(t))
+    return t.map(Ae);
+  if (t instanceof Map)
+    return new Map(Array.from(t.entries()).map(([n, s]) => [n, Ae(s)]));
+  if (t instanceof Set)
+    return new Set(Array.from(t).map(Ae));
+  const e = Object.create(Object.getPrototypeOf(t));
+  for (const n in t)
+    e[n] = Ae(t[n]);
+  return e;
+}
+function Fe(t) {
+  return be(t) ? Ae(t) : t;
+}
+function ue(t) {
+  var e;
+  t.assignedMap = (e = t.assignedMap) !== null && e !== void 0 ? e : /* @__PURE__ */ new Map(), t.operated || (t.operated = !0, t.parent && ue(t.parent));
+}
+function kt() {
+  throw new Error("Cannot modify frozen object");
+}
+function Re(t, e, n, s, i) {
+  {
+    n = n ?? /* @__PURE__ */ new WeakMap(), s = s ?? [], i = i ?? [];
+    const r = n.has(t) ? n.get(t) : t;
+    if (s.length > 0) {
+      const a = s.indexOf(r);
+      if (r && typeof r == "object" && a !== -1)
+        throw s[0] === r ? new Error("Forbids circular reference") : new Error(`Forbids circular reference: ~/${i.slice(0, a).map((u, l) => {
+          if (typeof u == "symbol")
+            return `[${u.toString()}]`;
+          const c = s[l];
+          return typeof u == "object" && (c instanceof Map || c instanceof Set) ? Array.from(c.keys()).indexOf(u) : u;
+        }).join("/")}`);
+      s.push(r), i.push(e);
+    } else
+      s.push(r);
+  }
+  if (Object.isFrozen(t) || be(t)) {
+    s.pop(), i.pop();
+    return;
+  }
+  switch (we(t)) {
+    case 2:
+      for (const [a, u] of t)
+        Re(a, a, n, s, i), Re(u, a, n, s, i);
+      t.set = t.clear = t.delete = kt;
+      break;
+    case 3:
+      for (const a of t)
+        Re(a, a, n, s, i);
+      t.add = t.clear = t.delete = kt;
+      break;
+    case 1:
+      Object.freeze(t);
+      let r = 0;
+      for (const a of t)
+        Re(a, r, n, s, i), r += 1;
+      break;
+    default:
+      Object.freeze(t), Object.keys(t).forEach((a) => {
+        const u = t[a];
+        Re(u, a, n, s, i);
+      });
+  }
+  s.pop(), i.pop();
+}
+function wt(t, e) {
+  const n = we(t);
+  if (n === 0)
+    Reflect.ownKeys(t).forEach((s) => {
+      e(s, t[s], t);
+    });
+  else if (n === 1) {
+    let s = 0;
+    for (const i of t)
+      e(s, i, t), s += 1;
+  } else
+    t.forEach((s, i) => e(i, s, t));
+}
+function Yt(t, e, n) {
+  if (be(t) || !se(t, n) || e.has(t) || Object.isFrozen(t))
+    return;
+  const s = t instanceof Set, i = s ? /* @__PURE__ */ new Map() : void 0;
+  if (e.add(t), wt(t, (o, r) => {
+    var a;
+    if (be(r)) {
+      const u = P(r);
+      X(u);
+      const l = !((a = u.assignedMap) === null || a === void 0) && a.size || u.operated ? u.copy : u.original;
+      Te(s ? i : t, o, l);
+    } else
+      Yt(r, e, n);
+  }), i) {
+    const o = t, r = Array.from(o);
+    o.clear(), r.forEach((a) => {
+      o.add(i.has(a) ? i.get(a) : a);
+    });
+  }
+}
+function kn(t, e) {
+  const n = t.type === 3 ? t.setMap : t.copy;
+  t.finalities.revoke.length > 1 && t.assignedMap.get(e) && n && Yt(he(n, e), t.finalities.handledSet, t.options);
+}
+function at(t) {
+  t.type === 3 && t.copy && (t.copy.clear(), t.setMap.forEach((e) => {
+    t.copy.add(bt(e));
+  }));
+}
+function ut(t, e, n, s) {
+  if (t.operated && t.assignedMap && t.assignedMap.size > 0 && !t.finalized) {
+    if (n && s) {
+      const o = qt(t);
+      o && e(t, o, n, s);
+    }
+    t.finalized = !0;
+  }
+}
+function vt(t, e, n, s) {
+  const i = P(n);
+  i && (i.callbacks || (i.callbacks = []), i.callbacks.push((o, r) => {
+    var a;
+    const u = t.type === 3 ? t.setMap : t.copy;
+    if (pe(he(u, e), n)) {
+      let l = i.original;
+      i.copy && (l = i.copy), at(t), ut(t, s, o, r), t.options.enableAutoFreeze && (t.options.updatedValues = (a = t.options.updatedValues) !== null && a !== void 0 ? a : /* @__PURE__ */ new WeakMap(), t.options.updatedValues.set(l, i.original)), Te(u, e, l);
+    }
+  }), t.options.enableAutoFreeze && i.finalities !== t.finalities && (t.options.enableAutoFreeze = !1)), se(n, t.options) && t.finalities.draft.push(() => {
+    const o = t.type === 3 ? t.setMap : t.copy;
+    pe(he(o, e), n) && kn(t, e);
+  });
+}
+function Hn(t, e, n, s, i) {
+  let { original: o, assignedMap: r, options: a } = t, u = t.copy;
+  u.length < o.length && ([o, u] = [u, o], [n, s] = [s, n]);
+  for (let l = 0; l < o.length; l += 1)
+    if (r.get(l.toString()) && u[l] !== o[l]) {
+      const c = e.concat([l]), d = _e(c, i);
+      n.push({
+        op: G.Replace,
+        path: d,
+        // If it is a draft, it needs to be deep cloned, and it may also be non-draft.
+        value: Fe(u[l])
+      }), s.push({
+        op: G.Replace,
+        path: d,
+        // If it is a draft, it needs to be deep cloned, and it may also be non-draft.
+        value: Fe(o[l])
+      });
+    }
+  for (let l = o.length; l < u.length; l += 1) {
+    const c = e.concat([l]), d = _e(c, i);
+    n.push({
+      op: G.Add,
+      path: d,
+      // If it is a draft, it needs to be deep cloned, and it may also be non-draft.
+      value: Fe(u[l])
+    });
+  }
+  if (o.length < u.length) {
+    const { arrayLengthAssignment: l = !0 } = a.enablePatches;
+    if (l) {
+      const c = e.concat(["length"]), d = _e(c, i);
+      s.push({
+        op: G.Replace,
+        path: d,
+        value: o.length
+      });
+    } else
+      for (let c = u.length; o.length < c; c -= 1) {
+        const d = e.concat([c - 1]), g = _e(d, i);
+        s.push({
+          op: G.Remove,
+          path: g
+        });
+      }
+  }
+}
+function Nn({ original: t, copy: e, assignedMap: n }, s, i, o, r) {
+  n.forEach((a, u) => {
+    const l = he(t, u), c = Fe(he(e, u)), d = a ? Ie(t, u) ? G.Replace : G.Add : G.Remove;
+    if (pe(l, c) && d === G.Replace)
+      return;
+    const g = s.concat(u), v = _e(g, r);
+    i.push(d === G.Remove ? { op: d, path: v } : { op: d, path: v, value: c }), o.push(d === G.Add ? { op: G.Remove, path: v } : d === G.Remove ? { op: G.Add, path: v, value: l } : { op: G.Replace, path: v, value: l });
+  });
+}
+function jn({ original: t, copy: e }, n, s, i, o) {
+  let r = 0;
+  t.forEach((a) => {
+    if (!e.has(a)) {
+      const u = n.concat([r]), l = _e(u, o);
+      s.push({
+        op: G.Remove,
+        path: l,
+        value: a
+      }), i.unshift({
+        op: G.Add,
+        path: l,
+        value: a
+      });
+    }
+    r += 1;
+  }), r = 0, e.forEach((a) => {
+    if (!t.has(a)) {
+      const u = n.concat([r]), l = _e(u, o);
+      s.push({
+        op: G.Add,
+        path: l,
+        value: a
+      }), i.unshift({
+        op: G.Remove,
+        path: l,
+        value: a
+      });
+    }
+    r += 1;
+  });
+}
+function $e(t, e, n, s) {
+  const { pathAsArray: i = !0 } = t.options.enablePatches;
+  switch (t.type) {
+    case 0:
+    case 2:
+      return Nn(t, e, n, s, i);
+    case 1:
+      return Hn(t, e, n, s, i);
+    case 3:
+      return jn(t, e, n, s, i);
+  }
+}
+let Un = !1;
+const ze = (t, e, n = !1) => {
+  if (typeof t == "object" && t !== null && (!se(t, e) || n) && !Un)
+    throw new Error("Strict mode: Mutable data cannot be accessed directly, please use 'unsafe(callback)' wrap.");
+}, ct = {
+  get size() {
+    return Y(P(this)).size;
+  },
+  has(t) {
+    return Y(P(this)).has(t);
+  },
+  set(t, e) {
+    const n = P(this), s = Y(n);
+    return (!s.has(t) || !pe(s.get(t), e)) && (X(n), ue(n), n.assignedMap.set(t, !0), n.copy.set(t, e), vt(n, t, e, $e)), this;
+  },
+  delete(t) {
+    if (!this.has(t))
+      return !1;
+    const e = P(this);
+    return X(e), ue(e), e.original.has(t) ? e.assignedMap.set(t, !1) : e.assignedMap.delete(t), e.copy.delete(t), !0;
+  },
+  clear() {
+    const t = P(this);
+    if (this.size) {
+      X(t), ue(t), t.assignedMap = /* @__PURE__ */ new Map();
+      for (const [e] of t.original)
+        t.assignedMap.set(e, !1);
+      t.copy.clear();
+    }
+  },
+  forEach(t, e) {
+    const n = P(this);
+    Y(n).forEach((s, i) => {
+      t.call(e, this.get(i), i, this);
+    });
+  },
+  get(t) {
+    var e, n;
+    const s = P(this), i = Y(s).get(t), o = ((n = (e = s.options).mark) === null || n === void 0 ? void 0 : n.call(e, i, Z)) === Z.mutable;
+    if (s.options.strict && ze(i, s.options, o), o || s.finalized || !se(i, s.options) || i !== s.original.get(t))
+      return i;
+    const r = _t.createDraft({
+      original: i,
+      parentDraft: s,
+      key: t,
+      finalities: s.finalities,
+      options: s.options
+    });
+    return X(s), s.copy.set(t, r), r;
+  },
+  keys() {
+    return Y(P(this)).keys();
+  },
+  values() {
+    const t = this.keys();
+    return {
+      [Be]: () => this.values(),
+      next: () => {
+        const e = t.next();
+        return e.done ? e : {
+          done: !1,
+          value: this.get(e.value)
+        };
+      }
+    };
+  },
+  entries() {
+    const t = this.keys();
+    return {
+      [Be]: () => this.entries(),
+      next: () => {
+        const e = t.next();
+        if (e.done)
+          return e;
+        const n = this.get(e.value);
+        return {
+          done: !1,
+          value: [e.value, n]
+        };
+      }
+    };
+  },
+  [Be]() {
+    return this.entries();
+  }
+}, Bn = Reflect.ownKeys(ct), Ht = (t, e, { isValuesIterator: n }) => () => {
+  var s, i;
+  const o = e.next();
+  if (o.done)
+    return o;
+  const r = o.value;
+  let a = t.setMap.get(r);
+  const u = P(a), l = ((i = (s = t.options).mark) === null || i === void 0 ? void 0 : i.call(s, a, Z)) === Z.mutable;
+  if (t.options.strict && ze(r, t.options, l), !l && !u && se(r, t.options) && !t.finalized && t.original.has(r)) {
+    const c = _t.createDraft({
+      original: r,
+      parentDraft: t,
+      key: r,
+      finalities: t.finalities,
+      options: t.options
+    });
+    t.setMap.set(r, c), a = c;
+  } else
+    u && (a = u.proxy);
+  return {
+    done: !1,
+    value: n ? a : [a, a]
+  };
+}, lt = {
+  get size() {
+    return P(this).setMap.size;
+  },
+  has(t) {
+    const e = P(this);
+    if (e.setMap.has(t))
+      return !0;
+    X(e);
+    const n = P(t);
+    return !!(n && e.setMap.has(n.original));
+  },
+  add(t) {
+    const e = P(this);
+    return this.has(t) || (X(e), ue(e), e.assignedMap.set(t, !0), e.setMap.set(t, t), vt(e, t, t, $e)), this;
+  },
+  delete(t) {
+    if (!this.has(t))
+      return !1;
+    const e = P(this);
+    X(e), ue(e);
+    const n = P(t);
+    return n && e.setMap.has(n.original) ? (e.assignedMap.set(n.original, !1), e.setMap.delete(n.original)) : (!n && e.setMap.has(t) ? e.assignedMap.set(t, !1) : e.assignedMap.delete(t), e.setMap.delete(t));
+  },
+  clear() {
+    if (!this.size)
+      return;
+    const t = P(this);
+    X(t), ue(t);
+    for (const e of t.original)
+      t.assignedMap.set(e, !1);
+    t.setMap.clear();
+  },
+  values() {
+    const t = P(this);
+    X(t);
+    const e = t.setMap.keys();
+    return {
+      [Symbol.iterator]: () => this.values(),
+      next: Ht(t, e, { isValuesIterator: !0 })
+    };
+  },
+  entries() {
+    const t = P(this);
+    X(t);
+    const e = t.setMap.keys();
+    return {
+      [Symbol.iterator]: () => this.entries(),
+      next: Ht(t, e, {
+        isValuesIterator: !1
+      })
+    };
+  },
+  keys() {
+    return this.values();
+  },
+  [Be]() {
+    return this.values();
+  },
+  forEach(t, e) {
+    const n = this.values();
+    let s = n.next();
+    for (; !s.done; )
+      t.call(e, s.value, s.value, this), s = n.next();
+  }
+}, Fn = Reflect.ownKeys(lt), Zt = /* @__PURE__ */ new WeakSet(), en = {
+  get(t, e, n) {
+    var s, i;
+    const o = (s = t.copy) === null || s === void 0 ? void 0 : s[e];
+    if (o && Zt.has(o))
+      return o;
+    if (e === Xt)
+      return t;
+    let r;
+    if (t.options.mark) {
+      const l = e === "size" && (t.original instanceof Map || t.original instanceof Set) ? Reflect.get(t.original, e) : Reflect.get(t.original, e, n);
+      if (r = t.options.mark(l, Z), r === Z.mutable)
+        return t.options.strict && ze(l, t.options, !0), l;
+    }
+    const a = Y(t);
+    if (a instanceof Map && Bn.includes(e)) {
+      if (e === "size")
+        return Object.getOwnPropertyDescriptor(ct, "size").get.call(t.proxy);
+      const l = ct[e];
+      if (l)
+        return l.bind(t.proxy);
+    }
+    if (a instanceof Set && Fn.includes(e)) {
+      if (e === "size")
+        return Object.getOwnPropertyDescriptor(lt, "size").get.call(t.proxy);
+      const l = lt[e];
+      if (l)
+        return l.bind(t.proxy);
+    }
+    if (!Ie(a, e)) {
+      const l = Dt(a, e);
+      return l ? "value" in l ? l.value : (
+        // !case: support for getter
+        (i = l.get) === null || i === void 0 ? void 0 : i.call(t.proxy)
+      ) : void 0;
+    }
+    const u = a[e];
+    if (t.options.strict && ze(u, t.options), t.finalized || !se(u, t.options))
+      return u;
+    if (u === et(t.original, e)) {
+      if (X(t), t.copy[e] = Rt({
+        original: t.original[e],
+        parentDraft: t,
+        key: t.type === 1 ? Number(e) : e,
+        finalities: t.finalities,
+        options: t.options
+      }), typeof r == "function") {
+        const l = P(t.copy[e]);
+        return X(l), ue(l), l.copy;
+      }
+      return t.copy[e];
+    }
+    return u;
+  },
+  set(t, e, n) {
+    var s;
+    if (t.type === 3 || t.type === 2)
+      throw new Error("Map/Set draft does not support any property assignment.");
+    let i;
+    if (t.type === 1 && e !== "length" && !(Number.isInteger(i = Number(e)) && i >= 0 && (e === 0 || i === 0 || String(i) === String(e))))
+      throw new Error("Only supports setting array indices and the 'length' property.");
+    const o = Dt(Y(t), e);
+    if (o != null && o.set)
+      return o.set.call(t.proxy, n), !0;
+    const r = et(Y(t), e), a = P(r);
+    return a && pe(a.original, n) ? (t.copy[e] = n, t.assignedMap = (s = t.assignedMap) !== null && s !== void 0 ? s : /* @__PURE__ */ new Map(), t.assignedMap.set(e, !1), !0) : (pe(n, r) && (n !== void 0 || Ie(t.original, e)) || (X(t), ue(t), Ie(t.original, e) && pe(n, t.original[e]) ? t.assignedMap.delete(e) : t.assignedMap.set(e, !0), t.copy[e] = n, vt(t, e, n, $e)), !0);
+  },
+  has(t, e) {
+    return e in Y(t);
+  },
+  ownKeys(t) {
+    return Reflect.ownKeys(Y(t));
+  },
+  getOwnPropertyDescriptor(t, e) {
+    const n = Y(t), s = Reflect.getOwnPropertyDescriptor(n, e);
+    return s && {
+      writable: !0,
+      configurable: t.type !== 1 || e !== "length",
+      enumerable: s.enumerable,
+      value: n[e]
+    };
+  },
+  getPrototypeOf(t) {
+    return Reflect.getPrototypeOf(t.original);
+  },
+  setPrototypeOf() {
+    throw new Error("Cannot call 'setPrototypeOf()' on drafts");
+  },
+  defineProperty() {
+    throw new Error("Cannot call 'defineProperty()' on drafts");
+  },
+  deleteProperty(t, e) {
+    var n;
+    return t.type === 1 ? en.set.call(this, t, e, void 0, t.proxy) : (et(t.original, e) !== void 0 || e in t.original ? (X(t), ue(t), t.assignedMap.set(e, !1)) : (t.assignedMap = (n = t.assignedMap) !== null && n !== void 0 ? n : /* @__PURE__ */ new Map(), t.assignedMap.delete(e)), t.copy && delete t.copy[e], !0);
+  }
+};
+function Rt(t) {
+  const { original: e, parentDraft: n, key: s, finalities: i, options: o } = t, r = we(e), a = {
+    type: r,
+    finalized: !1,
+    parent: n,
+    original: e,
+    copy: null,
+    proxy: null,
+    finalities: i,
+    options: o,
+    // Mapping of draft Set items to their corresponding draft values.
+    setMap: r === 3 ? new Map(e.entries()) : void 0
+  };
+  (s || "key" in t) && (a.key = s);
+  const { proxy: u, revoke: l } = Proxy.revocable(r === 1 ? Object.assign([], a) : a, en);
+  if (i.revoke.push(l), Zt.add(u), a.proxy = u, n) {
+    const c = n;
+    c.finalities.draft.push((d, g) => {
+      var v, y;
+      const R = P(u);
+      let w = c.type === 3 ? c.setMap : c.copy;
+      const $ = he(w, s), b = P($);
+      if (b) {
+        let A = b.original;
+        b.operated && (A = bt($)), at(b), ut(b, $e, d, g), c.options.enableAutoFreeze && (c.options.updatedValues = (v = c.options.updatedValues) !== null && v !== void 0 ? v : /* @__PURE__ */ new WeakMap(), c.options.updatedValues.set(A, b.original)), Te(w, s, A);
+      }
+      (y = R.callbacks) === null || y === void 0 || y.forEach((A) => {
+        A(d, g);
+      });
+    });
+  } else {
+    const c = P(u);
+    c.finalities.draft.push((d, g) => {
+      at(c), ut(c, $e, d, g);
+    });
+  }
+  return u;
+}
+_t.createDraft = Rt;
+function zn(t, e, n, s, i) {
+  var o;
+  const r = P(t), a = (o = r == null ? void 0 : r.original) !== null && o !== void 0 ? o : t, u = !!e.length;
+  if (r != null && r.operated)
+    for (; r.finalities.draft.length > 0; )
+      r.finalities.draft.pop()(n, s);
+  const l = u ? e[0] : r ? r.operated ? r.copy : r.original : t;
+  return r && ot(r), i && Re(l, l, r == null ? void 0 : r.options.updatedValues), [
+    l,
+    n && u ? [{ op: G.Replace, path: [], value: e[0] }] : n,
+    s && u ? [{ op: G.Replace, path: [], value: a }] : s
+  ];
+}
+function Gn(t, e) {
+  var n;
+  const s = {
+    draft: [],
+    revoke: [],
+    handledSet: /* @__PURE__ */ new WeakSet()
+  };
+  let i, o;
+  e.enablePatches && (i = [], o = []);
+  const a = ((n = e.mark) === null || n === void 0 ? void 0 : n.call(e, t, Z)) === Z.mutable || !se(t, e) ? t : Rt({
+    original: t,
+    parentDraft: null,
+    finalities: s,
+    options: e
+  });
+  return [
+    a,
+    (u = []) => {
+      const [l, c, d] = zn(a, u, i, o, e.enableAutoFreeze);
+      return e.enablePatches ? [l, c, d] : l;
+    }
+  ];
+}
+function ft(t) {
+  const { rootDraft: e, value: n, useRawReturn: s = !1, isRoot: i = !0 } = t;
+  wt(n, (o, r, a) => {
+    const u = P(r);
+    if (u && e && u.finalities === e.finalities) {
+      t.isContainDraft = !0;
+      const l = u.original;
+      if (a instanceof Set) {
+        const c = Array.from(a);
+        a.clear(), c.forEach((d) => a.add(o === d ? l : d));
+      } else
+        Te(a, o, l);
+    } else
+      typeof r == "object" && r !== null && (t.value = r, t.isRoot = !1, ft(t));
+  }), i && (t.isContainDraft || console.warn("The return value does not contain any draft, please use 'rawReturn()' to wrap the return value to improve performance."), s && console.warn("The return value contains drafts, please don't use 'rawReturn()' to wrap the return value."));
+}
+function tn(t) {
+  const e = P(t);
+  if (!se(t, e == null ? void 0 : e.options))
+    return t;
+  const n = we(t);
+  if (e && !e.operated)
+    return e.original;
+  let s;
+  function i() {
+    s = n === 2 ? new Map(t) : n === 3 ? Array.from(e.setMap.values()) : Qt(t, e == null ? void 0 : e.options);
+  }
+  if (e) {
+    e.finalized = !0;
+    try {
+      i();
+    } finally {
+      e.finalized = !1;
+    }
+  } else
+    s = t;
+  return wt(s, (o, r) => {
+    if (e && pe(he(e.original, o), r))
+      return;
+    const a = tn(r);
+    a !== r && (s === t && i(), Te(s, o, a));
+  }), n === 3 ? new Set(s) : s;
+}
+function Nt(t) {
+  if (!be(t))
+    throw new Error(`current() is only used for Draft, parameter: ${t}`);
+  return tn(t);
+}
+const Vn = (t) => {
+  if (t !== void 0 && Object.prototype.toString.call(t) !== "[object Object]")
+    throw new Error(`Invalid options: ${String(t)}, 'options' should be an object.`);
+  return function e(n, s, i) {
+    var o, r, a;
+    if (typeof n == "function" && typeof s != "function")
+      return function(O, ...H) {
+        return e(O, (S) => n.call(this, S, ...H), s);
+      };
+    const u = n, l = s;
+    let c = i;
+    if (typeof s != "function" && (c = s), c !== void 0 && Object.prototype.toString.call(c) !== "[object Object]")
+      throw new Error(`Invalid options: ${c}, 'options' should be an object.`);
+    c = Object.assign(Object.assign({}, t), c);
+    const d = be(u) ? Nt(u) : u, g = Array.isArray(c.mark) ? (O, H) => {
+      for (const S of c.mark) {
+        if (typeof S != "function")
+          throw new Error(`Invalid mark: ${S}, 'mark' should be a function.`);
+        const L = S(O, H);
+        if (L)
+          return L;
+      }
+    } : c.mark, v = (o = c.enablePatches) !== null && o !== void 0 ? o : !1, y = (r = c.strict) !== null && r !== void 0 ? r : !1, w = {
+      enableAutoFreeze: (a = c.enableAutoFreeze) !== null && a !== void 0 ? a : !1,
+      mark: g,
+      strict: y,
+      enablePatches: v
+    };
+    if (!se(d, w) && typeof d == "object" && d !== null)
+      throw new Error("Invalid base state: create() only supports plain objects, arrays, Set, Map or using mark() to mark the state as immutable.");
+    const [$, b] = Gn(d, w);
+    if (typeof s != "function") {
+      if (!se(d, w))
+        throw new Error("Invalid base state: create() only supports plain objects, arrays, Set, Map or using mark() to mark the state as immutable.");
+      return [$, b];
+    }
+    let A;
+    try {
+      A = l($);
+    } catch (O) {
+      throw ot(P($)), O;
+    }
+    const E = (O) => {
+      const H = P($);
+      if (!be(O)) {
+        if (O !== void 0 && !pe(O, $) && (H != null && H.operated))
+          throw new Error("Either the value is returned as a new non-draft value, or only the draft is modified without returning any value.");
+        const L = O == null ? void 0 : O[Ln];
+        if (L) {
+          const U = L[0];
+          return w.strict && typeof O == "object" && O !== null && ft({
+            rootDraft: H,
+            value: O,
+            useRawReturn: !0
+          }), b([U]);
+        }
+        if (O !== void 0)
+          return typeof O == "object" && O !== null && ft({ rootDraft: H, value: O }), b([O]);
+      }
+      if (O === $ || O === void 0)
+        return b([]);
+      const S = P(O);
+      if (w === S.options) {
+        if (S.operated)
+          throw new Error("Cannot return a modified child draft.");
+        return b([Nt(O)]);
+      }
+      return b([O]);
+    };
+    return A instanceof Promise ? A.then(E, (O) => {
+      throw ot(P($)), O;
+    }) : E(A);
+  };
+}, C = Vn();
+Object.prototype.constructor.toString();
+const Jn = gt(fetch), nn = async (t, e) => {
+  if (!t)
+    throw "Metapage definition null";
+  if (t.version || (t = C(t, (s) => {
+    s.version = "0.3";
+  })), !e)
+    throw 'Missing "version" argument';
+  if (j(e, Le) > 0)
+    try {
+      return await (await Jn(`https://module.metapage.io/conversion/metapage/v${e}`, {
+        redirect: "follow",
+        retries: 3,
+        retryDelay: 1e3,
+        method: "POST",
+        body: JSON.stringify(t),
+        headers: {
+          "Content-Type": "application/json"
+        }
+      })).json();
+    } catch (s) {
+      throw `Error converting metapage definition to version ${e}: ${s}`;
+    }
+  return Kn(t, e);
+}, Wn = async (t) => nn(t, Le), Kn = (t, e) => {
+  if (!t)
+    throw "Metapage definition null";
+  if (!t.version)
+    throw `Missing "version" key in metapage definition: ${JSON.stringify(t)}`;
+  let n = de(t.version);
+  if (n === e)
+    return t;
+  let s = t;
+  for (; n !== e; )
+    switch (n) {
+      case "0.2": {
+        if (j(e, n) > 0)
+          s = Xn(s), n = de(s.version);
+        else
+          throw `Cannot convert from version ${n} to ${e}`;
+        break;
+      }
+      case "0.3": {
+        j(e, n) > 0 ? (s = Qn(s), n = de(s.version)) : (s = qn(s), n = de(s.version));
+        break;
+      }
+      case "1": {
+        j(e, n) > 0 ? (s = es(s), n = de(s.version)) : (s = Yn(s), n = de(s.version));
+        break;
+      }
+      case "2": {
+        if (j(e, n) > 0)
+          throw `Cannot convert from version ${n} to ${e}, 1 is the latest version`;
+        s = Zn(s), n = de(s.version);
+        break;
+      }
+      default:
+        throw `Unknow version ${n} to ${e}`;
+    }
+  return s;
+}, Xn = (t) => C(t, (e) => {
+  e.version = "0.3";
+}), qn = (t) => C(t, (e) => {
+  e.version = "0.2";
+}), Qn = (t) => C(t, (e) => {
+  const n = e;
+  delete n.plugins, n.version = "1";
+}), Yn = (t) => C(t, (e) => (e.version = "0.3", e)), Zn = (t) => C(t, (e) => {
+  var n, s;
+  return e.version = "1", (n = e == null ? void 0 : e.meta) != null && n.tags && (e.meta.keywords = e.meta.tags, delete e.meta.tags), (s = e == null ? void 0 : e.meta) != null && s.authors && (e.meta.author = e.meta.authors[0], delete e.meta.authors), e;
+}), es = (t) => C(t, (e) => {
+  var n, s;
+  return e.version = "2", (n = e == null ? void 0 : e.meta) != null && n.keywords && (e.meta.tags = e.meta.keywords, delete e.meta.keywords), (s = e == null ? void 0 : e.meta) != null && s.author && (e.meta.authors = [e.meta.author], delete e.meta.author), e;
+}), de = (t) => {
+  if (t === "latest")
+    return Le;
+  if (j(t, "0.2") < 0)
+    throw `Unknown version: ${t}`;
+  if (j(t, "0.2") <= 0 && j(t, "0.3") < 0)
+    return "0.2";
+  if (j(t, "0.3") <= 0)
+    return "0.3";
+  if (j(t, "1") <= 0)
+    return "1";
+  if (t === "2")
+    return "2";
+  throw `Unknown version: ${t}`;
+}, ts = gt(fetch), sn = async (t, e) => {
+  if (!t)
+    throw "Metaframe definition null";
+  if (!t.version)
+    throw `Missing "version" key in metaframe definition: ${JSON.stringify(t)}`;
+  if (!e)
+    throw 'Missing "version" argument';
+  if (j(e, We) > 0)
+    try {
+      return await (await ts(`https://module.metapage.io/conversion/metaframe/v${e}`, {
+        redirect: "follow",
+        retries: 3,
+        retryDelay: 1e3,
+        method: "POST",
+        body: JSON.stringify(t),
+        headers: {
+          "Content-Type": "application/json"
+        }
+      })).json();
+    } catch (s) {
+      throw `Error converting metapage definition to version ${e}: ${s}`;
+    }
+  return ss(t, e);
+}, ns = async (t) => sn(t, We), ss = (t, e) => {
+  if (!t)
+    throw "Metaframe definition null";
+  t.version || (t = C(t, (i) => {
+    i.version = "0.3";
+  }));
+  let n = te(t.version);
+  if (n === e)
+    return t;
+  let s = t;
+  for (; n !== e; )
+    switch (n) {
+      case "0.3": {
+        if (j(e, n) > 0)
+          s = rs(s), n = te(s.version);
+        else
+          throw `Cannot convert from version ${n} to ${e}`;
+        break;
+      }
+      case "0.4": {
+        j(e, n) > 0 ? (s = os(s), n = te(s.version)) : (s = is(s), n = te(s.version));
+        break;
+      }
+      case "0.5": {
+        j(e, n) > 0 ? (s = ps(s), n = te(s.version)) : (s = as(s), n = te(s.version));
+        break;
+      }
+      case "0.6": {
+        j(e, n) > 0 ? (s = us(s), n = te(s.version)) : (s = hs(s), n = te(s.version));
+        break;
+      }
+      case "1": {
+        j(e, n) > 0 ? (s = fs(s), n = te(s.version)) : (s = cs(s), n = te(s.version));
+        break;
+      }
+      case "2": {
+        if (j(e, n) > 0)
+          throw `Cannot convert from version ${n} to ${e}`;
+        s = ls(s), n = te(s.version);
+        break;
+      }
+      default:
+        throw `Unknow version ${n} to ${e}`;
+    }
+  return s;
+}, pt = async (t, e) => {
+  if (t)
+    return ns(t);
+}, is = (t) => C(t, (e) => {
+  e.version = "0.3", delete e.allow;
+}), rs = (t) => C(t, (e) => {
+  e.version = "0.4";
+}), os = (t) => C(t, (e) => {
+  if (e.version = "0.5", !(e != null && e.metadata))
+    return;
+  const n = e.metadata.title;
+  delete e.metadata.title, e.metadata.name = n;
+  const s = e.metadata.descriptionUrl;
+  delete e.metadata.descriptionUrl, e.metadata.description = s;
+  const i = e.metadata.keywords;
+  delete e.metadata.keywords, e.metadata.tags = i;
+}), as = (t) => C(t, (e) => {
+  if (e.version = "0.4", !(e != null && e.metadata))
+    return;
+  const n = e.metadata.name;
+  delete e.metadata.name, e.metadata.title = n;
+  const s = e.metadata.description;
+  delete e.metadata.description, e.metadata.descriptionUrl = s;
+  const i = e.metadata.tags;
+  delete e.metadata.tags, e.metadata.keywords = i;
+}), us = (t) => C(t, (e) => {
+  var n;
+  e.version = "1", (n = e == null ? void 0 : e.metadata) != null && n.operations && delete e.metadata.operations;
+}), cs = (t) => C(t, (e) => {
+  var n;
+  e.version = "0.6", (n = e == null ? void 0 : e.metadata) != null && n.operations && delete e.metadata.operations;
+}), ls = (t) => C(t, (e) => {
+  var n, s;
+  return e.version = "1", (n = e == null ? void 0 : e.metadata) != null && n.authors && (e.metadata.author = (s = e == null ? void 0 : e.metadata) == null ? void 0 : s.authors[0], delete e.metadata.authors), e;
+}), fs = (t) => C(t, (e) => {
+  var n;
+  return e.version = "2", (n = e == null ? void 0 : e.metadata) != null && n.author && (e.metadata.authors = [
+    e.metadata.author
+  ], delete e.metadata.author), e;
+}), ps = (t) => C(t, (e) => {
+  var n;
+  e.version = "0.6", (n = e == null ? void 0 : e.metadata) != null && n.operations && delete e.metadata.operations;
+}), hs = (t) => C(t, (e) => {
+  var n;
+  e.version = "0.5", (n = e == null ? void 0 : e.metadata) != null && n.operations && delete e.metadata.operations;
+}), te = (t) => {
+  if (t === "latest")
+    return We;
+  if (j(t, "0.3") < 0)
+    throw `Unknown version: ${t}`;
+  if (j(t, "0.3") <= 0)
+    return "0.3";
+  if (j(t, "0.4") <= 0)
+    return "0.4";
+  if (j(t, "0.5") <= 0)
+    return "0.5";
+  if (j(t, "0.6") <= 0)
+    return "0.6";
+  if (j(t, "1") <= 0)
+    return "1";
+  if (t === "2")
+    return "2";
+  throw `Unknown version: ${t}`;
+};
+var Oe = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", Ee = typeof Uint8Array > "u" ? [] : new Uint8Array(256);
+for (var je = 0; je < Oe.length; je++)
+  Ee[Oe.charCodeAt(je)] = je;
+var Ue = function(t) {
+  var e = new Uint8Array(t), n, s = e.length, i = "";
+  for (n = 0; n < s; n += 3)
+    i += Oe[e[n] >> 2], i += Oe[(e[n] & 3) << 4 | e[n + 1] >> 4], i += Oe[(e[n + 1] & 15) << 2 | e[n + 2] >> 6], i += Oe[e[n + 2] & 63];
+  return s % 3 === 2 ? i = i.substring(0, i.length - 1) + "=" : s % 3 === 1 && (i = i.substring(0, i.length - 2) + "=="), i;
+}, me = function(t) {
+  var e = t.length * 0.75, n = t.length, s, i = 0, o, r, a, u;
+  t[t.length - 1] === "=" && (e--, t[t.length - 2] === "=" && e--);
+  var l = new ArrayBuffer(e), c = new Uint8Array(l);
+  for (s = 0; s < n; s += 4)
+    o = Ee[t.charCodeAt(s)], r = Ee[t.charCodeAt(s + 1)], a = Ee[t.charCodeAt(s + 2)], u = Ee[t.charCodeAt(s + 3)], c[i++] = o << 2 | r >> 4, c[i++] = (r & 15) << 4 | a >> 2, c[i++] = (a & 3) << 6 | u & 63;
+  return l;
+};
+const Ke = async (t) => C(t, async (e) => {
+  for (const n of Object.keys(t)) {
+    const s = await ds(t[n]);
+    return e[n] = s, e;
+  }
+}), Ce = async (t) => C(t, async (e) => {
+  for (const n of Object.keys(t)) {
+    const s = await rn(t[n]);
+    return e[n] = s, e;
+  }
+}), $i = async (t, e, n) => {
+  if (t = rn(t), n = n || {}, n.type || (n.type = "application/octet-stream"), t instanceof ArrayBuffer)
+    return new File([t], e, n);
+  if (t instanceof File || t instanceof Blob) {
+    const i = await t.arrayBuffer();
+    return t instanceof File && (n.type = t.type), new File([i], e, n);
+  }
+  if (t instanceof Int8Array || t instanceof Uint8Array || t instanceof Uint8ClampedArray || t instanceof Int16Array || t instanceof Uint16Array || t instanceof Int32Array || t instanceof Uint32Array || t instanceof Float32Array || t instanceof Float64Array) {
+    const i = t;
+    return new File([i.buffer], e, n);
+  }
+  if (typeof t == "string") {
+    var s = new Blob([t], { type: "text/plain" });
+    return n.type = "text/plain", new File([s], e, n);
+  }
+  if (typeof t == "object") {
+    const i = new Blob([JSON.stringify(t)], {
+      type: "application/json"
+    });
+    return n.type = "application/json", new File([i], e, n);
+  }
+  var s = new Blob([t], { type: "text/plain" });
+  return n.type = "text/plain", new File([s], e, n);
+}, ds = async (t) => {
+  if (t instanceof Int8Array || t instanceof Uint8Array || t instanceof Uint8ClampedArray || t instanceof Int16Array || t instanceof Uint16Array || t instanceof Int32Array || t instanceof Uint32Array || t instanceof Float32Array || t instanceof Float64Array) {
+    const e = t, n = {
+      _s: !0,
+      _c: t.constructor.name,
+      value: Ue(e.buffer),
+      byteLength: e.byteLength,
+      byteOffset: e.byteOffset,
+      size: e.byteLength
+    };
+    return Promise.resolve(n);
+  } else if (t instanceof File) {
+    const e = t, n = await e.arrayBuffer();
+    return {
+      _s: !0,
+      _c: File.name,
+      value: Ue(n),
+      name: e.name,
+      fileType: e.type,
+      lastModified: e.lastModified,
+      size: n.byteLength
+    };
+  } else if (t instanceof Blob) {
+    const e = t, n = await e.arrayBuffer();
+    return {
+      _s: !0,
+      _c: Blob.name,
+      value: Ue(n),
+      fileType: e.type,
+      size: n.byteLength
+    };
+  } else if (t instanceof ArrayBuffer) {
+    const e = t, n = {
+      _s: !0,
+      _c: ArrayBuffer.name,
+      value: Ue(e),
+      size: e.byteLength
+    };
+    return Promise.resolve(n);
+  }
+  return Promise.resolve(t);
+}, rn = (t) => {
+  if (!(t && typeof t == "object" && t._s === !0))
+    return t;
+  const e = t, n = e._c;
+  if (n === Blob.name) {
+    const r = t;
+    return new Blob([me(e.value)], {
+      type: r.fileType
+    });
+  } else if (n === File.name) {
+    const r = t;
+    return new File([me(e.value)], r.name, {
+      type: r.fileType,
+      lastModified: r.lastModified
+    });
+  } else if (n === ArrayBuffer.name)
+    return me(e.value);
+  const s = t, i = me(s.value), o = s._c;
+  try {
+    return new globalThis[o](i);
+  } catch {
+  }
+  return t;
+}, xi = (t) => {
+  if (!(t && typeof t == "object" && t._s === !0))
+    return;
+  const e = t, n = e._c;
+  if (n === Blob.name) {
+    const r = t, a = new Blob([me(e.value)], {
+      type: r.fileType
+    });
+    return new File([a], "file", {
+      type: a.type
+    });
+  } else if (n === File.name) {
+    const r = t;
+    return new File([me(e.value)], r.name, {
+      type: r.fileType,
+      lastModified: r.lastModified
+    });
+  } else if (n === ArrayBuffer.name) {
+    const r = me(e.value);
+    return new File([r], "file", {
+      type: "application/octet-stream"
+    });
+  }
+  const s = t, i = me(s.value), o = s._c;
+  try {
+    const r = new globalThis[o](i);
+    return new File([r], "file", {
+      type: "application/octet-stream"
+    });
+  } catch {
+  }
+};
+var x;
+(function(t) {
+  t.Inputs = "inputs", t.Outputs = "outputs", t.State = "state", t.Definition = "definition", t.Error = "error", t.Warning = "warning", t.UrlHashUpdate = "urlhashupdate", t.Message = "Message";
+})(x || (x = {}));
+var q;
+(function(t) {
+  t.InputsUpdate = "InputsUpdate", t.OutputsUpdate = "OutputsUpdate", t.SetupIframeClientRequest = "SetupIframeClientRequest", t.SetupIframeServerResponseAck = "SetupIframeServerResponseAck", t.HashParamsUpdate = "HashParamsUpdate";
+})(q || (q = {}));
+var fe;
+(function(t) {
+  t.InputsUpdate = "InputsUpdate", t.MessageAck = "MessageAck", t.SetupIframeServerResponse = "SetupIframeServerResponse";
+})(fe || (fe = {}));
+const Li = -32700, Ti = -32600, Pi = -32601, Di = -32602, ki = -32603;
+function Hi(t) {
+  switch (typeof t) {
+    case "string":
+      return !0;
+    case "number":
+      return t % 1 != 0;
+    case "object":
+      return t === null ? (console.warn("Use of null ID in JSONRPC 2.0 is discouraged."), !0) : !1;
+    default:
+      return !1;
+  }
+}
+var on = { exports: {} };
+(function(t) {
+  var e = Object.prototype.hasOwnProperty, n = "~";
+  function s() {
+  }
+  Object.create && (s.prototype = /* @__PURE__ */ Object.create(null), new s().__proto__ || (n = !1));
+  function i(u, l, c) {
+    this.fn = u, this.context = l, this.once = c || !1;
+  }
+  function o(u, l, c, d, g) {
+    if (typeof c != "function")
+      throw new TypeError("The listener must be a function");
+    var v = new i(c, d || u, g), y = n ? n + l : l;
+    return u._events[y] ? u._events[y].fn ? u._events[y] = [u._events[y], v] : u._events[y].push(v) : (u._events[y] = v, u._eventsCount++), u;
+  }
+  function r(u, l) {
+    --u._eventsCount === 0 ? u._events = new s() : delete u._events[l];
+  }
+  function a() {
+    this._events = new s(), this._eventsCount = 0;
+  }
+  a.prototype.eventNames = function() {
+    var l = [], c, d;
+    if (this._eventsCount === 0)
+      return l;
+    for (d in c = this._events)
+      e.call(c, d) && l.push(n ? d.slice(1) : d);
+    return Object.getOwnPropertySymbols ? l.concat(Object.getOwnPropertySymbols(c)) : l;
+  }, a.prototype.listeners = function(l) {
+    var c = n ? n + l : l, d = this._events[c];
+    if (!d)
+      return [];
+    if (d.fn)
+      return [d.fn];
+    for (var g = 0, v = d.length, y = new Array(v); g < v; g++)
+      y[g] = d[g].fn;
+    return y;
+  }, a.prototype.listenerCount = function(l) {
+    var c = n ? n + l : l, d = this._events[c];
+    return d ? d.fn ? 1 : d.length : 0;
+  }, a.prototype.emit = function(l, c, d, g, v, y) {
+    var R = n ? n + l : l;
+    if (!this._events[R])
+      return !1;
+    var w = this._events[R], $ = arguments.length, b, A;
+    if (w.fn) {
+      switch (w.once && this.removeListener(l, w.fn, void 0, !0), $) {
+        case 1:
+          return w.fn.call(w.context), !0;
+        case 2:
+          return w.fn.call(w.context, c), !0;
+        case 3:
+          return w.fn.call(w.context, c, d), !0;
+        case 4:
+          return w.fn.call(w.context, c, d, g), !0;
+        case 5:
+          return w.fn.call(w.context, c, d, g, v), !0;
+        case 6:
+          return w.fn.call(w.context, c, d, g, v, y), !0;
+      }
+      for (A = 1, b = new Array($ - 1); A < $; A++)
+        b[A - 1] = arguments[A];
+      w.fn.apply(w.context, b);
+    } else {
+      var E = w.length, O;
+      for (A = 0; A < E; A++)
+        switch (w[A].once && this.removeListener(l, w[A].fn, void 0, !0), $) {
+          case 1:
+            w[A].fn.call(w[A].context);
+            break;
+          case 2:
+            w[A].fn.call(w[A].context, c);
+            break;
+          case 3:
+            w[A].fn.call(w[A].context, c, d);
+            break;
+          case 4:
+            w[A].fn.call(w[A].context, c, d, g);
+            break;
+          default:
+            if (!b)
+              for (O = 1, b = new Array($ - 1); O < $; O++)
+                b[O - 1] = arguments[O];
+            w[A].fn.apply(w[A].context, b);
+        }
+    }
+    return !0;
+  }, a.prototype.on = function(l, c, d) {
+    return o(this, l, c, d, !1);
+  }, a.prototype.once = function(l, c, d) {
+    return o(this, l, c, d, !0);
+  }, a.prototype.removeListener = function(l, c, d, g) {
+    var v = n ? n + l : l;
+    if (!this._events[v])
+      return this;
+    if (!c)
+      return r(this, v), this;
+    var y = this._events[v];
+    if (y.fn)
+      y.fn === c && (!g || y.once) && (!d || y.context === d) && r(this, v);
+    else {
+      for (var R = 0, w = [], $ = y.length; R < $; R++)
+        (y[R].fn !== c || g && !y[R].once || d && y[R].context !== d) && w.push(y[R]);
+      w.length ? this._events[v] = w.length === 1 ? w[0] : w : r(this, v);
+    }
+    return this;
+  }, a.prototype.removeAllListeners = function(l) {
+    var c;
+    return l ? (c = n ? n + l : l, this._events[c] && r(this, c)) : (this._events = new s(), this._eventsCount = 0), this;
+  }, a.prototype.off = a.prototype.removeListener, a.prototype.addListener = a.prototype.on, a.prefixed = n, a.EventEmitter = a, t.exports = a;
+})(on);
+var Ot = on.exports;
+function ms(t) {
+  return t && t.__esModule && Object.prototype.hasOwnProperty.call(t, "default") ? t.default : t;
+}
+var ys = function(t, e) {
+  e || (e = {}), typeof e == "function" && (e = { cmp: e });
+  var n = typeof e.cycles == "boolean" ? e.cycles : !1, s = e.cmp && /* @__PURE__ */ function(o) {
+    return function(r) {
+      return function(a, u) {
+        var l = { key: a, value: r[a] }, c = { key: u, value: r[u] };
+        return o(l, c);
+      };
+    };
+  }(e.cmp), i = [];
+  return function o(r) {
+    if (r && r.toJSON && typeof r.toJSON == "function" && (r = r.toJSON()), r !== void 0) {
+      if (typeof r == "number")
+        return isFinite(r) ? "" + r : "null";
+      if (typeof r != "object")
+        return JSON.stringify(r);
+      var a, u;
+      if (Array.isArray(r)) {
+        for (u = "[", a = 0; a < r.length; a++)
+          a && (u += ","), u += o(r[a]) || "null";
+        return u + "]";
+      }
+      if (r === null)
+        return "null";
+      if (i.indexOf(r) !== -1) {
+        if (n)
+          return JSON.stringify("__cycle__");
+        throw new TypeError("Converting circular structure to JSON");
+      }
+      var l = i.push(r) - 1, c = Object.keys(r).sort(s && s(r));
+      for (u = "", a = 0; a < c.length; a++) {
+        var d = c[a], g = o(r[d]);
+        g && (u && (u += ","), u += JSON.stringify(d) + ":" + g);
+      }
+      return i.splice(l, 1), "{" + u + "}";
+    }
+  }(t);
+};
+const gs = /* @__PURE__ */ ms(ys), _s = (t) => an(gs(t)), bs = (t) => {
+  if (t && t.length > 0)
+    try {
+      return JSON.parse(ht(t));
+    } catch (e) {
+      try {
+        return JSON.parse(decodeURIComponent(ht(t)));
+      } catch {
+        throw e;
+      }
+    }
+}, an = (t) => btoa(t), ht = (t) => {
+  try {
+    return atob(t);
+  } catch {
+    return atob(decodeURIComponent(t));
+  }
+}, un = (t) => {
+  const e = t instanceof URL ? t : new URL(t);
+  return cn(e.hash);
+}, cn = (t) => {
+  let e = t;
+  for (; e.startsWith("#"); )
+    e = e.substring(1);
+  const n = e.indexOf("?");
+  if (n === -1)
+    return [e, {}];
+  const s = e.substring(0, n);
+  e = e.substring(n + 1);
+  const i = {};
+  return e.split("&").filter((o) => o.length > 0).map((o) => {
+    const r = o.indexOf("=");
+    if (r === -1)
+      return [o, ""];
+    const a = o.substring(0, r), u = o.substring(r + 1);
+    return [a, u];
+  }).forEach(([o, r]) => {
+    i[o] = r;
+  }), Object.keys(i).forEach((o) => {
+    i[o] = i[o];
+  }), [s, i];
+}, Pe = (t, e) => {
+  const [n, s] = un(t);
+  return s[e];
+}, ws = (t) => vs()[1][t], vs = () => un(window.location.href), Se = (t, e, n) => {
+  const s = window.location.hash.startsWith("#") ? window.location.hash.substring(1) : window.location.hash, i = Rs(s, t, e);
+  i !== s && (n != null && n.modifyHistory ? window.location.hash = i : (window.history.replaceState(null, document.title, `${window.location.pathname}${window.location.search}${i.startsWith("#") ? "" : "#"}${i}`), window.dispatchEvent(new HashChangeEvent("hashchange"))));
+}, Rs = (t, e, n) => {
+  const [s, i] = cn(t);
+  let o = !1;
+  if (i.hasOwnProperty(e) && n === null || n === void 0 ? (delete i[e], o = !0) : i[e] !== n && (i[e] = n, o = !0), !o)
+    return t;
+  const r = Object.keys(i);
+  r.sort();
+  const a = r.map((u, l) => {
+    const c = i[u];
+    return /^[A-Za-z0-9+/]+={0,2}$/.test(c) && c.length % 4, `${u}=${c}`;
+  }).join("&");
+  return !s && !a ? "" : `${s || ""}${a ? "?" + a : ""}`;
+}, St = (t, e) => {
+  const n = Pe(t, e);
+  if (n && n !== "")
+    return bs(n);
+}, Os = (t, e, n) => {
+  const s = e ? _s(e) : void 0;
+  Se(t, s, n);
+}, Ss = (t) => St(window.location.href, t), As = (t, e) => {
+  const n = Pe(t, e);
+  return n ? parseFloat(n) : void 0;
+}, ln = (t, e, n) => {
+  Se(t, e != null ? e.toString() : void 0, n);
+}, Es = (t) => As(window.location.href, t), Ms = (t, e) => {
+  const n = Pe(t, e);
+  return n ? parseInt(n) : void 0;
+}, Is = (t, e, n) => {
+  ln(t, e, n);
+}, Cs = (t) => Ms(window.location.href, t), $s = (t, e) => Pe(t, e) === "true", xs = (t, e, n) => {
+  Se(t, e ? "true" : void 0, n);
+}, Ls = (t) => $s(window.location.href, t), Ts = (t, e) => {
+  const n = Pe(t, e);
+  return n && n !== "" ? ht(n) : void 0;
+}, Ps = (t, e, n) => {
+  const s = e == null ? void 0 : an(e);
+  Se(t, s, n);
+}, Ds = (t) => Ts(window.location.href, t);
+var ks = function(t, e) {
+  e || (e = {}), typeof e == "function" && (e = { cmp: e });
+  var n = typeof e.cycles == "boolean" ? e.cycles : !1, s = e.cmp && function(o) {
+    return function(r) {
+      return function(a, u) {
+        var l = { key: a, value: r[a] }, c = { key: u, value: r[u] };
+        return o(l, c);
+      };
+    };
+  }(e.cmp), i = [];
+  return function o(r) {
+    if (r && r.toJSON && typeof r.toJSON == "function" && (r = r.toJSON()), r !== void 0) {
+      if (typeof r == "number")
+        return isFinite(r) ? "" + r : "null";
+      if (typeof r != "object")
+        return JSON.stringify(r);
+      var a, u;
+      if (Array.isArray(r)) {
+        for (u = "[", a = 0; a < r.length; a++)
+          a && (u += ","), u += o(r[a]) || "null";
+        return u + "]";
+      }
+      if (r === null)
+        return "null";
+      if (i.indexOf(r) !== -1) {
+        if (n)
+          return JSON.stringify("__cycle__");
+        throw new TypeError("Converting circular structure to JSON");
+      }
+      var l = i.push(r) - 1, c = Object.keys(r).sort(s && s(r));
+      for (u = "", a = 0; a < c.length; a++) {
+        var d = c[a], g = o(r[d]);
+        g && (u && (u += ","), u += JSON.stringify(d) + ":" + g);
+      }
+      return i.splice(l, 1), "{" + u + "}";
+    }
+  }(t);
+};
+const fn = /* @__PURE__ */ yt(ks);
+var xe;
+(function(t) {
+  t.mp_debug = "mp_debug";
+})(xe || (xe = {}));
+const Hs = () => {
+  try {
+    return window !== window.top;
+  } catch {
+    return !1;
+  }
+}, pn = {
+  version: Le,
+  metaframes: {}
+};
+class Ns extends Ot.EventEmitter {
+  constructor() {
+    super(), this._definition = pn, this.getDefinition = this.getDefinition.bind(this);
+  }
+  error(e) {
+    throw "Subclass should implement";
+  }
+  getDefinition() {
+    return this._definition;
+  }
+}
+const Ge = (t, e) => e ? C(t, (n) => {
+  Object.keys(e).forEach((s) => {
+    e[s] === void 0 ? delete n[s] : n[s] = e[s];
+  });
+}) : t, Ni = (t) => window.location.search ? new URLSearchParams(window.location.search).get(t) : null, ji = () => new URLSearchParams(window.location.search).has(xe.mp_debug), dt = () => {
+  const t = new URLSearchParams(window.location.search).get(xe.mp_debug);
+  return t === "true" || t === "1";
+}, Ui = (t = 8) => At(t), js = (t = 8) => At(t), Bi = (t = 8) => At(t), jt = "abcdefghijklmnopqrstuvwxyz0123456789", At = (t = 8) => {
+  for (var e = "", n = jt.length, s = 0; s < t; s++)
+    e += jt.charAt(Math.floor(Math.random() * n));
+  return e;
+}, Et = (t, e, n) => {
+  e = e || "000", e && e.trim() == "" && (e = void 0);
+  let s;
+  if (typeof t == "string" ? s = t : typeof t == "number" ? s = t + "" : s = JSON.stringify(t, null, "  "), e && e.trim() != "") {
+    var i = `color: #${e}`;
+    n && (i = `${i}; background: #${n}`), s = `%c${s}`, window.console.log(s, i);
+  } else
+    window.console.log(s);
+}, hn = (t) => Bs(Us(t)), Us = (t) => {
+  var e = 0;
+  for (let n = 0; n < t.length; n++)
+    e = t.charCodeAt(n) + ((e << 5) - e);
+  return e;
+}, Bs = (t) => {
+  var e = (t & 16777215).toString(16).toUpperCase();
+  return "00000".substring(0, 6 - e.length) + e;
+}, tt = () => document.readyState == "complete" || document.readyState == "interactive", Xe = async () => tt() ? Promise.resolve() : new Promise((t) => {
+  if (tt()) {
+    t();
+    return;
+  }
+  let e = !1;
+  window.addEventListener("load", () => {
+    e || (e = !0, t());
+  }), setTimeout(() => {
+    !e && tt() && (e = !0, t());
+  }, 200);
+}), Fi = async (t) => {
+  const e = fn(t);
+  return await dn(e);
+}, zi = async (t) => {
+  const e = fn({
+    version: t.version,
+    metaframes: t.metaframes
+  });
+  return await dn(e);
+};
+async function dn(t) {
+  const n = new TextEncoder().encode(t), s = await crypto.subtle.digest("SHA-256", n);
+  return btoa(String.fromCharCode(...new Uint8Array(s)));
+}
+var ae;
+(function(t) {
+  t.WaitingForPageLoad = "WaitingForPageLoad", t.SentSetupIframeClientRequest = "SentSetupIframeClientRequest", t.Ready = "Ready";
+})(ae || (ae = {}));
+var z;
+(function(t) {
+  t.Connected = "connected", t.Error = "error", t.Input = "input", t.Inputs = "inputs", t.Message = "message";
+})(z || (z = {}));
+class ie extends Ot.EventEmitter {
+  constructor(e) {
+    if (super(), this._inputPipeValues = {}, this._outputPipeValues = {}, this._state = ae.WaitingForPageLoad, this._messageSendCount = 0, this.debug = dt(), this.isInputOutputBlobSerialization = !0, this.id = window.name, this.debug = dt(), this._isIframe = Hs(), this.addListener = this.addListener.bind(this), this.dispose = this.dispose.bind(this), this.error = this.error.bind(this), this.getInput = this.getInput.bind(this), this.getInputs = this.getInputs.bind(this), this.log = this.log.bind(this), this.logInternal = this.logInternal.bind(this), this.onInput = this.onInput.bind(this), this.onInputs = this.onInputs.bind(this), this.onMessage = this.onMessage.bind(this), this.sendRpc = this.sendRpc.bind(this), this.setInput = this.setInput.bind(this), this.setInputs = this.setInputs.bind(this), this.setInternalInputsAndNotify = this.setInternalInputsAndNotify.bind(this), this.setOutput = this.setOutput.bind(this), this.setOutputs = this.setOutputs.bind(this), this.warn = this.warn.bind(this), this._resolveSetupIframeServerResponse = this._resolveSetupIframeServerResponse.bind(this), this.addListenerReturnDisposer = this.addListenerReturnDisposer.bind(this), this.connected = this.connected.bind(this), this.isConnected = this.isConnected.bind(this), this.disableNotifyOnHashUrlChange = this.disableNotifyOnHashUrlChange.bind(this), this._onHashUrlChange = this._onHashUrlChange.bind(this), this.setParameter = this.setParameter.bind(this), this.setParameterBoolean = this.setParameterBoolean.bind(this), this.setParameterJson = this.setParameterJson.bind(this), this.setParameterBase64 = this.setParameterBase64.bind(this), this.setParameterFloat = this.setParameterFloat.bind(this), this.setParameterInt = this.setParameterInt.bind(this), this.getParameter = this.getParameter.bind(this), this.getParameterBoolean = this.getParameterBoolean.bind(this), this.getParameterJson = this.getParameterJson.bind(this), this.getParameterBase64 = this.getParameterBase64.bind(this), this.getParameterFloat = this.getParameterFloat.bind(this), this.getParameterInt = this.getParameterInt.bind(this), this.deleteParameter = this.deleteParameter.bind(this), !this._isIframe) {
+      this.log("Not an iframe, metaframe code disabled");
+      return;
+    }
+    const n = this;
+    Xe().then(() => {
+      this.log("pageLoaded"), window.addEventListener("message", this.onMessage), n.sendRpc(q.SetupIframeClientRequest, {
+        version: ie.version
+      }), n._state = ae.SentSetupIframeClientRequest;
+    }), e && e.disableHashChangeEvent || window.addEventListener("hashchange", this._onHashUrlChange);
+  }
+  _resolveSetupIframeServerResponse(e) {
+    if (this._state === ae.WaitingForPageLoad)
+      throw "Got message but page has not finished loading, we should never get in this state";
+    (async () => this._parentId ? this.log("Got JsonRpcMethods.SetupIframeServerResponse but already resolved") : (this._parentVersion = e.version, this.color = hn(this.id), this._parentId = e.parentId, this.log(`metapage[${this._parentId}](v${this._parentVersion ? this._parentVersion : "unknown"}) registered`), e.state && e.state.inputs && (this.isInputOutputBlobSerialization ? this._inputPipeValues = await Ce(e.state.inputs) : this._inputPipeValues = e.state.inputs), this._state = ae.Ready, this.sendRpc(q.SetupIframeServerResponseAck, {
+      version: ie.version
+    }), this._inputPipeValues && Object.keys(this._inputPipeValues).length > 0 && (this.emit(z.Inputs, this._inputPipeValues), this.listenerCount(z.Input) > 0 && Object.keys(this._inputPipeValues).forEach((n) => this.emit(z.Input, n, this._inputPipeValues[n]))), this.emit(z.Connected), this.sendRpc(q.OutputsUpdate, this._outputPipeValues)))();
+  }
+  isConnected() {
+    return this._state === ae.Ready;
+  }
+  async connected() {
+    return new Promise((e, n) => {
+      if (this._state === ae.Ready) {
+        e();
+        return;
+      }
+      let s;
+      s = this.addListenerReturnDisposer(z.Connected, () => {
+        e(), s();
+      });
+    });
+  }
+  addListenerReturnDisposer(e, n) {
+    return super.addListener(e, n), () => {
+      super.removeListener(e, n);
+    };
+  }
+  log(e, n, s) {
+    this.debug && this.logInternal(e, n || this.color);
+  }
+  warn(e) {
+    this.debug && this.logInternal(e, "000", this.color);
+  }
+  error(e) {
+    this.logInternal(e, this.color, "f00");
+  }
+  logInternal(e, n, s) {
+    let i;
+    typeof e == "string" ? i = e : typeof e == "number" ? i = e + "" : i = JSON.stringify(e), n = n && n + "", i = (this.id ? `Metaframe[${this.id}] ` : "") + `${i}`, Et(i, n, s);
+  }
+  dispose() {
+    super.removeAllListeners(), window.removeEventListener("message", this.onMessage), this.disableNotifyOnHashUrlChange(), this._inputPipeValues = void 0, this._outputPipeValues = void 0;
+  }
+  addListener(e, n) {
+    return super.addListener(e, n), e === z.Inputs && window.setTimeout(() => {
+      this._inputPipeValues && n(this._inputPipeValues);
+    }, 0), this;
+  }
+  onInput(e, n) {
+    return this.addListenerReturnDisposer(z.Input, (s, i) => {
+      e === s && n(i);
+    });
+  }
+  onInputs(e) {
+    return this.addListenerReturnDisposer(z.Inputs, e);
+  }
+  setInput(e, n) {
+    var s = {};
+    s[e] = n, this.setInputs(s);
+  }
+  async setInputs(e) {
+    this.isInputOutputBlobSerialization && (e = await Ce(e)), this.sendRpc(q.InputsUpdate, e);
+  }
+  async setInternalInputsAndNotify(e) {
+    this.isInputOutputBlobSerialization && (e = await Ce(e));
+    const n = e;
+    if (this._inputPipeValues = Ge(this._inputPipeValues, e), this._inputPipeValues !== n) {
+      Object.keys(e).forEach((s) => {
+        try {
+          this.emit(z.Input, s, e[s]);
+        } catch (i) {
+          console.error(`Error emitting input ${s}: ${i}`), this.emit(z.Error, `Error emitting input ${s}: ${i}`);
+        }
+      });
+      try {
+        this.emit(z.Inputs, e);
+      } catch (s) {
+        console.error(`Error emitting inputs: ${s}`), this.emit(z.Error, `Error emitting inputs: ${s}`);
+      }
+    }
+  }
+  getInput(e) {
+    return console.assert(!!e), this._inputPipeValues[e];
+  }
+  getInputs() {
+    return this._inputPipeValues;
+  }
+  setOutput(e, n) {
+    console.assert(!!e);
+    var s = {};
+    s[e] = n, this.setOutputs(s);
+  }
+  async setOutputs(e) {
+    this.isInputOutputBlobSerialization && (e = await Ke(e));
+    const n = e;
+    this._outputPipeValues = Ge(this._outputPipeValues, e), this._outputPipeValues !== n && this._state === ae.Ready && this.sendRpc(q.OutputsUpdate, e);
+  }
+  disableNotifyOnHashUrlChange() {
+    window.removeEventListener("hashchange", this._onHashUrlChange);
+  }
+  _onHashUrlChange(e) {
+    const n = {
+      hash: window.location.hash,
+      metaframe: this.id
+    };
+    this.sendRpc(q.HashParamsUpdate, n);
+  }
+  sendRpc(e, n) {
+    if (this._isIframe) {
+      const s = {
+        jsonrpc: "2.0",
+        id: ++this._messageSendCount,
+        method: e,
+        params: n,
+        iframeId: this.id,
+        parentId: this._parentId
+      };
+      window.parent && window.parent.postMessage(s, "*");
+    } else
+      this.log("Cannot send JSON-RPC window message: there is no window.parent which means we are not an iframe");
+  }
+  onMessage(e) {
+    if (typeof e.data == "object") {
+      let s = e.data;
+      if (s.jsonrpc === "2.0") {
+        var n = s.method;
+        if (!(n == fe.SetupIframeServerResponse || s.parentId == this._parentId && s.iframeId == this.id)) {
+          this.log(`window.message: received message but jsonrpc.parentId=${s.parentId} _parentId=${this._parentId} jsonrpc.iframeId=${s.iframeId} id=${this.id}`);
+          return;
+        }
+        switch (n) {
+          case fe.SetupIframeServerResponse:
+            this._resolveSetupIframeServerResponse(s.params);
+            break;
+          case fe.InputsUpdate:
+            if (this._state !== ae.Ready)
+              throw "Got InputsUpdate but metaframe is not MetaframeLoadingState.Ready";
+            this.setInternalInputsAndNotify(s.params.inputs);
+            break;
+          case fe.MessageAck:
+            this.debug && this.log(`ACK: ${JSON.stringify(s)}`);
+            break;
+          default:
+            this.debug && this.log(`window.message: unknown JSON-RPC method: ${JSON.stringify(s)}`);
+            break;
+        }
+        this.listenerCount(z.Message) > 0 && this.emit(z.Message, s);
+      }
+    }
+  }
+  setParameter(e, n) {
+    Se(e, n);
+  }
+  getParameter(e) {
+    return ws(e);
+  }
+  setParameterBoolean(e, n) {
+    xs(e, n);
+  }
+  getParameterBoolean(e) {
+    return Ls(e);
+  }
+  setParameterJson(e, n) {
+    Os(e, n);
+  }
+  getParameterJson(e) {
+    return Ss(e);
+  }
+  setParameterBase64(e, n) {
+    Ps(e, n);
+  }
+  getParameterBase64(e) {
+    return Ds(e);
+  }
+  setParameterFloat(e, n) {
+    ln(e, n);
+  }
+  getParameterFloat(e) {
+    return Es(e);
+  }
+  setParameterInt(e, n) {
+    Is(e, n);
+  }
+  getParameterInt(e) {
+    return Cs(e);
+  }
+  deleteParameter(e) {
+    Se(e, void 0);
+  }
+}
+ie.version = En;
+ie.ERROR = z.Error;
+ie.CONNECTED = z.Connected;
+ie.INPUT = z.Input;
+ie.INPUTS = z.Inputs;
+ie.MESSAGE = z.Message;
+ie.deserializeInputs = Ce;
+ie.serializeInputs = Ke;
+var qe = {};
+const oe = "\\\\/", Ut = `[^${oe}]`, le = "\\.", Fs = "\\+", zs = "\\?", Qe = "\\/", Gs = "(?=.)", mn = "[^/]", Mt = `(?:${Qe}|$)`, yn = `(?:^|${Qe})`, It = `${le}{1,2}${Mt}`, Vs = `(?!${le})`, Js = `(?!${yn}${It})`, Ws = `(?!${le}{0,1}${Mt})`, Ks = `(?!${It})`, Xs = `[^.${Qe}]`, qs = `${mn}*?`, Qs = "/", gn = {
+  DOT_LITERAL: le,
+  PLUS_LITERAL: Fs,
+  QMARK_LITERAL: zs,
+  SLASH_LITERAL: Qe,
+  ONE_CHAR: Gs,
+  QMARK: mn,
+  END_ANCHOR: Mt,
+  DOTS_SLASH: It,
+  NO_DOT: Vs,
+  NO_DOTS: Js,
+  NO_DOT_SLASH: Ws,
+  NO_DOTS_SLASH: Ks,
+  QMARK_NO_DOT: Xs,
+  STAR: qs,
+  START_ANCHOR: yn,
+  SEP: Qs
+}, Ys = {
+  ...gn,
+  SLASH_LITERAL: `[${oe}]`,
+  QMARK: Ut,
+  STAR: `${Ut}*?`,
+  DOTS_SLASH: `${le}{1,2}(?:[${oe}]|$)`,
+  NO_DOT: `(?!${le})`,
+  NO_DOTS: `(?!(?:^|[${oe}])${le}{1,2}(?:[${oe}]|$))`,
+  NO_DOT_SLASH: `(?!${le}{0,1}(?:[${oe}]|$))`,
+  NO_DOTS_SLASH: `(?!${le}{1,2}(?:[${oe}]|$))`,
+  QMARK_NO_DOT: `[^.${oe}]`,
+  START_ANCHOR: `(?:^|[${oe}])`,
+  END_ANCHOR: `(?:[${oe}]|$)`,
+  SEP: "\\"
+}, Zs = {
+  alnum: "a-zA-Z0-9",
+  alpha: "a-zA-Z",
+  ascii: "\\x00-\\x7F",
+  blank: " \\t",
+  cntrl: "\\x00-\\x1F\\x7F",
+  digit: "0-9",
+  graph: "\\x21-\\x7E",
+  lower: "a-z",
+  print: "\\x20-\\x7E ",
+  punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~",
+  space: " \\t\\r\\n\\v\\f",
+  upper: "A-Z",
+  word: "A-Za-z0-9_",
+  xdigit: "A-Fa-f0-9"
+};
+var Ye = {
+  MAX_LENGTH: 1024 * 64,
+  POSIX_REGEX_SOURCE: Zs,
+  // regular expressions
+  REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+  REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+  REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+  REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+  REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+  REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+  // Replace globs with equivalent patterns to reduce parsing time.
+  REPLACEMENTS: {
+    "***": "*",
+    "**/**": "**",
+    "**/**/**": "**"
+  },
+  // Digits
+  CHAR_0: 48,
+  /* 0 */
+  CHAR_9: 57,
+  /* 9 */
+  // Alphabet chars.
+  CHAR_UPPERCASE_A: 65,
+  /* A */
+  CHAR_LOWERCASE_A: 97,
+  /* a */
+  CHAR_UPPERCASE_Z: 90,
+  /* Z */
+  CHAR_LOWERCASE_Z: 122,
+  /* z */
+  CHAR_LEFT_PARENTHESES: 40,
+  /* ( */
+  CHAR_RIGHT_PARENTHESES: 41,
+  /* ) */
+  CHAR_ASTERISK: 42,
+  /* * */
+  // Non-alphabetic chars.
+  CHAR_AMPERSAND: 38,
+  /* & */
+  CHAR_AT: 64,
+  /* @ */
+  CHAR_BACKWARD_SLASH: 92,
+  /* \ */
+  CHAR_CARRIAGE_RETURN: 13,
+  /* \r */
+  CHAR_CIRCUMFLEX_ACCENT: 94,
+  /* ^ */
+  CHAR_COLON: 58,
+  /* : */
+  CHAR_COMMA: 44,
+  /* , */
+  CHAR_DOT: 46,
+  /* . */
+  CHAR_DOUBLE_QUOTE: 34,
+  /* " */
+  CHAR_EQUAL: 61,
+  /* = */
+  CHAR_EXCLAMATION_MARK: 33,
+  /* ! */
+  CHAR_FORM_FEED: 12,
+  /* \f */
+  CHAR_FORWARD_SLASH: 47,
+  /* / */
+  CHAR_GRAVE_ACCENT: 96,
+  /* ` */
+  CHAR_HASH: 35,
+  /* # */
+  CHAR_HYPHEN_MINUS: 45,
+  /* - */
+  CHAR_LEFT_ANGLE_BRACKET: 60,
+  /* < */
+  CHAR_LEFT_CURLY_BRACE: 123,
+  /* { */
+  CHAR_LEFT_SQUARE_BRACKET: 91,
+  /* [ */
+  CHAR_LINE_FEED: 10,
+  /* \n */
+  CHAR_NO_BREAK_SPACE: 160,
+  /* \u00A0 */
+  CHAR_PERCENT: 37,
+  /* % */
+  CHAR_PLUS: 43,
+  /* + */
+  CHAR_QUESTION_MARK: 63,
+  /* ? */
+  CHAR_RIGHT_ANGLE_BRACKET: 62,
+  /* > */
+  CHAR_RIGHT_CURLY_BRACE: 125,
+  /* } */
+  CHAR_RIGHT_SQUARE_BRACKET: 93,
+  /* ] */
+  CHAR_SEMICOLON: 59,
+  /* ; */
+  CHAR_SINGLE_QUOTE: 39,
+  /* ' */
+  CHAR_SPACE: 32,
+  /*   */
+  CHAR_TAB: 9,
+  /* \t */
+  CHAR_UNDERSCORE: 95,
+  /* _ */
+  CHAR_VERTICAL_LINE: 124,
+  /* | */
+  CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
+  /* \uFEFF */
+  /**
+   * Create EXTGLOB_CHARS
+   */
+  extglobChars(t) {
+    return {
+      "!": { type: "negate", open: "(?:(?!(?:", close: `))${t.STAR})` },
+      "?": { type: "qmark", open: "(?:", close: ")?" },
+      "+": { type: "plus", open: "(?:", close: ")+" },
+      "*": { type: "star", open: "(?:", close: ")*" },
+      "@": { type: "at", open: "(?:", close: ")" }
+    };
+  },
+  /**
+   * Create GLOB_CHARS
+   */
+  globChars(t) {
+    return t === !0 ? Ys : gn;
+  }
+};
+(function(t) {
+  const {
+    REGEX_BACKSLASH: e,
+    REGEX_REMOVE_BACKSLASH: n,
+    REGEX_SPECIAL_CHARS: s,
+    REGEX_SPECIAL_CHARS_GLOBAL: i
+  } = Ye;
+  t.isObject = (o) => o !== null && typeof o == "object" && !Array.isArray(o), t.hasRegexChars = (o) => s.test(o), t.isRegexChar = (o) => o.length === 1 && t.hasRegexChars(o), t.escapeRegex = (o) => o.replace(i, "\\$1"), t.toPosixSlashes = (o) => o.replace(e, "/"), t.removeBackslashes = (o) => o.replace(n, (r) => r === "\\" ? "" : r), t.supportsLookbehinds = () => {
+    const o = process.version.slice(1).split(".").map(Number);
+    return o.length === 3 && o[0] >= 9 || o[0] === 8 && o[1] >= 10;
+  }, t.escapeLast = (o, r, a) => {
+    const u = o.lastIndexOf(r, a);
+    return u === -1 ? o : o[u - 1] === "\\" ? t.escapeLast(o, r, u - 1) : `${o.slice(0, u)}\\${o.slice(u)}`;
+  }, t.removePrefix = (o, r = {}) => {
+    let a = o;
+    return a.startsWith("./") && (a = a.slice(2), r.prefix = "./"), a;
+  }, t.wrapOutput = (o, r = {}, a = {}) => {
+    const u = a.contains ? "" : "^", l = a.contains ? "" : "$";
+    let c = `${u}(?:${o})${l}`;
+    return r.negated === !0 && (c = `(?:^(?!${c}).*$)`), c;
+  }, t.basename = (o, { windows: r } = {}) => r ? o.replace(/[\\/]$/, "").replace(/.*[\\/]/, "") : o.replace(/\/$/, "").replace(/.*\//, "");
+})(qe);
+const Bt = qe, {
+  CHAR_ASTERISK: nt,
+  /* * */
+  CHAR_AT: ei,
+  /* @ */
+  CHAR_BACKWARD_SLASH: Me,
+  /* \ */
+  CHAR_COMMA: ti,
+  /* , */
+  CHAR_DOT: st,
+  /* . */
+  CHAR_EXCLAMATION_MARK: Ft,
+  /* ! */
+  CHAR_FORWARD_SLASH: _n,
+  /* / */
+  CHAR_LEFT_CURLY_BRACE: it,
+  /* { */
+  CHAR_LEFT_PARENTHESES: rt,
+  /* ( */
+  CHAR_LEFT_SQUARE_BRACKET: ni,
+  /* [ */
+  CHAR_PLUS: si,
+  /* + */
+  CHAR_QUESTION_MARK: zt,
+  /* ? */
+  CHAR_RIGHT_CURLY_BRACE: ii,
+  /* } */
+  CHAR_RIGHT_PARENTHESES: Gt,
+  /* ) */
+  CHAR_RIGHT_SQUARE_BRACKET: ri
+  /* ] */
+} = Ye, Vt = (t) => t === _n || t === Me, Jt = (t) => {
+  t.isPrefix !== !0 && (t.depth = t.isGlobstar ? 1 / 0 : 1);
+}, oi = (t, e) => {
+  const n = e || {}, s = t.length - 1, i = n.parts === !0 || n.scanToEnd === !0, o = [], r = [], a = [];
+  let u = t, l = -1, c = 0, d = 0, g = !1, v = !1, y = !1, R = !1, w = !1, $ = !1, b = !1, A = !1, E = !1, O = 0, H, S, L = { value: "", depth: 0, isGlob: !1 };
+  const U = () => l >= s, f = () => u.charCodeAt(l + 1), M = () => (H = S, u.charCodeAt(++l));
+  for (; l < s; ) {
+    S = M();
+    let W;
+    if (S === Me) {
+      b = L.backslashes = !0, S = M(), S === it && ($ = !0);
+      continue;
+    }
+    if ($ === !0 || S === it) {
+      for (O++; U() !== !0 && (S = M()); ) {
+        if (S === Me) {
+          b = L.backslashes = !0, M();
+          continue;
+        }
+        if (S === it) {
+          O++;
+          continue;
+        }
+        if ($ !== !0 && S === st && (S = M()) === st) {
+          if (g = L.isBrace = !0, y = L.isGlob = !0, E = !0, i === !0)
+            continue;
+          break;
+        }
+        if ($ !== !0 && S === ti) {
+          if (g = L.isBrace = !0, y = L.isGlob = !0, E = !0, i === !0)
+            continue;
+          break;
+        }
+        if (S === ii && (O--, O === 0)) {
+          $ = !1, g = L.isBrace = !0, E = !0;
+          break;
+        }
+      }
+      if (i === !0)
+        continue;
+      break;
+    }
+    if (S === _n) {
+      if (o.push(l), r.push(L), L = { value: "", depth: 0, isGlob: !1 }, E === !0)
+        continue;
+      if (H === st && l === c + 1) {
+        c += 2;
+        continue;
+      }
+      d = l + 1;
+      continue;
+    }
+    if (n.noext !== !0 && (S === si || S === ei || S === nt || S === zt || S === Ft) === !0 && f() === rt) {
+      if (y = L.isGlob = !0, R = L.isExtglob = !0, E = !0, i === !0) {
+        for (; U() !== !0 && (S = M()); ) {
+          if (S === Me) {
+            b = L.backslashes = !0, S = M();
+            continue;
+          }
+          if (S === Gt) {
+            y = L.isGlob = !0, E = !0;
+            break;
+          }
+        }
+        continue;
+      }
+      break;
+    }
+    if (S === nt) {
+      if (H === nt && (w = L.isGlobstar = !0), y = L.isGlob = !0, E = !0, i === !0)
+        continue;
+      break;
+    }
+    if (S === zt) {
+      if (y = L.isGlob = !0, E = !0, i === !0)
+        continue;
+      break;
+    }
+    if (S === ni)
+      for (; U() !== !0 && (W = M()); ) {
+        if (W === Me) {
+          b = L.backslashes = !0, M();
+          continue;
+        }
+        if (W === ri) {
+          if (v = L.isBracket = !0, y = L.isGlob = !0, E = !0, i === !0)
+            continue;
+          break;
+        }
+      }
+    if (n.nonegate !== !0 && S === Ft && l === c) {
+      A = L.negated = !0, c++;
+      continue;
+    }
+    if (n.noparen !== !0 && S === rt) {
+      if (y = L.isGlob = !0, i === !0) {
+        for (; U() !== !0 && (S = M()); ) {
+          if (S === rt) {
+            b = L.backslashes = !0, S = M();
+            continue;
+          }
+          if (S === Gt) {
+            E = !0;
+            break;
+          }
+        }
+        continue;
+      }
+      break;
+    }
+    if (y === !0) {
+      if (E = !0, i === !0)
+        continue;
+      break;
+    }
+  }
+  n.noext === !0 && (R = !1, y = !1);
+  let I = u, B = "", h = "";
+  c > 0 && (B = u.slice(0, c), u = u.slice(c), d -= c), I && y === !0 && d > 0 ? (I = u.slice(0, d), h = u.slice(d)) : y === !0 ? (I = "", h = u) : I = u, I && I !== "" && I !== "/" && I !== u && Vt(I.charCodeAt(I.length - 1)) && (I = I.slice(0, -1)), n.unescape === !0 && (h && (h = Bt.removeBackslashes(h)), I && b === !0 && (I = Bt.removeBackslashes(I)));
+  const p = {
+    prefix: B,
+    input: t,
+    start: c,
+    base: I,
+    glob: h,
+    isBrace: g,
+    isBracket: v,
+    isGlob: y,
+    isExtglob: R,
+    isGlobstar: w,
+    negated: A
+  };
+  if (n.tokens === !0 && (p.maxDepth = 0, Vt(S) || r.push(L), p.tokens = r), n.parts === !0 || n.tokens === !0) {
+    let W;
+    for (let k = 0; k < o.length; k++) {
+      const re = W ? W + 1 : c, ce = o[k], Q = t.slice(re, ce);
+      n.tokens && (k === 0 && c !== 0 ? (r[k].isPrefix = !0, r[k].value = B) : r[k].value = Q, Jt(r[k]), p.maxDepth += r[k].depth), (k !== 0 || Q !== "") && a.push(Q), W = ce;
+    }
+    if (W && W + 1 < t.length) {
+      const k = t.slice(W + 1);
+      a.push(k), n.tokens && (r[r.length - 1].value = k, Jt(r[r.length - 1]), p.maxDepth += r[r.length - 1].depth);
+    }
+    p.slashes = o, p.parts = a;
+  }
+  return p;
+};
+var ai = oi;
+const Ve = Ye, ne = qe, {
+  MAX_LENGTH: Je,
+  POSIX_REGEX_SOURCE: ui,
+  REGEX_NON_SPECIAL_CHARS: ci,
+  REGEX_SPECIAL_CHARS_BACKREF: li,
+  REPLACEMENTS: bn
+} = Ve, fi = (t, e) => {
+  if (typeof e.expandRange == "function")
+    return e.expandRange(...t, e);
+  t.sort();
+  const n = `[${t.join("-")}]`;
+  try {
+    new RegExp(n);
+  } catch {
+    return t.map((i) => ne.escapeRegex(i)).join("..");
+  }
+  return n;
+}, ve = (t, e) => `Missing ${t}: "${e}" - use "\\\\${e}" to match literal characters`, wn = (t, e) => {
+  if (typeof t != "string")
+    throw new TypeError("Expected a string");
+  t = bn[t] || t;
+  const n = { ...e }, s = typeof n.maxLength == "number" ? Math.min(Je, n.maxLength) : Je;
+  let i = t.length;
+  if (i > s)
+    throw new SyntaxError(`Input length: ${i}, exceeds maximum allowed length: ${s}`);
+  const o = { type: "bos", value: "", output: n.prepend || "" }, r = [o], a = n.capture ? "" : "?:", u = Ve.globChars(n.windows), l = Ve.extglobChars(u), {
+    DOT_LITERAL: c,
+    PLUS_LITERAL: d,
+    SLASH_LITERAL: g,
+    ONE_CHAR: v,
+    DOTS_SLASH: y,
+    NO_DOT: R,
+    NO_DOT_SLASH: w,
+    NO_DOTS_SLASH: $,
+    QMARK: b,
+    QMARK_NO_DOT: A,
+    STAR: E,
+    START_ANCHOR: O
+  } = u, H = (_) => `(${a}(?:(?!${O}${_.dot ? y : c}).)*?)`, S = n.dot ? "" : R, L = n.dot ? b : A;
+  let U = n.bash === !0 ? H(n) : E;
+  n.capture && (U = `(${U})`), typeof n.noext == "boolean" && (n.noextglob = n.noext);
+  const f = {
+    input: t,
+    index: -1,
+    start: 0,
+    dot: n.dot === !0,
+    consumed: "",
+    output: "",
+    prefix: "",
+    backtrack: !1,
+    negated: !1,
+    brackets: 0,
+    braces: 0,
+    parens: 0,
+    quotes: 0,
+    globstar: !1,
+    tokens: r
+  };
+  t = ne.removePrefix(t, f), i = t.length;
+  const M = [], I = [], B = [];
+  let h = o, p;
+  const W = () => f.index === i - 1, k = f.peek = (_ = 1) => t[f.index + _], re = f.advance = () => t[++f.index], ce = () => t.slice(f.index + 1), Q = (_ = "", N = 0) => {
+    f.consumed += _, f.index += N;
+  }, De = (_) => {
+    f.output += _.output != null ? _.output : _.value, Q(_.value);
+  }, Sn = () => {
+    let _ = 1;
+    for (; k() === "!" && (k(2) !== "(" || k(3) === "?"); )
+      re(), f.start++, _++;
+    return _ % 2 === 0 ? !1 : (f.negated = !0, f.start++, !0);
+  }, ke = (_) => {
+    f[_]++, B.push(_);
+  }, ye = (_) => {
+    f[_]--, B.pop();
+  }, T = (_) => {
+    if (h.type === "globstar") {
+      const N = f.braces > 0 && (_.type === "comma" || _.type === "brace"), m = _.extglob === !0 || M.length && (_.type === "pipe" || _.type === "paren");
+      _.type !== "slash" && _.type !== "paren" && !N && !m && (f.output = f.output.slice(0, -h.output.length), h.type = "star", h.value = "*", h.output = U, f.output += h.output);
+    }
+    if (M.length && _.type !== "paren" && !l[_.value] && (M[M.length - 1].inner += _.value), (_.value || _.output) && De(_), h && h.type === "text" && _.type === "text") {
+      h.value += _.value, h.output = (h.output || "") + _.value;
+      return;
+    }
+    _.prev = h, r.push(_), h = _;
+  }, He = (_, N) => {
+    const m = { ...l[N], conditions: 1, inner: "" };
+    m.prev = h, m.parens = f.parens, m.output = f.output;
+    const D = (n.capture ? "(" : "") + m.open;
+    ke("parens"), T({ type: _, value: N, output: f.output ? "" : v }), T({ type: "paren", extglob: !0, value: re(), output: D }), M.push(m);
+  }, An = (_) => {
+    let N = _.close + (n.capture ? ")" : "");
+    if (_.type === "negate") {
+      let m = U;
+      _.inner && _.inner.length > 1 && _.inner.includes("/") && (m = H(n)), (m !== U || W() || /^\)+$/.test(ce())) && (N = _.close = `)$))${m}`), _.prev.type === "bos" && W() && (f.negatedExtglob = !0);
+    }
+    T({ type: "paren", extglob: !0, value: p, output: N }), ye("parens");
+  };
+  if (n.fastpaths !== !1 && !/(^[*!]|[/()[\]{}"])/.test(t)) {
+    let _ = !1, N = t.replace(li, (m, D, F, K, J, Ze) => K === "\\" ? (_ = !0, m) : K === "?" ? D ? D + K + (J ? b.repeat(J.length) : "") : Ze === 0 ? L + (J ? b.repeat(J.length) : "") : b.repeat(F.length) : K === "." ? c.repeat(F.length) : K === "*" ? D ? D + K + (J ? U : "") : U : D ? m : `\\${m}`);
+    return _ === !0 && (n.unescape === !0 ? N = N.replace(/\\/g, "") : N = N.replace(/\\+/g, (m) => m.length % 2 === 0 ? "\\\\" : m ? "\\" : "")), N === t && n.contains === !0 ? (f.output = t, f) : (f.output = ne.wrapOutput(N, f, e), f);
+  }
+  for (; !W(); ) {
+    if (p = re(), p === "\0")
+      continue;
+    if (p === "\\") {
+      const m = k();
+      if (m === "/" && n.bash !== !0 || m === "." || m === ";")
+        continue;
+      if (!m) {
+        p += "\\", T({ type: "text", value: p });
+        continue;
+      }
+      const D = /^\\+/.exec(ce());
+      let F = 0;
+      if (D && D[0].length > 2 && (F = D[0].length, f.index += F, F % 2 !== 0 && (p += "\\")), n.unescape === !0 ? p = re() || "" : p += re() || "", f.brackets === 0) {
+        T({ type: "text", value: p });
+        continue;
+      }
+    }
+    if (f.brackets > 0 && (p !== "]" || h.value === "[" || h.value === "[^")) {
+      if (n.posix !== !1 && p === ":") {
+        const m = h.value.slice(1);
+        if (m.includes("[") && (h.posix = !0, m.includes(":"))) {
+          const D = h.value.lastIndexOf("["), F = h.value.slice(0, D), K = h.value.slice(D + 2), J = ui[K];
+          if (J) {
+            h.value = F + J, f.backtrack = !0, re(), !o.output && r.indexOf(h) === 1 && (o.output = v);
+            continue;
+          }
+        }
+      }
+      (p === "[" && k() !== ":" || p === "-" && k() === "]") && (p = `\\${p}`), p === "]" && (h.value === "[" || h.value === "[^") && (p = `\\${p}`), n.posix === !0 && p === "!" && h.value === "[" && (p = "^"), h.value += p, De({ value: p });
+      continue;
+    }
+    if (f.quotes === 1 && p !== '"') {
+      p = ne.escapeRegex(p), h.value += p, De({ value: p });
+      continue;
+    }
+    if (p === '"') {
+      f.quotes = f.quotes === 1 ? 0 : 1, n.keepQuotes === !0 && T({ type: "text", value: p });
+      continue;
+    }
+    if (p === "(") {
+      ke("parens"), T({ type: "paren", value: p });
+      continue;
+    }
+    if (p === ")") {
+      if (f.parens === 0 && n.strictBrackets === !0)
+        throw new SyntaxError(ve("opening", "("));
+      const m = M[M.length - 1];
+      if (m && f.parens === m.parens + 1) {
+        An(M.pop());
+        continue;
+      }
+      T({ type: "paren", value: p, output: f.parens ? ")" : "\\)" }), ye("parens");
+      continue;
+    }
+    if (p === "[") {
+      if (n.nobracket === !0 || !ce().includes("]")) {
+        if (n.nobracket !== !0 && n.strictBrackets === !0)
+          throw new SyntaxError(ve("closing", "]"));
+        p = `\\${p}`;
+      } else
+        ke("brackets");
+      T({ type: "bracket", value: p });
+      continue;
+    }
+    if (p === "]") {
+      if (n.nobracket === !0 || h && h.type === "bracket" && h.value.length === 1) {
+        T({ type: "text", value: p, output: `\\${p}` });
+        continue;
+      }
+      if (f.brackets === 0) {
+        if (n.strictBrackets === !0)
+          throw new SyntaxError(ve("opening", "["));
+        T({ type: "text", value: p, output: `\\${p}` });
+        continue;
+      }
+      ye("brackets");
+      const m = h.value.slice(1);
+      if (h.posix !== !0 && m[0] === "^" && !m.includes("/") && (p = `/${p}`), h.value += p, De({ value: p }), n.literalBrackets === !1 || ne.hasRegexChars(m))
+        continue;
+      const D = ne.escapeRegex(h.value);
+      if (f.output = f.output.slice(0, -h.value.length), n.literalBrackets === !0) {
+        f.output += D, h.value = D;
+        continue;
+      }
+      h.value = `(${a}${D}|${h.value})`, f.output += h.value;
+      continue;
+    }
+    if (p === "{" && n.nobrace !== !0) {
+      ke("braces");
+      const m = {
+        type: "brace",
+        value: p,
+        output: "(",
+        outputIndex: f.output.length,
+        tokensIndex: f.tokens.length
+      };
+      I.push(m), T(m);
+      continue;
+    }
+    if (p === "}") {
+      const m = I[I.length - 1];
+      if (n.nobrace === !0 || !m) {
+        T({ type: "text", value: p, output: p });
+        continue;
+      }
+      let D = ")";
+      if (m.dots === !0) {
+        const F = r.slice(), K = [];
+        for (let J = F.length - 1; J >= 0 && (r.pop(), F[J].type !== "brace"); J--)
+          F[J].type !== "dots" && K.unshift(F[J].value);
+        D = fi(K, n), f.backtrack = !0;
+      }
+      if (m.comma !== !0 && m.dots !== !0) {
+        const F = f.output.slice(0, m.outputIndex), K = f.tokens.slice(m.tokensIndex);
+        m.value = m.output = "\\{", p = D = "\\}", f.output = F;
+        for (const J of K)
+          f.output += J.output || J.value;
+      }
+      T({ type: "brace", value: p, output: D }), ye("braces"), I.pop();
+      continue;
+    }
+    if (p === "|") {
+      M.length > 0 && M[M.length - 1].conditions++, T({ type: "text", value: p });
+      continue;
+    }
+    if (p === ",") {
+      let m = p;
+      const D = I[I.length - 1];
+      D && B[B.length - 1] === "braces" && (D.comma = !0, m = "|"), T({ type: "comma", value: p, output: m });
+      continue;
+    }
+    if (p === "/") {
+      if (h.type === "dot" && f.index === f.start + 1) {
+        f.start = f.index + 1, f.consumed = "", f.output = "", r.pop(), h = o;
+        continue;
+      }
+      T({ type: "slash", value: p, output: g });
+      continue;
+    }
+    if (p === ".") {
+      if (f.braces > 0 && h.type === "dot") {
+        h.value === "." && (h.output = c);
+        const m = I[I.length - 1];
+        h.type = "dots", h.output += p, h.value += p, m.dots = !0;
+        continue;
+      }
+      if (f.braces + f.parens === 0 && h.type !== "bos" && h.type !== "slash") {
+        T({ type: "text", value: p, output: c });
+        continue;
+      }
+      T({ type: "dot", value: p, output: c });
+      continue;
+    }
+    if (p === "?") {
+      if (!(h && h.value === "(") && n.noextglob !== !0 && k() === "(" && k(2) !== "?") {
+        He("qmark", p);
+        continue;
+      }
+      if (h && h.type === "paren") {
+        const D = k();
+        let F = p;
+        if (D === "<" && !ne.supportsLookbehinds())
+          throw new Error("Node.js v10 or higher is required for regex lookbehinds");
+        (h.value === "(" && !/[!=<:]/.test(D) || D === "<" && !/<([!=]|\w+>)/.test(ce())) && (F = `\\${p}`), T({ type: "text", value: p, output: F });
+        continue;
+      }
+      if (n.dot !== !0 && (h.type === "slash" || h.type === "bos")) {
+        T({ type: "qmark", value: p, output: A });
+        continue;
+      }
+      T({ type: "qmark", value: p, output: b });
+      continue;
+    }
+    if (p === "!") {
+      if (n.noextglob !== !0 && k() === "(" && (k(2) !== "?" || !/[!=<:]/.test(k(3)))) {
+        He("negate", p);
+        continue;
+      }
+      if (n.nonegate !== !0 && f.index === 0) {
+        Sn();
+        continue;
+      }
+    }
+    if (p === "+") {
+      if (n.noextglob !== !0 && k() === "(" && k(2) !== "?") {
+        He("plus", p);
+        continue;
+      }
+      if (h && h.value === "(" || n.regex === !1) {
+        T({ type: "plus", value: p, output: d });
+        continue;
+      }
+      if (h && (h.type === "bracket" || h.type === "paren" || h.type === "brace") || f.parens > 0) {
+        T({ type: "plus", value: p });
+        continue;
+      }
+      T({ type: "plus", value: d });
+      continue;
+    }
+    if (p === "@") {
+      if (n.noextglob !== !0 && k() === "(" && k(2) !== "?") {
+        T({ type: "at", extglob: !0, value: p, output: "" });
+        continue;
+      }
+      T({ type: "text", value: p });
+      continue;
+    }
+    if (p !== "*") {
+      (p === "$" || p === "^") && (p = `\\${p}`);
+      const m = ci.exec(ce());
+      m && (p += m[0], f.index += m[0].length), T({ type: "text", value: p });
+      continue;
+    }
+    if (h && (h.type === "globstar" || h.star === !0)) {
+      h.type = "star", h.star = !0, h.value += p, h.output = U, f.backtrack = !0, f.globstar = !0, Q(p);
+      continue;
+    }
+    let _ = ce();
+    if (n.noextglob !== !0 && /^\([^?]/.test(_)) {
+      He("star", p);
+      continue;
+    }
+    if (h.type === "star") {
+      if (n.noglobstar === !0) {
+        Q(p);
+        continue;
+      }
+      const m = h.prev, D = m.prev, F = m.type === "slash" || m.type === "bos", K = D && (D.type === "star" || D.type === "globstar");
+      if (n.bash === !0 && (!F || _[0] && _[0] !== "/")) {
+        T({ type: "star", value: p, output: "" });
+        continue;
+      }
+      const J = f.braces > 0 && (m.type === "comma" || m.type === "brace"), Ze = M.length && (m.type === "pipe" || m.type === "paren");
+      if (!F && m.type !== "paren" && !J && !Ze) {
+        T({ type: "star", value: p, output: "" });
+        continue;
+      }
+      for (; _.slice(0, 3) === "/**"; ) {
+        const Ne = t[f.index + 4];
+        if (Ne && Ne !== "/")
+          break;
+        _ = _.slice(3), Q("/**", 3);
+      }
+      if (m.type === "bos" && W()) {
+        h.type = "globstar", h.value += p, h.output = H(n), f.output = h.output, f.globstar = !0, Q(p);
+        continue;
+      }
+      if (m.type === "slash" && m.prev.type !== "bos" && !K && W()) {
+        f.output = f.output.slice(0, -(m.output + h.output).length), m.output = `(?:${m.output}`, h.type = "globstar", h.output = H(n) + (n.strictSlashes ? ")" : "|$)"), h.value += p, f.globstar = !0, f.output += m.output + h.output, Q(p);
+        continue;
+      }
+      if (m.type === "slash" && m.prev.type !== "bos" && _[0] === "/") {
+        const Ne = _[1] !== void 0 ? "|$" : "";
+        f.output = f.output.slice(0, -(m.output + h.output).length), m.output = `(?:${m.output}`, h.type = "globstar", h.output = `${H(n)}${g}|${g}${Ne})`, h.value += p, f.output += m.output + h.output, f.globstar = !0, Q(p + re()), T({ type: "slash", value: "/", output: "" });
+        continue;
+      }
+      if (m.type === "bos" && _[0] === "/") {
+        h.type = "globstar", h.value += p, h.output = `(?:^|${g}|${H(n)}${g})`, f.output = h.output, f.globstar = !0, Q(p + re()), T({ type: "slash", value: "/", output: "" });
+        continue;
+      }
+      f.output = f.output.slice(0, -h.output.length), h.type = "globstar", h.output = H(n), h.value += p, f.output += h.output, f.globstar = !0, Q(p);
+      continue;
+    }
+    const N = { type: "star", value: p, output: U };
+    if (n.bash === !0) {
+      N.output = ".*?", (h.type === "bos" || h.type === "slash") && (N.output = S + N.output), T(N);
+      continue;
+    }
+    if (h && (h.type === "bracket" || h.type === "paren") && n.regex === !0) {
+      N.output = p, T(N);
+      continue;
+    }
+    (f.index === f.start || h.type === "slash" || h.type === "dot") && (h.type === "dot" ? (f.output += w, h.output += w) : n.dot === !0 ? (f.output += $, h.output += $) : (f.output += S, h.output += S), k() !== "*" && (f.output += v, h.output += v)), T(N);
+  }
+  for (; f.brackets > 0; ) {
+    if (n.strictBrackets === !0)
+      throw new SyntaxError(ve("closing", "]"));
+    f.output = ne.escapeLast(f.output, "["), ye("brackets");
+  }
+  for (; f.parens > 0; ) {
+    if (n.strictBrackets === !0)
+      throw new SyntaxError(ve("closing", ")"));
+    f.output = ne.escapeLast(f.output, "("), ye("parens");
+  }
+  for (; f.braces > 0; ) {
+    if (n.strictBrackets === !0)
+      throw new SyntaxError(ve("closing", "}"));
+    f.output = ne.escapeLast(f.output, "{"), ye("braces");
+  }
+  if (n.strictSlashes !== !0 && (h.type === "star" || h.type === "bracket") && T({ type: "maybe_slash", value: "", output: `${g}?` }), f.backtrack === !0) {
+    f.output = "";
+    for (const _ of f.tokens)
+      f.output += _.output != null ? _.output : _.value, _.suffix && (f.output += _.suffix);
+  }
+  return f;
+};
+wn.fastpaths = (t, e) => {
+  const n = { ...e }, s = typeof n.maxLength == "number" ? Math.min(Je, n.maxLength) : Je, i = t.length;
+  if (i > s)
+    throw new SyntaxError(`Input length: ${i}, exceeds maximum allowed length: ${s}`);
+  t = bn[t] || t;
+  const {
+    DOT_LITERAL: o,
+    SLASH_LITERAL: r,
+    ONE_CHAR: a,
+    DOTS_SLASH: u,
+    NO_DOT: l,
+    NO_DOTS: c,
+    NO_DOTS_SLASH: d,
+    STAR: g,
+    START_ANCHOR: v
+  } = Ve.globChars(n.windows), y = n.dot ? c : l, R = n.dot ? d : l, w = n.capture ? "" : "?:", $ = { negated: !1, prefix: "" };
+  let b = n.bash === !0 ? ".*?" : g;
+  n.capture && (b = `(${b})`);
+  const A = (S) => S.noglobstar === !0 ? b : `(${w}(?:(?!${v}${S.dot ? u : o}).)*?)`, E = (S) => {
+    switch (S) {
+      case "*":
+        return `${y}${a}${b}`;
+      case ".*":
+        return `${o}${a}${b}`;
+      case "*.*":
+        return `${y}${b}${o}${a}${b}`;
+      case "*/*":
+        return `${y}${b}${r}${a}${R}${b}`;
+      case "**":
+        return y + A(n);
+      case "**/*":
+        return `(?:${y}${A(n)}${r})?${R}${a}${b}`;
+      case "**/*.*":
+        return `(?:${y}${A(n)}${r})?${R}${b}${o}${a}${b}`;
+      case "**/.*":
+        return `(?:${y}${A(n)}${r})?${o}${a}${b}`;
+      default: {
+        const L = /^(.*?)\.(\w+)$/.exec(S);
+        if (!L)
+          return;
+        const U = E(L[1]);
+        return U ? U + o + L[2] : void 0;
+      }
+    }
+  }, O = ne.removePrefix(t, $);
+  let H = E(O);
+  return H && n.strictSlashes !== !0 && (H += `${r}?`), H;
+};
+var pi = wn;
+const hi = ai, mt = pi, vn = qe, di = Ye, mi = (t) => t && typeof t == "object" && !Array.isArray(t), V = (t, e, n = !1) => {
+  if (Array.isArray(t)) {
+    const c = t.map((g) => V(g, e, n));
+    return (g) => {
+      for (const v of c) {
+        const y = v(g);
+        if (y)
+          return y;
+      }
+      return !1;
+    };
+  }
+  const s = mi(t) && t.tokens && t.input;
+  if (t === "" || typeof t != "string" && !s)
+    throw new TypeError("Expected pattern to be a non-empty string");
+  const i = e || {}, o = i.windows, r = s ? V.compileRe(t, e) : V.makeRe(t, e, !1, !0), a = r.state;
+  delete r.state;
+  let u = () => !1;
+  if (i.ignore) {
+    const c = { ...e, ignore: null, onMatch: null, onResult: null };
+    u = V(i.ignore, c, n);
+  }
+  const l = (c, d = !1) => {
+    const { isMatch: g, match: v, output: y } = V.test(c, r, e, { glob: t, posix: o }), R = { glob: t, state: a, regex: r, posix: o, input: c, output: y, match: v, isMatch: g };
+    return typeof i.onResult == "function" && i.onResult(R), g === !1 ? (R.isMatch = !1, d ? R : !1) : u(c) ? (typeof i.onIgnore == "function" && i.onIgnore(R), R.isMatch = !1, d ? R : !1) : (typeof i.onMatch == "function" && i.onMatch(R), d ? R : !0);
+  };
+  return n && (l.state = a), l;
+};
+V.test = (t, e, n, { glob: s, posix: i } = {}) => {
+  if (typeof t != "string")
+    throw new TypeError("Expected input to be a string");
+  if (t === "")
+    return { isMatch: !1, output: "" };
+  const o = n || {}, r = o.format || (i ? vn.toPosixSlashes : null);
+  let a = t === s, u = a && r ? r(t) : t;
+  return a === !1 && (u = r ? r(t) : t, a = u === s), (a === !1 || o.capture === !0) && (o.matchBase === !0 || o.basename === !0 ? a = V.matchBase(t, e, n, i) : a = e.exec(u)), { isMatch: !!a, match: a, output: u };
+};
+V.matchBase = (t, e, n) => (e instanceof RegExp ? e : V.makeRe(e, n)).test(vn.basename(t));
+V.isMatch = (t, e, n) => V(e, n)(t);
+V.parse = (t, e) => Array.isArray(t) ? t.map((n) => V.parse(n, e)) : mt(t, { ...e, fastpaths: !1 });
+V.scan = (t, e) => hi(t, e);
+V.compileRe = (t, e, n = !1, s = !1) => {
+  if (n === !0)
+    return t.output;
+  const i = e || {}, o = i.contains ? "" : "^", r = i.contains ? "" : "$";
+  let a = `${o}(?:${t.output})${r}`;
+  t && t.negated === !0 && (a = `^(?!${a}).*$`);
+  const u = V.toRegex(a, e);
+  return s === !0 && (u.state = t), u;
+};
+V.makeRe = (t, e, n = !1, s = !1) => {
+  if (!t || typeof t != "string")
+    throw new TypeError("Expected a non-empty string");
+  const i = e || {};
+  let o = { negated: !1, fastpaths: !0 }, r = "", a;
+  return t.startsWith("./") && (t = t.slice(2), r = o.prefix = "./"), i.fastpaths !== !1 && (t[0] === "." || t[0] === "*") && (a = mt.fastpaths(t, e)), a === void 0 ? (o = mt(t, e), o.prefix = r + (o.prefix || "")) : o.output = a, V.compileRe(o, e, n, s);
+};
+V.toRegex = (t, e) => {
+  try {
+    const n = e || {};
+    return new RegExp(t, n.flags || (n.nocase ? "i" : ""));
+  } catch (n) {
+    if (e && e.debug === !0)
+      throw n;
+    return /$^/;
+  }
+};
+V.constants = di;
+var yi = V, gi = yi;
+const _i = /* @__PURE__ */ yt(gi), Rn = gt(fetch), bi = async (t, e) => {
+  const n = new URL(t);
+  n.pathname = n.pathname + (n.pathname.endsWith("/") ? "metapage.json" : "/metapage.json");
+  const i = await (await Rn(n.href, {
+    redirect: "follow",
+    retries: 3,
+    retryDelay: 1e3
+  })).json();
+  return await nn(i, e || Le);
+}, wi = async (t, e) => {
+  if (t.startsWith("data:") || t.startsWith("https://docs.google.com"))
+    return;
+  const n = new URL(t);
+  if (n.origin.endsWith(".notion.site"))
+    return;
+  let s = St(t, "definition");
+  if (s != null && s.version)
+    return pt(s);
+  n.pathname.endsWith("metaframe.json") || (n.pathname = n.pathname + (n.pathname.endsWith("/") ? "metaframe.json" : "/metaframe.json"));
+  try {
+    const i = await Rn(n.href, {
+      redirect: "follow",
+      retries: 3,
+      retryDelay: 1e3
+    });
+    if (i.status !== 200)
+      return;
+    const o = await i.json();
+    return await sn(o, e || We);
+  } catch (i) {
+    console.error(`Error fetching metaframe definition from ${n.href}: ${i}`);
+    return;
+  }
+}, Gi = (t) => t ? !(t != null && t.inputs && Object.keys(t.inputs).length > 0 || t != null && t.outputs && Object.keys(t.outputs).length > 0 || t != null && t.allow || t != null && t.metadata && Object.keys(t.metadata).length > 0) : !0;
+class vi extends Ot.EventEmitter {
+  constructor(e, n, s, i, o, r = !1) {
+    if (super(), this.inputs = {}, this.outputs = {}, this._disposables = [], this._rpcListeners = [], this._loaded = !1, this._onLoaded = [], this._sendInputsAfterRegistration = !1, this._cachedEventInputsUpdate = {
+      iframeId: void 0,
+      inputs: void 0
+    }, this._cachedEventOutputsUpdate = {
+      iframeId: null,
+      inputs: null
+    }, !n.startsWith("data:") && !n.startsWith("http")) {
+      for (; n.startsWith("/"); )
+        n = n.substring(1);
+      n = window.location.protocol + "//" + window.location.hostname + (window.location.port && window.location.port != "" ? ":" + window.location.port : "") + "/" + n;
+    }
+    if (this.url = n, this._metapage = e, this._debug = r, r) {
+      var a = new URL(this.url);
+      a.searchParams.set(xe.mp_debug, "true"), this.url = a.href;
+    }
+    this.id = s, this._parentId = i, this._color = hn(this.id), this._consoleBackgroundColor = o, this._iframe = document.createElement("iframe"), this._iframe.name = this.id;
+    const u = this;
+    this.iframe = new Promise((l) => {
+      Xe().then(async () => {
+        var c, d, g, v;
+        if (u._iframe) {
+          if ((v = (g = (d = (c = this._metapage) == null ? void 0 : c._definition) == null ? void 0 : d.metaframes) == null ? void 0 : g[this.id]) != null && v.allow)
+            u._iframe.allow = this._metapage._definition.metaframes[this.id].allow, this._debug && this.log(`mf allow=${u._iframe.allow} from this._metapage?._definition`);
+          else {
+            let y = St(this.url, "definition");
+            if (y = y && (y != null && y.version) ? await pt(y) : void 0, !u._iframe)
+              return;
+            if (y != null && y.allow)
+              u._iframe.allow = y.allow;
+            else {
+              let R = await u.getDefinition();
+              if (this._debug && this.log(`mf metaframeDef=${JSON.stringify(R)}`), R = R && (R != null && R.version) ? await pt(R) : void 0, this._debug && this.log(`mf metaframeDef=${JSON.stringify(R)}`), !u._iframe)
+                return;
+              R && R.allow && (u._iframe.allow = R.allow);
+            }
+          }
+          this._debug && this.log(`mf allow=${u._iframe.allow} from ${this.url}`), u._iframe.src = this.url, l(u._iframe);
+        }
+      });
+    }), this.ack = this.ack.bind(this), this.dispose = this.dispose.bind(this), this.getDefinition = this.getDefinition.bind(this), this.getDefinitionUrl = this.getDefinitionUrl.bind(this), this.log = this.log.bind(this), this.logInternal = this.logInternal.bind(this), this.onInput = this.onInput.bind(this), this.onInputs = this.onInputs.bind(this), this.onOutput = this.onOutput.bind(this), this.onOutputs = this.onOutputs.bind(this), this.register = this.register.bind(this), this.registered = this.registered.bind(this), this.sendInputs = this.sendInputs.bind(this), this.sendOrBufferPostMessage = this.sendOrBufferPostMessage.bind(this), this.sendRpc = this.sendRpc.bind(this), this.sendRpcInternal = this.sendRpcInternal.bind(this), this.setInput = this.setInput.bind(this), this.setInputs = this.setInputs.bind(this), this.setMetapage = this.setMetapage.bind(this), this.setOutput = this.setOutput.bind(this), this.setOutputs = this.setOutputs.bind(this), this.addListenerReturnDisposer = this.addListenerReturnDisposer.bind(this), this.isDisposed = this.isDisposed.bind(this);
+  }
+  addListenerReturnDisposer(e, n) {
+    return super.addListener(e, n), () => {
+      super.removeListener(e, n);
+    };
+  }
+  setMetapage(e) {
+    return this._metapage = e, this;
+  }
+  getDefinitionUrl() {
+    var e = new URL(this.url);
+    return e.pathname = e.pathname + (e.pathname.endsWith("/") ? "metaframe.json" : "/metaframe.json"), e.href;
+  }
+  async getDefinition() {
+    if (this._definition)
+      return this._definition;
+    try {
+      const n = await wi(this.url);
+      if (n)
+        return this._definition = n, this._definition;
+    } catch (n) {
+      var e = this.getDefinitionUrl();
+      this.emit(x.Warning, `Failed to fetch or convert: ${e}
+Error: ${n != null && n.message ? n == null ? void 0 : n.message : n == null ? void 0 : n.toString()}`);
+    }
+  }
+  setInput(e, n) {
+    console.assert(!!e);
+    var s = {};
+    s[e] = n, this.setInputs(s);
+  }
+  setInputs(e) {
+    this.log({ m: "MetapageIFrameRpcClient", inputs: e });
+    const n = e;
+    if (this.inputs = Ge(this.inputs, e), this.inputs === n)
+      return this;
+    if (this._loaded || (this._sendInputsAfterRegistration = !0), this._iframe.parentNode && this._loaded && this.sendInputs(e), this.emit(x.Inputs, this.inputs), this._metapage.listenerCount(x.Inputs) > 0) {
+      var s = {};
+      s[this.id] = e, this._metapage.emit(x.Inputs, s);
+    }
+    return this;
+  }
+  setOutput(e, n) {
+    console.assert(!!e);
+    var s = {};
+    s[e] = n, this.setOutputs(s);
+  }
+  setOutputs(e) {
+    const n = e;
+    if (this.outputs = Ge(this.outputs, e), this.outputs === n)
+      return this;
+    if (this.emit(x.Outputs, e), this._metapage.listenerCount(x.Outputs) > 0) {
+      var s = {};
+      s[this.id] = this.outputs, this._metapage.emit(x.Outputs, s);
+    }
+  }
+  onInputs(e) {
+    return this.addListenerReturnDisposer(x.Inputs, e);
+  }
+  onInput(e, n) {
+    var s = function(i) {
+      i.hasOwnProperty(e) && n(i[e]);
+    };
+    return this.addListenerReturnDisposer(x.Inputs, s);
+  }
+  onOutputs(e) {
+    return this.addListenerReturnDisposer(x.Outputs, e);
+  }
+  onOutput(e, n) {
+    var s = function(i) {
+      i.hasOwnProperty(e) && n(i[e]);
+    };
+    return this.addListenerReturnDisposer(x.Outputs, s);
+  }
+  isDisposed() {
+    return this.inputs === void 0;
+  }
+  dispose() {
+    for (super.removeAllListeners(); this._disposables && this._disposables.length > 0; ) {
+      const e = this._disposables.pop();
+      e && e();
+    }
+    this._rpcListeners = void 0, this.inputs = void 0, this.outputs = void 0, this._iframe && this._iframe.parentNode && this._iframe.parentNode.removeChild(this._iframe), this._iframe = void 0, this._bufferMessages = void 0, this._bufferTimeout && (window.clearInterval(this._bufferTimeout), this._bufferTimeout = void 0), this._metapage = void 0;
+  }
+  register() {
+    var e = {
+      iframeId: this.id,
+      parentId: this._parentId,
+      state: {
+        inputs: this.inputs
+      },
+      version: Wt
+    };
+    this.sendRpcInternal(fe.SetupIframeServerResponse, e);
+  }
+  registered(e) {
+    if (this.log({ m: "MetapageIFrameRpcClient.registered", inputs: this.inputs }), !this._loaded) {
+      if (!e)
+        throw "Cannot register without a version";
+      for (this.version = e, this._loaded = !0; this._onLoaded && this._onLoaded.length > 0; )
+        this._onLoaded.pop()();
+      this._sendInputsAfterRegistration && this.sendInputs(this.inputs);
+    }
+  }
+  async sendInputs(e) {
+    e && (e = await Ke(e), !this.isDisposed() && this.sendRpc(fe.InputsUpdate, {
+      inputs: e,
+      parentId: this._parentId
+    }));
+  }
+  sendRpc(e, n) {
+    var s, i;
+    if ((s = this == null ? void 0 : this._iframe) != null && s.parentNode && this._loaded)
+      this.sendRpcInternal(e, n);
+    else {
+      (i = this == null ? void 0 : this._metapage) == null || i.error("sending rpc later");
+      const o = this;
+      this == null || this._onLoaded.push(() => {
+        o.sendRpcInternal(e, n);
+      });
+    }
+  }
+  ack(e) {
+    if (this._debug) {
+      this.log("⚒ ⚒ ⚒ sending ack from client to frame");
+      var n = {
+        message: e
+      };
+      this.sendRpc(fe.MessageAck, n);
+    }
+  }
+  log(e) {
+    this._debug && this.logInternal(e);
+  }
+  logInternal(e) {
+    let n;
+    typeof e == "string" ? n = e : typeof e == "string" ? n = e + "" : n = JSON.stringify(e), Et(`Metapage[${this._parentId}] Metaframe[${this.id}] ${n}`, this._color, this._consoleBackgroundColor);
+  }
+  sendRpcInternal(e, n) {
+    const s = {
+      id: "_",
+      iframeId: this.id,
+      jsonrpc: "2.0",
+      method: e,
+      params: n,
+      parentId: this._parentId
+    };
+    this._iframe ? this.sendOrBufferPostMessage(s) : this._metapage ? this._metapage.error(`Cannot send to child iframe messageJSON=${JSON.stringify(s).substring(0, 200)}`) : console.error(`Cannot send to child iframe messageJSON=${JSON.stringify(s).substring(0, 200)}`);
+  }
+  sendOrBufferPostMessage(e) {
+    if (this._iframe && this._iframe.contentWindow)
+      this._iframe.contentWindow.postMessage(e, this.url);
+    else if (this._bufferMessages)
+      this._bufferMessages.push(e);
+    else {
+      this._bufferMessages = [e];
+      const n = this;
+      this._bufferTimeout = window.setInterval(function() {
+        n._iframe && n._iframe.contentWindow && (n._bufferMessages.forEach((s) => n._iframe.contentWindow.postMessage(s, n.url)), window.clearInterval(n._bufferTimeout), n._bufferTimeout = void 0, n._bufferMessages = void 0);
+      }, 0);
+    }
+  }
+}
+const ge = C({
+  metaframes: {
+    inputs: {},
+    outputs: {}
+  }
+}, (t) => t), Vi = (t) => de(t), Ri = (t, e) => !!(!e || e === "**" || t === e || _i.isMatch(t, e)), Oi = "bcbcbc";
+class ee extends Ns {
+  static async from(e, n) {
+    if (e == null)
+      throw "Metapage definition cannot be null";
+    if (typeof e == "string")
+      try {
+        e = JSON.parse(e);
+      } catch {
+        throw "Cannot parse into JSON:\n${metaPageDef}";
+      }
+    var s = new ee();
+    return s.setDefinition(e);
+  }
+  constructor(e) {
+    super(), this._state = ge, this._metaframes = C({}, (n) => n), this.debug = dt(), this._internalReceivedMessageCounter = 0, this._cachedInputLookupMap = C({}, (n) => n), this._inputMap = {}, this._id = e && e.id ? e.id : js(), this._consoleBackgroundColor = e && e.color ? e.color : Oi, this.addPipe = this.addPipe.bind(this), this.dispose = this.dispose.bind(this), this.addMetaframe = this.addMetaframe.bind(this), this.getInputsFromOutput = this.getInputsFromOutput.bind(this), this.getMetaframe = this.getMetaframe.bind(this), this.getMetaframeIds = this.getMetaframeIds.bind(this), this.getMetaframe = this.getMetaframe.bind(this), this.getMetaframes = this.getMetaframes.bind(this), this.getState = this.getState.bind(this), this.getStateMetaframes = this.getStateMetaframes.bind(this), this.isValidJSONRpcMessage = this.isValidJSONRpcMessage.bind(this), this.log = this.log.bind(this), this.logInternal = this.logInternal.bind(this), this.metaframeIds = this.metaframeIds.bind(this), this.metaframes = this.metaframes.bind(this), this.onMessage = this.onMessage.bind(this), this.removeAll = this.removeAll.bind(this), this.removeMetaframe = this.removeMetaframe.bind(this), this.setDebugFromUrlParams = this.setDebugFromUrlParams.bind(this), this.setDefinition = this.setDefinition.bind(this), this.setInput = this.setInput.bind(this), this.setInputs = this.setInputs.bind(this), this.setInputStateOnlyMetaframeInputValue = this.setInputStateOnlyMetaframeInputValue.bind(this), this.setInputStateOnlyMetaframeInputMap = this.setInputStateOnlyMetaframeInputMap.bind(this), this.setInputStateOnlyMetapageInstanceInputs = this.setInputStateOnlyMetapageInstanceInputs.bind(this), this.setOutputStateOnlyMetaframeInputValue = this.setOutputStateOnlyMetaframeInputValue.bind(this), this.setOutputStateOnlyMetaframeInputMap = this.setOutputStateOnlyMetaframeInputMap.bind(this), this.setOutputStateOnlyMetapageInstanceInputs = this.setOutputStateOnlyMetapageInstanceInputs.bind(this), this.setMetadata = this.setMetadata.bind(this), this.setMetaframeClientInputAndSentClientEvent = this.setMetaframeClientInputAndSentClientEvent.bind(this), this.setState = this.setState.bind(this), this.isDisposed = this.isDisposed.bind(this), this._emitDefinitionEvent = this._emitDefinitionEvent.bind(this), Xe().then(() => {
+      this.isDisposed() || (window.addEventListener("message", this.onMessage), this.log("Initialized"));
+    });
+  }
+  isDisposed() {
+    return this._metaframes === void 0;
+  }
+  addListenerReturnDisposer(e, n) {
+    return super.addListener(e, n), () => {
+      super.removeListener(e, n);
+    };
+  }
+  setDebugFromUrlParams() {
+    const e = new URL(window.location.href);
+    return this.debug = ["debug", "mp_debug"].reduce((n, s) => n || e.searchParams.get(s) === "true" || e.searchParams.get(s) === "1", !1), this;
+  }
+  getState() {
+    return this._state;
+  }
+  setState(e) {
+    this._state = C(e, (n) => n), this.getMetaframeIds().forEach((n) => {
+      this.getMetaframe(n).setInputs(this._state.metaframes.inputs[n]), this.getMetaframe(n).setOutputs(this._state.metaframes.outputs[n]);
+    }), this.listenerCount(x.State) > 0 && ge !== this._state && this.emit(x.State, this._state);
+  }
+  getStateMetaframes() {
+    return this._state.metaframes;
+  }
+  getDefinition() {
+    return this._definition;
+  }
+  async setDefinition(e, n) {
+    if (!e.version)
+      throw "Metapage definition must have a version";
+    const s = await Wn(e);
+    if (this.isDisposed())
+      return this;
+    s.metaframes && Object.keys(s.metaframes).forEach((o) => {
+      var r = s.metaframes[o];
+      if (typeof r != "object")
+        throw this.emitErrorMessage(`Metaframe "${o}" is not an object`), `Metaframe "${o}" is not an object`;
+      if (!r.url)
+        throw this.emitErrorMessage(`Metaframe "${o}" missing field: url`), `Metaframe "${o}" missing field: url`;
+    });
+    const i = this._definition;
+    return this._definition = s, Object.keys(this._metaframes).forEach((o) => {
+      (!s.metaframes || !s.metaframes[o]) && this.removeMetaframe(o);
+    }), n && (this._state = C(n, (o) => o)), s.metaframes && Object.keys(s.metaframes).forEach((o) => {
+      if (!this._metaframes.hasOwnProperty(o)) {
+        const r = s.metaframes[o];
+        this.addMetaframe(o, r);
+      }
+    }), i !== pn && window.setTimeout(() => {
+      !this.isDisposed() && s === this._definition && (this._emitDefinitionEvent(), n && this.listenerCount(x.State) > 0 && ge !== this._state && this.emit(x.State, this._state));
+    }, 0), this;
+  }
+  setMetadata(e) {
+    this._definition = C(this._definition, (n) => {
+      n.meta = e;
+    }), this._emitDefinitionEvent();
+  }
+  _emitDefinitionEvent() {
+    if (this.listenerCount(x.Definition) > 0) {
+      const e = {
+        definition: this._definition,
+        metaframes: this._metaframes
+      };
+      this.emit(x.Definition, e);
+    }
+  }
+  addPipe(e, n) {
+    this._inputMap = C(this._inputMap, (s) => {
+      s[e] || (s[e] = []), s[e].push(n);
+    });
+  }
+  removeMetaframe(e) {
+    this._metaframes[e] && (this._metaframes[e].dispose(), this._metaframes = C(this._metaframes, (n) => {
+      delete n[e];
+    }), this._state = C(this._state, (n) => {
+      delete n.metaframes.inputs[e], delete n.metaframes.outputs[e];
+    }), this._inputMap = C(this._inputMap, (n) => {
+      delete n[e], Object.keys(n).forEach((s) => {
+        const i = n[s];
+        let o = 0;
+        for (; o <= i.length; )
+          i[o] && i[o].metaframe === e ? i.splice(o, 1) : o++;
+      });
+    }), this._cachedInputLookupMap = C({}, (n) => n));
+  }
+  removeAll() {
+    Object.keys(this._metaframes).forEach((e) => this._metaframes[e].dispose()), this._metaframes = C({}, (e) => e), this._state = ge, this._inputMap = C({}, (e) => e), this._cachedInputLookupMap = C({}, (e) => e);
+  }
+  metaframes() {
+    return this.getMetaframes();
+  }
+  metaframeIds() {
+    return this.getMetaframeIds();
+  }
+  getMetaframeIds() {
+    return Object.keys(this._metaframes);
+  }
+  getMetaframes() {
+    return this._metaframes;
+  }
+  getMetaframe(e) {
+    return this == null ? void 0 : this._metaframes[e];
+  }
+  addMetaframe(e, n) {
+    if (!e)
+      throw "addMetaframe missing metaframeId";
+    if (!n)
+      throw "addMetaframe missing definition";
+    if (this._metaframes[e])
+      throw this.emitErrorMessage(`Existing metaframe for id=${e}`), `Existing metaframe for id=${e}`;
+    if (!n.url)
+      throw this.emitErrorMessage(`Metaframe definition missing url id=${e}`), `Metaframe definition missing url id=${e}`;
+    var s = new vi(this, n.url, e, this._id, this._consoleBackgroundColor, this.debug).setMetapage(this);
+    return this._metaframes = C(this._metaframes, (i) => {
+      i[e] = s;
+    }), s.addListener(x.Error, (i) => {
+      this.emit(x.Error, {
+        metaframeId: s.id,
+        metaframeUrl: s.url,
+        error: i
+      });
+    }), n.inputs && n.inputs.forEach((i) => this.addPipe(e, i)), s.setInputs(this._state.metaframes.inputs[e]), s;
+  }
+  dispose() {
+    this.log("disposing"), super.removeAllListeners(), window.removeEventListener("message", this.onMessage), this._metaframes && Object.keys(this._metaframes).forEach((e) => this._metaframes[e].dispose()), this._id = void 0, this._metaframes = void 0, this._state = void 0, this._cachedInputLookupMap = void 0, this._inputMap = void 0;
+  }
+  log(e, n, s) {
+    this.debug && this.logInternal(e, n, s);
+  }
+  error(e) {
+    this.logInternal(e, "f00", this._consoleBackgroundColor), this.emitErrorMessage(`${e}`);
+  }
+  emitErrorMessage(e) {
+    this.emit(x.Error, e);
+  }
+  getInputsFromOutput(e, n) {
+    return this._cachedInputLookupMap[e] || (this._cachedInputLookupMap = C(this._cachedInputLookupMap, (s) => {
+      s[e] = C({}, (i) => i);
+    })), this._cachedInputLookupMap[e][n] || (this._cachedInputLookupMap = C(this._cachedInputLookupMap, (s) => {
+      var i = [];
+      s[e][n] = i, Object.keys(this._inputMap).forEach((o) => {
+        o !== e && this._inputMap[o].forEach((r) => {
+          if (r.metaframe === e && Ri(n, r.source)) {
+            var a = r.target || "";
+            !r.target || r.target.startsWith("*") || r.target === "" ? a = n : a && a.endsWith("/") && (a = a + n), i.push({ metaframe: o, pipe: a });
+          }
+        });
+      });
+    })), this._cachedInputLookupMap[e][n];
+  }
+  isValidJSONRpcMessage(e) {
+    if (e.jsonrpc !== "2.0")
+      return !1;
+    switch (e.method) {
+      case q.SetupIframeClientRequest:
+        return !0;
+      default:
+        var s = e.iframeId;
+        return s && e.parentId === this._id && !!this._metaframes[s];
+    }
+  }
+  setInput(e, n, s) {
+    var i, o;
+    typeof e == "object" ? this.setInputStateOnlyMetapageInstanceInputs(e) : typeof n == "string" ? this.setInputStateOnlyMetaframeInputValue(e, n, s) : this.setInputStateOnlyMetaframeInputMap(e, n || {}), this.setMetaframeClientInputAndSentClientEvent(e, n, s), (this.listenerCount(x.State) > 0 || this.listenerCount(x.Inputs) > 0) && ge !== this._state && (this.emit(x.State, this._state), this.emit(x.Inputs, (o = (i = this._state) == null ? void 0 : i.metaframes) == null ? void 0 : o.inputs));
+  }
+  setMetaframeClientInputAndSentClientEvent(e, n, s) {
+    if (typeof e == "object") {
+      if (n || s)
+        throw "bad arguments, see API docs";
+      const i = e;
+      Object.keys(i).forEach((o) => {
+        var r = o, a = i[r];
+        if (typeof a != "object")
+          throw "bad arguments, see API docs";
+        var u = this._metaframes[r];
+        u ? u.setInputs(a) : this.error("No iframe id=$metaframeId");
+      });
+    } else if (typeof e == "string") {
+      const i = this._metaframes[e];
+      if (i == null && this.error(`No iframe id=${e}`), typeof n == "string")
+        i.setInput(n, s);
+      else if (typeof n == "object")
+        i.setInputs(n);
+      else
+        throw "bad arguments, see API docs";
+    } else
+      throw "bad arguments, see API docs";
+  }
+  setInputs(e, n, s) {
+    this.setInput(e, n, s);
+  }
+  setOutputStateOnlyMetapageInstanceInputs(e) {
+    this._setStateOnlyMetaframes(!1, e);
+  }
+  setOutputStateOnlyMetaframeInputValue(e, n, s) {
+    this._setStateOnlyMetaframeInputValue(!1, e, n, s);
+  }
+  setOutputStateOnlyMetaframeInputMap(e, n) {
+    this._setStateOnlyMetaframeInputMap(!1, e, n);
+  }
+  setInputStateOnlyMetapageInstanceInputs(e) {
+    this._setStateOnlyMetaframes(!0, e);
+  }
+  setInputStateOnlyMetaframeInputValue(e, n, s) {
+    this._setStateOnlyMetaframeInputValue(!0, e, n, s);
+  }
+  setInputStateOnlyMetaframeInputMap(e, n) {
+    this._setStateOnlyMetaframeInputMap(!0, e, n);
+  }
+  _setStateOnlyMetaframeInputValue(e, n, s, i) {
+    this._state = C(this._state, (o) => {
+      if (!this._metaframes.hasOwnProperty(n))
+        throw `No metaframe: ${n}`;
+      o.metaframes || (o.metaframes = { inputs: {}, outputs: {} }), e ? o.metaframes.inputs || (o.metaframes.inputs = {}) : o.metaframes.outputs || (o.metaframes.outputs = {});
+      let a = e ? o.metaframes.inputs : o.metaframes.outputs;
+      a = a || {}, a[n] = a[n] ? a[n] : {}, i === void 0 ? delete a[n][s] : a[n][s] = i;
+    });
+  }
+  _setStateOnlyMetaframeInputMap(e, n, s) {
+    !s || Object.keys(s).length === 0 || (this._state = C(this._state, (i) => {
+      if (!this._metaframes.hasOwnProperty(n))
+        throw `No metaframe: ${n}`;
+      let r = e ? i.metaframes.inputs : i.metaframes.outputs;
+      r[n] = r[n] ? r[n] : {}, Object.keys(s).forEach((a) => {
+        s[a] === void 0 ? delete r[n][a] : r[n][a] = s[a];
+      });
+    }));
+  }
+  _setStateOnlyMetaframes(e, n) {
+    !n || Object.keys(n).length === 0 || (this._state = C(this._state, (s) => {
+      Object.keys(n).forEach((i) => {
+        var o = n[i];
+        if (typeof o != "object")
+          throw "Object values must be objects";
+        if (!this._metaframes.hasOwnProperty(i))
+          throw "No metaframe: ${metaframeId}";
+        const a = e ? s.metaframes.inputs : s.metaframes.outputs;
+        a[i] = a[i] ? a[i] : {}, Object.keys(o).forEach((u) => {
+          o[u] === void 0 ? delete a[i][u] : a[i][u] = o[u];
+        });
+      });
+    }));
+  }
+  onMessage(e) {
+    if (typeof e.data == "object") {
+      const r = e.data;
+      if (!this.isValidJSONRpcMessage(r))
+        return;
+      var n = r.method;
+      const a = r.iframeId;
+      if (!a)
+        return;
+      const u = this.getMetaframe(a);
+      if (!u) {
+        this.error(`💥 onMessage no metaframe id=${a}`);
+        return;
+      }
+      switch (r._messageCount = ++this._internalReceivedMessageCounter, this.debug && this.log(`processing ${JSON.stringify(r, null, "  ").substring(0, 500)}`), n) {
+        case q.SetupIframeClientRequest:
+          u.register();
+          break;
+        case q.SetupIframeServerResponseAck:
+          if (u) {
+            const c = r.params;
+            u.registered(c.version);
+          }
+          break;
+        case q.OutputsUpdate:
+          const l = r.params;
+          if (!l || Object.keys(l).length === 0)
+            break;
+          if (this._metaframes[a]) {
+            var s = this._metaframes[a];
+            this.setOutputStateOnlyMetaframeInputMap(a, l), s.setOutputs(l);
+            var i = !1;
+            const c = Object.keys(l), d = {};
+            c.forEach((g, v) => {
+              const y = this.getInputsFromOutput(a, g);
+              y.length > 0 && y.forEach((R) => {
+                d[R.metaframe] || (d[R.metaframe] = {}), d[R.metaframe][R.pipe] = l[g], i = !0;
+              });
+            }), i && (this.setInputStateOnlyMetapageInstanceInputs(d), Object.keys(d).forEach((g) => {
+              this._metaframes[g].setInputs(d[g]);
+            })), this.listenerCount(x.State) > 0 && ge !== this._state && this.emit(x.State, this._state), this.debug && s.ack({ jsonrpc: r, state: this._state });
+          } else
+            this.error(`missing metaframe=${a}`);
+          break;
+        case q.InputsUpdate:
+          var o = r.params;
+          this.debug && this.log(`inputs ${JSON.stringify(o)} from ${a}`), this._metaframes[a] ? (this.setInputStateOnlyMetaframeInputMap(a, o), this._metaframes[a].setInputs(o), this.listenerCount(x.State) > 0 && ge !== this._state && this.emit(x.State, this._state), this.debug && this._metaframes[a].ack({
+            jsonrpc: r,
+            state: this._state
+          })) : (console.error(`InputsUpdate failed no metaframe id: "${a}"`), this.error(`InputsUpdate failed no metaframe id: "${a}"`));
+          break;
+        case q.HashParamsUpdate:
+          if (u) {
+            const c = r.params, d = new URL(u.url);
+            d.hash = c.hash, u.url = d.href, this._definition = C(this._definition, (g) => {
+              g.metaframes[c.metaframe].url = d.href;
+            }), this._emitDefinitionEvent();
+          }
+          break;
+        default:
+          this.debug && this.log(`Unknown RPC method: "${n}"`);
+      }
+      this.listenerCount(x.Message) > 0 && this.emit(x.Message, r);
+    }
+  }
+  logInternal(e, n, s) {
+    s = s || this._consoleBackgroundColor;
+    let i;
+    typeof e == "string" ? i = e : typeof e == "number" ? i = e + "" : i = JSON.stringify(e), i = this._id ? `Metapage[${this._id}] ${i}` : i, Et(i, n, s);
+  }
+}
+ee.version = Wt;
+ee.DEFINITION = x.Definition;
+ee.ERROR = x.Error;
+ee.INPUTS = x.Inputs;
+ee.MESSAGE = x.Message;
+ee.OUTPUTS = x.Outputs;
+ee.STATE = x.State;
+ee.deserializeInputs = Ce;
+ee.serializeInputs = Ke;
+function On(t) {
+  return t.startsWith("data:") ? t.includes("type=metapage-divider") : !1;
+}
+function Si(t) {
+  const e = JSON.parse(JSON.stringify(t));
+  e.meta || (e.meta = {}), e.meta.layouts || (e.meta.layouts = {}), e.meta.layouts["react-grid-layout"] || (e.meta.layouts["react-grid-layout"] = {
+    docs: "https://www.npmjs.com/package/react-grid-layout",
+    props: {
+      cols: 12,
+      margin: [20, 40],
+      rowHeight: 100,
+      containerPadding: [5, 5]
+    },
+    layout: []
+  });
+  const n = e.meta.layouts["react-grid-layout"];
+  if (e.metaframes) {
+    Object.keys(e.metaframes).forEach((i) => {
+      if (!n.layout.some((o) => o.i === i)) {
+        const o = n.layout.length > 0 ? Math.max(...n.layout.map((r) => (r.y || 0) + (r.h || 2))) : 0;
+        n.layout.push({
+          i,
+          x: 0,
+          y: o,
+          w: n.props.cols,
+          h: On(e.metaframes[i].url) ? 1 : 3
+        });
+      }
+    });
+    const s = new Set(Object.keys(e.metaframes));
+    n.layout = n.layout.filter((i) => s.has(i.i)), n.layout.forEach((i) => {
+      i.x = i.x || 0, i.y = i.y || 0, i.w = i.w || 1, i.h = i.h || 1;
+    });
+  }
+  return e;
+}
+async function Ji(t) {
+  var O, H, S, L, U;
+  let { url: e, definition: n, onOutputs: s, rootDiv: i, options: o = {} } = t;
+  if (!e && !n)
+    throw new Error("Either url or definition must be provided");
+  if (e && n)
+    throw new Error("Either url or definition must be provided, not both");
+  if (e && (n = await bi(e)), !n)
+    throw new Error("Failed to fetch metapage definition");
+  n = Si(n), n = await Ei(n), await Xe();
+  const r = new ee();
+  r.debug = o.debug || !1;
+  try {
+    await r.setDefinition(JSON.parse(JSON.stringify(n)));
+  } catch (f) {
+    throw r.dispose(), new Error(`Failed to set metapage definition: ${f}`);
+  }
+  const a = [];
+  s && a.push(r.addListenerReturnDisposer(x.Outputs, s));
+  const u = (H = (O = n == null ? void 0 : n.meta) == null ? void 0 : O.layouts) == null ? void 0 : H["react-grid-layout"], l = u == null ? void 0 : u.layout;
+  if (!u || !l)
+    throw new Error("No valid layout found in metapage definition");
+  const c = /* @__PURE__ */ new Set(), d = l.map((f, M) => {
+    const I = r.getMetaframes()[f.i];
+    return I && On(I.url) ? { index: M, y: f.y, id: f.i } : null;
+  }).filter((f) => f !== null);
+  if (d.length > 0) {
+    const f = d.reduce((I, B) => B.y < I.y ? B : I), M = ((S = l.find((I) => I.i === f.id)) == null ? void 0 : S.y) ?? 0;
+    l.forEach((I) => {
+      I.y >= M && c.add(I.i);
+    });
+  }
+  const g = r.getMetaframeIds().filter((f) => !c.has(f));
+  let v = l.filter((f) => g.includes(f.i));
+  if (v.length === 0)
+    return {
+      metapage: r,
+      setInputs: (f) => {
+        r.isDisposed() || r.setInputs(f);
+      },
+      dispose: () => {
+        a.forEach((f) => f()), r.dispose(), i.innerHTML = "";
+      }
+    };
+  v.sort((f, M) => f.y !== M.y ? f.y - M.y : f.x - M.x);
+  const y = {
+    display: "grid",
+    gridTemplateColumns: "repeat(1, 1fr)",
+    gridAutoRows: "1fr",
+    gap: `${((L = u.props.margin) == null ? void 0 : L[0]) || 10}px`,
+    width: "100%",
+    height: "100%",
+    maxHeight: "100%",
+    padding: ((U = u.props.containerPadding) == null ? void 0 : U[0]) || 0,
+    minHeight: 0,
+    alignContent: "start",
+    alignItems: "start",
+    overflow: "hidden"
+  }, R = {
+    width: "100%",
+    height: "100%",
+    overflow: "hidden",
+    display: "flex",
+    flexDirection: "column"
+  };
+  i.innerHTML = "";
+  const w = document.createElement("div");
+  Object.assign(w.style, R);
+  const $ = document.createElement("div");
+  Object.assign($.style, y);
+  const b = [];
+  for (const f of g) {
+    const M = l.find((W) => W.i === f);
+    if (!M)
+      continue;
+    const I = r.getMetaframes()[f], B = await I.iframe;
+    if (!I)
+      continue;
+    b.push(M);
+    const h = {
+      gridColumn: `${M.x + 1} / span ${M.w}`,
+      gridRow: `${M.y + 1} / span ${M.h}`,
+      overflow: "hidden",
+      width: "100%",
+      height: "100%",
+      border: o.hideFrameBorders ? "none" : "1px solid #e0e0e0",
+      position: "relative",
+      alignSelf: "stretch",
+      justifySelf: "stretch"
+    }, p = document.createElement("div");
+    Object.assign(p.style, h), p.appendChild(B), $.appendChild(p);
+  }
+  const A = Math.max(...b.map((f) => f.x + f.w));
+  Math.max(...b.map((f) => f.y + f.h)), $.style.gridTemplateColumns = `repeat(${Math.max(1, A)}, 1fr)`;
+  const E = document.createElement("div");
+  E.style.position = "absolute", E.style.top = "-9999px", E.style.left = "-9999px", E.style.width = "1px", E.style.height = "1px", E.style.overflow = "hidden", E.style.pointerEvents = "none";
+  for (const f of Object.keys(r.getMetaframes()).filter((M) => c.has(M))) {
+    const M = r.getMetaframes()[f];
+    if (!M)
+      continue;
+    const I = document.createElement("div");
+    I.setAttribute("data-metaframe-id", f), I.style.width = "100px", I.style.height = "100px";
+    let B;
+    M.iframe ? B = await M.iframe : (B = document.createElement("iframe"), B.src = M.url, B.style.border = "none", B.style.width = "100%", B.style.height = "100%"), I.appendChild(B), E.appendChild(I);
+  }
+  return w.appendChild($), w.appendChild(E), i.appendChild(w), {
+    metapage: r,
+    setInputs: (f) => {
+      r.isDisposed() || r.setInputs(f);
+    },
+    dispose: () => {
+      a.forEach((f) => f()), r.dispose(), i.innerHTML = "";
+    }
+  };
+}
+const Ai = (t) => {
+  var n;
+  if (!t)
+    return;
+  typeof t == "string" && (t.startsWith("/") && (t = "https://metapage.io" + t), t = new URL(t));
+  let e = (n = /\/m?f\/([0-9a-zA-Z-]{3,})\/?(metaframe\.json)?.*$/g.exec(t.pathname)) == null ? void 0 : n[1];
+  return e || (t.searchParams.get("mfk") ?? void 0);
+}, Ei = async (t) => {
+  if (!(t != null && t.metaframes))
+    return t;
+  for (const [e, n] of Object.entries(t.metaframes)) {
+    if (!(n.url.startsWith("https://metapage.io/mf/") || n.url.startsWith("https://metapage.io/f/")))
+      continue;
+    const s = Ai(n.url);
+    if (!s)
+      continue;
+    const i = await fetch(`https://metapage.io/f/${s}/definition.json`).then((o) => o.json());
+    i != null && i.url && (n.url = i == null ? void 0 : i.url);
+  }
+  return t;
+};
 export {
-  pe as INITIAL_NULL_METAPAGE_DEFINITION,
-  u as INTERNAL_ERROR,
-  S as INVALID_PARAMS,
-  L as INVALID_REQUEST,
-  c as JsonRpcMethodsFromChild,
-  F as JsonRpcMethodsFromParent,
-  a as METAFRAME_JSON_FILE,
-  t as METAPAGE_KEY_DEFINITION,
-  o as METAPAGE_KEY_STATE,
-  O as METHOD_NOT_FOUND,
-  b as Metaframe,
-  y as MetaframeEvents,
-  z as MetaframeLoadingState,
-  le as MetaframeVersionCurrent,
-  Te as MetaframeVersionsAll,
-  J as Metapage,
-  h as MetapageEvents,
-  Me as MetapageHashParams,
-  B as MetapageIFrameRpcClient,
-  fe as MetapageShared,
-  Ie as MetapageVersionCurrent,
-  Ae as MetapageVersionsAll,
-  v as PARSE_ERROR,
-  i as VERSION_METAFRAME,
-  n as VERSION_METAPAGE,
-  g as convertMetaframeDefinitionToCurrentVersion,
-  E as convertMetaframeDefinitionToVersion,
-  l as convertMetaframeJsonToCurrentVersion,
-  m as convertMetapageDefinitionToCurrentVersion,
-  p as convertMetapageDefinitionToVersion,
-  A as deserializeInputs,
-  j as generateId,
-  k as generateMetaframeId,
-  q as generateMetapageId,
-  w as generateNonce,
-  H as getLibraryVersionMatching,
-  T as getMatchingMetaframeVersion,
-  M as getMatchingMetapageVersion,
-  Re as getMetaframeDefinitionFromUrl,
-  Ve as getMetapageDefinitionFromUrl,
-  W as getUrlParam,
-  X as getUrlParamDebug,
-  Z as hashCode,
-  $ as intToRGB,
-  ee as isDebugFromUrlsParams,
-  _e as isEmptyMetaframeDefinition,
-  ge as isIframe,
-  C as isJsonRpcId,
-  re as isPageLoaded,
-  ae as log,
-  K as matchPipe,
-  te as merge,
-  oe as metapageAllSha256Hash,
-  ie as metapageOnlyEssentailSha256Hash,
-  ne as pageLoaded,
-  D as possiblyDeserializeDatarefToFile,
-  R as possiblyDeserializeDatarefToValue,
-  V as possiblySerializeValueToDataref,
-  Ne as renderMetapage,
-  _ as serializeInputs,
-  se as stringToRgb,
-  d as valueToFile
+  pn as INITIAL_NULL_METAPAGE_DEFINITION,
+  ki as INTERNAL_ERROR,
+  Di as INVALID_PARAMS,
+  Ti as INVALID_REQUEST,
+  q as JsonRpcMethodsFromChild,
+  fe as JsonRpcMethodsFromParent,
+  Mi as METAFRAME_JSON_FILE,
+  Ii as METAPAGE_KEY_DEFINITION,
+  Ci as METAPAGE_KEY_STATE,
+  Pi as METHOD_NOT_FOUND,
+  ie as Metaframe,
+  z as MetaframeEvents,
+  ae as MetaframeLoadingState,
+  We as MetaframeVersionCurrent,
+  Ct as MetaframeVersionsAll,
+  ee as Metapage,
+  x as MetapageEvents,
+  xe as MetapageHashParams,
+  vi as MetapageIFrameRpcClient,
+  Ns as MetapageShared,
+  Le as MetapageVersionCurrent,
+  $t as MetapageVersionsAll,
+  Li as PARSE_ERROR,
+  En as VERSION_METAFRAME,
+  Wt as VERSION_METAPAGE,
+  ns as convertMetaframeDefinitionToCurrentVersion,
+  sn as convertMetaframeDefinitionToVersion,
+  pt as convertMetaframeJsonToCurrentVersion,
+  Wn as convertMetapageDefinitionToCurrentVersion,
+  nn as convertMetapageDefinitionToVersion,
+  Ce as deserializeInputs,
+  At as generateId,
+  Ui as generateMetaframeId,
+  js as generateMetapageId,
+  Bi as generateNonce,
+  Vi as getLibraryVersionMatching,
+  te as getMatchingMetaframeVersion,
+  de as getMatchingMetapageVersion,
+  wi as getMetaframeDefinitionFromUrl,
+  bi as getMetapageDefinitionFromUrl,
+  Ni as getUrlParam,
+  ji as getUrlParamDebug,
+  Us as hashCode,
+  Bs as intToRGB,
+  dt as isDebugFromUrlsParams,
+  Gi as isEmptyMetaframeDefinition,
+  Hs as isIframe,
+  Hi as isJsonRpcId,
+  tt as isPageLoaded,
+  Et as log,
+  Ri as matchPipe,
+  Ge as merge,
+  Fi as metapageAllSha256Hash,
+  zi as metapageOnlyEssentailSha256Hash,
+  Xe as pageLoaded,
+  xi as possiblyDeserializeDatarefToFile,
+  rn as possiblyDeserializeDatarefToValue,
+  ds as possiblySerializeValueToDataref,
+  Ji as renderMetapage,
+  Ke as serializeInputs,
+  hn as stringToRgb,
+  $i as valueToFile
 };
 //# sourceMappingURL=index.js.map