@marimo-team/islands 0.17.1 → 0.17.3

package/dist/uniq-DgSyegN3.js

@@ -0,0 +1,8 @@
+import { t as _baseUniq_default } from "./_baseUniq-D5kohCWB.js";
+function uniq(n) {
+  return n && n.length ? _baseUniq_default(n) : [];
+}
+var uniq_default = uniq;
+export {
+  uniq_default as t
+};

package/dist/{useAsyncData-DHBqeb9a.js → useAsyncData-Dp2V69OV.js}

@@ -1,8 +1,8 @@
 import { s as __toESM } from "./chunk-DgPTj83v.js";
 import { t as require_react } from "./react-DHL_F5hS.js";
-import { n as require_compiler_runtime } from "./jsx-runtime-DZyWJV5b.js";
-import { h as useEvent_default } from "./useTheme-CnMbo-iq.js";
-import { t as invariant } from "./invariant-D3JoRb4I.js";
+import { t as require_compiler_runtime } from "./compiler-runtime-5MdCVm0X.js";
+import { h as useEvent_default } from "./useTheme-D7vlj42b.js";
+import { t as invariant } from "./invariant-Cl2wkkjN.js";
 var import_compiler_runtime = /* @__PURE__ */ __toESM(require_compiler_runtime(), 1), import_react = /* @__PURE__ */ __toESM(require_react(), 1), Result = {
   error(e, s) {
     return {

package/dist/{useIframeCapabilities-BEvvwlwt.js → useIframeCapabilities-B9u0SmJ4.js}

@@ -1,8 +1,8 @@
 import { s as __toESM } from "./chunk-DgPTj83v.js";
 import { t as require_react } from "./react-DHL_F5hS.js";
-import { n as require_compiler_runtime } from "./jsx-runtime-DZyWJV5b.js";
+import { t as require_compiler_runtime } from "./compiler-runtime-5MdCVm0X.js";
 import { s as Logger } from "./hotkeys-DVxFjl2s.js";
-import { n as once } from "./once-3OSMKEsL.js";
+import { n as once } from "./once-rI5AYku5.js";
 function testStorage(e) {
   try {
     let s = window[e], c = "__storage_test__", l = "test";

package/dist/{useTheme-CnMbo-iq.js → useTheme-D7vlj42b.js}

@@ -1,10 +1,10 @@
 import { s as __toESM } from "./chunk-DgPTj83v.js";
 import { t as require_react } from "./react-DHL_F5hS.js";
-import { n as require_compiler_runtime } from "./jsx-runtime-DZyWJV5b.js";
+import { t as require_compiler_runtime } from "./compiler-runtime-5MdCVm0X.js";
 import { a as resolvePlatform, n as OverridingHotkeyProvider, s as Logger } from "./hotkeys-DVxFjl2s.js";
-import { t as _baseIsEqual_default } from "./_baseIsEqual-BFlyFUxC.js";
-import { t as merge_default } from "./merge-C_6cGM6o.js";
-import { E as boolean, F as object, L as record, P as number, V as union, b as _enum, j as looseObject, w as array, z as string } from "./zod-mAEs2ITo.js";
+import { t as _baseIsEqual_default } from "./_baseIsEqual-DbBiwJP8.js";
+import { t as merge_default } from "./merge-dMlizkC5.js";
+import { E as boolean, F as object, L as record, P as number, V as union, b as _enum, j as looseObject, w as array, z as string } from "./zod-0AbTN3Cg.js";
 var isSelfAtom = (e, A) => e.unstable_is ? e.unstable_is(A) : A === e, hasInitialValue = (e) => "init" in e, isActuallyWritableAtom = (e) => !!e.write, isAtomStateInitialized = (e) => "v" in e || "e" in e, returnAtomValue = (e) => {
   if ("e" in e) throw e.e;
   return e.v;

package/dist/vb-DNk7gts-.js

@@ -0,0 +1,4 @@
+import { t as vb } from "./vb-DKEmSA_2.js";
+export {
+  vb
+};

package/dist/vbscript-znK_5PUS.js

@@ -0,0 +1,4 @@
+import { t as vbScript } from "./vbscript-BPsxuP0n.js";
+export {
+  vbScript
+};

package/dist/vega-component-C58Jk3ub.js

@@ -0,0 +1,633 @@
+import { s as __toESM } from "./chunk-DgPTj83v.js";
+import { t as require_react } from "./react-DHL_F5hS.js";
+import { t as require_compiler_runtime } from "./compiler-runtime-5MdCVm0X.js";
+import "./Combination-DrSsMSEB.js";
+import { S as CircleQuestionMark, h as asRemoteURL, i as Alert, n as useDeepCompareMemoize, o as AlertTitle, s as isValid, t as arrow } from "./formats-kyFd0DPJ.js";
+import { u as Events } from "./button-B8zS4Mtw.js";
+import { o as Objects, s as Logger } from "./hotkeys-DVxFjl2s.js";
+import { t as require_jsx_runtime } from "./jsx-runtime-CvL6gNI-.js";
+import "./react-dom-BTjywDxo.js";
+import { c as Tooltip, n as ErrorBanner } from "./error-banner-B7LmpmGT.js";
+import { h as useEvent_default, n as useTheme } from "./useTheme-D7vlj42b.js";
+import "./isArrayLikeObject-1qkWxZbL.js";
+import "./isSymbol-BnxbuvDK.js";
+import "./toNumber-CUG0Hyhp.js";
+import "./_baseIsEqual-DbBiwJP8.js";
+import "./_baseUniq-D5kohCWB.js";
+import "./merge-dMlizkC5.js";
+import "./now-8WTe-KKa.js";
+import { r as debounce_default } from "./constants-BlvmN57i.js";
+import { a as tooltipHandler, n as vegaLoadData } from "./loader-Dj9XWZTh.js";
+import { t as uniq_default } from "./uniq-DgSyegN3.js";
+import "./zod-0AbTN3Cg.js";
+import "./invariant-Cl2wkkjN.js";
+import { t as useAsyncData } from "./useAsyncData-Dp2V69OV.js";
+import { n as formats } from "./vega-loader.browser-BK7-IO9k.js";
+import "./precisionRound-DMLkFNYv.js";
+import "./linear-CgANSWNu.js";
+import { t as j } from "./react-vega-B9eMrRW1.js";
+import "./ordinal-pQYxWJYN.js";
+import "./time-U9NHhrDC.js";
+import "./range-sX2tw-Jz.js";
+import "./defaultLocale-BPzjWfXP.js";
+import "./defaultLocale-Om7Wxg5c.js";
+import "./path-BeMi_1Je.js";
+import "./math-C2iLT5gz.js";
+import "./arc-DM-UhhIs.js";
+import "./array-D3smvOQ_.js";
+import "./step-BsM8YHun.js";
+import "./line-C7OvOvNm.js";
+import "./init-BNp5RczD.js";
+import "./timer-ly0jlpkr.js";
+import "./colors-DQmMCNWX.js";
+import "./treemap-D5sUCpbF.js";
+var import_compiler_runtime = /* @__PURE__ */ __toESM(require_compiler_runtime(), 1), import_react = /* @__PURE__ */ __toESM(require_react(), 1);
+function fixRelativeUrl(e) {
+  return e.data && "url" in e.data && (e.data.url = asRemoteURL(e.data.url).href), e;
+}
+const Mark = {
+  arc: "arc",
+  area: "area",
+  bar: "bar",
+  image: "image",
+  line: "line",
+  point: "point",
+  rect: "rect",
+  rule: "rule",
+  text: "text",
+  tick: "tick",
+  trail: "trail",
+  circle: "circle",
+  square: "square",
+  geoshape: "geoshape"
+};
+var NON_INTERACTIVE_MARKS = /* @__PURE__ */ new Set([
+  "boxplot",
+  "errorband",
+  "errorbar"
+]);
+const Marks = {
+  getMarkType(e) {
+    let D = typeof e == "string" ? e : e.type;
+    if (NON_INTERACTIVE_MARKS.has(D)) throw Error("Not supported");
+    return D;
+  },
+  isInteractive(e) {
+    let D = typeof e == "string" ? e : e.type;
+    return !NON_INTERACTIVE_MARKS.has(D);
+  },
+  makeClickable(e) {
+    let D = typeof e == "string" ? e : e.type;
+    return D in Mark ? typeof e == "string" ? {
+      type: e,
+      cursor: "pointer",
+      tooltip: true
+    } : {
+      ...e,
+      type: D,
+      cursor: "pointer",
+      tooltip: true
+    } : e;
+  },
+  getOpacity(e) {
+    return typeof e == "string" ? null : "opacity" in e && typeof e.opacity == "number" ? e.opacity : null;
+  }
+}, ParamNames = {
+  point(e) {
+    return e == null ? "select_point" : `select_point_${e}`;
+  },
+  interval(e) {
+    return e == null ? "select_interval" : `select_interval_${e}`;
+  },
+  legendSelection(e) {
+    return `legend_selection_${e}`;
+  },
+  binColoring(e) {
+    return e == null ? "bin_coloring" : `bin_coloring_${e}`;
+  },
+  HIGHLIGHT: "highlight",
+  PAN_ZOOM: "pan_zoom",
+  hasPoint(e) {
+    return e.some((e2) => e2.startsWith("select_point"));
+  },
+  hasInterval(e) {
+    return e.some((e2) => e2.startsWith("select_interval"));
+  },
+  hasLegend(e) {
+    return e.some((e2) => e2.startsWith("legend_selection"));
+  },
+  hasPanZoom(e) {
+    return e.some((e2) => e2.startsWith("pan_zoom"));
+  },
+  isBinColoring(e) {
+    return e.startsWith("bin_coloring");
+  }
+}, Params = {
+  highlight() {
+    return {
+      name: ParamNames.HIGHLIGHT,
+      select: {
+        type: "point",
+        on: "mouseover"
+      }
+    };
+  },
+  interval(e, D) {
+    return {
+      name: ParamNames.interval(D),
+      select: {
+        type: "interval",
+        encodings: getEncodingAxisForMark(e),
+        mark: {
+          fill: "#669EFF",
+          fillOpacity: 0.07,
+          stroke: "#669EFF",
+          strokeOpacity: 0.4
+        },
+        on: "[mousedown[!event.metaKey], mouseup] > mousemove[!event.metaKey]",
+        translate: "[mousedown[!event.metaKey], mouseup] > mousemove[!event.metaKey]"
+      }
+    };
+  },
+  point(e, D) {
+    return {
+      name: ParamNames.point(D),
+      select: {
+        type: "point",
+        encodings: getEncodingAxisForMark(e),
+        on: "click[!event.metaKey]"
+      }
+    };
+  },
+  binColoring(e) {
+    return {
+      name: ParamNames.binColoring(e),
+      select: {
+        type: "point",
+        on: "click[!event.metaKey]"
+      }
+    };
+  },
+  legend(e) {
+    return {
+      name: ParamNames.legendSelection(e),
+      select: {
+        type: "point",
+        fields: [e]
+      },
+      bind: "legend"
+    };
+  },
+  panZoom() {
+    return {
+      name: ParamNames.PAN_ZOOM,
+      bind: "scales",
+      select: {
+        type: "interval",
+        on: "[mousedown[event.metaKey], window:mouseup] > window:mousemove!",
+        translate: "[mousedown[event.metaKey], window:mouseup] > window:mousemove!",
+        zoom: "wheel![event.metaKey]"
+      }
+    };
+  }
+};
+function getEncodingAxisForMark(e) {
+  switch (Marks.getMarkType(e.mark)) {
+    case Mark.image:
+    case Mark.trail:
+      return;
+    case Mark.area:
+    case Mark.arc:
+      return ["color"];
+    case Mark.bar: {
+      let D = getDirectionOfBar(e);
+      return D === "horizontal" ? ["y"] : D === "vertical" ? ["x"] : void 0;
+    }
+    case Mark.circle:
+    case Mark.geoshape:
+    case Mark.line:
+    case Mark.point:
+    case Mark.rect:
+    case Mark.rule:
+    case Mark.square:
+    case Mark.text:
+    case Mark.tick:
+      return ["x", "y"];
+  }
+}
+function getSelectionParamNames(e) {
+  return "params" in e && e.params && e.params.length > 0 ? uniq_default(e.params.filter((e2) => e2 == null ? false : "select" in e2 && e2.select !== void 0).map((e2) => e2.name)) : "layer" in e ? uniq_default(e.layer.flatMap(getSelectionParamNames)) : "vconcat" in e ? uniq_default(e.vconcat.flatMap(getSelectionParamNames)) : "hconcat" in e ? uniq_default(e.hconcat.flatMap(getSelectionParamNames)) : [];
+}
+function getDirectionOfBar(e) {
+  var _a, _b;
+  if (!e || !("mark" in e)) return;
+  let D = (_a = e.encoding) == null ? void 0 : _a.x, O = (_b = e.encoding) == null ? void 0 : _b.y;
+  if (D && "type" in D && D.type === "nominal") return "vertical";
+  if (O && "type" in O && O.type === "nominal" || D && "aggregate" in D) return "horizontal";
+  if (O && "aggregate" in O) return "vertical";
+}
+function getBinnedFields(e) {
+  if (!e.encoding) return [];
+  let D = [];
+  for (let O of Object.values(e.encoding)) O && typeof O == "object" && "bin" in O && O.bin && "field" in O && typeof O.field == "string" && D.push(O.field);
+  return D;
+}
+function findEncodedFields(e) {
+  if (!e || !("encoding" in e)) return [];
+  let { encoding: D } = e;
+  return D ? Object.entries(D).flatMap((e2) => {
+    let [D2, O] = e2;
+    return !O || !ALLOWED_ENCODING_TYPES.has(D2) ? [] : "field" in O && typeof O.field == "string" ? [O.field] : "condition" in O && O.condition && typeof O.condition == "object" && "field" in O.condition && O.condition.field && typeof O.condition.field == "string" ? [O.condition.field] : [];
+  }) : [];
+}
+var ALLOWED_ENCODING_TYPES = /* @__PURE__ */ new Set([
+  "color",
+  "fill",
+  "fillOpacity",
+  "opacity",
+  "shape",
+  "size"
+]);
+function makeEncodingInteractive(e, D, O, k) {
+  let A = O.filter((e2) => ParamNames.isBinColoring(e2)), M = { and: (A.length > 0 ? A : O).map((e2) => ({ param: e2 })) };
+  switch (e) {
+    case "opacity": {
+      let e2 = Marks.getOpacity(k) || 1;
+      return {
+        ...D,
+        opacity: {
+          condition: {
+            test: M,
+            value: e2
+          },
+          value: e2 / 5
+        }
+      };
+    }
+    default:
+      return D;
+  }
+}
+function getParamSignature(e) {
+  if (!("select" in e) || !e.select) return JSON.stringify(e);
+  let D = e.select;
+  if (typeof D == "string") return JSON.stringify({
+    type: D,
+    bind: e.bind
+  });
+  let O = {
+    type: D.type,
+    encodings: "encodings" in D && D.encodings ? [...D.encodings].sort() : void 0,
+    fields: "fields" in D && D.fields ? [...D.fields].sort() : void 0,
+    bind: e.bind
+  };
+  return JSON.stringify(O);
+}
+function hoistParamsAndApplyOpacity(e) {
+  let D = collectAllUnitSpecParams(e);
+  if (D.length === 0) return e;
+  let O = findCommonParams(D);
+  return O.length === 0 ? e : {
+    ...applyOpacityToNestedSpecs(removeSpecificParamsFromNestedSpecs(e, new Set(O.map((e2) => e2.name))), O.map((e2) => e2.name)),
+    params: [...e.params || [], ...O]
+  };
+}
+function collectAllUnitSpecParams(e) {
+  let D = [];
+  if ("vconcat" in e && Array.isArray(e.vconcat)) for (let O of e.vconcat) D.push(...collectAllUnitSpecParams(O));
+  else if ("hconcat" in e && Array.isArray(e.hconcat)) for (let O of e.hconcat) D.push(...collectAllUnitSpecParams(O));
+  else if ("layer" in e) return [];
+  else "mark" in e && "params" in e && e.params && e.params.length > 0 && D.push({ params: e.params });
+  return D;
+}
+function findCommonParams(e) {
+  if (e.length === 0) return [];
+  let D = /* @__PURE__ */ new Map(), O = e.length;
+  for (let { params: O2 } of e) {
+    let e2 = /* @__PURE__ */ new Set();
+    for (let k2 of O2) {
+      let O3 = getParamSignature(k2);
+      e2.has(O3) || (e2.add(O3), D.has(O3) || D.set(O3, {
+        count: 0,
+        param: k2
+      }), D.get(O3).count++);
+    }
+  }
+  let k = [];
+  for (let [, { count: e2, param: A }] of D) e2 === O && k.push(A);
+  return k;
+}
+function removeSpecificParamsFromNestedSpecs(e, D) {
+  if ("vconcat" in e && Array.isArray(e.vconcat)) return {
+    ...e,
+    vconcat: e.vconcat.map((e2) => removeSpecificParamsFromNestedSpecs(e2, D))
+  };
+  if ("hconcat" in e && Array.isArray(e.hconcat)) return {
+    ...e,
+    hconcat: e.hconcat.map((e2) => removeSpecificParamsFromNestedSpecs(e2, D))
+  };
+  if ("mark" in e && "params" in e && e.params) {
+    let O = e.params, k = [];
+    for (let e2 of O) {
+      if (!e2 || typeof e2 != "object" || !("name" in e2)) {
+        k.push(e2);
+        continue;
+      }
+      D.has(e2.name) || k.push(e2);
+    }
+    if (k.length === 0) {
+      let { params: D2, ...O2 } = e;
+      return O2;
+    }
+    return {
+      ...e,
+      params: k
+    };
+  }
+  return e;
+}
+function applyOpacityToNestedSpecs(e, D) {
+  return "vconcat" in e && Array.isArray(e.vconcat) ? {
+    ...e,
+    vconcat: e.vconcat.map((e2) => applyOpacityToNestedSpecs(e2, D))
+  } : "hconcat" in e && Array.isArray(e.hconcat) ? {
+    ...e,
+    hconcat: e.hconcat.map((e2) => applyOpacityToNestedSpecs(e2, D))
+  } : "layer" in e ? e : "mark" in e && Marks.isInteractive(e.mark) ? {
+    ...e,
+    mark: Marks.makeClickable(e.mark),
+    encoding: makeEncodingInteractive("opacity", e.encoding || {}, D, e.mark)
+  } : e;
+}
+function makeSelectable(e, D) {
+  var _a, _b;
+  let { chartSelection: O = true, fieldSelection: k = true } = D;
+  if (!O && !k) return e;
+  if (((_a = e.params) == null ? void 0 : _a.some((e2) => e2.bind === "legend")) && (k = false), ((_b = e.params) == null ? void 0 : _b.some((e2) => !e2.bind)) && (O = false), "vconcat" in e) {
+    let D2 = e.vconcat.map((e2) => "mark" in e2 ? makeSelectable(e2, {
+      chartSelection: O,
+      fieldSelection: k
+    }) : e2);
+    return hoistParamsAndApplyOpacity({
+      ...e,
+      vconcat: D2
+    });
+  }
+  if ("hconcat" in e) {
+    let D2 = e.hconcat.map((e2) => "mark" in e2 ? makeSelectable(e2, {
+      chartSelection: O,
+      fieldSelection: k
+    }) : e2);
+    return hoistParamsAndApplyOpacity({
+      ...e,
+      hconcat: D2
+    });
+  }
+  if ("layer" in e) {
+    let D2 = e.params && e.params.length > 0, A2 = k !== false && !D2, M = [];
+    if (A2) {
+      let D3 = e.layer.flatMap((e2) => "mark" in e2 ? findEncodedFields(e2) : []);
+      M = [...new Set(D3)], Array.isArray(k) && (M = M.filter((e2) => k.includes(e2)));
+    }
+    let N = e.layer.map((e2, D3) => {
+      if (!("mark" in e2)) return e2;
+      let k2 = e2;
+      if (D3 === 0 && M.length > 0) {
+        let e3 = M.map((e4) => Params.legend(e4));
+        k2 = {
+          ...k2,
+          params: [...k2.params || [], ...e3]
+        };
+      }
+      return k2 = makeChartSelectable(k2, O, D3), k2 = makeChartInteractive(k2), D3 === 0 && (k2 = makeChartPanZoom(k2)), k2;
+    });
+    return {
+      ...e,
+      layer: N
+    };
+  }
+  if (!("mark" in e) || !Marks.isInteractive(e.mark)) return e;
+  let A = e;
+  return A = makeLegendSelectable(A, k), A = makeChartSelectable(A, O, void 0), A = makeChartInteractive(A), A = makeChartPanZoom(A), A;
+}
+function makeLegendSelectable(e, D) {
+  if (D === false) return e;
+  let O = findEncodedFields(e);
+  Array.isArray(D) && (O = O.filter((e2) => D.includes(e2)));
+  let k = O.map((e2) => Params.legend(e2)), A = [...e.params || [], ...k];
+  return {
+    ...e,
+    params: A
+  };
+}
+function makeChartSelectable(e, D, O) {
+  if (D === false) return e;
+  let k;
+  try {
+    k = Marks.getMarkType(e.mark);
+  } catch {
+    return e;
+  }
+  if (k === "geoshape") return e;
+  let A = getBinnedFields(e), M = D === true ? A.length > 0 ? ["point"] : getBestSelectionForMark(k) : [D];
+  if (!M || M.length === 0) return e;
+  let N = M.map((D2) => D2 === "interval" ? Params.interval(e, O) : Params.point(e, O)), P = [...e.params || [], ...N];
+  return A.length > 0 && M.includes("point") && P.push(Params.binColoring(O)), {
+    ...e,
+    params: P
+  };
+}
+function makeChartPanZoom(e) {
+  let D;
+  try {
+    D = Marks.getMarkType(e.mark);
+  } catch {
+  }
+  if (D === "geoshape") return e;
+  let O = e.params || [];
+  return O.some((e2) => e2.bind === "scales") ? e : {
+    ...e,
+    params: [...O, Params.panZoom()]
+  };
+}
+function makeChartInteractive(e) {
+  let D = "encoding" in e ? e.encoding : void 0, O = e.params || [], k = O.map((e2) => e2.name);
+  return O.length === 0 || !Marks.isInteractive(e.mark) ? e : {
+    ...e,
+    mark: Marks.makeClickable(e.mark),
+    encoding: makeEncodingInteractive("opacity", D || {}, k, e.mark)
+  };
+}
+function getBestSelectionForMark(e) {
+  switch (e) {
+    case "arc":
+    case "area":
+      return ["point"];
+    case "text":
+    case "bar":
+      return ["point", "interval"];
+    case "line":
+      return;
+    default:
+      return ["point", "interval"];
+  }
+}
+async function resolveVegaSpecData(e) {
+  if (!e) return e;
+  let D = "datasets" in e ? { ...e.datasets } : {}, O = async (e2) => {
+    if (!e2) return e2;
+    if ("layer" in e2) {
+      let D2 = await Promise.all(e2.layer.map(O));
+      e2 = {
+        ...e2,
+        layer: D2
+      };
+    }
+    if ("hconcat" in e2) {
+      let D2 = await Promise.all(e2.hconcat.map(O));
+      e2 = {
+        ...e2,
+        hconcat: D2
+      };
+    }
+    if ("vconcat" in e2) {
+      let D2 = await Promise.all(e2.vconcat.map(O));
+      e2 = {
+        ...e2,
+        vconcat: D2
+      };
+    }
+    if ("spec" in e2 && (e2 = {
+      ...e2,
+      spec: await O(e2.spec)
+    }), !e2.data || !("url" in e2.data)) return e2;
+    let k2;
+    try {
+      k2 = asRemoteURL(e2.data.url);
+    } catch {
+      return e2;
+    }
+    let M = await vegaLoadData(k2.href, e2.data.format);
+    return D[k2.pathname] = M, {
+      ...e2,
+      data: { name: k2.pathname }
+    };
+  }, k = await O(e);
+  return Object.keys(D).length === 0 ? k : {
+    ...k,
+    datasets: D
+  };
+}
+var import_jsx_runtime = /* @__PURE__ */ __toESM(require_jsx_runtime(), 1);
+formats("arrow", arrow);
+var VegaComponent = (e) => {
+  let D = (0, import_compiler_runtime.c)(11), { value: O, setValue: k, chartSelection: A, fieldSelection: M, spec: N } = e, P, F;
+  D[0] === N ? (P = D[1], F = D[2]) : (P = async () => resolveVegaSpecData(N), F = [N], D[0] = N, D[1] = P, D[2] = F);
+  let { data: I, error: L } = useAsyncData(P, F);
+  if (L) {
+    let e2;
+    return D[3] === L ? e2 = D[4] : (e2 = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ErrorBanner, { error: L }), D[3] = L, D[4] = e2), e2;
+  }
+  if (!I) return null;
+  let R;
+  return D[5] !== A || D[6] !== M || D[7] !== I || D[8] !== k || D[9] !== O ? (R = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(LoadedVegaComponent, {
+    value: O,
+    setValue: k,
+    chartSelection: A,
+    fieldSelection: M,
+    spec: I
+  }), D[5] = A, D[6] = M, D[7] = I, D[8] = k, D[9] = O, D[10] = R) : R = D[10], R;
+}, LoadedVegaComponent = ({ value: e, setValue: D, chartSelection: O, fieldSelection: A, spec: F }) => {
+  let { theme: I } = useTheme(), z = (0, import_react.useRef)(null), B = (0, import_react.useRef)(void 0), [V, H] = (0, import_react.useState)(), U = useDeepCompareMemoize(F), W = (0, import_react.useMemo)(() => makeSelectable(fixRelativeUrl(U), {
+    chartSelection: O,
+    fieldSelection: A
+  }), [
+    U,
+    O,
+    A
+  ]), G = (0, import_react.useMemo)(() => getSelectionParamNames(W), [W]), K = useEvent_default((O2) => {
+    D({
+      ...e,
+      ...O2
+    });
+  }), q = (0, import_react.useMemo)(() => debounce_default((e2, D2) => {
+    Logger.debug("[Vega signal]", e2, D2);
+    let O2 = Objects.mapValues(D2, convertDatetimeToEpochMilliseconds);
+    O2 = Objects.mapValues(O2, convertSetToList), K({ [e2]: O2 });
+  }, 100), [K]), J = useDeepCompareMemoize(G), Y = (0, import_react.useMemo)(() => J.reduce((e2, D2) => (ParamNames.PAN_ZOOM === D2 || ParamNames.isBinColoring(D2) || e2.push({
+    signalName: D2,
+    handler: (e3, D3) => q(e3, D3)
+  }), e2), []), [J, q]), X = useEvent_default((e2) => {
+    Logger.error(e2), Logger.debug(W), H(e2);
+  }), Z = useEvent_default((e2) => {
+    Logger.debug("[Vega view] created", e2), B.current = e2, H(void 0);
+  }), Q = () => {
+    let e2 = [];
+    return ParamNames.hasPoint(G) && e2.push(["Point selection", "click to select a point; hold shift for multi-select"]), ParamNames.hasInterval(G) && e2.push(["Interval selection", "click and drag to select an interval"]), ParamNames.hasLegend(G) && e2.push(["Legend selection", "click to select a legend item; hold shift for multi-select"]), ParamNames.hasPanZoom(G) && e2.push(["Pan", "hold the meta key and drag"], ["Zoom", "hold the meta key and scroll"]), e2.length === 0 ? null : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Tooltip, {
+      delayDuration: 300,
+      side: "left",
+      content: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+        className: "text-xs flex flex-col",
+        children: e2.map((e3, D2) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", {
+            className: "font-bold tracking-wide",
+            children: [e3[0], ":"]
+          }),
+          " ",
+          e3[1]
+        ] }, D2))
+      }),
+      children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(CircleQuestionMark, { className: "absolute bottom-1 right-0 m-2 h-4 w-4 cursor-help text-muted-foreground hover:text-foreground" })
+    });
+  }, $ = j({
+    ref: z,
+    spec: W,
+    options: {
+      theme: I === "dark" ? "dark" : void 0,
+      actions,
+      mode: "vega-lite",
+      tooltip: tooltipHandler.call,
+      renderer: "canvas"
+    },
+    onError: X,
+    onEmbed: Z
+  });
+  return (0, import_react.useEffect)(() => (Y.forEach(({ signalName: e2, handler: D2 }) => {
+    try {
+      $ == null ? void 0 : $.view.addSignalListener(e2, D2);
+    } catch (e3) {
+      Logger.error(e3);
+    }
+  }), () => {
+    Y.forEach(({ signalName: e2, handler: D2 }) => {
+      try {
+        $ == null ? void 0 : $.view.removeSignalListener(e2, D2);
+      } catch (e3) {
+        Logger.error(e3);
+      }
+    });
+  }), [$, Y]), /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [V && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Alert, {
+    variant: "destructive",
+    children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(AlertTitle, { children: V.message }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+      className: "text-md",
+      children: V.stack
+    })]
+  }), /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", {
+    className: "relative",
+    onPointerDown: Events.stopPropagation(),
+    children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: z }), Q()]
+  })] });
+}, actions = {
+  source: false,
+  compiled: false
+};
+function convertSetToList(e) {
+  return e instanceof Set ? [...e] : e;
+}
+function convertDatetimeToEpochMilliseconds(e) {
+  return Array.isArray(e) ? e.map((e2) => e2 instanceof Date && isValid(e2) ? new Date(e2).getTime() : e2) : e;
+}
+var vega_component_default = VegaComponent;
+export {
+  vega_component_default as default
+};