@lostgradient/cinder 0.5.0 → 0.7.0

package/dist/server/index.server-9s4na701.js

@@ -0,0 +1,195 @@
+import {
+  setTabsContext
+} from "./index.server-js3eva86.js";
+import {
+  handleRovingKeydown,
+  isRovingKey
+} from "./index.server-0a8m173j.js";
+import {
+  commitValue
+} from "./index.server-42qeekwc.js";
+import {
+  classNames
+} from "./index.server-z7nvkz8v.js";
+
+// src/components/tabs/tabs.svelte
+import * as $ from "svelte/internal/server";
+function Tabs($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const baseId = $.props_id($$renderer2);
+    let {
+      value = "",
+      onValueChange,
+      orientation = "horizontal",
+      fill = false,
+      activateOnFocus,
+      class: className,
+      children
+    } = $$props;
+    const effectiveActivateOnFocus = $.derived(() => activateOnFocus ?? orientation === "horizontal");
+    const buttons = new Map;
+    let version = 0;
+    const focusableValue = $.derived(() => {
+      for (const [registeredValue, entry] of buttons) {
+        if (!entry.disabled)
+          return registeredValue;
+      }
+      return;
+    });
+    function focusValue(target) {
+      const entry = buttons.get(target);
+      if (entry)
+        entry.button.focus();
+    }
+    function resolveFocusedIndex(active) {
+      const entries = [...buttons.values()];
+      return entries.findIndex(({ button }) => button === active);
+    }
+    function readActiveElement(event) {
+      const target = event.target instanceof HTMLElement ? event.target : null;
+      if (target) {
+        for (const { button } of buttons.values()) {
+          if (button === target)
+            return target;
+        }
+      }
+      const currentTarget = event.currentTarget instanceof HTMLElement ? event.currentTarget : null;
+      return currentTarget?.ownerDocument.activeElement ?? null;
+    }
+    function resolveStartingIndex(event) {
+      const entries = [...buttons.values()];
+      if (entries.length === 0)
+        return -1;
+      const focused = resolveFocusedIndex(readActiveElement(event));
+      if (focused !== -1)
+        return focused;
+      const order = [...buttons.keys()];
+      const activeIdx = order.indexOf(value);
+      if (activeIdx !== -1 && !entries[activeIdx]?.disabled)
+        return activeIdx;
+      return entries.findIndex((entry) => !entry.disabled);
+    }
+    function isOrientedKey(key, isHorizontal) {
+      if (!isRovingKey(key))
+        return false;
+      if (key === "Home" || key === "End")
+        return true;
+      if (isHorizontal)
+        return key === "ArrowLeft" || key === "ArrowRight";
+      return key === "ArrowUp" || key === "ArrowDown";
+    }
+    function handleKeydown(event) {
+      const entries = [...buttons.values()];
+      const order = [...buttons.keys()];
+      if (event.key === "Enter" || event.key === " ") {
+        const focused = resolveFocusedIndex(readActiveElement(event));
+        if (focused === -1)
+          return;
+        if (entries[focused]?.disabled !== false)
+          return;
+        const focusedValue = order[focused];
+        if (focusedValue === undefined)
+          return;
+        event.preventDefault();
+        commitValue(focusedValue, onValueChange, (next) => {
+          value = next;
+        });
+        return;
+      }
+      const isHorizontal = orientation === "horizontal";
+      if (!isOrientedKey(event.key, isHorizontal))
+        return;
+      if (entries.length === 0)
+        return;
+      const currentIndex = resolveStartingIndex(event);
+      if (currentIndex === -1) {
+        event.preventDefault();
+        return;
+      }
+      const nextIdx = handleRovingKeydown(event, currentIndex, entries.length, {
+        isDisabled: (i) => entries[i]?.disabled ?? false,
+        horizontal: isHorizontal,
+        vertical: !isHorizontal
+      });
+      if (nextIdx === null)
+        return;
+      event.preventDefault();
+      if (nextIdx === currentIndex)
+        return;
+      const nextValue = order[nextIdx];
+      if (nextValue === undefined)
+        return;
+      focusValue(nextValue);
+      if (effectiveActivateOnFocus()) {
+        commitValue(nextValue, onValueChange, (next) => {
+          value = next;
+        });
+      }
+    }
+    setTabsContext({
+      get value() {
+        return value;
+      },
+      get orientation() {
+        return orientation;
+      },
+      get activateOnFocus() {
+        return effectiveActivateOnFocus();
+      },
+      get baseId() {
+        return baseId;
+      },
+      select(next) {
+        commitValue(next, onValueChange, (nextValue) => {
+          value = nextValue;
+        });
+      },
+      isActive(candidate) {
+        return value === candidate;
+      },
+      register(target, button, disabled = false) {
+        const existing = buttons.get(target);
+        if (existing) {
+          existing.button = button;
+          existing.disabled = disabled;
+        } else {
+          buttons.set(target, { button, disabled });
+        }
+        version += 1;
+      },
+      unregister(target) {
+        if (buttons.delete(target)) {
+          version += 1;
+        }
+      },
+      setDisabled(target, disabled) {
+        const existing = buttons.get(target);
+        if (!existing)
+          return;
+        if (existing.disabled === disabled)
+          return;
+        existing.disabled = disabled;
+        version += 1;
+      },
+      isFocusable(candidate) {
+        const selectedEntry = buttons.get(value);
+        const selectedIsEnabled = selectedEntry !== undefined && !selectedEntry.disabled;
+        const entry = buttons.get(candidate);
+        if (!entry || entry.disabled)
+          return false;
+        if (selectedIsEnabled)
+          return value === candidate;
+        return focusableValue() === candidate;
+      },
+      handleKeydown
+    });
+    $$renderer2.push(`<div${$.attr_class($.clsx(classNames("cinder-tabs", className)))}${$.attr("data-cinder-orientation", orientation)}${$.attr("data-cinder-fill", fill ? "" : undefined)}>`);
+    children($$renderer2);
+    $$renderer2.push(`<!----></div>`);
+    $.bind_props($$props, { value });
+  }, Tabs);
+}
+
+export { Tabs };
+
+//# debugId=FBD0BDC5785052B564756E2164756E21

