@lostgradient/cinder 0.4.0 → 0.4.1

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

@@ -0,0 +1,2311 @@
+import {
+  Textarea
+} from "./index.server-41003crj.js";
+import {
+  Empty_state
+} from "./index.server-c3gbtj71.js";
+import {
+  Diff_viewer
+} from "./index.server-fnj6xyr0.js";
+import {
+  Checkbox
+} from "./index.server-qjdkp02z.js";
+import {
+  Chip
+} from "./index.server-xp53vmj5.js";
+import {
+  useAnnouncer
+} from "./index.server-gbzsb04q.js";
+import {
+  Input
+} from "./index.server-8gakk9d5.js";
+import {
+  Tooltip
+} from "./index.server-qxd1ej6r.js";
+import {
+  Alert
+} from "./index.server-fy9eb0xp.js";
+import {
+  Tabs
+} from "./index.server-n3zbnw3w.js";
+import {
+  Tab
+} from "./index.server-52fkd3c2.js";
+import {
+  Tab_list
+} from "./index.server-xpghbgpz.js";
+import {
+  Tab_panel
+} from "./index.server-8d3tttbj.js";
+import {
+  handleRovingKeydown
+} from "./index.server-0a8m173j.js";
+import {
+  Copy_button
+} from "./index.server-3cwyrz8f.js";
+import {
+  Badge
+} from "./index.server-bkz7h7jx.js";
+import {
+  Button
+} from "./index.server-34p02y48.js";
+import {
+  classNames
+} from "./index.server-z7nvkz8v.js";
+
+// src/components/json-schema-editor/json-schema-editor.svelte
+import * as $10 from "svelte/internal/server";
+
+// src/components/json-schema-editor/json-schema-editor-impl.svelte
+import * as $9 from "svelte/internal/server";
+import { untrack as untrack2 } from "svelte";
+
+// src/components/json-schema-editor/diff-view.svelte
+import * as $ from "svelte/internal/server";
+function Diff_view($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { state, class: className } = $$props;
+    $$renderer2.push(`<div${$.attr_class($.clsx(classNames("cinder-jse-diff-view", className)))}>`);
+    if (state.jsonDraftIsDirty) {
+      $$renderer2.push("<!--[0-->");
+      Alert($$renderer2, {
+        variant: "warning",
+        children: ($$renderer3) => {
+          $$renderer3.push(`<p>The diff shows the committed state; uncommitted JSON edits are not included.</p> <div class="cinder-jse-dirty-actions">`);
+          Button($$renderer3, {
+            variant: "primary",
+            size: "sm",
+            onclick: () => state.applyJsonDraft(),
+            children: ($$renderer4) => {
+              $$renderer4.push(`<!---->Apply JSON`);
+            },
+            $$slots: { default: true }
+          });
+          $$renderer3.push(`<!----> `);
+          Button($$renderer3, {
+            variant: "secondary",
+            size: "sm",
+            onclick: () => state.discardJsonDraft(),
+            children: ($$renderer4) => {
+              $$renderer4.push(`<!---->Discard JSON`);
+            },
+            $$slots: { default: true }
+          });
+          $$renderer3.push(`<!----></div>`);
+        },
+        $$slots: { default: true }
+      });
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    if (!state.hasChanges) {
+      $$renderer2.push("<!--[0-->");
+      Empty_state($$renderer2, {
+        title: "No changes yet",
+        description: "Edit the schema to see a diff here."
+      });
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      Diff_viewer($$renderer2, {
+        original: state.diffOriginal,
+        current: state.diffCurrent,
+        normalizeInputs: false,
+        readonly: true
+      });
+    }
+    $$renderer2.push(`<!--]--></div>`);
+  });
+}
+
+// src/components/json-schema-editor/form-view.svelte
+import * as $4 from "svelte/internal/server";
+
+// src/components/json-schema-editor/property-editor.svelte
+import * as $3 from "svelte/internal/server";
+import { onDestroy as onDestroy2 } from "svelte";
+
+// src/components/json-schema-editor/property-list.svelte
+import * as $2 from "svelte/internal/server";
+import { onDestroy } from "svelte";
+
+// src/components/json-schema-editor/property-list-validation.ts
+function calculatePropertyValidationErrorCount(propertyNames, childValidationCounts, hasRenameError) {
+  return (hasRenameError ? 1 : 0) + propertyNames.reduce((total, key) => total + (childValidationCounts[key] ?? 0), 0);
+}
+
+// src/components/json-schema-editor/property-list.svelte
+function Property_list($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      idPrefix,
+      properties,
+      required,
+      path,
+      depth = 0,
+      readonly = false,
+      onvalidationerrorcount,
+      onchange
+    } = $$props;
+    const propertyNames = $2.derived(() => Object.keys(properties));
+    const requiredOnly = $2.derived(() => required.filter((name) => !propertyNames().includes(name)));
+    let draftNames = {};
+    let renameError = null;
+    let expanded = {};
+    let childValidationCounts = {};
+    const validationErrorCount = $2.derived(() => calculatePropertyValidationErrorCount(propertyNames(), childValidationCounts, renameError !== null));
+    onDestroy(() => {
+      onvalidationerrorcount?.(0);
+    });
+    function getDraftName(key) {
+      return draftNames[key] ?? key;
+    }
+    function uniqueNewKey() {
+      let suffix = 1;
+      let candidate = "newField";
+      while (Object.prototype.hasOwnProperty.call(properties, candidate)) {
+        suffix += 1;
+        candidate = `newField${suffix}`;
+      }
+      return candidate;
+    }
+    function commitRename(oldKey) {
+      if (readonly)
+        return;
+      const draft = getDraftName(oldKey).trim();
+      if (!draft) {
+        renameError = "Property name cannot be empty";
+        return;
+      }
+      if (draft === oldKey) {
+        renameError = null;
+        return;
+      }
+      if (Object.prototype.hasOwnProperty.call(properties, draft)) {
+        renameError = `Duplicate property name: ${draft}`;
+        return;
+      }
+      renameError = null;
+      const next = {};
+      for (const k of propertyNames()) {
+        next[k === oldKey ? draft : k] = properties[k];
+      }
+      const nextRequired = required.map((name) => name === oldKey ? draft : name);
+      delete draftNames[oldKey];
+      if (expanded[oldKey]) {
+        expanded[draft] = true;
+        delete expanded[oldKey];
+      }
+      const childCount = childValidationCounts[oldKey];
+      if (childCount !== undefined) {
+        const { [oldKey]: _removedChildCount, ...remainingChildCounts } = childValidationCounts;
+        childValidationCounts = { ...remainingChildCounts, [draft]: childCount };
+      }
+      onchange(next, nextRequired);
+    }
+    function deleteProperty(key) {
+      if (readonly)
+        return;
+      const next = { ...properties };
+      delete next[key];
+      const nextRequired = required.filter((name) => name !== key);
+      delete draftNames[key];
+      delete expanded[key];
+      const { [key]: _removedChildCount, ...remainingChildCounts } = childValidationCounts;
+      childValidationCounts = remainingChildCounts;
+      onchange(next, nextRequired);
+    }
+    function setChildValidationErrorCount(key, count) {
+      if ((childValidationCounts[key] ?? 0) === count)
+        return;
+      if (count === 0) {
+        const { [key]: _removedChildCount, ...remainingChildCounts } = childValidationCounts;
+        childValidationCounts = remainingChildCounts;
+        return;
+      }
+      childValidationCounts = { ...childValidationCounts, [key]: count };
+    }
+    function toggleExpanded(key, isOpen) {
+      expanded[key] = !isOpen;
+      if (isOpen)
+        setChildValidationErrorCount(key, 0);
+    }
+    function moveProperty(key, direction) {
+      if (readonly)
+        return;
+      const index = propertyNames().indexOf(key);
+      const target = index + direction;
+      if (target < 0 || target >= propertyNames().length)
+        return;
+      const reordered = [...propertyNames()];
+      [reordered[index], reordered[target]] = [reordered[target], reordered[index]];
+      const next = {};
+      for (const name of reordered)
+        next[name] = properties[name];
+      onchange(next, required);
+    }
+    function toggleRequired(key) {
+      if (readonly)
+        return;
+      const set = new Set(required);
+      if (set.has(key))
+        set.delete(key);
+      else
+        set.add(key);
+      onchange(properties, [...set]);
+    }
+    function setPropertySchema(key, schema) {
+      if (readonly)
+        return;
+      onchange({ ...properties, [key]: schema }, required);
+    }
+    function addProperty() {
+      if (readonly)
+        return;
+      const key = uniqueNewKey();
+      onchange({ ...properties, [key]: { type: "string" } }, required);
+      expanded[key] = true;
+    }
+    function summariseType(schema) {
+      if (typeof schema === "boolean")
+        return schema ? "true" : "false";
+      const t = schema.type;
+      if (t === undefined)
+        return "any";
+      if (Array.isArray(t))
+        return t.join(" | ");
+      return t;
+    }
+    let newRequiredOnlyName = "";
+    function addRequiredOnly() {
+      if (readonly)
+        return;
+      const name = newRequiredOnlyName.trim();
+      if (!name) {
+        newRequiredOnlyName = "";
+        return;
+      }
+      if (required.includes(name)) {
+        newRequiredOnlyName = "";
+        return;
+      }
+      onchange(properties, [...required, name]);
+      newRequiredOnlyName = "";
+    }
+    function removeRequiredOnly(name) {
+      if (readonly)
+        return;
+      onchange(properties, required.filter((entry) => entry !== name));
+    }
+    $$renderer2.push(`<div class="cinder-jse-property-list">`);
+    if (renameError) {
+      $$renderer2.push("<!--[0-->");
+      Alert($$renderer2, {
+        variant: "danger",
+        children: ($$renderer3) => {
+          $$renderer3.push(`<!---->${$2.escape(renameError)}`);
+        },
+        $$slots: { default: true }
+      });
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    if (propertyNames().length === 0) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<p class="cinder-jse-property-list__empty">No properties yet.</p>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> <!--[-->`);
+    const each_array = $2.ensure_array_like(propertyNames());
+    for (let $$index = 0, $$length = each_array.length;$$index < $$length; $$index++) {
+      let key = each_array[$$index];
+      const isRequired = required.includes(key);
+      const isOpen = expanded[key] === true;
+      const panelId = `${idPrefix}-${key}-panel`;
+      $$renderer2.push(`<div class="cinder-jse-property-row"${$2.attr("data-cinder-required", isRequired ? "" : undefined)}><div class="cinder-jse-property-row__summary"${$2.attr_style(`--cinder-jse-property-depth: ${depth}`)}><button type="button" class="cinder-jse-property-row__trigger"${$2.attr("aria-label", `${isOpen ? "Collapse" : "Expand"} ${key} property`)}${$2.attr("aria-expanded", isOpen)}${$2.attr("aria-controls", panelId)}><span class="cinder-jse-property-row__chevron" aria-hidden="true">▸</span> <span class="cinder-jse-property-row__name">${$2.escape(key)}</span> <span class="cinder-jse-property-row__type">${$2.escape(summariseType(properties[key] ?? {}))}</span></button> <span class="cinder-jse-property-row__spacer"></span> `);
+      Button($$renderer2, {
+        variant: isRequired ? "primary" : "ghost",
+        size: "xs",
+        disabled: readonly,
+        "aria-pressed": isRequired,
+        "aria-label": isRequired ? "Required (toggle off)" : "Optional (toggle required)",
+        onclick: () => toggleRequired(key),
+        children: ($$renderer3) => {
+          $$renderer3.push(`<!---->${$2.escape(isRequired ? "Required" : "Optional")}`);
+        },
+        $$slots: { default: true }
+      });
+      $$renderer2.push(`<!----> `);
+      Button($$renderer2, {
+        variant: "ghost",
+        size: "xs",
+        disabled: readonly,
+        "aria-label": "Move up",
+        onclick: () => moveProperty(key, -1),
+        children: ($$renderer3) => {
+          $$renderer3.push(`<!---->↑`);
+        },
+        $$slots: { default: true }
+      });
+      $$renderer2.push(`<!----> `);
+      Button($$renderer2, {
+        variant: "ghost",
+        size: "xs",
+        disabled: readonly,
+        "aria-label": "Move down",
+        onclick: () => moveProperty(key, 1),
+        children: ($$renderer3) => {
+          $$renderer3.push(`<!---->↓`);
+        },
+        $$slots: { default: true }
+      });
+      $$renderer2.push(`<!----> `);
+      Button($$renderer2, {
+        variant: "ghost-danger",
+        size: "xs",
+        disabled: readonly,
+        "aria-label": `Delete ${key}`,
+        onclick: () => deleteProperty(key),
+        children: ($$renderer3) => {
+          $$renderer3.push(`<!---->Delete`);
+        },
+        $$slots: { default: true }
+      });
+      $$renderer2.push(`<!----></div> `);
+      if (isOpen) {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`<div${$2.attr("id", panelId)} class="cinder-jse-property-row__panel">`);
+        Input($$renderer2, {
+          id: `${idPrefix}-${key}-name`,
+          label: "Name",
+          value: getDraftName(key),
+          disabled: readonly,
+          oninput: (event) => draftNames[key] = event.target.value,
+          onblur: () => commitRename(key)
+        });
+        $$renderer2.push(`<!----> `);
+        Property_editor($$renderer2, {
+          idPrefix: `${idPrefix}-${key}-schema`,
+          path: `${path}/${key}`,
+          depth: depth + 1,
+          readonly,
+          value: properties[key] ?? {},
+          onvalidationerrorcount: (count) => setChildValidationErrorCount(key, count),
+          onchange: (next) => setPropertySchema(key, next)
+        });
+        $$renderer2.push(`<!----></div>`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--></div>`);
+    }
+    $$renderer2.push(`<!--]--> `);
+    Button($$renderer2, {
+      variant: "secondary",
+      size: "sm",
+      disabled: readonly,
+      onclick: addProperty,
+      children: ($$renderer3) => {
+        $$renderer3.push(`<!---->Add property`);
+      },
+      $$slots: { default: true }
+    });
+    $$renderer2.push(`<!----> `);
+    if (!readonly || requiredOnly().length > 0) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<details class="cinder-jse-required-only"${$2.attr("open", requiredOnly().length > 0, true)}><summary class="cinder-jse-required-only__summary">Required without property schema (${$2.escape(requiredOnly().length)})</summary> <div class="cinder-jse-required-only__panel"><!--[-->`);
+      const each_array_1 = $2.ensure_array_like(requiredOnly());
+      for (let $$index_1 = 0, $$length = each_array_1.length;$$index_1 < $$length; $$index_1++) {
+        let name = each_array_1[$$index_1];
+        Chip($$renderer2, {
+          mode: "removable",
+          label: name,
+          disabled: readonly,
+          onremove: () => removeRequiredOnly(name)
+        });
+      }
+      $$renderer2.push(`<!--]--> `);
+      Input($$renderer2, {
+        id: `${idPrefix}-required-only-add`,
+        label: "Add required name",
+        value: newRequiredOnlyName,
+        disabled: readonly,
+        oninput: (event) => newRequiredOnlyName = event.target.value,
+        onkeydown: (event) => {
+          if (event.key === "Enter") {
+            event.preventDefault();
+            addRequiredOnly();
+          }
+        }
+      });
+      $$renderer2.push(`<!----> `);
+      Button($$renderer2, {
+        variant: "secondary",
+        size: "sm",
+        disabled: readonly,
+        onclick: addRequiredOnly,
+        children: ($$renderer3) => {
+          $$renderer3.push(`<!---->Add required name`);
+        },
+        $$slots: { default: true }
+      });
+      $$renderer2.push(`<!----></div></details>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></div>`);
+  });
+}
+
+// src/components/json-schema-editor/property-editor.svelte
+var PRIMITIVE_TYPES = [
+  "string",
+  "number",
+  "integer",
+  "boolean",
+  "null",
+  "object",
+  "array"
+];
+var EDITABLE_KEYWORDS = new Set([
+  "type",
+  "title",
+  "description",
+  "default",
+  "examples",
+  "const",
+  "enum",
+  "minLength",
+  "maxLength",
+  "pattern",
+  "format",
+  "minimum",
+  "maximum",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "multipleOf",
+  "properties",
+  "required",
+  "additionalProperties",
+  "items",
+  "minItems",
+  "maxItems",
+  "uniqueItems",
+  "oneOf",
+  "anyOf",
+  "allOf",
+  "not",
+  "$ref",
+  "$schema"
+]);
+var DEFAULT_COLLAPSE_DEPTH = 3;
+var MAX_RENDER_DEPTH = 30;
+var NUMBER_CONSTRAINT_FIELDS = [
+  { key: "minimum", label: "Minimum" },
+  { key: "maximum", label: "Maximum" },
+  { key: "exclusiveMinimum", label: "Exclusive minimum" },
+  { key: "exclusiveMaximum", label: "Exclusive maximum" },
+  { key: "multipleOf", label: "Multiple of" }
+];
+function Property_editor($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      idPrefix,
+      value,
+      path,
+      depth = 0,
+      readonly = false,
+      onvalidationerrorcount,
+      onchange,
+      class: className
+    } = $$props;
+    const isBooleanSchema = $3.derived(() => typeof value === "boolean");
+    const objectValue = $3.derived(() => {
+      if (typeof value === "boolean")
+        return {};
+      return value;
+    });
+    const originalTypeRepresentation = $3.derived(() => objectValue().type === undefined ? "absent" : Array.isArray(objectValue().type) ? "array" : "scalar");
+    const selectedTypes = $3.derived(() => {
+      const t = objectValue().type;
+      if (t === undefined)
+        return [];
+      return Array.isArray(t) ? [...t] : [t];
+    });
+    const isAnyType = $3.derived(() => selectedTypes().length === 0);
+    const preservedKeys = $3.derived(() => {
+      return Object.keys(objectValue()).filter((key) => !EDITABLE_KEYWORDS.has(key));
+    });
+    function patch(edits, opts = undefined) {
+      if (readonly)
+        return;
+      const next = { ...objectValue(), ...edits };
+      for (const key of Object.keys(edits)) {
+        if (next[key] === undefined)
+          delete next[key];
+      }
+      onchange(next, opts);
+    }
+    function setTypeFromCheckboxes(types) {
+      if (readonly)
+        return;
+      if (types.length === 0) {
+        patch({ type: undefined }, { label: "change type" });
+        return;
+      }
+      if (types.length === 1) {
+        const next = originalTypeRepresentation() === "array" ? types : types[0];
+        patch({ type: next }, { label: "change type" });
+        return;
+      }
+      patch({ type: types }, { label: "change type" });
+    }
+    function toggleType(type, checked) {
+      const current = new Set(selectedTypes());
+      if (checked)
+        current.add(type);
+      else
+        current.delete(type);
+      setTypeFromCheckboxes([...current]);
+    }
+    function setAny(any) {
+      if (any) {
+        setTypeFromCheckboxes([]);
+      } else {
+        if (selectedTypes().length === 0)
+          setTypeFromCheckboxes(["object"]);
+      }
+    }
+    function convertBooleanToObject() {
+      if (readonly)
+        return;
+      onchange({}, { label: "convert to object schema" });
+    }
+    function parseOptionalFiniteNumber(raw) {
+      if (raw === "")
+        return;
+      const parsed = Number(raw);
+      return Number.isFinite(parsed) ? parsed : undefined;
+    }
+    function numberConstraintValue(key) {
+      const value2 = objectValue()[key];
+      return typeof value2 === "number" ? value2.toString() : "";
+    }
+    function patchNumberConstraint(key, raw) {
+      patch({ [key]: parseOptionalFiniteNumber(raw) }, { coalesceKey: `${key}:${path}`, label: `edit ${key}` });
+    }
+    const showStringConstraints = $3.derived(() => selectedTypes().includes("string"));
+    const showNumberConstraints = $3.derived(() => selectedTypes().includes("number") || selectedTypes().includes("integer"));
+    const showObjectConstraints = $3.derived(() => selectedTypes().includes("object"));
+    const showArrayConstraints = $3.derived(() => selectedTypes().includes("array"));
+    const tooDeep = $3.derived(() => depth >= MAX_RENDER_DEPTH);
+    let userExpanded = false;
+    const collapsedByDefault = $3.derived(() => depth >= DEFAULT_COLLAPSE_DEPTH);
+    const collapsed = $3.derived(() => collapsedByDefault() && !userExpanded);
+    function summaryLine() {
+      if (typeof value === "boolean")
+        return value ? "true (allow anything)" : "false (allow nothing)";
+      const parts = [];
+      if (objectValue().type !== undefined) {
+        parts.push(Array.isArray(objectValue().type) ? objectValue().type.join("|") : objectValue().type);
+      } else {
+        parts.push("any");
+      }
+      if (objectValue().properties) {
+        parts.push(`${Object.keys(objectValue().properties).length} props`);
+      }
+      if (objectValue().title)
+        parts.push(`"${objectValue().title}"`);
+      return parts.join(" · ");
+    }
+    let childValidationCounts = {};
+    const validationErrorCount = $3.derived(() => Object.values(childValidationCounts).reduce((total, count) => total + count, 0));
+    onDestroy2(() => {
+      onvalidationerrorcount?.(0);
+    });
+    function setChildValidationErrorCount(key, count) {
+      if ((childValidationCounts[key] ?? 0) === count)
+        return;
+      if (count === 0) {
+        const { [key]: _removedChildCount, ...remainingChildCounts } = childValidationCounts;
+        childValidationCounts = remainingChildCounts;
+        return;
+      }
+      childValidationCounts = { ...childValidationCounts, [key]: count };
+    }
+    function patchProperties(properties, required) {
+      const edits = { properties };
+      edits.required = required.length > 0 ? required : undefined;
+      patch(edits, { label: "edit properties" });
+    }
+    function setItems(items) {
+      patch({ items }, { label: "edit items" });
+    }
+    function patchComposition(keyword, next) {
+      patch({ [keyword]: next }, { label: `edit ${keyword}` });
+    }
+    let nextCompositionBranchKey = 1;
+    function createCompositionBranchKey() {
+      return `branch-${nextCompositionBranchKey++}`;
+    }
+    let allOfKeys = [];
+    let anyOfKeys = [];
+    let oneOfKeys = [];
+    const compositionBranchKeys = $3.derived(() => ({ allOf: allOfKeys, anyOf: anyOfKeys, oneOf: oneOfKeys }));
+    function setKeywordKeys(keyword, keys) {
+      if (keyword === "allOf")
+        allOfKeys = keys;
+      else if (keyword === "anyOf")
+        anyOfKeys = keys;
+      else
+        oneOfKeys = keys;
+    }
+    function removeCompositionBranch(keyword, branchIndex) {
+      const list = Array.isArray(objectValue()[keyword]) ? [...objectValue()[keyword]] : [];
+      const removedBranchKey = compositionBranchKeys()[keyword][branchIndex];
+      const nextBranchKeys = [...compositionBranchKeys()[keyword]];
+      list.splice(branchIndex, 1);
+      nextBranchKeys.splice(branchIndex, 1);
+      setKeywordKeys(keyword, nextBranchKeys);
+      if (removedBranchKey)
+        setChildValidationErrorCount(`${keyword}:${removedBranchKey}`, 0);
+      patchComposition(keyword, list.length > 0 ? list : undefined);
+    }
+    function addCompositionBranch(keyword) {
+      const list = Array.isArray(objectValue()[keyword]) ? [...objectValue()[keyword]] : [];
+      list.push({});
+      setKeywordKeys(keyword, [
+        ...compositionBranchKeys()[keyword],
+        createCompositionBranchKey()
+      ]);
+      patchComposition(keyword, list);
+    }
+    $$renderer2.push(`<div${$3.attr_class($3.clsx(classNames("cinder-jse-property-editor", className)))}${$3.attr("data-cinder-jse-depth", depth)}>`);
+    if (tooDeep()) {
+      $$renderer2.push("<!--[0-->");
+      Alert($$renderer2, {
+        variant: "info",
+        children: ($$renderer3) => {
+          $$renderer3.push(`<!---->Schema depth exceeded (30). Edit deeper sections via the JSON view.`);
+        },
+        $$slots: { default: true }
+      });
+    } else if (isBooleanSchema()) {
+      $$renderer2.push("<!--[1-->");
+      $$renderer2.push(`<div class="cinder-jse-boolean-schema"><span>Boolean schema — ${$3.escape(value ? "allows anything" : "allows nothing")}.</span> `);
+      Button($$renderer2, {
+        variant: "secondary",
+        size: "sm",
+        disabled: readonly,
+        onclick: convertBooleanToObject,
+        children: ($$renderer3) => {
+          $$renderer3.push(`<!---->Convert to object schema`);
+        },
+        $$slots: { default: true }
+      });
+      $$renderer2.push(`<!----></div>`);
+    } else if (collapsed()) {
+      $$renderer2.push("<!--[2-->");
+      $$renderer2.push(`<button type="button" class="cinder-jse-collapsed"><span class="cinder-jse-collapsed__summary">${$3.escape(summaryLine())}</span> <span class="cinder-jse-collapsed__hint">Expand</span></button>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      if (depth > 0 && collapsedByDefault()) {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`<div class="cinder-jse-section-header">`);
+        Button($$renderer2, {
+          variant: "ghost",
+          size: "sm",
+          onclick: () => userExpanded = false,
+          children: ($$renderer3) => {
+            $$renderer3.push(`<!---->Collapse`);
+          },
+          $$slots: { default: true }
+        });
+        $$renderer2.push(`<!----></div>`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--> <div class="cinder-jse-section cinder-jse-section--lead">`);
+      Input($$renderer2, {
+        id: `${idPrefix}-title`,
+        label: "Title",
+        value: objectValue().title ?? "",
+        disabled: readonly,
+        oninput: (event) => patch({ title: event.target.value || undefined }, { coalesceKey: `title:${path}`, label: "edit title" })
+      });
+      $$renderer2.push(`<!----> `);
+      Input($$renderer2, {
+        id: `${idPrefix}-description`,
+        label: "Description",
+        value: objectValue().description ?? "",
+        disabled: readonly,
+        oninput: (event) => patch({ description: event.target.value || undefined }, {
+          coalesceKey: `description:${path}`,
+          label: "edit description"
+        })
+      });
+      $$renderer2.push(`<!----></div> <div class="cinder-jse-section"><h4 class="cinder-jse-section__title">Type</h4> <div class="cinder-jse-type-row">`);
+      Checkbox($$renderer2, {
+        id: `${idPrefix}-type-any`,
+        checked: isAnyType(),
+        label: "Any",
+        disabled: readonly,
+        onchange: (event) => setAny(event.target.checked)
+      });
+      $$renderer2.push(`<!----> <!--[-->`);
+      const each_array = $3.ensure_array_like(PRIMITIVE_TYPES);
+      for (let $$index = 0, $$length = each_array.length;$$index < $$length; $$index++) {
+        let primitive = each_array[$$index];
+        Checkbox($$renderer2, {
+          id: `${idPrefix}-type-${primitive}`,
+          checked: selectedTypes().includes(primitive),
+          label: primitive,
+          disabled: readonly,
+          onchange: (event) => toggleType(primitive, event.target.checked)
+        });
+      }
+      $$renderer2.push(`<!--]--></div></div> `);
+      if (showObjectConstraints()) {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`<div class="cinder-jse-section"><h4 class="cinder-jse-section__title">Properties</h4> `);
+        Property_list($$renderer2, {
+          idPrefix,
+          readonly,
+          depth,
+          path: `${path}/properties`,
+          properties: objectValue().properties ?? {},
+          required: objectValue().required ?? [],
+          onvalidationerrorcount: (count) => setChildValidationErrorCount("properties", count),
+          onchange: patchProperties
+        });
+        $$renderer2.push(`<!----></div>`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--> `);
+      if (showArrayConstraints()) {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`<div class="cinder-jse-section"><h4 class="cinder-jse-section__title">Array items</h4> `);
+        Property_editor($$renderer2, {
+          idPrefix: `${idPrefix}-items`,
+          path: `${path}/items`,
+          depth: depth + 1,
+          readonly,
+          value: objectValue().items ?? {},
+          onvalidationerrorcount: (count) => setChildValidationErrorCount("items", count),
+          onchange: (next) => setItems(next)
+        });
+        $$renderer2.push(`<!----></div>`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--> `);
+      if (showStringConstraints()) {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`<details class="cinder-jse-section cinder-jse-section--collapsible"><summary class="cinder-jse-section__title">String constraints</summary> <div class="cinder-jse-section__body">`);
+        Input($$renderer2, {
+          id: `${idPrefix}-minLength`,
+          label: "Min length",
+          type: "text",
+          value: objectValue().minLength?.toString() ?? "",
+          disabled: readonly,
+          oninput: (event) => {
+            const raw = event.target.value;
+            const parsed = raw === "" ? undefined : Number.parseInt(raw, 10);
+            patch({ minLength: Number.isNaN(parsed) ? undefined : parsed }, { coalesceKey: `minLength:${path}`, label: "edit minLength" });
+          }
+        });
+        $$renderer2.push(`<!----> `);
+        Input($$renderer2, {
+          id: `${idPrefix}-maxLength`,
+          label: "Max length",
+          type: "text",
+          value: objectValue().maxLength?.toString() ?? "",
+          disabled: readonly,
+          oninput: (event) => {
+            const raw = event.target.value;
+            const parsed = raw === "" ? undefined : Number.parseInt(raw, 10);
+            patch({ maxLength: Number.isNaN(parsed) ? undefined : parsed }, { coalesceKey: `maxLength:${path}`, label: "edit maxLength" });
+          }
+        });
+        $$renderer2.push(`<!----> `);
+        Input($$renderer2, {
+          id: `${idPrefix}-pattern`,
+          label: "Pattern (regex)",
+          value: objectValue().pattern ?? "",
+          disabled: readonly,
+          oninput: (event) => patch({ pattern: event.target.value || undefined }, { coalesceKey: `pattern:${path}`, label: "edit pattern" })
+        });
+        $$renderer2.push(`<!----> `);
+        Input($$renderer2, {
+          id: `${idPrefix}-format`,
+          label: "Format",
+          value: objectValue().format ?? "",
+          disabled: readonly,
+          oninput: (event) => patch({ format: event.target.value || undefined }, { coalesceKey: `format:${path}`, label: "edit format" })
+        });
+        $$renderer2.push(`<!----></div></details>`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--> `);
+      if (showNumberConstraints()) {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`<details class="cinder-jse-section cinder-jse-section--collapsible"><summary class="cinder-jse-section__title">Number constraints</summary> <div class="cinder-jse-section__body"><!--[-->`);
+        const each_array_1 = $3.ensure_array_like(NUMBER_CONSTRAINT_FIELDS);
+        for (let $$index_1 = 0, $$length = each_array_1.length;$$index_1 < $$length; $$index_1++) {
+          let field = each_array_1[$$index_1];
+          Input($$renderer2, {
+            id: `${idPrefix}-${field.key}`,
+            label: field.label,
+            value: numberConstraintValue(field.key),
+            disabled: readonly,
+            oninput: (event) => patchNumberConstraint(field.key, event.target.value)
+          });
+        }
+        $$renderer2.push(`<!--]--></div></details>`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--> <!--[-->`);
+      const each_array_2 = $3.ensure_array_like(["allOf", "anyOf", "oneOf"]);
+      for (let $$index_3 = 0, $$length = each_array_2.length;$$index_3 < $$length; $$index_3++) {
+        let keyword = each_array_2[$$index_3];
+        if (Array.isArray(objectValue()[keyword])) {
+          $$renderer2.push("<!--[0-->");
+          $$renderer2.push(`<details class="cinder-jse-section cinder-jse-section--collapsible" open=""><summary class="cinder-jse-section__title">${$3.escape(keyword)}</summary> <div class="cinder-jse-section__body"><!--[-->`);
+          const each_array_3 = $3.ensure_array_like(objectValue()[keyword]);
+          for (let branchIndex = 0, $$length2 = each_array_3.length;branchIndex < $$length2; branchIndex++) {
+            let branch = each_array_3[branchIndex];
+            const branchKey = compositionBranchKeys()[keyword][branchIndex];
+            Property_editor($$renderer2, {
+              idPrefix: `${idPrefix}-${keyword}-${branchIndex}`,
+              path: `${path}/${keyword}/${branchIndex}`,
+              depth: depth + 1,
+              readonly,
+              value: branch,
+              onvalidationerrorcount: (count) => setChildValidationErrorCount(`${keyword}:${branchKey}`, count),
+              onchange: (next) => {
+                const list = [...objectValue()[keyword]];
+                list[branchIndex] = next;
+                patchComposition(keyword, list);
+              }
+            });
+            $$renderer2.push(`<!----> `);
+            Button($$renderer2, {
+              variant: "ghost",
+              size: "xs",
+              disabled: readonly,
+              onclick: () => removeCompositionBranch(keyword, branchIndex),
+              children: ($$renderer3) => {
+                $$renderer3.push(`<!---->Remove branch`);
+              },
+              $$slots: { default: true }
+            });
+            $$renderer2.push(`<!---->`);
+          }
+          $$renderer2.push(`<!--]--> `);
+          Button($$renderer2, {
+            variant: "secondary",
+            size: "sm",
+            disabled: readonly,
+            onclick: () => addCompositionBranch(keyword),
+            children: ($$renderer3) => {
+              $$renderer3.push(`<!---->Add ${$3.escape(keyword)} branch`);
+            },
+            $$slots: { default: true }
+          });
+          $$renderer2.push(`<!----></div></details>`);
+        } else {
+          $$renderer2.push("<!--[-1-->");
+        }
+        $$renderer2.push(`<!--]-->`);
+      }
+      $$renderer2.push(`<!--]--> `);
+      if (objectValue().$ref !== undefined) {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`<div class="cinder-jse-section"><h4 class="cinder-jse-section__title">$ref</h4> `);
+        Input($$renderer2, {
+          id: `${idPrefix}-ref`,
+          label: "$ref URI",
+          value: objectValue().$ref,
+          disabled: readonly,
+          oninput: (event) => patch({ $ref: event.target.value || undefined }, { coalesceKey: `$ref:${path}`, label: "edit $ref" })
+        });
+        $$renderer2.push(`<!----> `);
+        Button($$renderer2, {
+          variant: "ghost",
+          size: "xs",
+          disabled: readonly,
+          onclick: () => patch({ $ref: undefined }, { label: "remove $ref" }),
+          children: ($$renderer3) => {
+            $$renderer3.push(`<!---->Remove $ref`);
+          },
+          $$slots: { default: true }
+        });
+        $$renderer2.push(`<!----></div>`);
+      } else if (!readonly) {
+        $$renderer2.push("<!--[1-->");
+        $$renderer2.push(`<div class="cinder-jse-advanced-row">`);
+        Button($$renderer2, {
+          variant: "ghost",
+          size: "xs",
+          onclick: () => patch({ $ref: "" }, { label: "add $ref" }),
+          children: ($$renderer3) => {
+            $$renderer3.push(`<!---->Add $ref`);
+          },
+          $$slots: { default: true }
+        });
+        $$renderer2.push(`<!----> `);
+        if (preservedKeys().length > 0) {
+          $$renderer2.push("<!--[0-->");
+          Tooltip($$renderer2, {
+            text: `Preserved keys: ${preservedKeys().join(", ")}`,
+            children: ($$renderer3) => {
+              Badge($$renderer3, {
+                variant: "info",
+                children: ($$renderer4) => {
+                  $$renderer4.push(`<!---->+${$3.escape(preservedKeys().length)} preserved`);
+                },
+                $$slots: { default: true }
+              });
+            },
+            $$slots: { default: true }
+          });
+        } else {
+          $$renderer2.push("<!--[-1-->");
+        }
+        $$renderer2.push(`<!--]--></div>`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--> `);
+      if (readonly && objectValue().$ref === undefined && preservedKeys().length > 0) {
+        $$renderer2.push("<!--[0-->");
+        Tooltip($$renderer2, {
+          text: `Preserved keys: ${preservedKeys().join(", ")}`,
+          children: ($$renderer3) => {
+            Badge($$renderer3, {
+              variant: "info",
+              children: ($$renderer4) => {
+                $$renderer4.push(`<!---->+${$3.escape(preservedKeys().length)} preserved`);
+              },
+              $$slots: { default: true }
+            });
+          },
+          $$slots: { default: true }
+        });
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]-->`);
+    }
+    $$renderer2.push(`<!--]--></div>`);
+  });
+}
+
+// src/components/json-schema-editor/form-view.svelte
+function Form_view($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { state, idPrefix, onvalidationerrorcount, class: className } = $$props;
+    const rootSchema = $4.derived(() => state.committedSchema);
+    $$renderer2.push(`<div${$4.attr_class($4.clsx(classNames("cinder-jse-form-view", className)))}>`);
+    if (state.jsonDraftIsDirty) {
+      $$renderer2.push("<!--[0-->");
+      Alert($$renderer2, {
+        variant: "warning",
+        children: ($$renderer3) => {
+          $$renderer3.push(`<p>The JSON view has uncommitted changes. Apply or discard them to edit in the form.</p> <div class="cinder-jse-dirty-actions">`);
+          Button($$renderer3, {
+            variant: "primary",
+            size: "sm",
+            onclick: () => state.applyJsonDraft(),
+            children: ($$renderer4) => {
+              $$renderer4.push(`<!---->Apply JSON`);
+            },
+            $$slots: { default: true }
+          });
+          $$renderer3.push(`<!----> `);
+          Button($$renderer3, {
+            variant: "secondary",
+            size: "sm",
+            onclick: () => state.discardJsonDraft(),
+            children: ($$renderer4) => {
+              $$renderer4.push(`<!---->Discard JSON`);
+            },
+            $$slots: { default: true }
+          });
+          $$renderer3.push(`<!----></div>`);
+        },
+        $$slots: { default: true }
+      });
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    if (rootSchema() === null) {
+      $$renderer2.push("<!--[0-->");
+      Empty_state($$renderer2, {
+        title: "Schema not loaded",
+        description: state.originalLoadError ?? "The current input could not be parsed. Edit the JSON view to set a valid schema."
+      });
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      Property_editor($$renderer2, {
+        idPrefix,
+        path: "",
+        depth: 0,
+        readonly: state.readonly || state.jsonDraftIsDirty,
+        value: rootSchema(),
+        onvalidationerrorcount,
+        onchange: (next, options) => state.commitFromForm(next, options)
+      });
+    }
+    $$renderer2.push(`<!--]--></div>`);
+  });
+}
+
+// src/components/json-schema-editor/json-schema-editor-state.svelte.ts
+import * as $6 from "svelte/internal/server";
+
+// src/utilities/use-history.svelte.ts
+import * as $5 from "svelte/internal/server";
+function defaultClone(value) {
+  const snapshot = value;
+  return structuredClone(snapshot);
+}
+function isPlainObjectRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function stableSerialise(value) {
+  return JSON.stringify(value, (_key, val) => {
+    if (!isPlainObjectRecord(val))
+      return val;
+    const sorted = {};
+    for (const k of Object.keys(val).toSorted()) {
+      sorted[k] = val[k];
+    }
+    return sorted;
+  });
+}
+function defaultEquals(a, b) {
+  if (a === b) {
+    if (a === null || typeof a !== "object")
+      return true;
+  }
+  return stableSerialise(a) === stableSerialise(b);
+}
+function useHistory(options) {
+  const {
+    initial,
+    coalesceMs = 300,
+    clone = defaultClone,
+    equals = defaultEquals
+  } = options;
+  const maxDepth = Math.max(1, options.maxDepth ?? 100);
+  const seed = { value: clone(initial), committedAt: 0 };
+  let stack = [seed];
+  let pointer = 0;
+  let current = clone(initial);
+  function entryAt(index) {
+    const entry = stack[index];
+    if (!entry) {
+      throw new Error(`useHistory: stack index ${index} out of range (size ${stack.length})`);
+    }
+    return entry;
+  }
+  function evictIfNeeded() {
+    while (stack.length > maxDepth) {
+      stack.shift();
+      pointer = Math.max(0, pointer - 1);
+    }
+  }
+  function snapshotEntry(entry) {
+    return { value: clone(entry.value), label: entry.label };
+  }
+  return {
+    get current() {
+      return current;
+    },
+    get committedEntry() {
+      return snapshotEntry(entryAt(pointer));
+    },
+    get canUndo() {
+      return pointer > 0;
+    },
+    get canRedo() {
+      return pointer < stack.length - 1;
+    },
+    get size() {
+      return stack.length;
+    },
+    get index() {
+      return pointer;
+    },
+    set(next) {
+      current = next;
+    },
+    commit(next, commitOptions) {
+      const top = entryAt(pointer);
+      const cloned = clone(next);
+      if (equals(next, top.value)) {
+        current = clone(top.value);
+        return;
+      }
+      const now = Date.now();
+      const coalesceKey = commitOptions?.coalesceKey;
+      const label = commitOptions?.label;
+      const canCoalesce = coalesceKey !== undefined && top.coalesceKey === coalesceKey && now - top.committedAt <= coalesceMs && pointer === stack.length - 1;
+      if (canCoalesce) {
+        stack[pointer] = {
+          value: cloned,
+          label: label ?? top.label,
+          coalesceKey,
+          committedAt: now
+        };
+      } else {
+        if (pointer < stack.length - 1) {
+          stack = stack.slice(0, pointer + 1);
+        }
+        stack.push({ value: cloned, label, coalesceKey, committedAt: now });
+        pointer = stack.length - 1;
+        evictIfNeeded();
+      }
+      current = clone(entryAt(pointer).value);
+    },
+    undo() {
+      if (pointer === 0)
+        return null;
+      const left = entryAt(pointer);
+      pointer -= 1;
+      current = clone(entryAt(pointer).value);
+      return snapshotEntry(left);
+    },
+    redo() {
+      if (pointer >= stack.length - 1)
+        return null;
+      pointer += 1;
+      const moved = entryAt(pointer);
+      current = clone(moved.value);
+      return snapshotEntry(moved);
+    },
+    reset(value, label) {
+      stack = [{ value: clone(value), label, committedAt: Date.now() }];
+      pointer = 0;
+      current = clone(value);
+    }
+  };
+}
+
+// src/components/json-schema-editor/json-schema-validator.ts
+import Ajv from "ajv";
+import Ajv2019 from "ajv/dist/2019.js";
+import Ajv2020 from "ajv/dist/2020.js";
+var DRAFT_2020_IDS = new Set([
+  "https://json-schema.org/draft/2020-12/schema",
+  "http://json-schema.org/draft/2020-12/schema"
+]);
+var DRAFT_2019_IDS = new Set([
+  "https://json-schema.org/draft/2019-09/schema",
+  "http://json-schema.org/draft/2019-09/schema"
+]);
+var DRAFT_07_IDS = new Set([
+  "http://json-schema.org/draft-07/schema#",
+  "http://json-schema.org/draft-07/schema",
+  "https://json-schema.org/draft-07/schema",
+  "https://json-schema.org/draft-07/schema#"
+]);
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function getSchemaId(schema) {
+  if (!isObject(schema))
+    return;
+  const id = schema["$schema"];
+  return typeof id === "string" ? id : undefined;
+}
+function detectDraft(schema) {
+  const id = getSchemaId(schema);
+  if (!id)
+    return "2020-12";
+  if (DRAFT_2020_IDS.has(id))
+    return "2020-12";
+  if (DRAFT_2019_IDS.has(id))
+    return "2019-09";
+  if (DRAFT_07_IDS.has(id))
+    return "draft-07";
+  return "unknown";
+}
+function resolveDraft(draft) {
+  if (!draft || draft === "unknown")
+    return "2020-12";
+  return draft;
+}
+var metaAjv2020 = null;
+var metaAjv2019 = null;
+var metaAjv07 = null;
+function getMetaValidator(draft) {
+  if (draft === "2020-12") {
+    if (!metaAjv2020)
+      metaAjv2020 = new Ajv2020({ strict: false, allErrors: true });
+    return metaAjv2020;
+  }
+  if (draft === "2019-09") {
+    if (!metaAjv2019)
+      metaAjv2019 = new Ajv2019({ strict: false, allErrors: true });
+    return metaAjv2019;
+  }
+  if (!metaAjv07)
+    metaAjv07 = new Ajv({ strict: false, allErrors: true });
+  return metaAjv07;
+}
+function ajvErrorsToValidationErrors(errors) {
+  if (!errors)
+    return [];
+  return errors.map((error) => ({
+    path: error.instancePath ?? "",
+    message: error.message ?? "Validation error",
+    keyword: error.keyword ?? ""
+  }));
+}
+function validateMetaSchema(schema, draft) {
+  if (typeof schema === "boolean")
+    return { valid: true, errors: [] };
+  if (!isObject(schema)) {
+    return {
+      valid: false,
+      errors: [{ path: "", message: "Schema must be an object or boolean", keyword: "" }]
+    };
+  }
+  const resolved = resolveDraft(draft ?? detectDraft(schema));
+  const ajv = getMetaValidator(resolved);
+  try {
+    const valid = ajv.validateSchema(schema);
+    return {
+      valid: Boolean(valid),
+      errors: ajvErrorsToValidationErrors(ajv.errors)
+    };
+  } catch (error) {
+    return {
+      valid: false,
+      errors: [
+        {
+          path: "",
+          message: error instanceof Error ? error.message : "Meta-schema validation failed",
+          keyword: ""
+        }
+      ]
+    };
+  }
+}
+function tryCompile(schema, draft) {
+  if (typeof schema === "boolean")
+    return { ok: true };
+  if (!isObject(schema)) {
+    return { ok: false, error: "Schema must be an object or boolean" };
+  }
+  const resolved = resolveDraft(draft ?? detectDraft(schema));
+  let ajv;
+  if (resolved === "2020-12") {
+    ajv = new Ajv2020({ strict: false, addUsedSchema: false });
+  } else if (resolved === "2019-09") {
+    ajv = new Ajv2019({ strict: false, addUsedSchema: false });
+  } else {
+    ajv = new Ajv({ strict: false, addUsedSchema: false });
+  }
+  try {
+    ajv.compile(schema);
+    return { ok: true };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function extractParsePosition(error, source) {
+  const positionMatch = error.message.match(/position (\d+)/);
+  const positionString = positionMatch?.[1];
+  if (!positionString)
+    return;
+  const offset = Number.parseInt(positionString, 10);
+  if (Number.isNaN(offset) || offset < 0 || offset > source.length)
+    return;
+  let line = 1;
+  let column = 1;
+  for (let i = 0;i < offset; i += 1) {
+    if (source[i] === `
+`) {
+      line += 1;
+      column = 1;
+    } else {
+      column += 1;
+    }
+  }
+  return { line, column };
+}
+function tryParseJson(text) {
+  try {
+    return { ok: true, value: JSON.parse(text) };
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      const position = extractParsePosition(error, text);
+      const errorPayload = {
+        message: error.message
+      };
+      if (position) {
+        errorPayload.line = position.line;
+        errorPayload.column = position.column;
+      }
+      return { ok: false, error: errorPayload };
+    }
+    return {
+      ok: false,
+      error: {
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+}
+function findJsonIncompatibility(value, path, seen) {
+  if (value === null)
+    return null;
+  const valueType = typeof value;
+  if (valueType === "string" || valueType === "boolean")
+    return null;
+  if (valueType === "number") {
+    if (typeof value === "number" && !Number.isFinite(value)) {
+      return `non-finite number at ${path || "root"}`;
+    }
+    return null;
+  }
+  if (valueType === "undefined")
+    return `undefined at ${path || "root"}`;
+  if (valueType === "function")
+    return `function at ${path || "root"}`;
+  if (valueType === "symbol")
+    return `symbol at ${path || "root"}`;
+  if (valueType === "bigint")
+    return `bigint at ${path || "root"}`;
+  if (seen.has(value))
+    return `cycle at ${path || "root"}`;
+  seen.add(value);
+  if (Array.isArray(value)) {
+    for (let i = 0;i < value.length; i += 1) {
+      const error = findJsonIncompatibility(value[i], `${path}[${i}]`, seen);
+      if (error)
+        return error;
+    }
+    seen.delete(value);
+    return null;
+  }
+  if (isObject(value)) {
+    const proto = Object.getPrototypeOf(value);
+    if (proto !== null && proto !== Object.prototype) {
+      const constructorName = typeof proto.constructor?.name === "string" ? proto.constructor.name : "unknown";
+      return `non-plain object (${constructorName}) at ${path || "root"}`;
+    }
+    for (const key of Object.keys(value)) {
+      const child = value[key];
+      const error = findJsonIncompatibility(child, `${path}.${key}`, seen);
+      if (error)
+        return error;
+    }
+    seen.delete(value);
+    return null;
+  }
+  return `unsupported value at ${path || "root"}`;
+}
+var PRETTY_INDENT = 2;
+function normaliseSchemaInput(input) {
+  if (typeof input === "string") {
+    const parsed = tryParseJson(input);
+    if (!parsed.ok) {
+      return { ok: false, rawText: input, error: parsed.error.message };
+    }
+    if (typeof parsed.value !== "boolean" && !isObject(parsed.value)) {
+      return {
+        ok: false,
+        rawText: input,
+        error: "Top-level schema must be an object or boolean"
+      };
+    }
+    const schema = parsed.value;
+    return {
+      ok: true,
+      rawText: input,
+      canonicalText: JSON.stringify(schema, null, PRETTY_INDENT),
+      schema
+    };
+  }
+  if (typeof input === "boolean") {
+    return {
+      ok: true,
+      rawText: JSON.stringify(input),
+      canonicalText: JSON.stringify(input, null, PRETTY_INDENT),
+      schema: input
+    };
+  }
+  if (!isObject(input)) {
+    return {
+      ok: false,
+      rawText: "",
+      error: "Top-level schema must be an object or boolean"
+    };
+  }
+  const incompatibility = findJsonIncompatibility(input, "", new Set);
+  if (incompatibility) {
+    return { ok: false, rawText: "", error: incompatibility };
+  }
+  return {
+    ok: true,
+    rawText: JSON.stringify(input),
+    canonicalText: JSON.stringify(input, null, PRETTY_INDENT),
+    schema: input
+  };
+}
+
+// src/components/json-schema-editor/json-schema-editor-state.svelte.ts
+var PRETTY_INDENT2 = 2;
+var META_DEBOUNCE_MS = 250;
+var COMPILE_DEBOUNCE_MS = 500;
+var COMPILE_DEFER_BYTES = 1e5;
+function serialise(value) {
+  return JSON.stringify(value, null, PRETTY_INDENT2);
+}
+function isPlainRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function createEditorState(options) {
+  let originalRawText = "";
+  let originalCanonicalText = "";
+  let originalSchema = null;
+  let originalLoadError = null;
+  let history = null;
+  let jsonDraftText = "";
+  let view = "form";
+  let readonly = Boolean(options.readonly);
+  let draftOverride = options.draftOverride;
+  function setReadonly(next) {
+    readonly = next;
+  }
+  let metaResult = { valid: true, errors: [] };
+  let compileResult = null;
+  let validationStatus = "valid";
+  let metaDebounceHandle = null;
+  let compileDebounceHandle = null;
+  function clearTimers() {
+    if (metaDebounceHandle !== null)
+      clearTimeout(metaDebounceHandle);
+    if (compileDebounceHandle !== null)
+      clearTimeout(compileDebounceHandle);
+    metaDebounceHandle = null;
+    compileDebounceHandle = null;
+  }
+  function emitValidation(result) {
+    options.onvalidate?.(result);
+  }
+  function buildResult(overrides = {}) {
+    const compilable = compileResult === null ? null : compileResult.ok;
+    const result = {
+      status: validationStatus,
+      valid: metaResult.valid,
+      errors: metaResult.errors,
+      compilable
+    };
+    if (compileResult && !compileResult.ok) {
+      result.compileError = compileResult.error;
+    }
+    return { ...result, ...overrides };
+  }
+  function detectActiveDraft(schema) {
+    if (draftOverride)
+      return draftOverride;
+    if (schema === null)
+      return "2020-12";
+    return detectDraft(schema);
+  }
+  function schemaToValidate() {
+    const committed = history?.current ?? null;
+    const committedText = committed === null ? "" : serialise(committed);
+    if (jsonDraftText !== committedText) {
+      const parsed = tryParseJson(jsonDraftText);
+      if (parsed.ok) {
+        return parsed.value;
+      }
+    }
+    return committed;
+  }
+  function runMetaValidation() {
+    const schema = schemaToValidate();
+    if (schema === null) {
+      metaResult = { valid: false, errors: [] };
+      return;
+    }
+    metaResult = validateMetaSchema(schema, detectActiveDraft(schema));
+  }
+  function runCompile() {
+    const schema = schemaToValidate();
+    if (schema === null) {
+      compileResult = null;
+      return;
+    }
+    compileResult = tryCompile(schema, detectActiveDraft(schema));
+  }
+  function recomputeStatus() {
+    const parse = tryParseJson(jsonDraftText);
+    if (!parse.ok) {
+      validationStatus = "invalid";
+      return;
+    }
+    if (!metaResult.valid) {
+      validationStatus = "invalid";
+      return;
+    }
+    if (compileResult === null) {
+      validationStatus = "pending";
+      return;
+    }
+    if (!compileResult.ok) {
+      validationStatus = "invalid";
+      return;
+    }
+    validationStatus = "valid";
+  }
+  function scheduleValidation() {
+    clearTimers();
+    validationStatus = "pending";
+    emitValidation(buildResult({ status: "pending" }));
+    metaDebounceHandle = setTimeout(() => {
+      runMetaValidation();
+      recomputeStatus();
+      emitValidation(buildResult());
+    }, META_DEBOUNCE_MS);
+    if (jsonDraftText.length > COMPILE_DEFER_BYTES) {
+      compileResult = null;
+      return;
+    }
+    compileDebounceHandle = setTimeout(() => {
+      runCompile();
+      recomputeStatus();
+      emitValidation(buildResult());
+    }, COMPILE_DEBOUNCE_MS);
+  }
+  function emitChange() {
+    const schema = history?.current ?? null;
+    if (schema === null)
+      return;
+    options.onchange?.({ schema, jsonString: serialise(schema) });
+  }
+  function loadFrom(schemaInput, originalInput) {
+    const schemaResult = normaliseSchemaInput(schemaInput);
+    const baselineInput = originalInput ?? schemaInput;
+    const baselineResult = normaliseSchemaInput(baselineInput);
+    if (baselineResult.ok) {
+      originalRawText = baselineResult.rawText;
+      originalCanonicalText = baselineResult.canonicalText;
+      originalSchema = baselineResult.schema;
+      originalLoadError = null;
+    } else {
+      originalRawText = baselineResult.rawText;
+      originalCanonicalText = "";
+      originalSchema = null;
+      originalLoadError = baselineResult.error;
+    }
+    if (schemaResult.ok) {
+      const useHistoryOptions = { initial: schemaResult.schema };
+      if (options.maxHistory !== undefined)
+        useHistoryOptions.maxDepth = options.maxHistory;
+      history = useHistory(useHistoryOptions);
+      jsonDraftText = schemaResult.canonicalText;
+    } else {
+      history = null;
+      jsonDraftText = schemaResult.rawText || "";
+    }
+    runMetaValidation();
+    runCompile();
+    recomputeStatus();
+    emitValidation(buildResult());
+  }
+  loadFrom(options.schema, options.original);
+  const committedSchema = $6.derived(() => history?.current ?? null);
+  const committedCanonicalText = $6.derived(() => committedSchema() === null ? "" : serialise(committedSchema()));
+  const jsonDraftIsDirty = $6.derived(() => jsonDraftText !== committedCanonicalText());
+  const hasChanges = $6.derived(() => {
+    if (originalSchema === null && committedSchema() === null)
+      return false;
+    if (originalSchema === null) {
+      return originalRawText !== committedCanonicalText();
+    }
+    if (committedSchema() === null)
+      return originalRawText.length > 0;
+    return stableSerialise(originalSchema) !== stableSerialise(committedSchema());
+  });
+  const isFormEditable = $6.derived(() => committedSchema() !== null && !readonly && !jsonDraftIsDirty());
+  return {
+    get view() {
+      return view;
+    },
+    set view(next) {
+      view = next;
+    },
+    get readonly() {
+      return readonly;
+    },
+    get originalRawText() {
+      return originalRawText;
+    },
+    get originalCanonicalText() {
+      return originalCanonicalText;
+    },
+    get originalSchema() {
+      return originalSchema;
+    },
+    get originalLoadError() {
+      return originalLoadError;
+    },
+    get committedSchema() {
+      return committedSchema();
+    },
+    get committedCanonicalText() {
+      return committedCanonicalText();
+    },
+    get jsonDraftText() {
+      return jsonDraftText;
+    },
+    get jsonDraftIsDirty() {
+      return jsonDraftIsDirty();
+    },
+    get hasChanges() {
+      return hasChanges();
+    },
+    get isFormEditable() {
+      return isFormEditable();
+    },
+    get diffOriginal() {
+      return originalCanonicalText || originalRawText;
+    },
+    get diffCurrent() {
+      return committedCanonicalText();
+    },
+    get copyValue() {
+      return committedCanonicalText();
+    },
+    get canUndo() {
+      return history?.canUndo ?? false;
+    },
+    get canRedo() {
+      return history?.canRedo ?? false;
+    },
+    get validationStatus() {
+      return validationStatus;
+    },
+    get validationResult() {
+      return buildResult();
+    },
+    get activeDraft() {
+      return detectActiveDraft(schemaToValidate());
+    },
+    setView(next) {
+      view = next;
+    },
+    setJsonDraftText(text) {
+      jsonDraftText = text;
+      scheduleValidation();
+    },
+    discardJsonDraft() {
+      clearTimers();
+      jsonDraftText = committedCanonicalText();
+      runMetaValidation();
+      runCompile();
+      recomputeStatus();
+      emitValidation(buildResult());
+    },
+    applyJsonDraft() {
+      if (readonly)
+        return false;
+      clearTimers();
+      const parsed = tryParseJson(jsonDraftText);
+      if (!parsed.ok)
+        return false;
+      const value = parsed.value;
+      if (typeof value !== "boolean" && !isPlainRecord(value))
+        return false;
+      const schema = value;
+      const meta = validateMetaSchema(schema, detectActiveDraft(schema));
+      if (!meta.valid)
+        return false;
+      if (history) {
+        history.commit(schema, { label: "apply JSON" });
+      } else {
+        const applyOptions = { initial: schema };
+        if (options.maxHistory !== undefined)
+          applyOptions.maxDepth = options.maxHistory;
+        history = useHistory(applyOptions);
+      }
+      jsonDraftText = serialise(history.current);
+      runMetaValidation();
+      runCompile();
+      recomputeStatus();
+      emitChange();
+      emitValidation(buildResult());
+      return true;
+    },
+    commitFromForm(next, commitOptions) {
+      if (!history || readonly || jsonDraftIsDirty())
+        return;
+      clearTimers();
+      history.commit(next, commitOptions);
+      jsonDraftText = serialise(history.current);
+      runMetaValidation();
+      runCompile();
+      recomputeStatus();
+      emitChange();
+      emitValidation(buildResult());
+    },
+    undo() {
+      if (!history || readonly)
+        return;
+      clearTimers();
+      const left = history.undo();
+      if (!left)
+        return;
+      jsonDraftText = serialise(history.current);
+      runMetaValidation();
+      runCompile();
+      recomputeStatus();
+      emitChange();
+      emitValidation(buildResult());
+      return left.label;
+    },
+    redo() {
+      if (!history || readonly)
+        return;
+      clearTimers();
+      const moved = history.redo();
+      if (!moved)
+        return;
+      jsonDraftText = serialise(history.current);
+      runMetaValidation();
+      runCompile();
+      recomputeStatus();
+      emitChange();
+      emitValidation(buildResult());
+      return moved.label;
+    },
+    revert() {
+      if (readonly)
+        return;
+      clearTimers();
+      if (originalSchema !== null) {
+        const revertOptions = { initial: originalSchema };
+        if (options.maxHistory !== undefined)
+          revertOptions.maxDepth = options.maxHistory;
+        history = useHistory(revertOptions);
+        jsonDraftText = originalCanonicalText;
+        runMetaValidation();
+        runCompile();
+        recomputeStatus();
+        emitChange();
+        emitValidation(buildResult());
+        options.onrevert?.({ restoredFrom: "original-schema" });
+      } else {
+        history = null;
+        jsonDraftText = originalRawText;
+        metaResult = { valid: false, errors: [] };
+        compileResult = null;
+        recomputeStatus();
+        emitValidation(buildResult());
+        options.onrevert?.({ restoredFrom: "original-text" });
+      }
+    },
+    setDraftOverride(next) {
+      draftOverride = next;
+      runMetaValidation();
+      runCompile();
+      recomputeStatus();
+      emitValidation(buildResult());
+    },
+    setReadonly,
+    reload(schemaInput, originalInput) {
+      clearTimers();
+      loadFrom(schemaInput, originalInput);
+    },
+    destroy() {
+      clearTimers();
+    }
+  };
+}
+
+// src/components/json-schema-editor/json-schema-toolbar.svelte
+import * as $7 from "svelte/internal/server";
+import { untrack } from "svelte";
+function Json_schema_toolbar($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      state: editorState,
+      localValidationErrorCount = 0,
+      onUndo,
+      onRedo,
+      onRevert,
+      class: className
+    } = $$props;
+    const validationBadgeVariant = $7.derived(() => {
+      if (localValidationErrorCount > 0)
+        return "danger";
+      switch (editorState.validationStatus) {
+        case "valid":
+          return "success";
+        case "invalid":
+          return "danger";
+        case "pending":
+          return "neutral";
+      }
+    });
+    const validationBadgeText = $7.derived(() => {
+      if (localValidationErrorCount > 0) {
+        return `Invalid — ${localValidationErrorCount} field ${localValidationErrorCount === 1 ? "error" : "errors"}`;
+      }
+      switch (editorState.validationStatus) {
+        case "valid":
+          return `Valid (${editorState.activeDraft})`;
+        case "invalid":
+          return `Invalid${editorState.validationResult.errors.length > 0 ? ` — ${editorState.validationResult.errors.length} errors` : ""}`;
+        case "pending":
+          return "Validating…";
+      }
+    });
+    let toolbarRightElement = undefined;
+    let rovingIndex = 0;
+    function getActionButtons() {
+      if (!toolbarRightElement)
+        return [];
+      return Array.from(toolbarRightElement.querySelectorAll("button:not(:disabled)"));
+    }
+    function handleKeydown(event) {
+      const buttons = getActionButtons();
+      if (buttons.length === 0)
+        return;
+      const currentIndex = buttons.findIndex((button) => button === document.activeElement);
+      if (currentIndex === -1)
+        return;
+      const nextIndex = handleRovingKeydown(event, currentIndex, buttons.length, {
+        isDisabled: () => false,
+        vertical: true,
+        horizontal: true
+      });
+      if (nextIndex !== null && nextIndex !== currentIndex) {
+        event.preventDefault();
+        rovingIndex = nextIndex;
+        buttons[nextIndex]?.focus();
+      }
+    }
+    function handleRightFocusin(event) {
+      const buttons = getActionButtons();
+      const index = buttons.findIndex((button) => button === event.target);
+      if (index !== -1) {
+        rovingIndex = index;
+      }
+    }
+    $$renderer2.push(`<div${$7.attr_class($7.clsx(classNames("cinder-jse-toolbar", className)))} role="toolbar" tabindex="-1" aria-label="Schema editor actions"><div class="cinder-jse-toolbar__left">`);
+    Badge($$renderer2, {
+      variant: validationBadgeVariant(),
+      children: ($$renderer3) => {
+        $$renderer3.push(`<!---->${$7.escape(validationBadgeText())}`);
+      },
+      $$slots: { default: true }
+    });
+    $$renderer2.push(`<!----> `);
+    if (editorState.validationResult.compileError) {
+      $$renderer2.push("<!--[0-->");
+      Badge($$renderer2, {
+        variant: "warning",
+        title: editorState.validationResult.compileError,
+        children: ($$renderer3) => {
+          $$renderer3.push(`<!---->Compile warning`);
+        },
+        $$slots: { default: true }
+      });
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></div> <div class="cinder-jse-toolbar__right">`);
+    Button($$renderer2, {
+      variant: "ghost",
+      size: "sm",
+      disabled: !editorState.canUndo || editorState.readonly,
+      onclick: () => onUndo?.(),
+      children: ($$renderer3) => {
+        $$renderer3.push(`<!---->Undo`);
+      },
+      $$slots: { default: true }
+    });
+    $$renderer2.push(`<!----> `);
+    Button($$renderer2, {
+      variant: "ghost",
+      size: "sm",
+      disabled: !editorState.canRedo || editorState.readonly,
+      onclick: () => onRedo?.(),
+      children: ($$renderer3) => {
+        $$renderer3.push(`<!---->Redo`);
+      },
+      $$slots: { default: true }
+    });
+    $$renderer2.push(`<!----> `);
+    {
+      let children = function($$renderer3) {
+        $$renderer3.push(`<!---->Copy JSON`);
+      }, confirmation = function($$renderer3) {
+        $$renderer3.push(`<!---->Copied`);
+      };
+      Copy_button($$renderer2, {
+        value: editorState.copyValue,
+        children,
+        confirmation,
+        $$slots: { default: true, confirmation: true }
+      });
+    }
+    $$renderer2.push(`<!----> `);
+    Button($$renderer2, {
+      variant: "secondary",
+      size: "sm",
+      disabled: !editorState.hasChanges || editorState.readonly,
+      onclick: () => onRevert?.(),
+      children: ($$renderer3) => {
+        $$renderer3.push(`<!---->Revert`);
+      },
+      $$slots: { default: true }
+    });
+    $$renderer2.push(`<!----></div></div>`);
+  });
+}
+
+// src/components/json-schema-editor/json-view.svelte
+import * as $8 from "svelte/internal/server";
+function Json_view($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { state, idPrefix, class: className } = $$props;
+    const draftParse = $8.derived(() => tryParseJson(state.jsonDraftText));
+    const draftMeta = $8.derived(() => {
+      if (!draftParse().ok)
+        return null;
+      return validateMetaSchema(draftParse().value, state.activeDraft);
+    });
+    const draftErrorMessage = $8.derived(() => {
+      if (!draftParse().ok)
+        return draftParse().error.message;
+      if (draftMeta() && !draftMeta().valid) {
+        return draftMeta().errors.map((e) => `${e.path || "(root)"}: ${e.message}`).join(`
+`);
+      }
+      return null;
+    });
+    const canApply = $8.derived(() => !state.readonly && state.jsonDraftIsDirty && draftParse().ok && draftMeta()?.valid === true);
+    const canDiscard = $8.derived(() => state.jsonDraftIsDirty && !state.readonly);
+    $$renderer2.push(`<div${$8.attr_class($8.clsx(classNames("cinder-jse-json-view", className)))}><div class="cinder-jse-json-view__toolbar">`);
+    if (state.jsonDraftIsDirty) {
+      $$renderer2.push("<!--[0-->");
+      Badge($$renderer2, {
+        variant: "warning",
+        children: ($$renderer3) => {
+          $$renderer3.push(`<!---->Draft modified — Apply to commit`);
+        },
+        $$slots: { default: true }
+      });
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    Button($$renderer2, {
+      variant: "primary",
+      size: "sm",
+      disabled: !canApply(),
+      onclick: () => state.applyJsonDraft(),
+      children: ($$renderer3) => {
+        $$renderer3.push(`<!---->Apply`);
+      },
+      $$slots: { default: true }
+    });
+    $$renderer2.push(`<!----> `);
+    Button($$renderer2, {
+      variant: "secondary",
+      size: "sm",
+      disabled: !canDiscard(),
+      onclick: () => state.discardJsonDraft(),
+      children: ($$renderer3) => {
+        $$renderer3.push(`<!---->Discard`);
+      },
+      $$slots: { default: true }
+    });
+    $$renderer2.push(`<!----></div> `);
+    Textarea($$renderer2, {
+      id: `${idPrefix}-textarea`,
+      label: "JSON",
+      value: state.jsonDraftText,
+      disabled: state.readonly,
+      rows: 20,
+      class: "cinder-jse-json-view__textarea",
+      oninput: (event) => state.setJsonDraftText(event.target.value)
+    });
+    $$renderer2.push(`<!----> `);
+    if (draftErrorMessage()) {
+      $$renderer2.push("<!--[0-->");
+      Alert($$renderer2, {
+        variant: "danger",
+        children: ($$renderer3) => {
+          $$renderer3.push(`<pre class="cinder-jse-json-view__errors">${$8.escape(draftErrorMessage())}</pre>`);
+        },
+        $$slots: { default: true }
+      });
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></div>`);
+  });
+}
+
+// src/components/json-schema-editor/json-schema-editor-impl.svelte
+function detectMacPlatform() {
+  if (typeof navigator === "undefined")
+    return false;
+  const navigatorWithUserAgentData = navigator;
+  const modernPlatform = navigatorWithUserAgentData.userAgentData?.platform;
+  if (typeof modernPlatform === "string" && modernPlatform.length > 0) {
+    return /Mac/.test(modernPlatform);
+  }
+  return /Mac/.test(navigator.platform);
+}
+var isMacPlatform = detectMacPlatform();
+function Json_schema_editor_impl($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      id,
+      schema,
+      original,
+      schemaKey,
+      view = "form",
+      readonly = false,
+      maxHistory,
+      draftOverride,
+      onchange,
+      onrevert,
+      onvalidate,
+      class: className
+    } = $$props;
+    const announcer = useAnnouncer();
+    const stateOptions = untrack2(() => {
+      const options = {
+        schema,
+        readonly,
+        onchange: (event) => onchange?.(event),
+        onrevert: (event) => onrevert?.(event),
+        onvalidate: (result) => onvalidate?.(result)
+      };
+      if (original !== undefined)
+        options.original = original;
+      if (maxHistory !== undefined)
+        options.maxHistory = maxHistory;
+      if (draftOverride !== undefined)
+        options.draftOverride = draftOverride;
+      return options;
+    });
+    let localValidationErrorCount = 0;
+    const editorState = createEditorState(stateOptions);
+    const toolbarValidationErrorCount = $9.derived(() => view === "form" ? localValidationErrorCount : 0);
+    let lastDraftOverride = untrack2(() => draftOverride);
+    let lastSchemaKey = untrack2(() => schemaKey);
+    function handleUndo() {
+      const label = editorState.undo();
+      announcer.announce(label ? `Undid: ${label}` : "Undid last edit");
+    }
+    function handleRedo() {
+      const label = editorState.redo();
+      announcer.announce(label ? `Redid: ${label}` : "Redid edit");
+    }
+    function handleRevert() {
+      editorState.revert();
+      announcer.announce("Reverted to original schema");
+    }
+    function isEditableTarget(target) {
+      if (!(target instanceof HTMLElement))
+        return false;
+      const tag = target.tagName;
+      if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT")
+        return true;
+      return target.isContentEditable;
+    }
+    function onKeyDown(event) {
+      const meta = isMacPlatform ? event.metaKey : event.ctrlKey;
+      if (!meta)
+        return;
+      if (isEditableTarget(event.target))
+        return;
+      const key = event.key.toLowerCase();
+      if (key === "z" && !event.shiftKey) {
+        event.preventDefault();
+        handleUndo();
+      } else if (key === "z" && event.shiftKey || key === "y") {
+        event.preventDefault();
+        handleRedo();
+      }
+    }
+    let $$settled = true;
+    let $$inner_renderer;
+    function $$render_inner($$renderer3) {
+      $$renderer3.push(`<div${$9.attr("id", id)}${$9.attr_class($9.clsx(classNames("cinder-jse", className)))} data-cinder-jse="" role="region" aria-label="JSON Schema editor">`);
+      Json_schema_toolbar($$renderer3, {
+        state: editorState,
+        localValidationErrorCount: toolbarValidationErrorCount(),
+        onUndo: handleUndo,
+        onRedo: handleRedo,
+        onRevert: handleRevert
+      });
+      $$renderer3.push(`<!----> `);
+      Tabs($$renderer3, {
+        get value() {
+          return view;
+        },
+        set value($$value) {
+          view = $$value;
+          $$settled = false;
+        },
+        children: ($$renderer4) => {
+          Tab_list($$renderer4, {
+            label: "Editor view",
+            children: ($$renderer5) => {
+              Tab($$renderer5, {
+                value: "form",
+                children: ($$renderer6) => {
+                  $$renderer6.push(`<!---->Form`);
+                },
+                $$slots: { default: true }
+              });
+              $$renderer5.push(`<!----> `);
+              Tab($$renderer5, {
+                value: "json",
+                children: ($$renderer6) => {
+                  $$renderer6.push(`<!---->JSON`);
+                },
+                $$slots: { default: true }
+              });
+              $$renderer5.push(`<!----> `);
+              {
+                let trailing = function($$renderer6) {
+                  if (editorState.hasChanges) {
+                    $$renderer6.push("<!--[0-->");
+                    Badge($$renderer6, {
+                      variant: "neutral",
+                      "aria-hidden": "true",
+                      children: ($$renderer7) => {
+                        $$renderer7.push(`<!---->●`);
+                      },
+                      $$slots: { default: true }
+                    });
+                  } else {
+                    $$renderer6.push("<!--[-1-->");
+                  }
+                  $$renderer6.push(`<!--]-->`);
+                };
+                Tab($$renderer5, {
+                  value: "diff",
+                  trailing,
+                  children: ($$renderer6) => {
+                    $$renderer6.push(`<!---->Diff`);
+                    if (editorState.hasChanges) {
+                      $$renderer6.push("<!--[0-->");
+                      $$renderer6.push(`<span class="cinder-sr-only">, has changes</span>`);
+                    } else {
+                      $$renderer6.push("<!--[-1-->");
+                    }
+                    $$renderer6.push(`<!--]-->`);
+                  },
+                  $$slots: { trailing: true, default: true }
+                });
+              }
+              $$renderer5.push(`<!---->`);
+            },
+            $$slots: { default: true }
+          });
+          $$renderer4.push(`<!----> `);
+          Tab_panel($$renderer4, {
+            value: "form",
+            children: ($$renderer5) => {
+              Form_view($$renderer5, {
+                state: editorState,
+                idPrefix: `${id}-form`,
+                onvalidationerrorcount: (count) => localValidationErrorCount = count
+              });
+            },
+            $$slots: { default: true }
+          });
+          $$renderer4.push(`<!----> `);
+          Tab_panel($$renderer4, {
+            value: "json",
+            children: ($$renderer5) => {
+              Json_view($$renderer5, { state: editorState, idPrefix: `${id}-json` });
+            },
+            $$slots: { default: true }
+          });
+          $$renderer4.push(`<!----> `);
+          Tab_panel($$renderer4, {
+            value: "diff",
+            children: ($$renderer5) => {
+              Diff_view($$renderer5, { state: editorState });
+            },
+            $$slots: { default: true }
+          });
+          $$renderer4.push(`<!---->`);
+        },
+        $$slots: { default: true }
+      });
+      $$renderer3.push(`<!----></div>`);
+    }
+    do {
+      $$settled = true;
+      $$inner_renderer = $$renderer2.copy();
+      $$render_inner($$inner_renderer);
+    } while (!$$settled);
+    $$renderer2.subsume($$inner_renderer);
+    $9.bind_props($$props, { view });
+  });
+}
+
+// src/components/json-schema-editor/json-schema-editor.svelte
+function Json_schema_editor($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { view = "form", class: className, $$slots, $$events, ...rest } = $$props;
+    const mergedClassName = $10.derived(() => classNames(className));
+    let $$settled = true;
+    let $$inner_renderer;
+    function $$render_inner($$renderer3) {
+      Json_schema_editor_impl($$renderer3, $10.spread_props([
+        { class: mergedClassName() },
+        rest,
+        {
+          get view() {
+            return view;
+          },
+          set view($$value) {
+            view = $$value;
+            $$settled = false;
+          }
+        }
+      ]));
+    }
+    do {
+      $$settled = true;
+      $$inner_renderer = $$renderer2.copy();
+      $$render_inner($$inner_renderer);
+    } while (!$$settled);
+    $$renderer2.subsume($$inner_renderer);
+    $10.bind_props($$props, { view });
+  });
+}
+
+// src/components/json-schema-editor/index.ts
+var json_schema_editor_default = Json_schema_editor;
+export { useHistory, Json_schema_editor, json_schema_editor_default };
+
+//# debugId=EDF073C740D58F8464756E2164756E21