@jxsuite/studio 4.1.0 → 5.1.0

package/dist/chunks/iframe-entry-15g3n6xv.js

@@ -0,0 +1,114 @@
+// ../ui/src/behaviors/toast.ts
+var HOST = "jx-toast";
+var TOAST_PAUSE2 = "jx-toast-pause";
+var TOAST_RESUME2 = "jx-toast-resume";
+var HOLD_REASON = {
+  focusin: "focus",
+  focusout: "focus",
+  [TOAST_PAUSE2]: "stack",
+  [TOAST_RESUME2]: "stack",
+  pointerenter: "pointer",
+  pointerleave: "pointer",
+  pointerout: "pointer",
+  pointerover: "pointer"
+};
+var clocks = new WeakMap;
+var hosts = new WeakMap;
+function clockOf(state) {
+  const found = clocks.get(state);
+  if (found) {
+    return found;
+  }
+  const fresh = { holds: new Set, remaining: 0, startedAt: 0, timer: null };
+  clocks.set(state, fresh);
+  return fresh;
+}
+function ownerOf(event) {
+  const target = event.currentTarget ?? event.target;
+  return target instanceof Element ? target.closest(HOST) : null;
+}
+function staysInside2(event) {
+  const to = event.relatedTarget;
+  const from = event.currentTarget;
+  return to instanceof Node && from instanceof Node && from.contains(to);
+}
+function park(clock) {
+  if (clock.timer !== null) {
+    clearTimeout(clock.timer);
+    clock.timer = null;
+  }
+}
+function schedule(state) {
+  const clock = clockOf(state);
+  park(clock);
+  if (state.open !== true || clock.holds.size > 0 || clock.remaining <= 0) {
+    return;
+  }
+  clock.startedAt = Date.now();
+  clock.timer = setTimeout(() => {
+    clock.timer = null;
+    const host = hosts.get(state);
+    if (host) {
+      closeToast2(host, "timeout");
+    }
+  }, clock.remaining);
+}
+function closeToast2(host, reason) {
+  const el = host;
+  if (el.open !== true) {
+    return;
+  }
+  el.open = false;
+  host.dispatchEvent(new CustomEvent("close", { bubbles: true, detail: { reason } }));
+}
+function onToastMount2(state, host) {
+  hosts.set(state, host);
+  const clock = clockOf(state);
+  clock.remaining = Number(state.timeout) || 0;
+  schedule(state);
+  const observer = new MutationObserver(() => {
+    if (state.open === true) {
+      clock.remaining = Number(state.timeout) || 0;
+      schedule(state);
+      return;
+    }
+    park(clock);
+  });
+  observer.observe(host, { attributeFilter: ["data-open"], attributes: true });
+}
+function onToastUnmount2(state) {
+  park(clockOf(state));
+}
+function onToastHold2(state, event) {
+  const clock = clockOf(state);
+  const reason = HOLD_REASON[event.type] ?? event.type;
+  if (clock.timer !== null) {
+    clock.remaining = Math.max(1, clock.remaining - (Date.now() - clock.startedAt));
+  }
+  clock.holds.add(reason);
+  park(clock);
+}
+function onToastRelease2(state, event) {
+  if (staysInside2(event)) {
+    return;
+  }
+  clockOf(state).holds.delete(HOLD_REASON[event.type] ?? event.type);
+  schedule(state);
+}
+function onToastDismiss2(_state, event) {
+  const host = ownerOf(event);
+  if (host) {
+    closeToast2(host, "dismissed");
+  }
+}
+function onToastAction2(_state, event) {
+  const host = ownerOf(event);
+  if (host) {
+    closeToast2(host, "action");
+  }
+}
+
+export { TOAST_PAUSE2, TOAST_RESUME2, staysInside2, closeToast2, onToastMount2, onToastUnmount2, onToastHold2, onToastRelease2, onToastDismiss2, onToastAction2 };
+
+//# debugId=C529CABC4E1F392664756E2164756E21
+//# sourceMappingURL=iframe-entry-15g3n6xv.js.map

package/dist/chunks/iframe-entry-b27vq81n.js