package/dist/server/index.server-a2hz77tt.js

@@ -0,0 +1,458 @@
+import {
+  Color_swatch_picker
+} from "./index.server-0svdq2kq.js";
+import {
+  parseColor
+} from "./index.server-7wsshxkg.js";
+import {
+  classNames
+} from "./index.server-z7nvkz8v.js";
+
+// src/components/color-picker/color-picker.svelte
+import * as $ from "svelte/internal/server";
+import { untrack } from "svelte";
+function Color_picker($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const pickerId = $.props_id($$renderer2);
+    let {
+      value = undefined,
+      defaultValue,
+      alpha = false,
+      name,
+      swatches,
+      disabled = false,
+      class: className,
+      label = "Color picker",
+      onchange,
+      oninput
+    } = $$props;
+    const gradientId = `${pickerId}-gradient`;
+    const hueId = `${pickerId}-hue`;
+    const alphaId = `${pickerId}-alpha`;
+    const previewId = `${pickerId}-preview`;
+    let hue = 0;
+    let saturation = 100;
+    let lightnessValue = 50;
+    let alphaValue = 1;
+    let internalValue = "";
+    let lastEmittedHex = "";
+    let isDragging = false;
+    function clamp(n, min, max) {
+      return Math.max(min, Math.min(max, n));
+    }
+    function toHex2(n) {
+      return clamp(Math.round(n), 0, 255).toString(16).padStart(2, "0");
+    }
+    function normalizeHue(h) {
+      return Math.min((h % 360 + 360) % 360, 359);
+    }
+    function rgbToHsl(r, g, b) {
+      const rn = r / 255;
+      const gn = g / 255;
+      const bn = b / 255;
+      const max = Math.max(rn, gn, bn);
+      const min = Math.min(rn, gn, bn);
+      const l = (max + min) / 2;
+      if (max === min)
+        return { h: 0, s: 0, l: l * 100 };
+      const d = max - min;
+      const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+      let h = 0;
+      if (max === rn)
+        h = ((gn - bn) / d + (gn < bn ? 6 : 0)) * 60;
+      else if (max === gn)
+        h = ((bn - rn) / d + 2) * 60;
+      else
+        h = ((rn - gn) / d + 4) * 60;
+      return { h, s: s * 100, l: l * 100 };
+    }
+    function hslToRgb(h, s, l) {
+      const sn = clamp(s, 0, 100) / 100;
+      const ln = clamp(l, 0, 100) / 100;
+      const hn = (h % 360 + 360) % 360 / 360;
+      if (sn === 0) {
+        const v = Math.round(ln * 255);
+        return { r: v, g: v, b: v };
+      }
+      const q = ln < 0.5 ? ln * (1 + sn) : ln + sn - ln * sn;
+      const p = 2 * ln - q;
+      const hueToRgb = (t) => {
+        let tn = t;
+        if (tn < 0)
+          tn += 1;
+        if (tn > 1)
+          tn -= 1;
+        if (tn < 1 / 6)
+          return p + (q - p) * 6 * tn;
+        if (tn < 1 / 2)
+          return q;
+        if (tn < 2 / 3)
+          return p + (q - p) * (2 / 3 - tn) * 6;
+        return p;
+      };
+      return {
+        r: Math.round(hueToRgb(hn + 1 / 3) * 255),
+        g: Math.round(hueToRgb(hn) * 255),
+        b: Math.round(hueToRgb(hn - 1 / 3) * 255)
+      };
+    }
+    function formatHex(h, s, l, a, withAlpha) {
+      const { r, g, b } = hslToRgb(h, s, l);
+      const base = `#${toHex2(r)}${toHex2(g)}${toHex2(b)}`;
+      if (!withAlpha)
+        return base;
+      return base + toHex2(a * 255);
+    }
+    function parseToHsla(input) {
+      const parsed = parseColor(input);
+      if (!parsed)
+        return null;
+      const { h, s, l } = rgbToHsl(parsed.r, parsed.g, parsed.b);
+      return { h: normalizeHue(h), s, l, a: parsed.a };
+    }
+    function applyHsla(next) {
+      hue = next.h;
+      saturation = next.s;
+      lightnessValue = next.l;
+      alphaValue = alpha ? next.a : 1;
+    }
+    const initialValue = untrack(() => value);
+    const initialDefaultValue = untrack(() => defaultValue);
+    const initialAlpha = untrack(() => alpha);
+    if (initialValue === undefined && initialDefaultValue) {
+      const parsed = parseToHsla(initialDefaultValue);
+      if (parsed) {
+        applyHsla(parsed);
+        internalValue = formatHex(parsed.h, parsed.s, parsed.l, parsed.a, initialAlpha);
+      } else {
+        hue = 0;
+        saturation = 0;
+        lightnessValue = 0;
+        alphaValue = 1;
+        internalValue = "";
+        lastEmittedHex = "";
+      }
+    } else if (initialValue !== undefined) {
+      const parsed = parseToHsla(initialValue);
+      if (parsed) {
+        applyHsla(parsed);
+        internalValue = formatHex(parsed.h, parsed.s, parsed.l, parsed.a, initialAlpha);
+      } else {
+        hue = 0;
+        saturation = 0;
+        lightnessValue = 0;
+        alphaValue = 1;
+        internalValue = "";
+        lastEmittedHex = "";
+      }
+    }
+    function emit(reason) {
+      const hex = formatHex(hue, saturation, lightnessValue, alphaValue, alpha);
+      internalValue = hex;
+      lastEmittedHex = hex;
+      if (value !== undefined)
+        value = hex;
+      oninput?.(hex);
+      if (reason === "change")
+        onchange?.(hex);
+    }
+    function commitFromHsla(next, reason) {
+      applyHsla(next);
+      emit(reason);
+    }
+    function commitCurrentValueChange() {
+      const hex = formatHex(hue, saturation, lightnessValue, alphaValue, alpha);
+      internalValue = hex;
+      lastEmittedHex = hex;
+      if (value !== undefined)
+        value = hex;
+      onchange?.(hex);
+    }
+    let gradientElement = null;
+    function pointerToHsl(event) {
+      const target = gradientElement;
+      if (!target)
+        return { s: saturation, l: lightnessValue };
+      const rect = target.getBoundingClientRect();
+      const x = clamp(event.clientX - rect.left, 0, rect.width);
+      const y = clamp(event.clientY - rect.top, 0, rect.height);
+      const sv = rect.width === 0 ? 0 : x / rect.width;
+      const vv = rect.height === 0 ? 1 : 1 - y / rect.height;
+      const l = vv * (1 - sv / 2);
+      const s = l === 0 || l === 1 ? 0 : (vv - l) / Math.min(l, 1 - l);
+      return { s: s * 100, l: l * 100 };
+    }
+    function handleGradientPointerDown(event) {
+      if (disabled)
+        return;
+      event.preventDefault();
+      gradientElement?.setPointerCapture(event.pointerId);
+      isDragging = true;
+      const { s, l } = pointerToHsl(event);
+      commitFromHsla({ h: hue, s, l, a: alphaValue }, "input");
+    }
+    function handleGradientPointerMove(event) {
+      if (!isDragging || disabled)
+        return;
+      const { s, l } = pointerToHsl(event);
+      commitFromHsla({ h: hue, s, l, a: alphaValue }, "input");
+    }
+    function handleGradientPointerUp(event) {
+      if (!isDragging)
+        return;
+      isDragging = false;
+      gradientElement?.releasePointerCapture(event.pointerId);
+      commitCurrentValueChange();
+    }
+    function handleGradientPointerCancel(event) {
+      if (!isDragging)
+        return;
+      isDragging = false;
+      gradientElement?.releasePointerCapture(event.pointerId);
+    }
+    let hueElement = null;
+    let alphaElement = null;
+    let draggingSlider = null;
+    function pointerToFraction(event, element) {
+      const rect = element.getBoundingClientRect();
+      const x = clamp(event.clientX - rect.left, 0, rect.width);
+      return rect.width === 0 ? 0 : x / rect.width;
+    }
+    function handleHuePointerDown(event) {
+      if (disabled || !hueElement)
+        return;
+      event.preventDefault();
+      hueElement.setPointerCapture(event.pointerId);
+      draggingSlider = "hue";
+      const fraction = pointerToFraction(event, hueElement);
+      commitFromHsla({
+        h: fraction * 359,
+        s: saturation,
+        l: lightnessValue,
+        a: alphaValue
+      }, "input");
+    }
+    function handleHuePointerMove(event) {
+      if (draggingSlider !== "hue" || disabled || !hueElement)
+        return;
+      const fraction = pointerToFraction(event, hueElement);
+      commitFromHsla({
+        h: fraction * 359,
+        s: saturation,
+        l: lightnessValue,
+        a: alphaValue
+      }, "input");
+    }
+    function handleHuePointerUp(event) {
+      if (draggingSlider !== "hue")
+        return;
+      draggingSlider = null;
+      hueElement?.releasePointerCapture(event.pointerId);
+      commitCurrentValueChange();
+    }
+    function handleHuePointerCancel(event) {
+      if (draggingSlider !== "hue")
+        return;
+      draggingSlider = null;
+      hueElement?.releasePointerCapture(event.pointerId);
+    }
+    function handleAlphaPointerDown(event) {
+      if (disabled || !alphaElement)
+        return;
+      event.preventDefault();
+      alphaElement.setPointerCapture(event.pointerId);
+      draggingSlider = "alpha";
+      const fraction = pointerToFraction(event, alphaElement);
+      commitFromHsla({ h: hue, s: saturation, l: lightnessValue, a: fraction }, "input");
+    }
+    function handleAlphaPointerMove(event) {
+      if (draggingSlider !== "alpha" || disabled || !alphaElement)
+        return;
+      const fraction = pointerToFraction(event, alphaElement);
+      commitFromHsla({ h: hue, s: saturation, l: lightnessValue, a: fraction }, "input");
+    }
+    function handleAlphaPointerUp(event) {
+      if (draggingSlider !== "alpha")
+        return;
+      draggingSlider = null;
+      alphaElement?.releasePointerCapture(event.pointerId);
+      commitCurrentValueChange();
+    }
+    function handleAlphaPointerCancel(event) {
+      if (draggingSlider !== "alpha")
+        return;
+      draggingSlider = null;
+      alphaElement?.releasePointerCapture(event.pointerId);
+    }
+    function adjustHue(delta) {
+      const next = ((hue + delta) % 360 + 360) % 360;
+      commitFromHsla({ h: next, s: saturation, l: lightnessValue, a: alphaValue }, "change");
+    }
+    function adjustAlpha(delta) {
+      const next = clamp(alphaValue + delta, 0, 1);
+      commitFromHsla({ h: hue, s: saturation, l: lightnessValue, a: next }, "change");
+    }
+    function handleHueKeydown(event) {
+      if (disabled)
+        return;
+      const step = event.shiftKey ? 10 : 1;
+      switch (event.key) {
+        case "ArrowLeft":
+        case "ArrowDown":
+          event.preventDefault();
+          adjustHue(-step);
+          break;
+        case "ArrowRight":
+        case "ArrowUp":
+          event.preventDefault();
+          adjustHue(step);
+          break;
+        case "Home":
+          event.preventDefault();
+          commitFromHsla({ h: 0, s: saturation, l: lightnessValue, a: alphaValue }, "change");
+          break;
+        case "End":
+          event.preventDefault();
+          commitFromHsla({ h: 359, s: saturation, l: lightnessValue, a: alphaValue }, "change");
+          break;
+        case "PageUp":
+          event.preventDefault();
+          adjustHue(36);
+          break;
+        case "PageDown":
+          event.preventDefault();
+          adjustHue(-36);
+          break;
+      }
+    }
+    function handleAlphaKeydown(event) {
+      if (disabled)
+        return;
+      const step = event.shiftKey ? 0.1 : 0.01;
+      switch (event.key) {
+        case "ArrowLeft":
+        case "ArrowDown":
+          event.preventDefault();
+          adjustAlpha(-step);
+          break;
+        case "ArrowRight":
+        case "ArrowUp":
+          event.preventDefault();
+          adjustAlpha(step);
+          break;
+        case "Home":
+          event.preventDefault();
+          commitFromHsla({ h: hue, s: saturation, l: lightnessValue, a: 0 }, "change");
+          break;
+        case "End":
+          event.preventDefault();
+          commitFromHsla({ h: hue, s: saturation, l: lightnessValue, a: 1 }, "change");
+          break;
+        case "PageUp":
+          event.preventDefault();
+          adjustAlpha(0.1);
+          break;
+        case "PageDown":
+          event.preventDefault();
+          adjustAlpha(-0.1);
+          break;
+      }
+    }
+    function handleGradientKeydown(event) {
+      if (disabled)
+        return;
+      const step = event.shiftKey ? 10 : 1;
+      let nextS = saturation;
+      let nextL = lightnessValue;
+      let handled = false;
+      switch (event.key) {
+        case "ArrowLeft":
+          nextS = clamp(saturation - step, 0, 100);
+          handled = true;
+          break;
+        case "ArrowRight":
+          nextS = clamp(saturation + step, 0, 100);
+          handled = true;
+          break;
+        case "ArrowUp":
+          nextL = clamp(lightnessValue + step, 0, 100);
+          handled = true;
+          break;
+        case "ArrowDown":
+          nextL = clamp(lightnessValue - step, 0, 100);
+          handled = true;
+          break;
+      }
+      if (handled) {
+        event.preventDefault();
+        commitFromHsla({ h: hue, s: nextS, l: nextL, a: alphaValue }, "change");
+      }
+    }
+    function normalizeSwatch(swatch) {
+      const parsed = parseToHsla(swatch);
+      if (!parsed)
+        return null;
+      return formatHex(parsed.h, parsed.s, parsed.l, parsed.a, alpha).toLowerCase();
+    }
+    const normalizedSwatchColors = $.derived(() => (swatches ?? []).map((swatch) => ({ color: normalizeSwatch(swatch) ?? swatch })));
+    const currentHex = $.derived(() => formatHex(hue, saturation, lightnessValue, alphaValue, alpha));
+    function handleSwatchChange(selectedColor) {
+      if (disabled)
+        return;
+      const parsed = parseToHsla(selectedColor);
+      if (!parsed)
+        return;
+      commitFromHsla(parsed, "change");
+    }
+    let hiddenInput = null;
+    const hueColor = $.derived(() => `hsl(${hue}, 100%, 50%)`);
+    const previewColor = $.derived(() => internalValue === "" ? "transparent" : alpha ? `hsla(${hue}, ${saturation}%, ${lightnessValue}%, ${alphaValue})` : `hsl(${hue}, ${saturation}%, ${lightnessValue}%)`);
+    const handlePosition = $.derived(() => {
+      const ln = lightnessValue / 100;
+      const sn = saturation / 100;
+      const v = ln + sn * Math.min(ln, 1 - ln);
+      const svFromHsl = v === 0 ? 0 : 2 * (1 - ln / v);
+      return { x: svFromHsl * 100, y: (1 - v) * 100 };
+    });
+    const hueAriaValue = $.derived(() => Math.round(hue));
+    const alphaAriaValue = $.derived(() => Math.round(alphaValue * 100));
+    $$renderer2.push(`<div${$.attr_class($.clsx(classNames("cinder-color-picker", className)))}${$.attr("data-cinder-disabled", disabled ? "" : undefined)}${$.attr("data-cinder-alpha", alpha ? "" : undefined)}${$.attr("aria-label", label)} role="group"${$.attr("id", pickerId)}><div${$.attr("id", gradientId)} role="application" aria-label="Color saturation and lightness. Use a pointer to select; arrow keys provide coarse keyboard adjustment."${$.attr("aria-describedby", previewId)}${$.attr("aria-disabled", disabled ? "true" : undefined)} class="cinder-color-picker__gradient"${$.attr_style(`--cinder-color-picker-hue: ${hueColor()};`)}${$.attr("tabindex", disabled ? -1 : 0)}><div class="cinder-color-picker__gradient-handle"${$.attr_style(`left: ${$.stringify(handlePosition().x)}%; top: ${$.stringify(handlePosition().y)}%;`)} aria-hidden="true"></div></div> <div${$.attr("id", hueId)} role="slider" aria-label="Hue"${$.attr("aria-valuemin", 0)}${$.attr("aria-valuemax", 359)}${$.attr("aria-valuenow", hueAriaValue())}${$.attr("aria-disabled", disabled ? "true" : undefined)}${$.attr("tabindex", disabled ? -1 : 0)} class="cinder-color-picker__hue"><div class="cinder-color-picker__hue-thumb"${$.attr_style(`left: ${$.stringify(hue / 359 * 100)}%;`)} aria-hidden="true"></div></div> `);
+    if (alpha) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<div${$.attr("id", alphaId)} role="slider" aria-label="Alpha"${$.attr("aria-valuemin", 0)}${$.attr("aria-valuemax", 100)}${$.attr("aria-valuenow", alphaAriaValue())}${$.attr("aria-valuetext", `${$.stringify(alphaAriaValue())}%`)}${$.attr("aria-disabled", disabled ? "true" : undefined)}${$.attr("tabindex", disabled ? -1 : 0)} class="cinder-color-picker__alpha"${$.attr_style(`--cinder-color-picker-base: hsl(${$.stringify(hue)}, ${$.stringify(saturation)}%, ${$.stringify(lightnessValue)}%);`)}><div class="cinder-color-picker__alpha-thumb"${$.attr_style(`left: ${$.stringify(alphaValue * 100)}%;`)} aria-hidden="true"></div></div>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> <div class="cinder-color-picker__footer"><div${$.attr("id", previewId)} role="img" class="cinder-color-picker__preview"${$.attr("data-cinder-alpha", alpha ? "" : undefined)}${$.attr("aria-label", internalValue ? `Selected color: ${internalValue}` : "Selected color: none")}${$.attr_style(`--cinder-color-picker-preview: ${previewColor()};`)}></div> <span class="cinder-color-picker__hex-value" aria-hidden="true">${$.escape(internalValue || "—")}</span></div> `);
+    if (normalizedSwatchColors().length > 0) {
+      $$renderer2.push("<!--[0-->");
+      Color_swatch_picker($$renderer2, {
+        colors: normalizedSwatchColors(),
+        value: internalValue !== "" ? currentHex().toLowerCase() : "",
+        label: "Color swatches",
+        size: "sm",
+        disabled,
+        class: "cinder-color-picker__swatches",
+        onchange: handleSwatchChange
+      });
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    if (name) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<input type="hidden"${$.attr("name", name)}${$.attr("value", internalValue)}/>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      $$renderer2.push(`<input type="hidden"${$.attr("value", internalValue)} hidden=""/>`);
+    }
+    $$renderer2.push(`<!--]--></div>`);
+    $.bind_props($$props, { value });
+  }, Color_picker);
+}
+
+// src/components/color-picker/index.ts
+var color_picker_default = Color_picker;
+export { Color_picker, color_picker_default };
+
+//# debugId=7E5B66E2F31225A164756E2164756E21

package/dist/server/index.server-aeexcxdp.js

@@ -0,0 +1,9 @@
+import {
+  Payload_inspector
+} from "./index.server-vt6sn9y4.js";
+
+// src/components/payload-inspector/index.ts
+var payload_inspector_default = Payload_inspector;
+export { payload_inspector_default };
+
+//# debugId=8794D2FF31174F1E64756E2164756E21