codebay 0.14.0 → 0.16.0

package/.mochi/svelte-compile/{chunk-60mpagr9.js → chunk-gnf5cnct.js}

@@ -3238,7 +3238,7 @@ import * as $3 from "svelte/internal/server";
 import"svelte/internal/flags/async";
 import * as $2 from "svelte/internal/server";
 
-// node_modules/@lucide/svelte/dist/defaultAttributes.js
+// node_modules/@lucide/svelte/dist/utils/defaultAttributes.js
 var defaultAttributes = {
   xmlns: "http://www.w3.org/2000/svg",
   width: 24,
@@ -3252,6 +3252,65 @@ var defaultAttributes = {
 };
 var defaultAttributes_default = defaultAttributes;
 
+// node_modules/@lucide/svelte/dist/utils/mergeClasses.js
+var mergeClasses = (...classes) => classes.filter((className, index, array) => {
+  return Boolean(className) && className.trim() !== "" && array.indexOf(className) === index;
+}).join(" ").trim();
+
+// node_modules/@lucide/svelte/dist/utils/buildLucideIconNode.js
+function isDefined(value) {
+  return value !== null && value !== undefined;
+}
+function buildLucideIconNode(icon, params2 = {}) {
+  const attributeNames = params2.attributeNames ?? {};
+  const getAttributeName = (attributeName) => attributeNames[attributeName] ?? attributeName;
+  const viewBoxWidth = icon.size ?? icon.width ?? defaultAttributes_default["width"];
+  const viewBoxHeight = icon.size ?? icon.height ?? defaultAttributes_default["height"];
+  const aliasClassNames = icon.aliases?.filter((alias) => typeof alias === "string" && alias.trim() !== "").map((alias) => `lucide-${alias}`) ?? [];
+  const iconClassNames = [...icon.name ? [`lucide-${icon.name}`] : [], ...aliasClassNames];
+  const classNamesFromClassName = params2.className?.split(" ").filter(Boolean) ?? [];
+  const className = params2.includeDefaultClasses === false ? mergeClasses(...classNamesFromClassName) : mergeClasses("lucide", ...iconClassNames, ...classNamesFromClassName);
+  const calculatedStrokeWidth = params2.absoluteStrokeWidth ? Number(params2.strokeWidth ?? defaultAttributes_default["stroke-width"]) * Number(icon.size ?? icon.width ?? defaultAttributes_default["width"]) / Number(params2.size ?? params2.width ?? defaultAttributes_default["width"]) : params2.strokeWidth ?? defaultAttributes_default["stroke-width"];
+  const attributes = {
+    ...Object.entries(defaultAttributes_default).reduce((attrs, [attrName, value]) => {
+      attrs[getAttributeName(attrName)] = value;
+      return attrs;
+    }, {}),
+    ..."color" in params2 && params2.color && {
+      [getAttributeName("stroke")]: params2.color
+    },
+    ..."size" in params2 && isDefined(params2.size) && {
+      [getAttributeName("width")]: params2.size,
+      [getAttributeName("height")]: params2.size
+    },
+    ..."width" in params2 && isDefined(params2.width) && {
+      [getAttributeName("width")]: params2.width
+    },
+    ..."height" in params2 && isDefined(params2.height) && {
+      [getAttributeName("height")]: params2.height
+    },
+    [getAttributeName("stroke-width")]: calculatedStrokeWidth,
+    ...className && {
+      [getAttributeName("class")]: className
+    },
+    [getAttributeName("viewBox")]: `0 0 ${viewBoxWidth} ${viewBoxHeight}`,
+    ...params2.hasA11yProp === false ? {
+      [getAttributeName("aria-hidden")]: "true"
+    } : {},
+    ..."attributes" in params2 && params2.attributes
+  };
+  return [
+    "svg",
+    attributes,
+    icon.node.map((child) => {
+      const [name, attrs, children] = child;
+      const nextAttrs = params2.nonScalingStroke ? { [getAttributeName("vector-effect")]: "non-scaling-stroke", ...attrs } : attrs;
+      return children ? [name, nextAttrs, children] : [name, nextAttrs];
+    })
+  ];
+}
+var buildLucideIconNode_default = buildLucideIconNode;
+
 // node_modules/@lucide/svelte/dist/utils/hasA11yProp.js
 var hasA11yProp = (props) => {
   for (const prop in props) {
@@ -3272,34 +3331,39 @@ function Icon($$renderer, $$props) {
   $$renderer.component(($$renderer2) => {
     const globalProps = getLucideContext() ?? {};
     const {
-      name,
       color = globalProps.color ?? "currentColor",
       size = globalProps.size ?? 24,
+      width = size,
+      height = size,
       strokeWidth = globalProps.strokeWidth ?? 2,
       absoluteStrokeWidth = globalProps.absoluteStrokeWidth ?? false,
+      nonScalingStroke = globalProps.nonScalingStroke ?? false,
       iconNode = [],
+      icon = { node: iconNode, aliases: [], size: 24 },
+      class: propsClass,
       children,
       $$slots,
       $$events,
       ...props
     } = $$props;
-    const calculatedStrokeWidth = $2.derived(() => absoluteStrokeWidth ? Number(strokeWidth) * 24 / Number(size) : strokeWidth);
-    $$renderer2.push(`<svg${$2.attributes({
-      ...defaultAttributes_default,
-      ...!children && !hasA11yProp(props) && { "aria-hidden": "true" },
-      ...props,
-      width: size,
-      height: size,
-      stroke: color,
-      "stroke-width": calculatedStrokeWidth(),
-      class: $2.clsx([
-        "lucide-icon lucide",
-        globalProps.class,
-        name && `lucide-${name}`,
-        props.class
-      ])
-    }, undefined, undefined, undefined, 3)}><!--[-->`);
-    const each_array = $2.ensure_array_like(iconNode);
+    const hasAccessibleProp = $2.derived(() => Boolean(children) || hasA11yProp(props));
+    const $$d = $2.derived(() => buildLucideIconNode_default(icon, {
+      color,
+      width,
+      height,
+      strokeWidth,
+      absoluteStrokeWidth,
+      nonScalingStroke,
+      className: mergeClasses("lucide-icon", globalProps.class),
+      hasA11yProp: hasAccessibleProp(),
+      attributes: props
+    })), $$derived_array = $2.derived(() => $2.to_array($$d(), 3)), svgAttributes = $2.derived(() => $$derived_array()[1]), builtIconNode = $2.derived(() => $2.fallback($$derived_array()[2], () => [], true));
+    const iconAttributes = $2.derived(() => ({
+      ...svgAttributes(),
+      class: [...svgAttributes().class.split(" "), propsClass]
+    }));
+    $$renderer2.push(`<svg${$2.attributes({ ...iconAttributes() }, undefined, undefined, undefined, 3)}><!--[-->`);
+    const each_array = $2.ensure_array_like(builtIconNode());
     for (let $$index = 0, $$length = each_array.length;$$index < $$length; $$index++) {
       let [tag, attrs] = each_array[$$index];
       $2.element($$renderer2, tag, () => {
@@ -3315,8 +3379,12 @@ function Icon($$renderer, $$props) {
 // node_modules/@lucide/svelte/dist/icons/x.svelte
 function X($$renderer, $$props) {
   let { $$slots, $$events, ...props } = $$props;
-  const iconNode = [["path", { d: "M18 6 6 18" }], ["path", { d: "m6 6 12 12" }]];
-  Icon($$renderer, $3.spread_props([{ name: "x" }, props, { iconNode }]));
+  const iconData = {
+    name: "x",
+    size: 24,
+    node: [["path", { d: "M18 6 6 18" }], ["path", { d: "m6 6 12 12" }]]
+  };
+  Icon($$renderer, $3.spread_props([props, { icon: iconData }]));
 }
 // src/lib/popup-nav.ts
 var POPUP_PARAM = "popup";
@@ -3324,4 +3392,575 @@ function withPopupMarker(href) {
   return `${href}?${POPUP_PARAM}=1`;
 }
 
-export { emitIslandProps, isDev, cookies, HydratableBoundary, Icon, X, withPopupMarker };
+// node_modules/svelte-french-toast/dist/components/Toaster.svelte
+import"svelte/internal/flags/async";
+import * as $11 from "svelte/internal/server";
+
+// node_modules/svelte-french-toast/dist/core/store.js
+import { get as get2, writable } from "svelte/store";
+
+// node_modules/svelte-writable-derived/index.mjs
+import { derived as derived2, get } from "svelte/store";
+function writableDerived(origins, derive, reflect, initial) {
+  var childDerivedSetter, originValues, blockNextDerive = false;
+  var reflectOldValues = reflect.length >= 2;
+  var wrappedDerive = (got, set, update2) => {
+    childDerivedSetter = set;
+    if (reflectOldValues) {
+      originValues = got;
+    }
+    if (!blockNextDerive) {
+      let returned = derive(got, set, update2);
+      if (derive.length < 2) {
+        set(returned);
+      } else {
+        return returned;
+      }
+    }
+    blockNextDerive = false;
+  };
+  var childDerived = derived2(origins, wrappedDerive, initial);
+  var singleOrigin = !Array.isArray(origins);
+  function doReflect(reflecting) {
+    var setWith = reflect(reflecting, originValues);
+    if (singleOrigin) {
+      blockNextDerive = true;
+      origins.set(setWith);
+    } else {
+      setWith.forEach((value, i) => {
+        blockNextDerive = true;
+        origins[i].set(value);
+      });
+    }
+    blockNextDerive = false;
+  }
+  var tryingSet = false;
+  function update(fn) {
+    var isUpdated, mutatedBySubscriptions, oldValue, newValue;
+    if (tryingSet) {
+      newValue = fn(get(childDerived));
+      childDerivedSetter(newValue);
+      return;
+    }
+    var unsubscribe = childDerived.subscribe((value) => {
+      if (!tryingSet) {
+        oldValue = value;
+      } else if (!isUpdated) {
+        isUpdated = true;
+      } else {
+        mutatedBySubscriptions = true;
+      }
+    });
+    newValue = fn(oldValue);
+    tryingSet = true;
+    childDerivedSetter(newValue);
+    unsubscribe();
+    tryingSet = false;
+    if (mutatedBySubscriptions) {
+      newValue = get(childDerived);
+    }
+    if (isUpdated) {
+      doReflect(newValue);
+    }
+  }
+  return {
+    subscribe: childDerived.subscribe,
+    set(value) {
+      update(() => value);
+    },
+    update
+  };
+}
+
+// node_modules/svelte-french-toast/dist/core/store.js
+var TOAST_LIMIT = 20;
+var toasts = writable([]);
+var pausedAt = writable(null);
+var toastTimeouts = new Map;
+var addToRemoveQueue = (toastId) => {
+  if (toastTimeouts.has(toastId)) {
+    return;
+  }
+  const timeout = setTimeout(() => {
+    toastTimeouts.delete(toastId);
+    remove(toastId);
+  }, 1000);
+  toastTimeouts.set(toastId, timeout);
+};
+var clearFromRemoveQueue = (toastId) => {
+  const timeout = toastTimeouts.get(toastId);
+  if (timeout) {
+    clearTimeout(timeout);
+  }
+};
+function update(toast) {
+  if (toast.id) {
+    clearFromRemoveQueue(toast.id);
+  }
+  toasts.update(($toasts) => $toasts.map((t) => t.id === toast.id ? { ...t, ...toast } : t));
+}
+function add(toast) {
+  toasts.update(($toasts) => [toast, ...$toasts].slice(0, TOAST_LIMIT));
+}
+function upsert(toast) {
+  if (get2(toasts).find((t) => t.id === toast.id)) {
+    update(toast);
+  } else {
+    add(toast);
+  }
+}
+function dismiss(toastId) {
+  toasts.update(($toasts) => {
+    if (toastId) {
+      addToRemoveQueue(toastId);
+    } else {
+      $toasts.forEach((toast) => {
+        addToRemoveQueue(toast.id);
+      });
+    }
+    return $toasts.map((t) => t.id === toastId || toastId === undefined ? { ...t, visible: false } : t);
+  });
+}
+function remove(toastId) {
+  toasts.update(($toasts) => {
+    if (toastId === undefined) {
+      return [];
+    }
+    return $toasts.filter((t) => t.id !== toastId);
+  });
+}
+function startPause(time) {
+  pausedAt.set(time);
+}
+function endPause(time) {
+  let diff;
+  pausedAt.update(($pausedAt) => {
+    diff = time - ($pausedAt || 0);
+    return null;
+  });
+  toasts.update(($toasts) => $toasts.map((t) => ({
+    ...t,
+    pauseDuration: t.pauseDuration + diff
+  })));
+}
+var defaultTimeouts = {
+  blank: 4000,
+  error: 4000,
+  success: 2000,
+  loading: Infinity,
+  custom: 4000
+};
+function useToasterStore(toastOptions = {}) {
+  const mergedToasts = writableDerived(toasts, ($toasts) => $toasts.map((t) => ({
+    ...toastOptions,
+    ...toastOptions[t.type],
+    ...t,
+    duration: t.duration || toastOptions[t.type]?.duration || toastOptions?.duration || defaultTimeouts[t.type],
+    style: [toastOptions.style, toastOptions[t.type]?.style, t.style].join(";")
+  })), ($toasts) => $toasts);
+  return {
+    toasts: mergedToasts,
+    pausedAt
+  };
+}
+
+// node_modules/svelte-french-toast/dist/core/types.js
+var isFunction = (valOrFunction) => typeof valOrFunction === "function";
+var resolveValue = (valOrFunction, arg) => isFunction(valOrFunction) ? valOrFunction(arg) : valOrFunction;
+
+// node_modules/svelte-french-toast/dist/core/utils.js
+var genId = (() => {
+  let count = 0;
+  return () => {
+    count += 1;
+    return count.toString();
+  };
+})();
+var prefersReducedMotion = (() => {
+  let shouldReduceMotion;
+  return () => {
+    if (shouldReduceMotion === undefined && typeof window !== "undefined") {
+      const mediaQuery = matchMedia("(prefers-reduced-motion: reduce)");
+      shouldReduceMotion = !mediaQuery || mediaQuery.matches;
+    }
+    return shouldReduceMotion;
+  };
+})();
+
+// node_modules/svelte-french-toast/dist/core/toast.js
+var createToast = (message, type = "blank", opts) => ({
+  createdAt: Date.now(),
+  visible: true,
+  type,
+  ariaProps: {
+    role: "status",
+    "aria-live": "polite"
+  },
+  message,
+  pauseDuration: 0,
+  ...opts,
+  id: opts?.id || genId()
+});
+var createHandler = (type) => (message, options) => {
+  const toast = createToast(message, type, options);
+  upsert(toast);
+  return toast.id;
+};
+var toast = (message, opts) => createHandler("blank")(message, opts);
+toast.error = createHandler("error");
+toast.success = createHandler("success");
+toast.loading = createHandler("loading");
+toast.custom = createHandler("custom");
+toast.dismiss = (toastId) => {
+  dismiss(toastId);
+};
+toast.remove = (toastId) => remove(toastId);
+toast.promise = (promise, msgs, opts) => {
+  const id = toast.loading(msgs.loading, { ...opts, ...opts?.loading });
+  promise.then((p) => {
+    toast.success(resolveValue(msgs.success, p), {
+      id,
+      ...opts,
+      ...opts?.success
+    });
+    return p;
+  }).catch((e) => {
+    toast.error(resolveValue(msgs.error, e), {
+      id,
+      ...opts,
+      ...opts?.error
+    });
+  });
+  return promise;
+};
+var toast_default = toast;
+
+// node_modules/svelte-french-toast/dist/core/use-toaster.js
+import { onDestroy } from "svelte";
+function calculateOffset(toast2, $toasts, opts) {
+  const { reverseOrder, gutter = 8, defaultPosition } = opts || {};
+  const relevantToasts = $toasts.filter((t) => (t.position || defaultPosition) === (toast2.position || defaultPosition) && t.height);
+  const toastIndex = relevantToasts.findIndex((t) => t.id === toast2.id);
+  const toastsBefore = relevantToasts.filter((toast3, i) => i < toastIndex && toast3.visible).length;
+  const offset = relevantToasts.filter((t) => t.visible).slice(...reverseOrder ? [toastsBefore + 1] : [0, toastsBefore]).reduce((acc, t) => acc + (t.height || 0) + gutter, 0);
+  return offset;
+}
+var handlers = {
+  startPause() {
+    startPause(Date.now());
+  },
+  endPause() {
+    endPause(Date.now());
+  },
+  updateHeight: (toastId, height) => {
+    update({ id: toastId, height });
+  },
+  calculateOffset
+};
+function useToaster(toastOptions) {
+  const { toasts: toasts2, pausedAt: pausedAt2 } = useToasterStore(toastOptions);
+  const timeouts = new Map;
+  let _pausedAt;
+  const unsubscribes = [
+    pausedAt2.subscribe(($pausedAt) => {
+      if ($pausedAt) {
+        for (const [, timeoutId] of timeouts) {
+          clearTimeout(timeoutId);
+        }
+        timeouts.clear();
+      }
+      _pausedAt = $pausedAt;
+    }),
+    toasts2.subscribe(($toasts) => {
+      if (_pausedAt) {
+        return;
+      }
+      const now = Date.now();
+      for (const t of $toasts) {
+        if (timeouts.has(t.id)) {
+          continue;
+        }
+        if (t.duration === Infinity) {
+          continue;
+        }
+        const durationLeft = (t.duration || 0) + t.pauseDuration - (now - t.createdAt);
+        if (durationLeft < 0) {
+          if (t.visible) {
+            toast_default.dismiss(t.id);
+          }
+          return null;
+        }
+        timeouts.set(t.id, setTimeout(() => toast_default.dismiss(t.id), durationLeft));
+      }
+    })
+  ];
+  onDestroy(() => {
+    for (const unsubscribe of unsubscribes) {
+      unsubscribe();
+    }
+  });
+  return { toasts: toasts2, handlers };
+}
+
+// node_modules/svelte-french-toast/dist/components/ToastWrapper.svelte
+import"svelte/internal/flags/async";
+import * as $10 from "svelte/internal/server";
+import { onMount } from "svelte";
+
+// node_modules/svelte-french-toast/dist/components/ToastBar.svelte
+import"svelte/internal/flags/async";
+import * as $9 from "svelte/internal/server";
+
+// node_modules/svelte-french-toast/dist/components/ToastIcon.svelte
+import"svelte/internal/flags/async";
+import * as $7 from "svelte/internal/server";
+
+// node_modules/svelte-french-toast/dist/components/CheckmarkIcon.svelte
+import"svelte/internal/flags/async";
+import * as $4 from "svelte/internal/server";
+function CheckmarkIcon($$renderer, $$props) {
+  let primary = $4.fallback($$props["primary"], "#61d345");
+  let secondary = $4.fallback($$props["secondary"], "#fff");
+  $$renderer.push(`<div class="svelte-1did3zw"${$4.attr_style("", { "--primary": primary, "--secondary": secondary })}></div>`);
+  $4.bind_props($$props, { primary, secondary });
+}
+
+// node_modules/svelte-french-toast/dist/components/ErrorIcon.svelte
+import"svelte/internal/flags/async";
+import * as $5 from "svelte/internal/server";
+function ErrorIcon($$renderer, $$props) {
+  let primary = $5.fallback($$props["primary"], "#ff4b4b");
+  let secondary = $5.fallback($$props["secondary"], "#fff");
+  $$renderer.push(`<div class="svelte-1ro2ggf"${$5.attr_style("", { "--primary": primary, "--secondary": secondary })}></div>`);
+  $5.bind_props($$props, { primary, secondary });
+}
+
+// node_modules/svelte-french-toast/dist/components/LoaderIcon.svelte
+import"svelte/internal/flags/async";
+import * as $6 from "svelte/internal/server";
+function LoaderIcon($$renderer, $$props) {
+  let primary = $6.fallback($$props["primary"], "#616161");
+  let secondary = $6.fallback($$props["secondary"], "#e0e0e0");
+  $$renderer.push(`<div class="svelte-tyythq"${$6.attr_style("", { "--primary": primary, "--secondary": secondary })}></div>`);
+  $6.bind_props($$props, { primary, secondary });
+}
+
+// node_modules/svelte-french-toast/dist/components/ToastIcon.svelte
+function ToastIcon($$renderer, $$props) {
+  let type, icon, iconTheme;
+  let toast2 = $$props["toast"];
+  $:
+    ({ type, icon, iconTheme } = toast2);
+  if (typeof icon === "string") {
+    $$renderer.push(`<!--[0--><div class="animated svelte-t33qv2">${$7.escape(icon)}</div>`);
+  } else if (typeof icon !== "undefined") {
+    $$renderer.push("<!--[1-->");
+    if (icon) {
+      $$renderer.push("<!--[-->");
+      icon($$renderer, {});
+      $$renderer.push("<!--]-->");
+    } else {
+      $$renderer.push("<!--[!-->");
+      $$renderer.push("<!--]-->");
+    }
+  } else if (type !== "blank") {
+    $$renderer.push(`<!--[2--><div class="indicator svelte-t33qv2">`);
+    LoaderIcon($$renderer, $7.spread_props([iconTheme]));
+    $$renderer.push(`<!----> `);
+    if (type !== "loading") {
+      $$renderer.push(`<!--[0--><div class="status svelte-t33qv2">`);
+      if (type === "error") {
+        $$renderer.push("<!--[0-->");
+        ErrorIcon($$renderer, $7.spread_props([iconTheme]));
+      } else {
+        $$renderer.push("<!--[-1-->");
+        CheckmarkIcon($$renderer, $7.spread_props([iconTheme]));
+      }
+      $$renderer.push(`<!--]--></div>`);
+    } else {
+      $$renderer.push("<!--[-1-->");
+    }
+    $$renderer.push(`<!--]--></div>`);
+  } else {
+    $$renderer.push("<!--[-1-->");
+  }
+  $$renderer.push(`<!--]-->`);
+  $7.bind_props($$props, { toast: toast2 });
+}
+
+// node_modules/svelte-french-toast/dist/components/ToastMessage.svelte
+import"svelte/internal/flags/async";
+import * as $8 from "svelte/internal/server";
+function ToastMessage($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let toast2 = $$props["toast"];
+    $$renderer2.push(`<div${$8.attributes({ class: "message", ...toast2.ariaProps }, "svelte-1gudbf6")}>`);
+    if (typeof toast2.message === "string") {
+      $$renderer2.push(`<!--[0-->${$8.escape(toast2.message)}`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      if (toast2.message) {
+        $$renderer2.push("<!--[-->");
+        toast2.message($$renderer2, { toast: toast2 });
+        $$renderer2.push("<!--]-->");
+      } else {
+        $$renderer2.push("<!--[!-->");
+        $$renderer2.push("<!--]-->");
+      }
+    }
+    $$renderer2.push(`<!--]--></div>`);
+    $8.bind_props($$props, { toast: toast2 });
+  });
+}
+
+// node_modules/svelte-french-toast/dist/components/ToastBar.svelte
+function ToastBar($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let toast2 = $$props["toast"];
+    let position = $9.fallback($$props["position"], () => {
+      return;
+    }, true);
+    let style = $9.fallback($$props["style"], "");
+    let Component = $9.fallback($$props["Component"], () => {
+      return;
+    }, true);
+    let factor;
+    let animation;
+    $: {
+      const top = (toast2.position || position || "top-center").includes("top");
+      factor = top ? 1 : -1;
+      const [enter, exit] = prefersReducedMotion() ? ["fadeIn", "fadeOut"] : ["enter", "exit"];
+      animation = toast2.visible ? enter : exit;
+    }
+    $$renderer2.push(`<div${$9.attr_class(`base ${$9.stringify(toast2.height ? animation : "transparent")} ${$9.stringify(toast2.className || "")}`, "svelte-yae3e8")}${$9.attr_style(`${$9.stringify(style)}; ${$9.stringify(toast2.style)}`, { "--factor": factor })}>`);
+    if (Component) {
+      $$renderer2.push("<!--[0-->");
+      if (Component) {
+        $$renderer2.push("<!--[-->");
+        Component($$renderer2, {
+          $$slots: {
+            icon: ($$renderer3) => {
+              ToastIcon($$renderer3, { toast: toast2, slot: "icon" });
+            },
+            message: ($$renderer3) => {
+              ToastMessage($$renderer3, { toast: toast2, slot: "message" });
+            }
+          }
+        });
+        $$renderer2.push("<!--]-->");
+      } else {
+        $$renderer2.push("<!--[!-->");
+        $$renderer2.push("<!--]-->");
+      }
+    } else {
+      $$renderer2.push(`<!--[-1--><!--[-->`);
+      $9.slot($$renderer2, $$props, "default", { ToastIcon, ToastMessage, toast: toast2 }, () => {
+        ToastIcon($$renderer2, { toast: toast2 });
+        $$renderer2.push(`<!----> `);
+        ToastMessage($$renderer2, { toast: toast2 });
+        $$renderer2.push(`<!---->`);
+      });
+      $$renderer2.push(`<!--]-->`);
+    }
+    $$renderer2.push(`<!--]--></div>`);
+    $9.bind_props($$props, { toast: toast2, position, style, Component });
+  });
+}
+
+// node_modules/svelte-french-toast/dist/components/ToastWrapper.svelte
+function ToastWrapper($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let top, bottom, factor, justifyContent;
+    let toast2 = $$props["toast"];
+    let setHeight = $$props["setHeight"];
+    let wrapperEl;
+    onMount(() => {
+      setHeight(wrapperEl.getBoundingClientRect().height);
+    });
+    $:
+      top = toast2.position?.includes("top") ? 0 : null;
+    $:
+      bottom = toast2.position?.includes("bottom") ? 0 : null;
+    $:
+      factor = toast2.position?.includes("top") ? 1 : -1;
+    $:
+      justifyContent = toast2.position?.includes("center") && "center" || (toast2.position?.includes("right") || toast2.position?.includes("end")) && "flex-end" || null;
+    $$renderer2.push(`<div${$10.attr_class("wrapper svelte-1pz3gqy", undefined, {
+      active: toast2.visible,
+      transition: !prefersReducedMotion()
+    })}${$10.attr_style("", {
+      "--factor": factor,
+      "--offset": toast2.offset,
+      top,
+      bottom,
+      "justify-content": justifyContent
+    })}>`);
+    if (toast2.type === "custom") {
+      $$renderer2.push("<!--[0-->");
+      ToastMessage($$renderer2, { toast: toast2 });
+    } else {
+      $$renderer2.push(`<!--[-1--><!--[-->`);
+      $10.slot($$renderer2, $$props, "default", { toast: toast2 }, () => {
+        ToastBar($$renderer2, { toast: toast2, position: toast2.position });
+      });
+      $$renderer2.push(`<!--]-->`);
+    }
+    $$renderer2.push(`<!--]--></div>`);
+    $10.bind_props($$props, { toast: toast2, setHeight });
+  });
+}
+
+// node_modules/svelte-french-toast/dist/components/Toaster.svelte
+function Toaster($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    var $$store_subs;
+    let reverseOrder = $11.fallback($$props["reverseOrder"], false);
+    let position = $11.fallback($$props["position"], "top-center");
+    let toastOptions = $11.fallback($$props["toastOptions"], () => {
+      return;
+    }, true);
+    let gutter = $11.fallback($$props["gutter"], 8);
+    let containerStyle = $11.fallback($$props["containerStyle"], () => {
+      return;
+    }, true);
+    let containerClassName = $11.fallback($$props["containerClassName"], () => {
+      return;
+    }, true);
+    const { toasts: toasts2, handlers: handlers2 } = useToaster(toastOptions);
+    let _toasts;
+    $:
+      _toasts = $11.store_get($$store_subs ??= {}, "$toasts", toasts2).map((toast2) => ({
+        ...toast2,
+        position: toast2.position || position,
+        offset: handlers2.calculateOffset(toast2, $11.store_get($$store_subs ??= {}, "$toasts", toasts2), { reverseOrder, gutter, defaultPosition: position })
+      }));
+    $$renderer2.push(`<div${$11.attr_class(`toaster ${$11.stringify(containerClassName || "")}`, "svelte-haq5xk")}${$11.attr_style(containerStyle)} role="alert"><!--[-->`);
+    const each_array = $11.ensure_array_like(_toasts);
+    for (let $$index = 0, $$length = each_array.length;$$index < $$length; $$index++) {
+      let toast2 = each_array[$$index];
+      ToastWrapper($$renderer2, {
+        toast: toast2,
+        setHeight: (height) => handlers2.updateHeight(toast2.id, height)
+      });
+    }
+    $$renderer2.push(`<!--]--></div>`);
+    if ($$store_subs)
+      $11.unsubscribe_stores($$store_subs);
+    $11.bind_props($$props, {
+      reverseOrder,
+      position,
+      toastOptions,
+      gutter,
+      containerStyle,
+      containerClassName
+    });
+  });
+}
+// node_modules/svelte-french-toast/dist/index.js
+var dist_default = toast_default;
+
+// src/toast.ts
+var TOAST_STYLE = "border:1px solid var(--edge); background:var(--bg-card); color:var(--ink); box-shadow:4px 4px 0 var(--shadow); font-family:var(--font-mono); font-size:13px;";
+var TOAST_OPTIONS = { style: TOAST_STYLE };
+
+export { emitIslandProps, isDev, cookies, HydratableBoundary, Icon, X, withPopupMarker, Toaster, dist_default, TOAST_OPTIONS };