@@ -0,0 +1,203 @@
+// ../ui/src/color.ts
+function clamp2(value, min, max) {
+  if (!Number.isFinite(value)) {
+    return min;
+  }
+  return value < min ? min : value > max ? max : value;
+}
+function snapToStep2(value, step, min, max) {
+  const held = clamp2(value, min, max);
+  if (!Number.isFinite(step) || step <= 0) {
+    return held;
+  }
+  let snapped = min + Math.round((held - min) / step) * step;
+  if (snapped > max) {
+    snapped -= step;
+  }
+  return clamp2(Number(snapped.toFixed(6)), min, max);
+}
+function hexPair(channel) {
+  return Math.round(clamp2(channel, 0, 255)).toString(16).padStart(2, "0");
+}
+function parseHex2(text) {
+  const digits = text.trim().replace(/^#/, "");
+  if (!/^[0-9a-f]+$/i.test(digits)) {
+    return null;
+  }
+  const wide = digits.length === 6 || digits.length === 8;
+  const short = digits.length === 3 || digits.length === 4;
+  if (!wide && !short) {
+    return null;
+  }
+  const size = wide ? 2 : 1;
+  const at = (index) => {
+    const part = digits.slice(index * size, index * size + size);
+    return Number.parseInt(size === 1 ? part + part : part, 16);
+  };
+  const hasAlpha = digits.length === 4 || digits.length === 8;
+  return { a: hasAlpha ? at(3) / 255 : 1, b: at(2), g: at(1), r: at(0) };
+}
+function component(token, full) {
+  if (token.endsWith("%")) {
+    return Number(token.slice(0, -1)) / 100 * full;
+  }
+  return Number(token);
+}
+function argsOf(text, name) {
+  const match = new RegExp(`^${name}a?\\(([^)]*)\\)$`, "i").exec(text.trim());
+  if (!match) {
+    return null;
+  }
+  return match[1].trim().split(/[\s,/]+/).filter(Boolean);
+}
+function parseColor2(text) {
+  const trimmed = text.trim();
+  const rgb = argsOf(trimmed, "rgb");
+  if (rgb && rgb.length >= 3) {
+    const parts = [component(rgb[0], 255), component(rgb[1], 255), component(rgb[2], 255)];
+    const alpha = rgb.length > 3 ? component(rgb[3], 1) : 1;
+    if (parts.some((n) => Number.isNaN(n)) || Number.isNaN(alpha)) {
+      return null;
+    }
+    return {
+      a: clamp2(alpha, 0, 1),
+      b: clamp2(parts[2], 0, 255),
+      g: clamp2(parts[1], 0, 255),
+      r: clamp2(parts[0], 0, 255)
+    };
+  }
+  const lch = argsOf(trimmed, "oklch");
+  if (lch && lch.length >= 3) {
+    const l = component(lch[0], 1);
+    const c = component(lch[1], 0.4);
+    const h = Number(lch[2].replace(/deg$/i, ""));
+    const alpha = lch.length > 3 ? component(lch[3], 1) : 1;
+    if ([l, c, h, alpha].some((n) => Number.isNaN(n))) {
+      return null;
+    }
+    return oklchToSrgb2({ a: clamp2(alpha, 0, 1), c, h, l });
+  }
+  return parseHex2(trimmed);
+}
+function formatHex2(rgb) {
+  const base = `#${hexPair(rgb.r)}${hexPair(rgb.g)}${hexPair(rgb.b)}`;
+  return rgb.a >= 1 ? base : `${base}${hexPair(clamp2(rgb.a, 0, 1) * 255)}`;
+}
+function rgbToHsv2(rgb) {
+  const r = clamp2(rgb.r, 0, 255) / 255;
+  const g = clamp2(rgb.g, 0, 255) / 255;
+  const b = clamp2(rgb.b, 0, 255) / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const span = max - min;
+  let h = 0;
+  if (span !== 0) {
+    if (max === r) {
+      h = 60 * ((g - b) / span % 6);
+    } else if (max === g) {
+      h = 60 * ((b - r) / span + 2);
+    } else {
+      h = 60 * ((r - g) / span + 4);
+    }
+  }
+  return {
+    a: clamp2(rgb.a, 0, 1),
+    h: (h + 360) % 360,
+    s: max === 0 ? 0 : span / max * 100,
+    v: max * 100
+  };
+}
+function hsvToRgb2(hsv) {
+  const h = (hsv.h % 360 + 360) % 360;
+  const s = clamp2(hsv.s, 0, 100) / 100;
+  const v = clamp2(hsv.v, 0, 100) / 100;
+  const chroma = v * s;
+  const x = chroma * (1 - Math.abs(h / 60 % 2 - 1));
+  const m = v - chroma;
+  const sector = Math.floor(h / 60) % 6;
+  const table = [
+    [chroma, x, 0],
+    [x, chroma, 0],
+    [0, chroma, x],
+    [0, x, chroma],
+    [x, 0, chroma],
+    [chroma, 0, x]
+  ];
+  const [r, g, b] = table[sector];
+  return {
+    a: clamp2(hsv.a, 0, 1),
+    b: (b + m) * 255,
+    g: (g + m) * 255,
+    r: (r + m) * 255
+  };
+}
+function linearize(channel) {
+  return channel <= 0.04045 ? channel / 12.92 : ((channel + 0.055) / 1.055) ** 2.4;
+}
+function delinearize(channel) {
+  return channel <= 0.0031308 ? channel * 12.92 : 1.055 * channel ** (1 / 2.4) - 0.055;
+}
+function srgbToOklch2(rgb) {
+  const r = linearize(clamp2(rgb.r, 0, 255) / 255);
+  const g = linearize(clamp2(rgb.g, 0, 255) / 255);
+  const b = linearize(clamp2(rgb.b, 0, 255) / 255);
+  const lCone = Math.cbrt(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b);
+  const mCone = Math.cbrt(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b);
+  const sCone = Math.cbrt(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b);
+  const l = 0.2104542553 * lCone + 0.793617785 * mCone - 0.0040720468 * sCone;
+  const a = 1.9779984951 * lCone - 2.428592205 * mCone + 0.4505937099 * sCone;
+  const bAxis = 0.0259040371 * lCone + 0.7827717662 * mCone - 0.808675766 * sCone;
+  const chroma = Math.hypot(a, bAxis);
+  return {
+    a: clamp2(rgb.a, 0, 1),
+    c: chroma,
+    h: chroma < 0.000001 ? 0 : (Math.atan2(bAxis, a) * 180 / Math.PI + 360) % 360,
+    l
+  };
+}
+function oklchToSrgb2(color) {
+  const hue = (color.h % 360 + 360) % 360 * (Math.PI / 180);
+  const a = color.c * Math.cos(hue);
+  const bAxis = color.c * Math.sin(hue);
+  const lCone = (color.l + 0.3963377774 * a + 0.2158037573 * bAxis) ** 3;
+  const mCone = (color.l - 0.1055613458 * a - 0.0638541728 * bAxis) ** 3;
+  const sCone = (color.l - 0.0894841775 * a - 1.291485548 * bAxis) ** 3;
+  const r = 4.0767416621 * lCone - 3.3077115913 * mCone + 0.2309699292 * sCone;
+  const g = -1.2684380046 * lCone + 2.6097574011 * mCone - 0.3413193965 * sCone;
+  const b = -0.0041960863 * lCone - 0.7034186147 * mCone + 1.707614701 * sCone;
+  return {
+    a: clamp2(color.a, 0, 1),
+    b: clamp2(delinearize(b) * 255, 0, 255),
+    g: clamp2(delinearize(g) * 255, 0, 255),
+    r: clamp2(delinearize(r) * 255, 0, 255)
+  };
+}
+function formatOklch2(color) {
+  const body = `${(color.l * 100).toFixed(1)}% ${color.c.toFixed(3)} ${color.h.toFixed(1)}`;
+  return color.a >= 1 ? `oklch(${body})` : `oklch(${body} / ${Number(color.a.toFixed(3))})`;
+}
+function relativeLuminance2(rgb) {
+  const r = linearize(clamp2(rgb.r, 0, 255) / 255);
+  const g = linearize(clamp2(rgb.g, 0, 255) / 255);
+  const b = linearize(clamp2(rgb.b, 0, 255) / 255);
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+function contrastRatio2(one, two) {
+  const a = relativeLuminance2(one);
+  const b = relativeLuminance2(two);
+  return (Math.max(a, b) + 0.05) / (Math.min(a, b) + 0.05);
+}
+var BLACK = { a: 1, b: 0, g: 0, r: 0 };
+var WHITE = { a: 1, b: 255, g: 255, r: 255 };
+function preferredInk2(rgb) {
+  return contrastRatio2(rgb, BLACK) >= contrastRatio2(rgb, WHITE) ? "black" : "white";
+}
+function inkOn2(color) {
+  const parsed = typeof color === "string" ? parseColor2(color) : null;
+  return parsed ? preferredInk2({ ...parsed, a: 1 }) : "";
+}
+
+export { clamp2, snapToStep2, parseHex2, parseColor2, formatHex2, rgbToHsv2, hsvToRgb2, srgbToOklch2, oklchToSrgb2, formatOklch2, relativeLuminance2, contrastRatio2, preferredInk2, inkOn2 };
+
+//# debugId=D9BA3CB5A73B069064756E2164756E21
+//# sourceMappingURL=iframe-entry-b27vq81n.js.map

package/dist/chunks/iframe-entry-nbyxee1y.js

@@ -0,0 +1,154 @@
+// ../ui/src/behaviors/popover.ts
+function supportsAnchorPositioning2() {
+  const css = globalThis.CSS;
+  return typeof css?.supports === "function" && css.supports("position-area", "block-end");
+}
+function apiOf(host) {
+  return host;
+}
+var anchors = new WeakMap;
+function hostOf(event) {
+  const target = event.currentTarget;
+  return target instanceof HTMLElement ? target : null;
+}
+function anchorOf2(host) {
+  return anchors.get(host) ?? null;
+}
+function openAt2(host, anchor) {
+  const api = apiOf(host);
+  if (typeof api.showPopover !== "function") {
+    return;
+  }
+  if (!anchor) {
+    api.showPopover();
+    return;
+  }
+  anchors.set(host, anchor);
+  try {
+    show(api, anchor);
+  } catch (error) {
+    anchors.delete(host);
+    throw error;
+  }
+}
+function show(api, anchor) {
+  try {
+    api.showPopover?.({ source: anchor });
+  } catch (error) {
+    if (!(error instanceof TypeError)) {
+      throw error;
+    }
+    api.showPopover?.();
+  }
+}
+function close2(host) {
+  const api = apiOf(host);
+  if (typeof api.hidePopover === "function") {
+    api.hidePopover();
+  }
+}
+function invokerOf(host) {
+  const { id } = host;
+  if (!id) {
+    return null;
+  }
+  for (const invoker of host.ownerDocument.querySelectorAll("[popovertarget]")) {
+    if (invoker.getAttribute("popovertarget") === id) {
+      return invoker;
+    }
+  }
+  return null;
+}
+function toggleSourceOf(host, event) {
+  const { source } = event;
+  if (source instanceof Element) {
+    return source;
+  }
+  return anchorOf2(host) ?? invokerOf(host);
+}
+function measureAnchor2(state, host, anchor = anchorOf2(host)) {
+  if (state.matchWidth !== true || !anchor) {
+    return;
+  }
+  const box = anchor.getBoundingClientRect();
+  if (box.width > 0) {
+    state.anchorWidth = Math.round(box.width);
+  }
+}
+function clearWhenStill(state, host) {
+  const settle = () => {
+    if (typeof host.getAnimations === "function" && host.getAnimations().length > 0) {
+      return;
+    }
+    state.settling = false;
+  };
+  if (typeof requestAnimationFrame === "function") {
+    requestAnimationFrame(settle);
+  } else {
+    settle();
+  }
+}
+function onBeforeToggle2(state, event) {
+  const host = hostOf(event);
+  if (!host) {
+    return;
+  }
+  const opening = event.newState === "open";
+  const floor = Number(state.floor ?? 0);
+  state.anchored = opening && floor <= 0 && toggleSourceOf(host, event) !== null;
+}
+function onToggle2(state, event) {
+  const host = hostOf(event);
+  if (!host) {
+    return;
+  }
+  const opening = event.newState === "open";
+  state.open = opening;
+  state.settling = true;
+  if (opening) {
+    measureAnchor2(state, host, toggleSourceOf(host, event));
+    if (!(state.anchored === true && supportsAnchorPositioning2())) {
+      clampIntoViewport2(state, host, { floor: Number(state.floor ?? 0) });
+    }
+  } else {
+    anchors.delete(host);
+  }
+  clearWhenStill(state, host);
+}
+function onTransitionEnd2(state, event) {
+  if (event.target === event.currentTarget) {
+    state.settling = false;
+  }
+}
+function blockOffsetOf(panel) {
+  const offset = Number.parseFloat(getComputedStyle(panel).marginBlockStart);
+  return Number.isFinite(offset) && offset > 0 ? offset : 0;
+}
+function clampIntoViewport2(state, panel, options = {}) {
+  const measure = () => {
+    const box = panel.getBoundingClientRect();
+    if (box.width === 0 && box.height === 0) {
+      return;
+    }
+    const margin = 4;
+    const floor = options.floor && options.floor > 0 ? options.floor : window.innerHeight;
+    if (box.right > window.innerWidth - margin) {
+      const parent = options.flipAgainst ?? null;
+      const flipped = parent ? Math.round(parent.getBoundingClientRect().left) - box.width + 2 : -1;
+      state.x = flipped >= margin ? flipped : Math.max(margin, Math.round(window.innerWidth - box.width - margin));
+    }
+    if (box.bottom > floor) {
+      state.y = Math.max(margin, Math.round(floor - box.height - blockOffsetOf(panel)));
+    }
+  };
+  if (typeof requestAnimationFrame === "function") {
+    requestAnimationFrame(measure);
+  } else {
+    measure();
+  }
+}
+
+export { supportsAnchorPositioning2, anchorOf2, openAt2, close2, measureAnchor2, onBeforeToggle2, onToggle2, onTransitionEnd2, clampIntoViewport2 };
+
+//# debugId=637E57C667B3FE6D64756E2164756E21
+//# sourceMappingURL=iframe-entry-nbyxee1y.js.map

package/dist/chunks/iframe-host-syr0f9sb.js

@@ -0,0 +1,115 @@
+import {
+  sawIframeDragOver2,
+  allowAutoRequestsOnNextRender2,
+  requestCanvasEval2,
+  flushCanvasEdits2,
+  hostForCanvas2,
+  liveDragHostAt2,
+  beginDragSession2,
+  currentDragSession2,
+  hostDragGeometry2,
+  canvasIdleBlockers2,
+  canvasPointAt2,
+  revealCanvasPath2,
+  revealCanvasPathIn2,
+  measureInCanvas2,
+  adoptCanvasPreviewMode2,
+  postDragMessage2,
+  endDragSession2,
+  clearDropIndicator2,
+  setNativeDragEnterHandler2,
+  setInsertZoneClickHandler2,
+  setFileDropHandler2,
+  setCanvasSlashHandler2,
+  setCanvasContextMenuHandler2,
+  setStylebookHitHandler2,
+  isCaretActive2,
+  setToolbarRefresh2,
+  setCanvasPointerDownHandler2,
+  setIframePatchEscalation2,
+  postPopoverOpen2,
+  postDialogOpen2,
+  postPatchToHosts2,
+  dragHostTab2,
+  releaseCanvasHosts2,
+  mountIframeCanvas2,
+  mountStylebookCanvas2,
+  postColorSchemeToLiveHosts2,
+  postLocaleToLiveHosts2,
+  postRedefineElementToLiveHosts2,
+  postSiteStyleToLiveHosts2,
+  postStyleUpdateToStylebookHosts2,
+  panToStylebookTag2,
+  getEditSnapshot2,
+  setKeymapSource2,
+  postApplyFormat2,
+  postOpenSlash2,
+  commitActiveEditSession2,
+  getEditBarAnchorRect2
+} from "./studio-1z1kcjv4.js";
+import"./studio-qk90fgqm.js";
+import"./studio-zdn2g6dt.js";
+import"./studio-y9zedyjn.js";
+import"./studio-nzzpvzx9.js";
+import"./studio-k75n7vhp.js";
+import"./studio-q3x06vmj.js";
+import"./studio-6ewqv390.js";
+import"./studio-esrxgwh6.js";
+import"./studio-vw7mzp6z.js";
+import"./studio-6nzaktvy.js";
+import"./studio-kkqkcp3d.js";
+import"./studio-p1dw8wfw.js";
+import"./studio-yxa81f45.js";
+import"./studio-7r42c6ca.js";
+export {
+  adoptCanvasPreviewMode2 as adoptCanvasPreviewMode,
+  allowAutoRequestsOnNextRender2 as allowAutoRequestsOnNextRender,
+  beginDragSession2 as beginDragSession,
+  canvasIdleBlockers2 as canvasIdleBlockers,
+  canvasPointAt2 as canvasPointAt,
+  clearDropIndicator2 as clearDropIndicator,
+  commitActiveEditSession2 as commitActiveEditSession,
+  currentDragSession2 as currentDragSession,
+  dragHostTab2 as dragHostTab,
+  endDragSession2 as endDragSession,
+  flushCanvasEdits2 as flushCanvasEdits,
+  getEditBarAnchorRect2 as getEditBarAnchorRect,
+  getEditSnapshot2 as getEditSnapshot,
+  hostDragGeometry2 as hostDragGeometry,
+  hostForCanvas2 as hostForCanvas,
+  isCaretActive2 as isCaretActive,
+  liveDragHostAt2 as liveDragHostAt,
+  measureInCanvas2 as measureInCanvas,
+  mountIframeCanvas2 as mountIframeCanvas,
+  mountStylebookCanvas2 as mountStylebookCanvas,
+  panToStylebookTag2 as panToStylebookTag,
+  postApplyFormat2 as postApplyFormat,
+  postColorSchemeToLiveHosts2 as postColorSchemeToLiveHosts,
+  postDialogOpen2 as postDialogOpen,
+  postDragMessage2 as postDragMessage,
+  postLocaleToLiveHosts2 as postLocaleToLiveHosts,
+  postOpenSlash2 as postOpenSlash,
+  postPatchToHosts2 as postPatchToHosts,
+  postPopoverOpen2 as postPopoverOpen,
+  postRedefineElementToLiveHosts2 as postRedefineElementToLiveHosts,
+  postSiteStyleToLiveHosts2 as postSiteStyleToLiveHosts,
+  postStyleUpdateToStylebookHosts2 as postStyleUpdateToStylebookHosts,
+  releaseCanvasHosts2 as releaseCanvasHosts,
+  requestCanvasEval2 as requestCanvasEval,
+  revealCanvasPath2 as revealCanvasPath,
+  revealCanvasPathIn2 as revealCanvasPathIn,
+  sawIframeDragOver2 as sawIframeDragOver,
+  setCanvasContextMenuHandler2 as setCanvasContextMenuHandler,
+  setCanvasPointerDownHandler2 as setCanvasPointerDownHandler,
+  setCanvasSlashHandler2 as setCanvasSlashHandler,
+  setFileDropHandler2 as setFileDropHandler,
+  setIframePatchEscalation2 as setIframePatchEscalation,
+  setInsertZoneClickHandler2 as setInsertZoneClickHandler,
+  setKeymapSource2 as setKeymapSource,
+  setNativeDragEnterHandler2 as setNativeDragEnterHandler,
+  setStylebookHitHandler2 as setStylebookHitHandler,
+  setToolbarRefresh2 as setToolbarRefresh
+};
+
+//# debugId=C707DC9880497DB564756E2164756E21
+//# sourceMappingURL=iframe-host-syr0f9sb.js.map

package/dist/chunks/{index-wcnt3r9g.js → index-mdmyx6s2.js}

@@ -1,19 +1,19 @@
 import {
-  require_applicator,
   require_codegen,
+  require_validate,
+  require_validation_error,
+  require_ref_error,
   require_core,
-  require_core1 as require_core2,
-  require_discriminator,
+  require_core2,
+  require_validation,
+  require_applicator,
   require_format,
   require_metadata,
-  require_ref_error,
-  require_validate,
-  require_validation,
-  require_validation_error
-} from "./studio-gcye7qka.js";
+  require_discriminator
+} from "./studio-7e11jpa9.js";
 import {
   __commonJS
-} from "./studio-a0tswy0w.js";
+} from "./studio-5te5tqng.js";
 
 // ../../node_modules/ajv-formats/dist/formats.js
 var require_formats = __commonJS(function(exports) {
@@ -543,5 +543,5 @@ var require_dist = __commonJS(function(exports, module) {
 });
 export default require_dist();
 
-//# debugId=63B9398DFFB8851464756E2164756E21
-//# sourceMappingURL=index-wcnt3r9g.js.map
+//# debugId=253F70DB2934D83664756E2164756E21
+//# sourceMappingURL=index-mdmyx6s2.js.map