@lostgradient/cinder 0.2.0 → 0.4.0

package/dist/server/components/schema-form/index.js

@@ -0,0 +1,1984 @@
+import { createRequire } from "node:module";
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/components/schema-form/schema-form.svelte
+import * as $7 from "svelte/internal/server";
+
+// src/components/schema-form/schema-form-body.svelte
+import * as $6 from "svelte/internal/server";
+import { tick } from "svelte";
+
+// src/utilities/class-names.ts
+function classNames(...parts) {
+  return parts.filter((part) => typeof part === "string" && part.length > 0).join(" ");
+}
+
+// src/components/checkbox/checkbox.svelte
+import * as $ from "svelte/internal/server";
+
+// src/_internal/field-control.ts
+function describeId(fieldId, hasDescription) {
+  return hasDescription ? `${fieldId}-description` : undefined;
+}
+function errorId(fieldId, hasError) {
+  return hasError ? `${fieldId}-error` : undefined;
+}
+function composeDescribedBy(...ids) {
+  const filtered = ids.flatMap((id) => typeof id === "string" ? id.trim().split(/\s+/).filter(Boolean) : []);
+  const unique = Array.from(new Set(filtered));
+  return unique.length > 0 ? unique.join(" ") : undefined;
+}
+function ariaInvalid(hasError) {
+  return hasError ? "true" : undefined;
+}
+function resolveFieldControl(input) {
+  const resolvedId = input.id ?? input.context?.controlId ?? input.generatedId;
+  const defaultDescriptionId = describeId(resolvedId, input.hasDescription ?? false);
+  const defaultErrorId = errorId(resolvedId, input.hasError ?? false);
+  const ownDescriptionId = defaultDescriptionId && defaultDescriptionId === input.context?.descriptionId && input.localIdNamespace ? `${resolvedId}-${input.localIdNamespace}-description` : defaultDescriptionId;
+  const ownErrorId = defaultErrorId && defaultErrorId === input.context?.errorId && input.localIdNamespace ? `${resolvedId}-${input.localIdNamespace}-error` : defaultErrorId;
+  const descriptionId = ownDescriptionId ?? input.context?.descriptionId;
+  const resolvedErrorId = ownErrorId ?? input.context?.errorId;
+  const explicitInvalid = ariaInvalid(input.hasError ?? false);
+  const consumerInvalid = input.consumerInvalid === true ? "true" : input.consumerInvalid === false ? undefined : input.consumerInvalid ?? undefined;
+  return {
+    id: resolvedId,
+    ownDescriptionId,
+    ownErrorId,
+    descriptionId,
+    errorId: resolvedErrorId,
+    describedBy: composeDescribedBy(descriptionId, ...input.additionalDescribedBy ?? [], resolvedErrorId, input.context?.describedBy, input.consumerDescribedBy),
+    ariaInvalid: explicitInvalid ?? input.context?.invalid ?? consumerInvalid,
+    required: input.required ?? input.context?.required ?? false,
+    disabled: input.disabled ?? input.context?.disabled ?? false
+  };
+}
+
+// src/_internal/form-field-context.ts
+import { createContext } from "svelte";
+
+// src/_internal/optional-context.ts
+function optionalContext(getStrict) {
+  return () => {
+    try {
+      return getStrict();
+    } catch {
+      return;
+    }
+  };
+}
+
+// src/_internal/form-field-context.ts
+var [getFormFieldContextStrict, setFormFieldContextRaw] = createContext();
+function setFormFieldContext(context) {
+  setFormFieldContextRaw(context);
+}
+var getFormFieldContext = optionalContext(getFormFieldContextStrict);
+
+// ../../node_modules/esm-env/false.js
+var false_default = false;
+// ../../node_modules/esm-env/true.js
+var true_default = true;
+// src/utilities/dev-warn.ts
+function devWarn(message, ...args) {
+  if (!true_default)
+    return;
+  console.warn(message, ...args);
+}
+
+// src/utilities/value-change.ts
+function commitValue(proposed, onValueChange, setValue) {
+  const committed = onValueChange?.(proposed) ?? proposed;
+  setValue(committed);
+  return committed;
+}
+
+// src/components/checkbox/checkbox.svelte
+function Checkbox($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const generatedId = $.props_id($$renderer2);
+    let {
+      id,
+      checked = false,
+      onValueChange,
+      indeterminate = false,
+      label,
+      description,
+      error,
+      disabled,
+      required,
+      class: className,
+      "aria-describedby": consumerDescribedBy,
+      "aria-invalid": consumerInvalid,
+      onchange: consumerOnchange,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    const context = getFormFieldContext();
+    const field = $.derived(() => resolveFieldControl({
+      ...id !== undefined ? { id } : {},
+      generatedId,
+      context,
+      hasDescription: !!description,
+      hasError: !!error,
+      localIdNamespace: "checkbox",
+      consumerDescribedBy,
+      consumerInvalid,
+      disabled,
+      required: required ?? undefined
+    }));
+    let inputElement = undefined;
+    let resetSyncTimeout;
+    function syncCheckedAfterFormReset() {
+      if (resetSyncTimeout !== undefined)
+        clearTimeout(resetSyncTimeout);
+      resetSyncTimeout = setTimeout(() => {
+        resetSyncTimeout = undefined;
+        if (!inputElement)
+          return;
+        checked = inputElement.checked;
+        inputElement.indeterminate = indeterminate && !inputElement.checked;
+      }, 0);
+    }
+    function handleChange(event) {
+      const target = event.currentTarget;
+      const committed = commitValue(target.checked, onValueChange, (next) => {
+        checked = next;
+      });
+      target.checked = committed;
+      target.indeterminate = indeterminate && !committed;
+      consumerOnchange?.(event);
+    }
+    $$renderer2.push(`<div class="cinder-checkbox-field"><div class="cinder-checkbox-row"><span class="cinder-checkbox-field__control"><input${$.attributes({
+      id: field().id,
+      type: "checkbox",
+      ...rest,
+      disabled: field().disabled,
+      required: field().required,
+      checked,
+      class: $.clsx(classNames("cinder-checkbox", className)),
+      "aria-invalid": field().ariaInvalid,
+      "aria-describedby": field().describedBy
+    }, undefined, undefined, undefined, 4)}/> <span class="cinder-checkbox-field__indicator" aria-hidden="true"></span></span> `);
+    if (label) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<label${$.attr("for", field().id)} class="cinder-checkbox-field__label"${$.attr("data-disabled", field().disabled || undefined)}>${$.escape(label)} `);
+      if (field().required) {
+        $$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> `);
+    if (description) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<p${$.attr("id", field().ownDescriptionId)} class="cinder-checkbox-field__description">${$.escape(description)}</p>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    if (error) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<p${$.attr("id", field().ownErrorId)} class="cinder-checkbox-field__error" aria-live="polite">${$.escape(error)}</p>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></div>`);
+    $.bind_props($$props, { checked, indeterminate });
+  });
+}
+
+// src/components/input/input.svelte
+import * as $2 from "svelte/internal/server";
+function calendarIcon($$renderer) {
+  $$renderer.push(`<svg aria-hidden="true" xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="4" width="18" height="18" rx="2" ry="2"></rect><line x1="16" y1="2" x2="16" y2="6"></line><line x1="8" y1="2" x2="8" y2="6"></line><line x1="3" y1="10" x2="21" y2="10"></line></svg>`);
+}
+function Input($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      id,
+      value = "",
+      onValueChange,
+      label,
+      description,
+      error,
+      disabled,
+      required,
+      type = "text",
+      class: className,
+      leading,
+      trailing,
+      leadingInteractive = false,
+      trailingInteractive = false,
+      "aria-describedby": consumerDescribedBy,
+      "aria-invalid": consumerInvalid,
+      oninput: consumerOninput,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    const context = getFormFieldContext();
+    const field = $2.derived(() => resolveFieldControl({
+      id,
+      generatedId: id,
+      context,
+      hasDescription: !!description,
+      hasError: !!error,
+      localIdNamespace: "input",
+      consumerDescribedBy,
+      consumerInvalid,
+      required,
+      disabled
+    }));
+    const ownDescriptionId = $2.derived(() => field().ownDescriptionId);
+    const ownErrorId = $2.derived(() => field().ownErrorId);
+    const describedBy = $2.derived(() => field().describedBy);
+    const resolvedAriaInvalid = $2.derived(() => field().ariaInvalid);
+    const resolvedRequired = $2.derived(() => field().required);
+    const resolvedDisabled = $2.derived(() => field().disabled);
+    const isNativeDateInput = $2.derived(() => type === "date");
+    const rendersNativeDateIcon = $2.derived(() => isNativeDateInput() && !trailing);
+    const hasTrailing = $2.derived(() => !!trailing || isNativeDateInput());
+    const hasGroupWrapper = $2.derived(() => !!leading || hasTrailing());
+    const isInvalid = $2.derived(() => resolvedAriaInvalid() === "true");
+    let inputNode = undefined;
+    let resetSyncTimeout;
+    function syncValueAfterFormReset() {
+      if (resetSyncTimeout !== undefined)
+        clearTimeout(resetSyncTimeout);
+      resetSyncTimeout = setTimeout(() => {
+        resetSyncTimeout = undefined;
+        if (inputNode)
+          value = inputNode.value;
+      }, 0);
+    }
+    function handleInput(event) {
+      const target = event.currentTarget;
+      const committed = commitValue(target.value, onValueChange, (next) => {
+        value = next;
+      });
+      target.value = committed;
+      consumerOninput?.(event);
+    }
+    function inputElement($$renderer3) {
+      $$renderer3.push(`<input${$2.attributes({
+        id,
+        type,
+        ...rest,
+        disabled: resolvedDisabled(),
+        required: resolvedRequired(),
+        value,
+        class: $2.clsx(classNames("cinder-input", className)),
+        "data-cinder-native-date": rendersNativeDateIcon() ? "" : undefined,
+        "aria-invalid": resolvedAriaInvalid(),
+        "aria-describedby": describedBy()
+      }, undefined, undefined, undefined, 4)}/>`);
+    }
+    $$renderer2.push(`<div class="cinder-input-field">`);
+    if (label) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<label${$2.attr("for", id)} class="cinder-input-field__label"${$2.attr("data-disabled", resolvedDisabled() || undefined)}>${$2.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(`<!--]--> `);
+    if (hasGroupWrapper()) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<div class="cinder-input-group"${$2.attr("data-leading", leading ? "" : undefined)}${$2.attr("data-trailing", hasTrailing() ? "" : undefined)}${$2.attr("data-native-date", rendersNativeDateIcon() ? "" : undefined)}${$2.attr("data-disabled", resolvedDisabled() ? "" : undefined)}${$2.attr("data-invalid", isInvalid() ? "" : undefined)}>`);
+      if (leading) {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`<span class="cinder-input-group__leading cinder-_truncate"${$2.attr("aria-hidden", leadingInteractive ? undefined : "true")}>`);
+        leading($$renderer2);
+        $$renderer2.push(`<!----></span>`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--> `);
+      inputElement($$renderer2);
+      $$renderer2.push(`<!----> `);
+      if (trailing) {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`<span class="cinder-input-group__trailing cinder-_truncate"${$2.attr("aria-hidden", trailingInteractive ? undefined : "true")}>`);
+        trailing($$renderer2);
+        $$renderer2.push(`<!----></span>`);
+      } else if (rendersNativeDateIcon()) {
+        $$renderer2.push("<!--[1-->");
+        $$renderer2.push(`<span class="cinder-input-group__trailing cinder-input-group__date-icon cinder-_truncate" aria-hidden="true">`);
+        calendarIcon($$renderer2);
+        $$renderer2.push(`<!----></span>`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--></div>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      inputElement($$renderer2);
+    }
+    $$renderer2.push(`<!--]--> `);
+    if (description) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<p${$2.attr("id", ownDescriptionId())} class="cinder-input-field__description">${$2.escape(description)}</p>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    if (error) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<p${$2.attr("id", ownErrorId())} class="cinder-input-field__error" aria-live="polite">${$2.escape(error)}</p>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></div>`);
+    $2.bind_props($$props, { value });
+  });
+}
+
+// src/components/number-input/number-input.svelte
+import * as $3 from "svelte/internal/server";
+import { untrack } from "svelte";
+
+// src/_internal/locale-context.ts
+import { createContext as createContext2 } from "svelte";
+var [getLocaleContextStrict, setLocaleContextRaw] = createContext2();
+function setLocaleContext(context) {
+  setLocaleContextRaw(context);
+}
+var getLocaleContext = optionalContext(getLocaleContextStrict);
+
+// src/utilities/format-number.ts
+function formatNumber(value, locale = "en-US", options) {
+  return new Intl.NumberFormat(locale, options).format(value);
+}
+
+// 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 = $3.derived(() => locale ?? localeContext?.locale ?? (hasMounted ? navigator.language : "en-US"));
+    const resolvedMin = $3.derived(() => typeof min === "number" && Number.isFinite(min) ? min : -Infinity);
+    const resolvedMax = $3.derived(() => typeof max === "number" && Number.isFinite(max) ? max : Infinity);
+    const isValidStep = (s) => typeof s === "number" && Number.isFinite(s) && s > 0;
+    const incrementStep = $3.derived(() => isValidStep(step) ? step : 1);
+    const snapStep = $3.derived(() => isValidStep(step) ? step : null);
+    const resolvedRequired = $3.derived(() => required ?? context?.required ?? false);
+    const resolvedDisabled = $3.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 = $3.derived(() => isFocused ? editorBuffer : malformedError ? editorBuffer : value === null || value === undefined ? "" : formatNumber(value, resolvedLocale(), format));
+    const parentValueSignature = $3.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 = $3.derived(() => isFocused ? ariaValueNowFromText(editorBuffer) : value === null || value === undefined ? undefined : format?.style === "percent" ? roundToPrecision(value * 100, 12) : value);
+    const resolvedAriaValueMin = $3.derived(() => Number.isFinite(resolvedMin()) ? format?.style === "percent" ? roundToPrecision(resolvedMin() * 100, 12) : resolvedMin() : undefined);
+    const resolvedAriaValueMax = $3.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 = $3.derived(() => !error && malformedError ? "Please enter a valid number." : !error && requiredEmptyError ? "Please enter a number." : null);
+    const internalErrorId = $3.derived(() => internalErrorMessage() ? `${id}-internal-error` : undefined);
+    const internalInvalid = $3.derived(() => malformedError || requiredEmptyError ? "true" : undefined);
+    const field = $3.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 = $3.derived(() => field().ownDescriptionId);
+    const ownErrorId = $3.derived(() => field().ownErrorId);
+    const describedBy = $3.derived(() => field().describedBy);
+    const resolvedAriaInvalid = $3.derived(() => field().ariaInvalid);
+    const incrementDisabled = $3.derived(() => resolvedDisabled() || value !== null && value !== undefined && value >= resolvedMax());
+    const decrementDisabled = $3.derived(() => resolvedDisabled() || value !== null && value !== undefined && value <= resolvedMin());
+    const showHiddenInput = $3.derived(() => typeof name === "string" && name.length > 0 && !resolvedDisabled());
+    const stepperLabelSuffix = $3.derived(() => label ? ` ${label} by ${incrementStep()}` : ` by ${incrementStep()}`);
+    $$renderer2.push(`<div${$3.attr_class($3.clsx(classNames("cinder-input-field", className)))}>`);
+    if (label) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<label${$3.attr("for", id)} class="cinder-input-field__label"${$3.attr("data-disabled", resolvedDisabled() || undefined)}>${$3.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"${$3.attr("data-disabled", resolvedDisabled() ? "" : undefined)}><input${$3.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"${$3.attr("aria-label", `Increment${stepperLabelSuffix()}`)}${$3.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"${$3.attr("aria-label", `Decrement${stepperLabelSuffix()}`)}${$3.attr("disabled", decrementDisabled(), true)} tabindex="-1"><span aria-hidden="true">−</span></button></div> `);
+    if (showHiddenInput()) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<input type="hidden"${$3.attr("name", name)}${$3.attr("value", value === null || value === undefined ? "" : String(value))}/>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    if (description) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<p${$3.attr("id", ownDescriptionId())} class="cinder-input-field__description">${$3.escape(description)}</p>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    if (error) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<p${$3.attr("id", ownErrorId())} class="cinder-input-field__error" aria-live="polite">${$3.escape(error)}</p>`);
+    } else if (internalErrorMessage()) {
+      $$renderer2.push("<!--[1-->");
+      $$renderer2.push(`<p${$3.attr("id", internalErrorId())} class="cinder-input-field__error" aria-live="polite">${$3.escape(internalErrorMessage())}</p>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></div>`);
+    $3.bind_props($$props, { value });
+  });
+}
+
+// src/components/select/select.svelte
+import * as $4 from "svelte/internal/server";
+function Select($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      id,
+      value = undefined,
+      options,
+      label,
+      description,
+      error,
+      required,
+      disabled,
+      class: className,
+      "aria-describedby": consumerDescribedBy,
+      "aria-invalid": consumerInvalid,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    const context = getFormFieldContext();
+    const field = $4.derived(() => resolveFieldControl({
+      id,
+      generatedId: id,
+      context,
+      hasDescription: !!description,
+      hasError: !!error,
+      localIdNamespace: "select",
+      consumerDescribedBy,
+      consumerInvalid,
+      required,
+      disabled
+    }));
+    const stableLocalErrorId = $4.derived(() => context?.errorId === `${field().id}-error` ? `${field().id}-select-error` : `${field().id}-error`);
+    $$renderer2.push(`<div${$4.attr_class($4.clsx(classNames("cinder-select-field", className)))}>`);
+    if (label) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<label${$4.attr("for", id)} class="cinder-select-field__label"${$4.attr("data-disabled", field().disabled || undefined)}>${$4.escape(label)} `);
+      if (field().required) {
+        $$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(`<!--]--> <span class="cinder-select-field__control">`);
+    if (options.length === 0) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.select({
+        id,
+        class: "cinder-_input-frame cinder-select",
+        disabled: field().disabled,
+        required: field().required,
+        "data-cinder-empty": "true",
+        ...rest,
+        "aria-describedby": field().describedBy,
+        "aria-invalid": field().ariaInvalid
+      }, ($$renderer3) => {});
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      $$renderer2.select({
+        id,
+        class: "cinder-_input-frame cinder-select",
+        disabled: field().disabled,
+        required: field().required,
+        value,
+        ...rest,
+        "aria-describedby": field().describedBy,
+        "aria-invalid": field().ariaInvalid
+      }, ($$renderer3) => {
+        $$renderer3.push(`<!--[-->`);
+        const each_array = $4.ensure_array_like(options);
+        for (let $$index = 0, $$length = each_array.length;$$index < $$length; $$index++) {
+          let option = each_array[$$index];
+          $$renderer3.option({ value: option.value, disabled: option.disabled }, ($$renderer4) => {
+            $$renderer4.push(`${$4.escape(option.label)}`);
+          });
+        }
+        $$renderer3.push(`<!--]-->`);
+      });
+    }
+    $$renderer2.push(`<!--]--> <span class="cinder-select-field__chevron" aria-hidden="true"></span></span> `);
+    if (description) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<p${$4.attr("id", field().ownDescriptionId)} class="cinder-select-field__description">${$4.escape(description)}</p>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> <p${$4.attr("id", field().ownErrorId ?? stableLocalErrorId())} class="cinder-select-field__error" aria-live="polite"${$4.attr("data-cinder-error", !!error || undefined)}>${$4.escape(error ?? "")}</p></div>`);
+    $4.bind_props($$props, { value });
+  });
+}
+
+// src/components/textarea/textarea.svelte
+import * as $5 from "svelte/internal/server";
+
+// src/components/textarea-count.ts
+function resolveMaximumLength(value) {
+  if (typeof value === "number") {
+    return Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!/^\d+$/.test(trimmed))
+      return;
+    const parsed = Number(trimmed);
+    return parsed >= 0 && Number.isSafeInteger(parsed) ? parsed : undefined;
+  }
+  return;
+}
+
+// src/components/textarea/textarea.svelte
+function Textarea($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      id,
+      value = "",
+      label,
+      description,
+      error,
+      rows = 4,
+      disabled,
+      required,
+      class: customClassName,
+      maxlength,
+      showCount = false,
+      "aria-describedby": consumerDescribedBy,
+      "aria-invalid": consumerInvalid,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    const context = getFormFieldContext();
+    const maximumLength = $5.derived(() => resolveMaximumLength(maxlength));
+    const countId = $5.derived(() => showCount && maximumLength() !== undefined ? `${id}-count` : undefined);
+    const currentCount = $5.derived(() => value?.length ?? 0);
+    const ownRequired = $5.derived(() => required ?? undefined);
+    const field = $5.derived(() => resolveFieldControl({
+      id,
+      generatedId: id,
+      context,
+      hasDescription: !!description,
+      hasError: !!error,
+      localIdNamespace: "textarea",
+      consumerDescribedBy,
+      consumerInvalid,
+      additionalDescribedBy: [countId()],
+      required: ownRequired(),
+      disabled
+    }));
+    $$renderer2.push(`<div class="cinder-textarea-field">`);
+    if (label) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<label${$5.attr("for", id)} class="cinder-textarea-label"${$5.attr("data-disabled", field().disabled || undefined)}>${$5.escape(label)} `);
+      if (field().required) {
+        $$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(`<!--]--> <textarea${$5.attributes({
+      id,
+      rows,
+      disabled: field().disabled,
+      required: field().required,
+      maxlength,
+      class: $5.clsx(classNames("cinder-_input-frame", "cinder-textarea", customClassName)),
+      "aria-invalid": field().ariaInvalid,
+      "aria-describedby": field().describedBy,
+      ...rest
+    })}>`);
+    const $$body = $5.escape(value);
+    if ($$body) {
+      $$renderer2.push(`${$$body}`);
+    } else {}
+    $$renderer2.push(`</textarea> `);
+    if (description) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<p${$5.attr("id", field().ownDescriptionId)} class="cinder-textarea-description">${$5.escape(description)}</p>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    if (countId()) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<output${$5.attr("id", countId())}${$5.attr("for", id)} class="cinder-textarea-count" aria-live="polite" aria-atomic="true">${$5.escape(currentCount())}/${$5.escape(maximumLength())}</output>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    if (error) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<p${$5.attr("id", field().ownErrorId)} class="cinder-textarea-error" aria-live="polite">${$5.escape(error)}</p>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></div>`);
+    $5.bind_props($$props, { value });
+  });
+}
+
+// src/components/schema-form/schema-form-model.ts
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function createSchemaFormModel(schema) {
+  return {
+    field: fieldFromJsonSchema(schema, [], "value", true),
+    sourceSchema: schema
+  };
+}
+function fieldFromJsonSchema(schema, path, key, required) {
+  if (!isRecord(schema)) {
+    return baseField("json", {}, path, key, required);
+  }
+  const normalizedSchema = schema;
+  const options = enumOptions(normalizedSchema);
+  if (options.length > 0) {
+    return { ...baseField("enum", normalizedSchema, path, key, required), options };
+  }
+  const schemaType = schemaTypeOf(normalizedSchema);
+  const schemaProperties = normalizedSchema["properties"];
+  if (schemaType === "object" || isRecord(schemaProperties)) {
+    const requiredProperties = requiredPropertyNames(normalizedSchema);
+    const properties = isRecord(schemaProperties) ? schemaProperties : {};
+    const fields = Object.entries(properties).map(([propertyKey, propertySchema]) => fieldFromJsonSchema(propertySchema, [...path, propertyKey], propertyKey, requiredProperties.has(propertyKey)));
+    return { ...baseField("object", normalizedSchema, path, key, required), fields };
+  }
+  if (schemaType === "array") {
+    const schemaItems = normalizedSchema["items"];
+    const itemSchema = isRecord(schemaItems) ? schemaItems : {};
+    const item = fieldFromJsonSchema(itemSchema, [...path, "0"], "item", true);
+    return { ...baseField("array", normalizedSchema, path, key, required), item };
+  }
+  const fieldKind = fieldKindForSchemaType(schemaType);
+  if (fieldKind) {
+    return baseField(fieldKind, normalizedSchema, path, key, required);
+  }
+  return baseField("json", normalizedSchema, path, key, required);
+}
+function fieldKindForSchemaType(type) {
+  switch (type) {
+    case "string":
+    case "number":
+    case "integer":
+    case "boolean":
+    case "array":
+    case "object":
+      return type;
+    default:
+      return;
+  }
+}
+function baseField(kind, schema, path, key, required) {
+  const description = schema["description"];
+  return {
+    kind,
+    key,
+    path,
+    label: fieldLabel(schema, key),
+    required,
+    ...typeof description === "string" && description.length > 0 ? { description } : {},
+    schema,
+    fields: [],
+    options: []
+  };
+}
+function schemaTypeOf(schema) {
+  const { type } = schema;
+  if (typeof type === "string")
+    return type;
+  if (Array.isArray(type)) {
+    const supported = type.find((candidate) => typeof candidate === "string" && candidate !== "null");
+    return typeof supported === "string" ? supported : undefined;
+  }
+  return;
+}
+function requiredPropertyNames(schema) {
+  const required = schema["required"];
+  if (!Array.isArray(required))
+    return new Set;
+  return new Set(required.filter((property) => typeof property === "string"));
+}
+function enumOptions(schema) {
+  const values = schema["enum"];
+  if (!Array.isArray(values) || values.length === 0)
+    return [];
+  if (!values.every((value) => isJsonPrimitive(value)))
+    return [];
+  return values.map((value) => ({
+    label: String(value),
+    value,
+    encodedValue: encodeEnumValue(value)
+  }));
+}
+function isJsonPrimitive(value) {
+  return value === null || ["string", "number", "boolean"].includes(typeof value);
+}
+function encodeEnumValue(value) {
+  return JSON.stringify(value);
+}
+function decodeEnumValue(value) {
+  const parsed = JSON.parse(value);
+  if (!isJsonPrimitive(parsed)) {
+    throw new Error("SchemaForm enum values must be JSON primitives.");
+  }
+  return parsed;
+}
+function fieldLabel(schema, key) {
+  const title = schema["title"];
+  if (typeof title === "string" && title.trim().length > 0) {
+    return title;
+  }
+  if (key === "value")
+    return "Value";
+  return key.replaceAll(/[-_]+/g, " ").replaceAll(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/^\w/, (letter) => letter.toUpperCase());
+}
+function defaultValueForField(field) {
+  if ("default" in field.schema)
+    return cloneJsonCompatible(field.schema["default"]);
+  if (field.kind === "object") {
+    const value = {};
+    for (const child of field.fields) {
+      value[child.key] = defaultValueForField(child);
+    }
+    return value;
+  }
+  if (field.kind === "array")
+    return [];
+  if (field.kind === "boolean")
+    return false;
+  if (field.kind === "enum")
+    return field.options[0]?.value ?? "";
+  if (field.kind === "string")
+    return "";
+  if (field.kind === "json")
+    return null;
+  return;
+}
+function initialValueForField(field, value) {
+  if (value === undefined)
+    return defaultValueForField(field);
+  const clonedValue = cloneJsonCompatible(value);
+  if (clonedValue === undefined)
+    return defaultValueForField(field);
+  return mergeInitialValueWithFieldDefaults(field, clonedValue);
+}
+function mergeInitialValueWithFieldDefaults(field, value) {
+  if (field.kind === "object" && isRecord(value)) {
+    const defaultValue = defaultValueForField(field);
+    const defaultRecord = isRecord(defaultValue) ? defaultValue : {};
+    const result = { ...defaultRecord };
+    const fieldKeys = new Set(field.fields.map((child) => child.key));
+    for (const child of field.fields) {
+      const seededValue = Object.hasOwn(value, child.key) ? value[child.key] : defaultRecord[child.key];
+      result[child.key] = seededValue === undefined ? defaultValueForField(child) : mergeInitialValueWithFieldDefaults(child, seededValue);
+    }
+    for (const [key, extraValue] of Object.entries(value)) {
+      if (!fieldKeys.has(key))
+        result[key] = extraValue;
+    }
+    return result;
+  }
+  if (field.kind === "array" && Array.isArray(value) && field.item) {
+    return value.map((item) => mergeInitialValueWithFieldDefaults(field.item, item));
+  }
+  return value;
+}
+function cloneJsonCompatible(value) {
+  if (value === undefined)
+    return;
+  try {
+    const serializedValue = JSON.stringify(value, cloneJsonCompatibleReplacer);
+    if (serializedValue === undefined)
+      return;
+    const clonedValue = JSON.parse(serializedValue);
+    return clonedValue;
+  } catch {
+    return;
+  }
+}
+function cloneJsonCompatibleReplacer(_key, value) {
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    throw new TypeError("SchemaForm values must contain finite numbers.");
+  }
+  if (typeof value === "bigint") {
+    throw new TypeError("SchemaForm values must not contain bigint values.");
+  }
+  return value;
+}
+function pathKey(path) {
+  return path.map((segment) => segment.replaceAll("~", "~0").replaceAll("/", "~1")).join("/");
+}
+function pathId(path) {
+  return path.length === 0 ? "value" : path.map(domIdSegment).join("__");
+}
+function domIdSegment(segment) {
+  let encoded = "";
+  for (const character of segment) {
+    if (/^[a-zA-Z0-9]$/.test(character)) {
+      encoded += character;
+    } else {
+      encoded += `_${character.codePointAt(0)?.toString(16) ?? "0"}_`;
+    }
+  }
+  return `${segment.length}_${encoded}`;
+}
+function getValueAtPath(value, path) {
+  let current = value;
+  for (const segment of path) {
+    if (Array.isArray(current)) {
+      const index = Number(segment);
+      current = Number.isInteger(index) ? current[index] : undefined;
+    } else if (isRecord(current)) {
+      current = current[segment];
+    } else {
+      return;
+    }
+  }
+  return current;
+}
+function setValueAtPath(value, path, next) {
+  if (path.length === 0)
+    return next;
+  const [head, ...tail] = path;
+  if (head === undefined)
+    return next;
+  if (Array.isArray(value)) {
+    const copy2 = [...value];
+    const index = Number(head);
+    if (!Number.isInteger(index) || index < 0)
+      return copy2;
+    copy2[index] = setValueAtPath(copy2[index], tail, next);
+    return copy2;
+  }
+  const copy = isRecord(value) ? { ...value } : {};
+  copy[head] = setValueAtPath(copy[head], tail, next);
+  return copy;
+}
+function pruneUndefined(value) {
+  if (Array.isArray(value))
+    return value.map((item) => pruneUndefined(item));
+  if (!isRecord(value))
+    return value;
+  const output = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (child !== undefined)
+      output[key] = pruneUndefined(child);
+  }
+  return output;
+}
+function arrayValueAtPath(value, path) {
+  const array = getValueAtPath(value, path);
+  return Array.isArray(array) ? array : [];
+}
+function rebaseFieldPath(field, path) {
+  const originalPath = field.path;
+  function rebase(candidate) {
+    const suffix = candidate.path.slice(originalPath.length);
+    return {
+      ...candidate,
+      path: [...path, ...suffix],
+      fields: candidate.fields.map(rebase),
+      ...candidate.item ? { item: rebase(candidate.item) } : {}
+    };
+  }
+  return rebase(field);
+}
+
+// src/components/schema-form/schema-form-validation.ts
+var validatorCache = new WeakMap;
+async function validateSchemaValue(schema, value) {
+  if (!isRecord(schema)) {
+    return validationFailure(value, "SchemaForm only accepts JSON Schema objects.");
+  }
+  if (isLegacyStandardSchema(schema)) {
+    return validationFailure(value, "SchemaForm only accepts JSON Schema objects.");
+  }
+  return validateJsonSchemaValue(schema, value);
+}
+async function validateJsonSchemaValue(schema, value) {
+  let validate;
+  try {
+    validate = await validatorForSchema(schema);
+  } catch (error) {
+    return validationFailure(value, readableSchemaError(error));
+  }
+  let valid;
+  try {
+    const result = validate(value);
+    valid = isPromiseLike(result) ? (await result, true) : result;
+  } catch (error) {
+    if (isAjvValidationError(error)) {
+      return {
+        valid: false,
+        value,
+        issues: ajvIssues(error.errors)
+      };
+    }
+    return validationFailure(value, readableSchemaError(error));
+  }
+  if (valid)
+    return { valid: true, value, issues: [] };
+  return {
+    valid: false,
+    value,
+    issues: ajvIssues(validate.errors ?? [])
+  };
+}
+function validationFailure(value, message) {
+  return {
+    valid: false,
+    value,
+    issues: [{ path: [], message }]
+  };
+}
+function isLegacyStandardSchema(schema) {
+  const standard = schema["~standard"];
+  return isRecord(standard) && standard["version"] === 1;
+}
+function readableSchemaError(error) {
+  const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
+  if (message.startsWith("Invalid JSON Schema"))
+    return message;
+  return message === "" ? "Invalid JSON Schema." : `Invalid JSON Schema: ${message}`;
+}
+function isPromiseLike(value) {
+  return isRecord(value) && typeof value["then"] === "function";
+}
+function isAjvValidationError(error) {
+  return isRecord(error) && Array.isArray(error["errors"]);
+}
+function validatorForSchema(schema) {
+  const cached = validatorCache.get(schema);
+  if (cached)
+    return cached;
+  const promise = createValidator(schema).catch((error) => {
+    validatorCache.delete(schema);
+    throw error;
+  });
+  validatorCache.set(schema, promise);
+  return promise;
+}
+async function createValidator(schema) {
+  const draft = jsonSchemaDraft(schema);
+  if (draft === "draft-07") {
+    const { default: Ajv } = await import("ajv");
+    return new Ajv({ strict: false, allErrors: true, addUsedSchema: false }).compile(schema);
+  }
+  if (draft === "2019-09") {
+    const { default: Ajv2019 } = await import("ajv/dist/2019.js");
+    return new Ajv2019({ strict: false, allErrors: true, addUsedSchema: false }).compile(schema);
+  }
+  const { default: Ajv2020 } = await import("ajv/dist/2020.js");
+  return new Ajv2020({ strict: false, allErrors: true, addUsedSchema: false }).compile(schema);
+}
+function jsonSchemaDraft(schema) {
+  const id = schema["$schema"];
+  if (typeof id !== "string")
+    return "2020-12";
+  if (id.includes("draft-07"))
+    return "draft-07";
+  if (id.includes("2019-09"))
+    return "2019-09";
+  return "2020-12";
+}
+function ajvIssues(errors) {
+  return errors.map((error) => ({
+    path: ajvErrorPath(error),
+    message: readableAjvMessage(error)
+  }));
+}
+function readableAjvMessage(error) {
+  const fieldName = ajvErrorPath(error).at(-1) ?? "Value";
+  const label = humanizeFieldName(fieldName);
+  if (error.keyword === "required")
+    return `${label} is required.`;
+  if (error.keyword === "minLength")
+    return `${label} is too short.`;
+  if (error.keyword === "maxLength")
+    return `${label} is too long.`;
+  if (error.keyword === "minimum")
+    return `${label} must be at least ${error.params?.["limit"]}.`;
+  if (error.keyword === "maximum")
+    return `${label} must be at most ${error.params?.["limit"]}.`;
+  if (error.keyword === "type")
+    return `${label} must be ${error.params?.["type"]}.`;
+  return error.message ?? "Invalid value";
+}
+function humanizeFieldName(name) {
+  return name.replace(/[_-]+/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").replace(/^./, (character) => character.toUpperCase());
+}
+function ajvErrorPath(error) {
+  const parentPath = jsonPointerToPath(error.instancePath);
+  if (error.keyword !== "required" || !isRecord(error.params))
+    return parentPath;
+  const missingProperty = error.params["missingProperty"];
+  return typeof missingProperty === "string" ? [...parentPath, missingProperty] : parentPath;
+}
+function jsonPointerToPath(pointer) {
+  if (pointer === "")
+    return [];
+  return pointer.slice(1).split("/").map((segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~"));
+}
+function issuesByPath(issues) {
+  const grouped = {};
+  for (const issue of issues) {
+    const key = pathKey(issue.path);
+    grouped[key] ??= issue.message;
+  }
+  return grouped;
+}
+function parseJsonDraft(path, text) {
+  try {
+    return { ok: true, value: JSON.parse(text) };
+  } catch (error) {
+    return {
+      ok: false,
+      issue: {
+        path,
+        message: error instanceof Error ? error.message : "Invalid JSON"
+      }
+    };
+  }
+}
+function serializeValidatedValue(value) {
+  try {
+    const serialized = JSON.stringify(value, schemaFormJsonReplacer);
+    if (serialized === undefined) {
+      throw new TypeError("Validated value is not JSON serializable.");
+    }
+    return { ok: true, value: serialized };
+  } catch (error) {
+    return {
+      ok: false,
+      issue: {
+        path: [],
+        message: error instanceof Error ? error.message : "Validated value is not JSON serializable"
+      }
+    };
+  }
+}
+function schemaFormJsonReplacer(_key, value) {
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    throw new TypeError("Validated value contains a non-finite number.");
+  }
+  if (typeof value === "bigint") {
+    throw new TypeError("Validated value contains a bigint, which is not JSON serializable.");
+  }
+  return value;
+}
+function readSchemaFormData(formData, name = "value") {
+  const raw = formData.get(name);
+  if (typeof raw !== "string")
+    return;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return;
+  }
+}
+
+// src/components/schema-form/schema-form-body.svelte
+function Schema_form_body($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const generatedId = $6.props_id($$renderer2);
+    let {
+      schema,
+      value,
+      name = "value",
+      submitLabel = "Submit",
+      class: customClassName,
+      onsubmit,
+      novalidate,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    const initialModel = createSchemaFormModel(schema);
+    const initialFormValue = initialValueForField(initialModel.field, value);
+    const model = $6.derived(() => createSchemaFormModel(schema));
+    let formElement = undefined;
+    let serializedInputElement = undefined;
+    let formValue = initialFormValue;
+    let errors = {};
+    let rawDrafts = seedRawDrafts(initialModel.field, initialFormValue);
+    let touchedValidationSequences = {};
+    let serializedValue = "";
+    let submitting = false;
+    let allowNativeSubmit = false;
+    let activeSubmitId = 0;
+    let arrayKeyCounter = 0;
+    let arrayKeys = seedArrayKeys(initialModel.field, initialFormValue);
+    const formId = $6.derived(() => rest.id ?? `${generatedId}-form`);
+    const rootFields = $6.derived(() => model().field.kind === "object" ? model().field.fields : [model().field]);
+    const rootError = $6.derived(() => model().field.kind === "object" ? errors[pathKey([])] : undefined);
+    const rootErrorId = $6.derived(() => `${formId()}-${pathId([])}-error`);
+    function fieldDomId(field) {
+      return `${formId()}-${pathId(field.path)}`;
+    }
+    function fieldError(field) {
+      return errors[pathKey(field.path)];
+    }
+    function stringValue(field) {
+      const current = getValueAtPath(formValue, field.path);
+      return current === undefined || current === null ? "" : String(current);
+    }
+    function numberValue(field) {
+      const current = getValueAtPath(formValue, field.path);
+      return typeof current === "number" ? current : undefined;
+    }
+    function booleanValue(field) {
+      return getValueAtPath(formValue, field.path) === true;
+    }
+    function enumValue(field) {
+      const current = getValueAtPath(formValue, field.path);
+      const option = field.options.find((candidate) => Object.is(candidate.value, current));
+      return option?.encodedValue ?? field.options[0]?.encodedValue ?? "";
+    }
+    function selectOptions(field) {
+      return field.options.map((option) => ({ value: option.encodedValue, label: option.label }));
+    }
+    function numberFieldValue(field) {
+      return numberValue(field) ?? null;
+    }
+    function rawJsonValue(field) {
+      const key = pathKey(field.path);
+      if (rawDrafts[key] !== undefined)
+        return rawDrafts[key];
+      return JSON.stringify(getValueAtPath(formValue, field.path) ?? null, null, 2);
+    }
+    function bumpTouchedValidationSequence(path) {
+      const key = pathKey(path);
+      touchedValidationSequences = {
+        ...touchedValidationSequences,
+        [key]: (touchedValidationSequences[key] ?? 0) + 1
+      };
+    }
+    function updateValue(path, next) {
+      if (submitting)
+        return;
+      formValue = setValueAtPath(formValue, path, next);
+      const key = pathKey(path);
+      bumpTouchedValidationSequence(path);
+      if (errors[key]) {
+        const { [key]: _removed, ...remaining } = errors;
+        errors = remaining;
+      }
+      setSerializedValue("");
+    }
+    async function validateTouchedField(field) {
+      if (submitting)
+        return;
+      const fieldKey = pathKey(field.path);
+      const sequence = (touchedValidationSequences[fieldKey] ?? 0) + 1;
+      touchedValidationSequences = { ...touchedValidationSequences, [fieldKey]: sequence };
+      const raw = rawJsonIssues();
+      const rawIssue = raw.issues.find((candidateIssue) => {
+        const candidateKey = pathKey(candidateIssue.path);
+        return candidateKey === fieldKey || candidateKey.startsWith(`${fieldKey}/`);
+      });
+      if (rawIssue) {
+        errors = { ...errors, [fieldKey]: rawIssue.message };
+        return;
+      }
+      const candidate = pruneUndefined(raw.value);
+      const result = await validateSchemaValue(schema, candidate);
+      if (touchedValidationSequences[fieldKey] !== sequence)
+        return;
+      const issue = (result.valid ? [] : result.issues).find((candidateIssue) => {
+        const candidateKey = pathKey(candidateIssue.path);
+        return candidateKey === fieldKey || candidateKey.startsWith(`${fieldKey}/`);
+      });
+      if (issue) {
+        errors = { ...errors, [fieldKey]: issue.message };
+        return;
+      }
+      if (errors[fieldKey]) {
+        const { [fieldKey]: _removed, ...remaining } = errors;
+        errors = remaining;
+      }
+    }
+    function setSerializedValue(next) {
+      serializedValue = next;
+      if (serializedInputElement)
+        serializedInputElement.value = next;
+    }
+    function updateEnum(field, event) {
+      if (submitting)
+        return;
+      const select = event.currentTarget;
+      updateValue(field.path, decodeEnumValue(select.value));
+    }
+    function updateRawJsonValue(field, next) {
+      if (submitting)
+        return;
+      const key = pathKey(field.path);
+      rawDrafts = { ...rawDrafts, [key]: next };
+      bumpTouchedValidationSequence(field.path);
+      if (errors[key]) {
+        const { [key]: _removed, ...remaining } = errors;
+        errors = remaining;
+      }
+      setSerializedValue("");
+    }
+    function arrayRows(field) {
+      const values = arrayValueAtPath(formValue, field.path);
+      const keys = arrayKeys[pathKey(field.path)] ?? [];
+      return values.map((_, index) => ({ key: keys[index] ?? `${pathKey(field.path)}-${index}`, index }));
+    }
+    function addArrayItem(field) {
+      if (submitting)
+        return;
+      const values = arrayValueAtPath(formValue, field.path);
+      const nextValue = field.item ? defaultValueForField(field.item) : null;
+      updateValue(field.path, [...values, nextValue]);
+      const key = pathKey(field.path);
+      arrayKeys = {
+        ...arrayKeys,
+        [key]: [...arrayKeys[key] ?? [], `${key}-${arrayKeyCounter++}`]
+      };
+    }
+    function removeArrayItem(field, index) {
+      if (submitting)
+        return;
+      const values = arrayValueAtPath(formValue, field.path);
+      updateValue(field.path, values.filter((_, candidateIndex) => candidateIndex !== index));
+      rawDrafts = reindexArrayPathState(rawDrafts, field.path, index);
+      errors = reindexArrayPathState(errors, field.path, index);
+      touchedValidationSequences = bumpPathValidationSequences(reindexArrayPathState(touchedValidationSequences, field.path, index), field.path);
+      const key = pathKey(field.path);
+      arrayKeys = {
+        ...arrayKeys,
+        [key]: (arrayKeys[key] ?? []).filter((_, candidateIndex) => candidateIndex !== index)
+      };
+    }
+    function reindexArrayPathState(state, arrayPath, removedIndex) {
+      const prefix = pathKey(arrayPath);
+      const pathPrefix = prefix === "" ? "" : `${prefix}/`;
+      const next = {};
+      for (const [key, stateValue] of Object.entries(state)) {
+        if (!key.startsWith(pathPrefix)) {
+          next[key] = stateValue;
+          continue;
+        }
+        const relativeKey = key.slice(pathPrefix.length);
+        if (relativeKey === "") {
+          next[key] = stateValue;
+          continue;
+        }
+        const [indexSegment = "", ...remainingSegments] = relativeKey.split("/");
+        const index = Number(indexSegment);
+        if (!Number.isInteger(index) || index < 0) {
+          next[key] = stateValue;
+          continue;
+        }
+        if (index < removedIndex) {
+          next[key] = stateValue;
+          continue;
+        }
+        if (index === removedIndex)
+          continue;
+        const shiftedKey = [String(index - 1), ...remainingSegments].join("/");
+        next[`${pathPrefix}${shiftedKey}`] = stateValue;
+      }
+      return next;
+    }
+    function bumpPathValidationSequences(state, path) {
+      const prefix = pathKey(path);
+      const pathPrefix = prefix === "" ? "" : `${prefix}/`;
+      const next = {};
+      for (const [key, sequence] of Object.entries(state)) {
+        next[key] = key === prefix || key.startsWith(pathPrefix) ? sequence + 1 : sequence;
+      }
+      return next;
+    }
+    function seedRawDrafts(field, currentValue) {
+      const drafts = {};
+      for (const jsonField of currentJsonFields(field, currentValue)) {
+        drafts[pathKey(jsonField.path)] = JSON.stringify(getValueAtPath(currentValue, jsonField.path) ?? null, null, 2);
+      }
+      return drafts;
+    }
+    function currentJsonFields(field, currentValue) {
+      const fields = [];
+      function visit(candidate) {
+        if (candidate.kind === "json")
+          fields.push(candidate);
+        for (const child of candidate.fields)
+          visit(child);
+        if (candidate.kind === "array" && candidate.item) {
+          for (const [index] of arrayValueAtPath(currentValue, candidate.path).entries()) {
+            visit(rebaseFieldPath(candidate.item, [...candidate.path, String(index)]));
+          }
+        }
+      }
+      visit(field);
+      return fields;
+    }
+    function seedArrayKeys(field, currentValue) {
+      const keys = {};
+      function visit(candidate) {
+        if (candidate.kind === "array") {
+          const key = pathKey(candidate.path);
+          keys[key] = arrayValueAtPath(currentValue, candidate.path).map(() => `${key}-${arrayKeyCounter++}`);
+        }
+        for (const child of candidate.fields)
+          visit(child);
+        if (candidate.item)
+          visit(candidate.item);
+      }
+      visit(field);
+      return keys;
+    }
+    function rawJsonIssues() {
+      let nextValue = formValue;
+      const issues = [];
+      for (const field of currentJsonFields(model().field, formValue)) {
+        const draft = rawDrafts[pathKey(field.path)];
+        if (draft === undefined)
+          continue;
+        const parsed = parseJsonDraft(field.path, draft);
+        if (parsed.ok) {
+          nextValue = setValueAtPath(nextValue, field.path, parsed.value);
+        } else {
+          issues.push(parsed.issue);
+        }
+      }
+      return { value: nextValue, issues };
+    }
+    async function reportSubmitIssues(issues, submitId) {
+      if (activeSubmitId !== submitId)
+        return;
+      errors = issuesByPath(issues);
+      setSerializedValue("");
+      submitting = false;
+      await focusFirstError(submitId);
+    }
+    async function focusFirstError(submitId) {
+      await tick();
+      if (activeSubmitId !== submitId)
+        return;
+      formElement?.querySelector('[aria-invalid="true"], [data-cinder-invalid="true"], .cinder-schema-form__error')?.focus();
+    }
+    function shouldResumeNativeSubmit() {
+      return onsubmit === undefined && (rest.action !== undefined || rest.method !== undefined);
+    }
+    function nativeSubmitter(event) {
+      const submitter = event.submitter;
+      if (submitter instanceof HTMLButtonElement && submitter.type === "submit" && submitter.form === formElement) {
+        return submitter;
+      }
+      if (submitter instanceof HTMLInputElement && (submitter.type === "submit" || submitter.type === "image") && submitter.form === formElement) {
+        return submitter;
+      }
+      return;
+    }
+    async function handleSubmit(event) {
+      if (allowNativeSubmit) {
+        allowNativeSubmit = false;
+        return;
+      }
+      event.preventDefault();
+      if (submitting)
+        return;
+      const submitId = activeSubmitId + 1;
+      activeSubmitId = submitId;
+      submitting = true;
+      try {
+        const raw = rawJsonIssues();
+        if (raw.issues.length > 0) {
+          await reportSubmitIssues(raw.issues, submitId);
+          return;
+        }
+        const candidate = pruneUndefined(raw.value);
+        const result = await validateSchemaValue(schema, candidate);
+        if (!result.valid) {
+          await reportSubmitIssues(result.issues, submitId);
+          return;
+        }
+        const serialized = serializeValidatedValue(result.value);
+        if (!serialized.ok) {
+          await reportSubmitIssues([serialized.issue], submitId);
+          return;
+        }
+        formValue = result.value;
+        errors = {};
+        setSerializedValue(serialized.value);
+        await onsubmit?.(result.value, event);
+        if (shouldResumeNativeSubmit()) {
+          allowNativeSubmit = true;
+          await tick();
+          formElement?.requestSubmit(nativeSubmitter(event));
+        }
+      } finally {
+        if (activeSubmitId === submitId)
+          submitting = false;
+      }
+    }
+    function groupLegend($$renderer3, field) {
+      $$renderer3.push(`<legend class="cinder-schema-form__legend">${$6.escape(field.label)} `);
+      if (field.required) {
+        $$renderer3.push("<!--[0-->");
+        $$renderer3.push(`<span class="cinder-_required-marker" aria-hidden="true">*</span>`);
+      } else {
+        $$renderer3.push("<!--[-1-->");
+      }
+      $$renderer3.push(`<!--]--></legend> `);
+      if (field.description) {
+        $$renderer3.push("<!--[0-->");
+        $$renderer3.push(`<p${$6.attr("id", `${$6.stringify(fieldDomId(field))}-description`)} class="cinder-schema-form__description">${$6.escape(field.description)}</p>`);
+      } else {
+        $$renderer3.push("<!--[-1-->");
+      }
+      $$renderer3.push(`<!--]--> `);
+      if (fieldError(field)) {
+        $$renderer3.push("<!--[0-->");
+        $$renderer3.push(`<p${$6.attr("id", `${$6.stringify(fieldDomId(field))}-error`)} class="cinder-schema-form__error" aria-live="polite" tabindex="-1">${$6.escape(fieldError(field))}</p>`);
+      } else {
+        $$renderer3.push("<!--[-1-->");
+      }
+      $$renderer3.push(`<!--]-->`);
+    }
+    function renderField($$renderer3, field) {
+      const id = fieldDomId(field);
+      const error = fieldError(field);
+      const labelledProps = {
+        label: field.label,
+        ...field.description !== undefined ? { description: field.description } : {},
+        ...error !== undefined ? { error } : {}
+      };
+      if (field.kind === "object") {
+        $$renderer3.push("<!--[0-->");
+        $$renderer3.push(`<fieldset class="cinder-schema-form__fieldset">`);
+        groupLegend($$renderer3, field);
+        $$renderer3.push(`<!----> <div class="cinder-schema-form__fields"><!--[-->`);
+        const each_array = $6.ensure_array_like(field.fields);
+        for (let $$index = 0, $$length = each_array.length;$$index < $$length; $$index++) {
+          let child = each_array[$$index];
+          renderField($$renderer3, child);
+        }
+        $$renderer3.push(`<!--]--></div></fieldset>`);
+      } else if (field.kind === "array") {
+        $$renderer3.push("<!--[1-->");
+        $$renderer3.push(`<fieldset class="cinder-schema-form__fieldset">`);
+        groupLegend($$renderer3, field);
+        $$renderer3.push(`<!----> <div class="cinder-schema-form__array"${$6.attr("data-cinder-empty", arrayRows(field).length === 0 || undefined)}><!--[-->`);
+        const each_array_1 = $6.ensure_array_like(arrayRows(field));
+        for (let $$index_1 = 0, $$length = each_array_1.length;$$index_1 < $$length; $$index_1++) {
+          let row = each_array_1[$$index_1];
+          const itemField = field.item ? rebaseFieldPath(field.item, [...field.path, String(row.index)]) : undefined;
+          $$renderer3.push(`<div class="cinder-schema-form__array-item">`);
+          if (itemField) {
+            $$renderer3.push("<!--[0-->");
+            renderField($$renderer3, itemField);
+          } else {
+            $$renderer3.push("<!--[-1-->");
+          }
+          $$renderer3.push(`<!--]--> <button type="button" class="cinder-schema-form__secondary-button"${$6.attr("aria-label", `Remove ${field.label} item ${row.index + 1}`)}${$6.attr("disabled", submitting, true)}>Remove</button></div>`);
+        }
+        $$renderer3.push(`<!--]--></div> <button type="button" class="cinder-schema-form__secondary-button"${$6.attr("disabled", submitting, true)}>Add ${$6.escape(field.label)}</button></fieldset>`);
+      } else {
+        $$renderer3.push("<!--[-1-->");
+        $$renderer3.push(`<div class="cinder-schema-form__field">`);
+        if (field.kind === "string") {
+          $$renderer3.push("<!--[0-->");
+          var bind_get = () => stringValue(field);
+          var bind_set = (next) => updateValue(field.path, next);
+          Input($$renderer3, $6.spread_props([
+            { id },
+            labelledProps,
+            {
+              required: field.required,
+              disabled: submitting,
+              onblur: () => validateTouchedField(field),
+              get value() {
+                return bind_get();
+              },
+              set value($$value) {
+                bind_set($$value);
+              }
+            }
+          ]));
+        } else if (field.kind === "number" || field.kind === "integer") {
+          $$renderer3.push("<!--[1-->");
+          var bind_get_1 = () => numberFieldValue(field);
+          var bind_set_1 = (next) => updateValue(field.path, next ?? undefined);
+          Number_input($$renderer3, $6.spread_props([
+            { id },
+            labelledProps,
+            {
+              required: field.required,
+              disabled: submitting,
+              step: field.kind === "integer" ? 1 : undefined,
+              onblur: () => validateTouchedField(field),
+              get value() {
+                return bind_get_1();
+              },
+              set value($$value) {
+                bind_set_1($$value);
+              }
+            }
+          ]));
+        } else if (field.kind === "enum") {
+          $$renderer3.push("<!--[2-->");
+          Select($$renderer3, $6.spread_props([
+            { id },
+            labelledProps,
+            {
+              required: field.required,
+              disabled: submitting,
+              options: selectOptions(field),
+              value: enumValue(field),
+              onchange: (event) => updateEnum(field, event),
+              onblur: () => validateTouchedField(field)
+            }
+          ]));
+        } else if (field.kind === "boolean") {
+          $$renderer3.push("<!--[3-->");
+          var bind_get_2 = () => booleanValue(field);
+          var bind_set_2 = (next) => updateValue(field.path, next);
+          Checkbox($$renderer3, $6.spread_props([
+            { id },
+            labelledProps,
+            {
+              disabled: submitting,
+              get checked() {
+                return bind_get_2();
+              },
+              set checked($$value) {
+                bind_set_2($$value);
+              }
+            }
+          ]));
+        } else {
+          $$renderer3.push("<!--[-1-->");
+          var bind_get_3 = () => rawJsonValue(field);
+          var bind_set_3 = (next) => updateRawJsonValue(field, next);
+          Textarea($$renderer3, $6.spread_props([
+            { id },
+            labelledProps,
+            {
+              required: field.required,
+              disabled: submitting,
+              rows: 6,
+              spellcheck: false,
+              class: "cinder-schema-form__json-control",
+              onblur: () => validateTouchedField(field),
+              get value() {
+                return bind_get_3();
+              },
+              set value($$value) {
+                bind_set_3($$value);
+              }
+            }
+          ]));
+        }
+        $$renderer3.push(`<!--]--></div>`);
+      }
+      $$renderer3.push(`<!--]-->`);
+    }
+    let $$settled = true;
+    let $$inner_renderer;
+    function $$render_inner($$renderer3) {
+      $$renderer3.push(`<form${$6.attributes({
+        ...rest,
+        id: formId(),
+        class: $6.clsx(classNames("cinder-schema-form", customClassName)),
+        novalidate: novalidate ?? true
+      })}>`);
+      if (rootError()) {
+        $$renderer3.push("<!--[0-->");
+        $$renderer3.push(`<p${$6.attr("id", rootErrorId())} class="cinder-schema-form__error" role="alert" aria-live="polite" tabindex="-1">${$6.escape(rootError())}</p>`);
+      } else {
+        $$renderer3.push("<!--[-1-->");
+      }
+      $$renderer3.push(`<!--]--> <div class="cinder-schema-form__fields"><!--[-->`);
+      const each_array_2 = $6.ensure_array_like(rootFields());
+      for (let $$index_2 = 0, $$length = each_array_2.length;$$index_2 < $$length; $$index_2++) {
+        let field = each_array_2[$$index_2];
+        renderField($$renderer3, field);
+      }
+      $$renderer3.push(`<!--]--></div> <input type="hidden"${$6.attr("name", name)}${$6.attr("value", serializedValue)}/> <button type="submit" class="cinder-schema-form__submit"${$6.attr("disabled", submitting, true)}>${$6.escape(submitting ? "Validating..." : submitLabel)}</button></form>`);
+    }
+    do {
+      $$settled = true;
+      $$inner_renderer = $$renderer2.copy();
+      $$render_inner($$inner_renderer);
+    } while (!$$settled);
+    $$renderer2.subsume($$inner_renderer);
+  });
+}
+
+// src/components/schema-form/schema-form.svelte
+function Schema_form($$renderer, $$props) {
+  let { schema, $$slots, $$events, ...rest } = $$props;
+  $$renderer.push(`<!---->`);
+  {
+    Schema_form_body($$renderer, $7.spread_props([{ schema }, rest]));
+  }
+  $$renderer.push(`<!---->`);
+}
+
+// src/components/schema-form/index.ts
+var schema_form_default = Schema_form;
+export {
+  readSchemaFormData,
+  schema_form_default as default,
+  Schema_form as SchemaForm
+};
+
+//# debugId=CC6E6ECA2FC0CCC564756E2164756E21