@lostgradient/cinder 0.4.0 → 0.5.0

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

@@ -0,0 +1,423 @@
+import {
+  formatNumber
+} from "./index.server-chh0fzxj.js";
+import {
+  getLocaleContext
+} from "./index.server-sz8sxsj6.js";
+import {
+  getFormFieldContext
+} from "./index.server-weae7gs2.js";
+import {
+  resolveFieldControl
+} from "./index.server-abm21gz1.js";
+import {
+  classNames
+} from "./index.server-z7nvkz8v.js";
+
+// src/components/number-input/number-input.svelte
+import * as $ from "svelte/internal/server";
+import { untrack } from "svelte";
+
+// src/utilities/parse-locale-number.ts
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function parseLocaleNumber(text, locale, format) {
+  if (text.trim() === "")
+    return { value: null, status: "empty" };
+  let working = text;
+  const digitFormatter = new Intl.NumberFormat(locale, {
+    useGrouping: false,
+    maximumFractionDigits: 0
+  });
+  for (let d = 0;d <= 9; d++) {
+    const glyph = digitFormatter.format(d);
+    if (glyph !== String(d)) {
+      working = working.split(glyph).join(String(d));
+    }
+  }
+  const sepParts = new Intl.NumberFormat(locale, {
+    useGrouping: true,
+    minimumFractionDigits: 1,
+    maximumFractionDigits: 1
+  }).formatToParts(-12345.6);
+  const groupSep = sepParts.find((p) => p.type === "group")?.value ?? "";
+  const decimalSep = sepParts.find((p) => p.type === "decimal")?.value ?? ".";
+  working = working.replace(/[؜‎‏‪-‮⁦-⁩]/g, "");
+  const localeMinus = sepParts.find((p) => p.type === "minusSign")?.value ?? "-";
+  if (localeMinus !== "-") {
+    working = working.split(localeMinus).join("-");
+  }
+  let isNegativeByFormatAffix = false;
+  if (format) {
+    const positiveAffixValues = new Set(new Intl.NumberFormat(locale, format).formatToParts(0).filter((part) => part.type === "currency" || part.type === "percentSign" || part.type === "literal" || part.type === "unit" || part.type === "compact").map((part) => part.value));
+    const negativeParts = new Intl.NumberFormat(locale, format).formatToParts(-1);
+    const negativeOnlyAffixes = negativeParts.filter((part) => (part.type === "currency" || part.type === "percentSign" || part.type === "literal" || part.type === "unit" || part.type === "compact") && part.value.trim() !== "" && !positiveAffixValues.has(part.value)).map((part) => part.value);
+    isNegativeByFormatAffix = negativeOnlyAffixes.length > 0 && negativeOnlyAffixes.every((part) => working.includes(part));
+    const stripSamples = [0, -1];
+    for (const sample of stripSamples) {
+      const parts = new Intl.NumberFormat(locale, format).formatToParts(sample);
+      for (const part of parts) {
+        if (part.type === "currency" || part.type === "percentSign" || part.type === "literal" || part.type === "unit" || part.type === "compact") {
+          if (part.value)
+            working = working.split(part.value).join("");
+        }
+      }
+    }
+  }
+  if (isNegativeByFormatAffix && !/^[+-]/.test(working)) {
+    working = "-" + working;
+  }
+  working = working.split("%").join("");
+  working = working.replace(/^[\s  ]+|[\s  ]+$/g, "");
+  if (working === "")
+    return { value: null, status: "empty" };
+  const decimalSplit = working.split(decimalSep);
+  if (decimalSplit.length > 2)
+    return { value: null, status: "malformed" };
+  const integerPart = decimalSplit[0] ?? "";
+  const fractionPart = decimalSplit[1];
+  if (groupSep && integerPart.includes(groupSep)) {
+    const probeParts = new Intl.NumberFormat(locale, {
+      useGrouping: true
+    }).formatToParts(12345678);
+    const integerRuns = [];
+    for (const p of probeParts) {
+      if (p.type === "integer")
+        integerRuns.push(p.value);
+    }
+    const primary = integerRuns.length > 0 ? (integerRuns[integerRuns.length - 1] ?? "").length : 3;
+    const secondary = integerRuns.length > 1 ? (integerRuns[integerRuns.length - 2] ?? "").length : primary;
+    const groupEsc = escapeRegex(groupSep);
+    const grouped = new RegExp(`^[+-]?\\d{1,${secondary}}(${groupEsc}\\d{${secondary}})*${groupEsc}\\d{${primary}}$`);
+    if (!grouped.test(integerPart))
+      return { value: null, status: "malformed" };
+  }
+  let normalized = groupSep.length > 0 ? integerPart.split(groupSep).join("") : integerPart;
+  if (fractionPart !== undefined)
+    normalized += "." + fractionPart;
+  if (!/^[+-]?(\d+\.?\d*|\.\d+)$/.test(normalized)) {
+    return { value: null, status: "malformed" };
+  }
+  const parsed = parseFloat(normalized);
+  if (!Number.isFinite(parsed))
+    return { value: null, status: "malformed" };
+  return { value: parsed, status: "valid" };
+}
+
+// src/components/number-input/number-input.svelte
+function Number_input($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      id,
+      defaultValue = null,
+      value = null,
+      min,
+      max,
+      step,
+      format,
+      locale,
+      disabled,
+      required,
+      name,
+      label,
+      description,
+      error,
+      class: className,
+      onchange,
+      onblur: consumerBlur,
+      "aria-describedby": consumerDescribedBy,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    const context = getFormFieldContext();
+    const localeContext = getLocaleContext();
+    let editorBuffer = "";
+    let isFocused = false;
+    let hasMounted = false;
+    let inputElement = undefined;
+    let malformedError = false;
+    let requiredEmptyError = false;
+    untrack(() => {
+      if (value === null && defaultValue !== null) {
+        value = defaultValue;
+      }
+    });
+    const resolvedLocale = $.derived(() => locale ?? localeContext?.locale ?? (hasMounted ? navigator.language : "en-US"));
+    const resolvedMin = $.derived(() => typeof min === "number" && Number.isFinite(min) ? min : -Infinity);
+    const resolvedMax = $.derived(() => typeof max === "number" && Number.isFinite(max) ? max : Infinity);
+    const isValidStep = (s) => typeof s === "number" && Number.isFinite(s) && s > 0;
+    const incrementStep = $.derived(() => isValidStep(step) ? step : 1);
+    const snapStep = $.derived(() => isValidStep(step) ? step : null);
+    const resolvedRequired = $.derived(() => required ?? context?.required ?? false);
+    const resolvedDisabled = $.derived(() => disabled ?? context?.disabled ?? false);
+    function roundToPrecision(n, digits) {
+      return Number(n.toFixed(Math.min(digits, 12)));
+    }
+    function fractionalDigits(n) {
+      if (!Number.isFinite(n))
+        return 0;
+      const s = String(n);
+      if (s.includes("e") || s.includes("E")) {
+        const parts = s.toLowerCase().split("e");
+        const mantissa = parts[0] ?? "";
+        const expStr = parts[1] ?? "0";
+        const exp = Number(expStr);
+        const fracOfMantissa = mantissa.split(".")[1]?.length ?? 0;
+        return Math.max(0, fracOfMantissa - exp);
+      }
+      return s.split(".")[1]?.length ?? 0;
+    }
+    function commit(next, parseStatus, emitChange) {
+      const nextMalformed = !resolvedDisabled() && parseStatus === "malformed";
+      const nextRequiredEmpty = !resolvedDisabled() && !nextMalformed && resolvedRequired() && next === null;
+      if (inputElement) {
+        if (nextMalformed) {
+          inputElement.setCustomValidity("Please enter a valid number.");
+        } else if (nextRequiredEmpty) {
+          inputElement.setCustomValidity("Please enter a number.");
+        } else {
+          inputElement.setCustomValidity("");
+        }
+      }
+      malformedError = nextMalformed;
+      requiredEmptyError = nextRequiredEmpty;
+      if (!Object.is(next, value)) {
+        isInternalValueChange = true;
+        value = next;
+      }
+      if (emitChange) {
+        onchange?.(next);
+      }
+      return next;
+    }
+    function commitFromNumber(source, raw, parseStatus = "valid") {
+      if (raw === null)
+        return commit(null, parseStatus, true);
+      if (!Number.isFinite(raw))
+        return commit(null, "malformed", true);
+      let result = raw;
+      if (source === "typed" && snapStep() !== null) {
+        const origin = Number.isFinite(resolvedMin()) ? resolvedMin() : 0;
+        result = origin + Math.round((raw - origin) / snapStep()) * snapStep();
+        result = roundToPrecision(result, fractionalDigits(snapStep()));
+      } else if (source === "delta" && snapStep() !== null) {
+        const cleanRaw = roundToPrecision(raw, 12);
+        result = roundToPrecision(raw, Math.max(fractionalDigits(snapStep()), fractionalDigits(cleanRaw)));
+      }
+      const clamped = Math.min(resolvedMax(), Math.max(resolvedMin(), result));
+      return commit(clamped, parseStatus, true);
+    }
+    function commitFromText(source, text) {
+      const result = parseLocaleNumber(text, resolvedLocale(), format);
+      if (result.status !== "valid") {
+        return commit(null, result.status, true);
+      }
+      const canonical = format?.style === "percent" ? roundToPrecision(result.value / 100, Math.max(2, fractionalDigits(result.value) + 2)) : result.value;
+      return commitFromNumber(source, canonical, "valid");
+    }
+    let isInternalValueChange = false;
+    let enterKeyFlushed = false;
+    const displayValue = $.derived(() => isFocused ? editorBuffer : malformedError ? editorBuffer : value === null || value === undefined ? "" : formatNumber(value, resolvedLocale(), format));
+    const parentValueSignature = $.derived(() => `${value ?? ""}|${resolvedLocale()}|${JSON.stringify(format ?? null)}`);
+    let lastSeenParentSignature = untrack(() => parentValueSignature());
+    function buildEditDisplay(v) {
+      const editFormat = {
+        ...format,
+        style: "decimal",
+        useGrouping: false,
+        currency: undefined,
+        currencyDisplay: undefined,
+        notation: "standard",
+        compactDisplay: undefined
+      };
+      if (format?.style === "percent") {
+        const asPercent = roundToPrecision(v * 100, 12);
+        return formatNumber(asPercent, resolvedLocale(), editFormat);
+      }
+      return formatNumber(v, resolvedLocale(), editFormat);
+    }
+    function ariaValueNowFromText(text) {
+      const result = parseLocaleNumber(text, resolvedLocale(), format);
+      if (result.status !== "valid")
+        return;
+      return Number.isFinite(result.value) ? result.value : undefined;
+    }
+    const resolvedAriaValueNow = $.derived(() => isFocused ? ariaValueNowFromText(editorBuffer) : value === null || value === undefined ? undefined : format?.style === "percent" ? roundToPrecision(value * 100, 12) : value);
+    const resolvedAriaValueMin = $.derived(() => Number.isFinite(resolvedMin()) ? format?.style === "percent" ? roundToPrecision(resolvedMin() * 100, 12) : resolvedMin() : undefined);
+    const resolvedAriaValueMax = $.derived(() => Number.isFinite(resolvedMax()) ? format?.style === "percent" ? roundToPrecision(resolvedMax() * 100, 12) : resolvedMax() : undefined);
+    function onFocus() {
+      if (!malformedError) {
+        editorBuffer = value === null || value === undefined ? "" : buildEditDisplay(value);
+      }
+      isFocused = true;
+    }
+    function onBlur(event) {
+      const buffered = editorBuffer;
+      isFocused = false;
+      commitFromText("typed", buffered);
+      consumerBlur?.(event);
+    }
+    function onInput(event) {
+      editorBuffer = event.currentTarget.value;
+      if (malformedError) {
+        malformedError = false;
+        inputElement?.setCustomValidity("");
+      }
+    }
+    function getBaseForStep(direction) {
+      const parsed = isFocused ? parseLocaleNumber(editorBuffer, resolvedLocale(), format) : null;
+      let baseFromDisplay = null;
+      if (parsed && parsed.status === "valid") {
+        baseFromDisplay = format?.style === "percent" ? roundToPrecision(parsed.value / 100, Math.max(2, fractionalDigits(parsed.value) + 2)) : parsed.value;
+      }
+      const defaultStart = direction === "increment" ? Number.isFinite(resolvedMin()) ? resolvedMin() : 0 : Number.isFinite(resolvedMax()) ? resolvedMax() : 0;
+      return baseFromDisplay ?? value ?? defaultStart;
+    }
+    function stepBy(direction, multiplier = 1) {
+      const base = getBaseForStep(direction);
+      const delta = incrementStep() * multiplier * (direction === "increment" ? 1 : -1);
+      const next = commitFromNumber("delta", base + delta);
+      if (isFocused) {
+        editorBuffer = next === null ? "" : buildEditDisplay(next);
+      }
+      inputElement?.focus();
+    }
+    function onKeyDown(event) {
+      if (resolvedDisabled())
+        return;
+      switch (event.key) {
+        case "ArrowUp":
+          event.preventDefault();
+          stepBy("increment");
+          break;
+        case "ArrowDown":
+          event.preventDefault();
+          stepBy("decrement");
+          break;
+        case "PageUp":
+          event.preventDefault();
+          stepBy("increment", 10);
+          break;
+        case "PageDown":
+          event.preventDefault();
+          stepBy("decrement", 10);
+          break;
+        case "Home":
+          if (Number.isFinite(resolvedMin())) {
+            event.preventDefault();
+            const homeNext = commitFromNumber("delta", resolvedMin());
+            if (isFocused)
+              editorBuffer = homeNext === null ? "" : buildEditDisplay(homeNext);
+          }
+          break;
+        case "End":
+          if (Number.isFinite(resolvedMax())) {
+            event.preventDefault();
+            const endNext = commitFromNumber("delta", resolvedMax());
+            if (isFocused)
+              editorBuffer = endNext === null ? "" : buildEditDisplay(endNext);
+          }
+          break;
+        case "Enter": {
+          event.preventDefault();
+          commitFromText("typed", isFocused ? editorBuffer : "");
+          const form = inputElement?.closest("form");
+          if (form) {
+            if (form.checkValidity()) {
+              enterKeyFlushed = true;
+              form.requestSubmit();
+            } else {
+              form.reportValidity();
+            }
+          }
+          break;
+        }
+      }
+    }
+    const internalErrorMessage = $.derived(() => !error && malformedError ? "Please enter a valid number." : !error && requiredEmptyError ? "Please enter a number." : null);
+    const internalErrorId = $.derived(() => internalErrorMessage() ? `${id}-internal-error` : undefined);
+    const internalInvalid = $.derived(() => malformedError || requiredEmptyError ? "true" : undefined);
+    const field = $.derived(() => resolveFieldControl({
+      id,
+      generatedId: id,
+      context,
+      hasDescription: !!description,
+      hasError: !!error,
+      localIdNamespace: "number-input",
+      consumerDescribedBy,
+      consumerInvalid: internalInvalid() ?? rest["aria-invalid"],
+      additionalDescribedBy: [internalErrorId()],
+      required,
+      disabled
+    }));
+    const ownDescriptionId = $.derived(() => field().ownDescriptionId);
+    const ownErrorId = $.derived(() => field().ownErrorId);
+    const describedBy = $.derived(() => field().describedBy);
+    const resolvedAriaInvalid = $.derived(() => field().ariaInvalid);
+    const incrementDisabled = $.derived(() => resolvedDisabled() || value !== null && value !== undefined && value >= resolvedMax());
+    const decrementDisabled = $.derived(() => resolvedDisabled() || value !== null && value !== undefined && value <= resolvedMin());
+    const showHiddenInput = $.derived(() => typeof name === "string" && name.length > 0 && !resolvedDisabled());
+    const stepperLabelSuffix = $.derived(() => label ? ` ${label} by ${incrementStep()}` : ` by ${incrementStep()}`);
+    $$renderer2.push(`<div${$.attr_class($.clsx(classNames("cinder-input-field", className)))}>`);
+    if (label) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<label${$.attr("for", id)} class="cinder-input-field__label"${$.attr("data-disabled", resolvedDisabled() || undefined)}>${$.escape(label)} `);
+      if (resolvedRequired()) {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`<span class="cinder-_required-marker" aria-hidden="true">*</span>`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--></label>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> <div class="cinder-number-input"${$.attr("data-disabled", resolvedDisabled() ? "" : undefined)}><input${$.attributes({
+      id,
+      type: "text",
+      role: "spinbutton",
+      inputmode: "decimal",
+      value: displayValue(),
+      disabled: resolvedDisabled(),
+      required: resolvedRequired(),
+      class: "cinder-input cinder-number-input__input",
+      ...rest,
+      "aria-invalid": resolvedAriaInvalid(),
+      "aria-describedby": describedBy(),
+      "aria-valuenow": resolvedAriaValueNow(),
+      "aria-valuemin": resolvedAriaValueMin(),
+      "aria-valuemax": resolvedAriaValueMax()
+    }, undefined, undefined, undefined, 4)}/> <button type="button" class="cinder-number-input__stepper cinder-number-input__stepper--increment"${$.attr("aria-label", `Increment${stepperLabelSuffix()}`)}${$.attr("disabled", incrementDisabled(), true)} tabindex="-1"><span aria-hidden="true">+</span></button> <button type="button" class="cinder-number-input__stepper cinder-number-input__stepper--decrement"${$.attr("aria-label", `Decrement${stepperLabelSuffix()}`)}${$.attr("disabled", decrementDisabled(), true)} tabindex="-1"><span aria-hidden="true">−</span></button></div> `);
+    if (showHiddenInput()) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<input type="hidden"${$.attr("name", name)}${$.attr("value", value === null || value === undefined ? "" : String(value))}/>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    if (description) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<p${$.attr("id", ownDescriptionId())} class="cinder-input-field__description">${$.escape(description)}</p>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    if (error) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<p${$.attr("id", ownErrorId())} class="cinder-input-field__error" aria-live="polite">${$.escape(error)}</p>`);
+    } else if (internalErrorMessage()) {
+      $$renderer2.push("<!--[1-->");
+      $$renderer2.push(`<p${$.attr("id", internalErrorId())} class="cinder-input-field__error" aria-live="polite">${$.escape(internalErrorMessage())}</p>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></div>`);
+    $.bind_props($$props, { value });
+  }, Number_input);
+}
+
+export { Number_input };
+
+//# debugId=70629DBB54F006F464756E2164756E21

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

@@ -0,0 +1,29 @@
+import {
+  classNames
+} from "./index.server-z7nvkz8v.js";
+
+// src/components/spinner/spinner.svelte
+import * as $ from "svelte/internal/server";
+function Spinner($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const {
+      size = "md",
+      label = "Loading",
+      class: className,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    $$renderer2.push(`<span${$.attributes({
+      ...rest,
+      class: $.clsx(classNames("cinder-spinner", className)),
+      role: "status",
+      "aria-label": label,
+      "data-cinder-size": size
+    })}><span class="cinder-spinner__sr-only">${$.escape(label)}</span></span>`);
+  }, Spinner);
+}
+
+export { Spinner };
+
+//# debugId=0B7C13107FD500AB64756E2164756E21

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

@@ -0,0 +1,22 @@
+import {
+  setTableSectionContext
+} from "./index.server-7pdq2w0a.js";
+import {
+  classNames
+} from "./index.server-z7nvkz8v.js";
+
+// src/components/table-body/table-body.svelte
+import * as $ from "svelte/internal/server";
+function Table_body($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { class: className, children } = $$props;
+    setTableSectionContext("body");
+    $$renderer2.push(`<tbody${$.attr_class($.clsx(classNames("cinder-table__body", className)))}>`);
+    children($$renderer2);
+    $$renderer2.push(`<!----></tbody>`);
+  }, Table_body);
+}
+
+export { Table_body };
+
+//# debugId=40FBE024F7CD324664756E2164756E21

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

@@ -0,0 +1,85 @@
+// src/_internal/chart/heatmap-utilities.ts
+function toFiniteOrNull(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function heatmapDomain(values) {
+  let min = Infinity;
+  let max = -Infinity;
+  let count = 0;
+  for (const value of values) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+      if (value < min)
+        min = value;
+      if (value > max)
+        max = value;
+      count += 1;
+    }
+  }
+  if (count === 0)
+    return { min: 0, max: 1, isEmpty: true };
+  return { min, max, isEmpty: false };
+}
+function heatmapDomainOfRows(rows) {
+  let min = Infinity;
+  let max = -Infinity;
+  let count = 0;
+  for (const row of rows) {
+    for (const value of row) {
+      if (typeof value === "number" && Number.isFinite(value)) {
+        if (value < min)
+          min = value;
+        if (value > max)
+          max = value;
+        count += 1;
+      }
+    }
+  }
+  if (count === 0)
+    return { min: 0, max: 1, isEmpty: true };
+  return { min, max, isEmpty: false };
+}
+function normalizeHeatmapValue(value, domain, scale = "sequential") {
+  if (!Number.isFinite(value))
+    return 0.5;
+  if (scale === "diverging") {
+    const bound = Math.max(Math.abs(domain.min), Math.abs(domain.max));
+    if (bound === 0)
+      return 0.5;
+    return clamp01(0.5 + value / (2 * bound));
+  }
+  const range = domain.max - domain.min;
+  if (range === 0)
+    return 0.5;
+  return clamp01((value - domain.min) / range);
+}
+function clamp01(value) {
+  if (value < 0)
+    return 0;
+  if (value > 1)
+    return 1;
+  return value;
+}
+function heatmapCellFill(value, domain, scale = "sequential") {
+  if (value === null)
+    return "var(--cinder-surface-inset)";
+  const normalized = normalizeHeatmapValue(value, domain, scale);
+  if (scale === "diverging") {
+    if (normalized < 0.5) {
+      const ratio2 = (0.5 - normalized) * 2;
+      return `color-mix(in oklch, var(--cinder-chart-series-5) ${Math.round(ratio2 * 100)}%, var(--cinder-surface-inset))`;
+    }
+    const ratio = (normalized - 0.5) * 2;
+    return `color-mix(in oklch, var(--cinder-chart-series-3) ${Math.round(ratio * 100)}%, var(--cinder-surface-inset))`;
+  }
+  return `color-mix(in oklch, var(--cinder-chart-series-1) ${Math.round(normalized * 100)}%, var(--cinder-surface-inset))`;
+}
+function heatmapLabelFill(value, domain, scale = "sequential") {
+  if (value === null)
+    return "var(--cinder-text-muted)";
+  const intensity = scale === "diverging" ? Math.abs(normalizeHeatmapValue(value, domain, scale) - 0.5) * 2 : normalizeHeatmapValue(value, domain, scale);
+  return intensity > 0.5 ? "var(--cinder-surface)" : "var(--cinder-text)";
+}
+
+export { toFiniteOrNull, heatmapDomain, heatmapDomainOfRows, heatmapCellFill, heatmapLabelFill };
+
+//# debugId=54D46247831791CC64756E2164756E21

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

@@ -0,0 +1,31 @@
+import {
+  tryGetSideNavigationGroupContext
+} from "./index.server-amfq2v2p.js";
+import {
+  Navigation_item
+} from "./index.server-jnyznmzv.js";
+import {
+  classNames
+} from "./index.server-z7nvkz8v.js";
+
+// src/components/side-navigation-item/side-navigation-item.svelte
+import * as $ from "svelte/internal/server";
+function Side_navigation_item($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const { $$slots, $$events, ...props } = $$props;
+    const active = $.derived(() => props.active ?? false);
+    const navigationItemProps = $.derived(() => {
+      const { listItemClass: _omit, ...rest } = props;
+      return rest;
+    });
+    const group = tryGetSideNavigationGroupContext();
+    let handle;
+    $$renderer2.push(`<li${$.attr_class($.clsx(classNames("cinder-side-navigation__item", props.listItemClass)))}>`);
+    Navigation_item($$renderer2, $.spread_props([navigationItemProps(), { variant: "vertical" }]));
+    $$renderer2.push(`<!----></li>`);
+  }, Side_navigation_item);
+}
+
+export { Side_navigation_item };
+
+//# debugId=11408E6CF987622664756E2164756E21

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

@@ -0,0 +1,56 @@
+import {
+  classNames
+} from "./index.server-z7nvkz8v.js";
+
+// src/components/typography/typography.svelte
+import * as $ from "svelte/internal/server";
+function Typography($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      variant = "body1",
+      component,
+      gutterBottom = false,
+      noWrap = false,
+      class: className,
+      children,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    const defaultElements = {
+      h1: "h1",
+      h2: "h2",
+      h3: "h3",
+      h4: "h4",
+      h5: "h5",
+      h6: "h6",
+      subtitle1: "p",
+      subtitle2: "p",
+      body1: "p",
+      body2: "p",
+      caption: "span",
+      overline: "span",
+      label: "span"
+    };
+    const resolvedVariant = $.derived(() => Object.hasOwn(defaultElements, variant) ? variant : "body1");
+    const resolvedTag = $.derived(() => component ?? defaultElements[resolvedVariant()]);
+    $.element($$renderer2, resolvedTag(), () => {
+      $$renderer2.push(`${$.attributes({
+        ...rest,
+        class: $.clsx(classNames("cinder-typography", className)),
+        "data-cinder-variant": resolvedVariant(),
+        "data-cinder-gutter": gutterBottom ? "" : undefined,
+        "data-cinder-nowrap": noWrap ? "" : undefined
+      })}`);
+    }, () => {
+      children($$renderer2);
+      $$renderer2.push(`<!---->`);
+    });
+  }, Typography);
+}
+
+// src/components/typography/index.ts
+var typography_default = Typography;
+export { Typography, typography_default };
+
+//# debugId=978FF8DE08143C8C64756E2164756E21