@lostgradient/cinder 0.1.0

package/dist/server/components/markdown-editor/index.js

@@ -0,0 +1,3723 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/components/portal/portal.svelte
+import * as $2 from "svelte/internal/server";
+
+// src/utilities/class-names.ts
+function classNames(...parts) {
+  return parts.filter((part) => typeof part === "string" && part.length > 0).join(" ");
+}
+
+// src/components/portal/portal.utilities.svelte.ts
+import * as $ from "svelte/internal/server";
+
+// ../../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/read-option.ts
+function isOptionGetter(value) {
+  return typeof value === "function";
+}
+function readOption(value) {
+  return isOptionGetter(value) ? value() : value;
+}
+
+// src/components/portal/portal.utilities.svelte.ts
+function resolvePortalTarget(target) {
+  if (typeof document === "undefined")
+    return null;
+  if (target == null) {
+    return { kind: "resolved", target: document.body };
+  }
+  if (target instanceof HTMLElement) {
+    return { kind: "resolved", target };
+  }
+  try {
+    const resolved = document.querySelector(target);
+    return resolved instanceof HTMLElement ? { kind: "resolved", target: resolved } : { kind: "unresolved", key: target };
+  } catch {
+    return { kind: "unresolved", key: target };
+  }
+}
+function createPortalAttachment(options = {}) {
+  let lastWarnedUnresolvedKey = null;
+  return (element) => {
+    const initialParent = element.parentElement;
+    const initialAttributes = {
+      dir: element.getAttribute("dir"),
+      theme: element.getAttribute("data-cinder-theme")
+    };
+    const anchor = typeof document !== "undefined" ? document.createComment("@lostgradient/cinder/portal") : null;
+    if (anchor && initialParent && element.parentNode === initialParent) {
+      initialParent.insertBefore(anchor, element);
+    }
+    function restoreInline() {
+      if (!anchor || !anchor.parentNode)
+        return;
+      if (element.parentNode === anchor.parentNode && element.previousSibling === anchor)
+        return;
+      anchor.parentNode.insertBefore(element, anchor.nextSibling);
+    }
+    return () => {
+      if (anchor && anchor.parentNode) {
+        anchor.parentNode.removeChild(anchor);
+      }
+    };
+  };
+}
+
+// src/components/portal/portal.svelte
+function Portal($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      target = null,
+      disabled = false,
+      class: className,
+      inheritAttributes = true,
+      children,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    let hasHydrated = false;
+    const resolvedTarget = $2.derived(() => !disabled ? resolvePortalTarget(target) : null);
+    const shouldRenderChildren = $2.derived(() => disabled || hasHydrated && resolvedTarget() !== null);
+    $$renderer2.push(`<div${$2.attributes({ class: $2.clsx(classNames(className)), ...rest })}>`);
+    if (shouldRenderChildren()) {
+      $$renderer2.push("<!--[0-->");
+      children($$renderer2);
+      $$renderer2.push(`<!---->`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></div>`);
+  });
+}
+
+// src/components/portal/index.ts
+var portal_default = Portal;
+// src/components/focus-trap/focus-trap.svelte
+import * as $4 from "svelte/internal/server";
+
+// src/components/focus-trap/focus-trap.utilities.svelte.ts
+import * as $3 from "svelte/internal/server";
+
+// src/utilities/focus.ts
+function restoreFocusTo(target) {
+  if (!target)
+    return false;
+  if (typeof document === "undefined")
+    return false;
+  if (!target.isConnected)
+    return false;
+  if (target.ownerDocument !== document)
+    return false;
+  try {
+    target.focus();
+  } catch {
+    return false;
+  }
+  return true;
+}
+
+// src/components/focus-trap/focus-trap.utilities.svelte.ts
+var trapStack = [];
+var FOCUSABLE_SELECTOR = [
+  "a[href]",
+  "button:not([disabled])",
+  "input:not([disabled])",
+  "select:not([disabled])",
+  "textarea:not([disabled])",
+  "summary",
+  '[tabindex]:not([tabindex="-1"])',
+  '[contenteditable]:not([contenteditable="false"])'
+].join(", ");
+function noop() {}
+function isHiddenByTree(element) {
+  if (element.hidden)
+    return true;
+  if (element.matches('[inert], [aria-hidden="true"]'))
+    return true;
+  const ancestor = element.closest('[hidden], [inert], [aria-hidden="true"]');
+  return ancestor !== null && ancestor !== element;
+}
+function isFocusableCandidate(element) {
+  if (isHiddenByTree(element))
+    return false;
+  if (element.hasAttribute("disabled"))
+    return false;
+  if (element.getAttribute("tabindex") === "-1")
+    return false;
+  return true;
+}
+var NATIVELY_FOCUSABLE_TAGS = new Set(["BUTTON", "INPUT", "SELECT", "TEXTAREA", "SUMMARY"]);
+function isProgrammaticallyFocusable(element) {
+  if (isHiddenByTree(element))
+    return false;
+  if (element.hasAttribute("disabled"))
+    return false;
+  if (element.hasAttribute("tabindex"))
+    return true;
+  if (NATIVELY_FOCUSABLE_TAGS.has(element.tagName))
+    return true;
+  if (element.tagName === "A" && element.hasAttribute("href"))
+    return true;
+  const contentEditable = element.getAttribute("contenteditable");
+  if (contentEditable !== null && contentEditable !== "false")
+    return true;
+  return false;
+}
+function getTabbableElements(root) {
+  return Array.from(root.querySelectorAll(FOCUSABLE_SELECTOR)).filter((element) => root.contains(element) && isFocusableCandidate(element));
+}
+function resolveScopedTarget(root, target) {
+  const resolved = readOption(target ?? null);
+  if (!resolved)
+    return null;
+  if (typeof resolved === "string") {
+    let match = null;
+    try {
+      match = root.querySelector(resolved);
+    } catch {
+      return null;
+    }
+    return match && root.contains(match) ? match : null;
+  }
+  return resolved instanceof HTMLElement && root.contains(resolved) ? resolved : null;
+}
+function getFallbackTarget(root, fallbackFocus) {
+  const resolved = resolveScopedTarget(root, fallbackFocus);
+  return resolved && isProgrammaticallyFocusable(resolved) ? resolved : null;
+}
+function tryFocus(element) {
+  element.focus();
+  return document.activeElement === element;
+}
+function ensureRootFocusable(root) {
+  if (root.hasAttribute("tabindex")) {
+    return () => {};
+  }
+  root.setAttribute("tabindex", "-1");
+  return () => {
+    root.removeAttribute("tabindex");
+  };
+}
+function pushTrap(instance) {
+  const existingIndex = trapStack.findIndex((entry) => entry.id === instance.id);
+  if (existingIndex !== -1) {
+    trapStack.splice(existingIndex, 1);
+  }
+  trapStack.push(instance);
+}
+function removeTrap(id) {
+  const index = trapStack.findIndex((entry) => entry.id === id);
+  if (index !== -1) {
+    trapStack.splice(index, 1);
+  }
+}
+function isTopTrap(id) {
+  return trapStack.at(-1)?.id === id;
+}
+function createFocusTrap(options = {}) {
+  const trapId = Symbol("focus-trap");
+  return (node) => {
+    const isActive = () => readOption(options.active ?? true);
+    const restoreFocus = options.restoreFocus ?? true;
+    const initialFocus = options.initialFocus ?? null;
+    const fallbackFocus = options.fallbackFocus ?? null;
+    let activated = false;
+    let activationGeneration = 0;
+    let capturedFocus = null;
+    let restoreRootFocusability = noop;
+    function focusTrapTarget() {
+      const preferred = resolveScopedTarget(node, initialFocus);
+      if (preferred && isProgrammaticallyFocusable(preferred) && tryFocus(preferred)) {
+        return;
+      }
+      const tabbable = getTabbableElements(node);
+      if (tabbable.length > 0 && tabbable[0] && tryFocus(tabbable[0])) {
+        return;
+      }
+      const fallbackTarget = getFallbackTarget(node, fallbackFocus);
+      if (fallbackTarget && tryFocus(fallbackTarget)) {
+        return;
+      }
+      restoreRootFocusability = ensureRootFocusable(node);
+      node.focus();
+    }
+    function activate() {
+      if (activated)
+        return;
+      activated = true;
+      const generation = ++activationGeneration;
+      capturedFocus = document.activeElement instanceof HTMLElement && document.activeElement !== document.body ? document.activeElement : null;
+      pushTrap({ id: trapId, node });
+      queueMicrotask(() => {
+        if (!activated || generation !== activationGeneration)
+          return;
+        focusTrapTarget();
+      });
+    }
+    function deactivate() {
+      if (!activated)
+        return;
+      activated = false;
+      restoreRootFocusability();
+      restoreRootFocusability = noop;
+      removeTrap(trapId);
+      if (restoreFocus) {
+        restoreFocusTo(capturedFocus);
+      }
+      capturedFocus = null;
+    }
+    function handleKeydown(event) {
+      if (!isActive() || !isTopTrap(trapId) || event.key !== "Tab")
+        return;
+      const tabbable = getTabbableElements(node);
+      if (tabbable.length === 0) {
+        const fallbackTarget = getFallbackTarget(node, fallbackFocus);
+        event.preventDefault();
+        if (!fallbackTarget || !tryFocus(fallbackTarget)) {
+          restoreRootFocusability = ensureRootFocusable(node);
+          node.focus();
+        }
+        return;
+      }
+      const first = tabbable[0];
+      const last = tabbable[tabbable.length - 1];
+      const activeElement = document.activeElement;
+      if (event.shiftKey && activeElement === first) {
+        event.preventDefault();
+        last?.focus();
+      } else if (!event.shiftKey && activeElement === last) {
+        event.preventDefault();
+        first?.focus();
+      }
+    }
+    node.addEventListener("keydown", handleKeydown);
+    return () => {
+      node.removeEventListener("keydown", handleKeydown);
+      deactivate();
+    };
+  };
+}
+
+// src/components/focus-trap/focus-trap.svelte
+function Focus_trap($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      active = true,
+      restoreFocus = true,
+      initialFocus = null,
+      fallbackFocus = null,
+      class: className,
+      children,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    $$renderer2.push(`<div${$4.attributes({ class: $4.clsx(classNames(className)), ...rest })}>`);
+    children($$renderer2);
+    $$renderer2.push(`<!----></div>`);
+  });
+}
+
+// src/components/focus-trap/index.ts
+var focus_trap_default = Focus_trap;
+// src/components/markdown-editor/markdown-editor.svelte
+import * as $42 from "svelte/internal/server";
+import { onDestroy } from "svelte";
+import {
+  createEditorAttachment,
+  setEditorReadonly,
+  getActiveMarks,
+  getActiveBlockType,
+  getLinkAtCursor,
+  getLinkTextAtCursor,
+  isSelectionCollapsed,
+  insertLinkAtCursor,
+  applyLinkToSelection,
+  updateLinkAtCursor,
+  removeLink,
+  getLinkRangeAtCursor,
+  undo as undoCommand,
+  redo as redoCommand,
+  DEFAULT_DEBOUNCE_MS
+} from "@lostgradient/cinder/editor/component-runtime";
+
+// src/components/segment/segment.svelte
+import * as $6 from "svelte/internal/server";
+import { untrack } from "svelte";
+
+// src/components/segmented-control/segmented-control-state.svelte.ts
+import * as $5 from "svelte/internal/server";
+import { createContext } from "svelte";
+
+// src/utilities/document-order.ts
+function inDocumentOrder(items) {
+  return items.toSorted((a, b) => {
+    if (a.node === b.node)
+      return 0;
+    const position = a.node.compareDocumentPosition(b.node);
+    if (position & Node.DOCUMENT_POSITION_FOLLOWING)
+      return -1;
+    if (position & Node.DOCUMENT_POSITION_PRECEDING)
+      return 1;
+    return 0;
+  });
+}
+
+// src/utilities/roving-tabindex.ts
+var ROVING_KEYS = new Set(["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown", "Home", "End"]);
+function isRovingKey(key) {
+  return ROVING_KEYS.has(key);
+}
+function findNextIndex(currentIndex, length, direction, isDisabled) {
+  if (length === 0)
+    return -1;
+  if (!isDisabled) {
+    return (currentIndex + direction + length) % length;
+  }
+  for (let offset = 1;offset <= length; offset += 1) {
+    const candidateIndex = (currentIndex + offset * direction + length * offset) % length;
+    if (!isDisabled(candidateIndex)) {
+      return candidateIndex;
+    }
+  }
+  return currentIndex;
+}
+function findFirstIndex(length, isDisabled, currentIndex = 0) {
+  if (length === 0)
+    return -1;
+  if (!isDisabled)
+    return 0;
+  for (let index = 0;index < length; index += 1) {
+    if (!isDisabled(index))
+      return index;
+  }
+  return currentIndex;
+}
+function findLastIndex(length, isDisabled, currentIndex = 0) {
+  if (length === 0)
+    return -1;
+  if (!isDisabled)
+    return length - 1;
+  for (let index = length - 1;index >= 0; index -= 1) {
+    if (!isDisabled(index))
+      return index;
+  }
+  return currentIndex;
+}
+function handleRovingKeydown(event, currentIndex, length, options = {}) {
+  const { isDisabled, vertical = true, horizontal = true } = options;
+  if (length === 0)
+    return null;
+  switch (event.key) {
+    case "ArrowRight":
+      return horizontal ? findNextIndex(currentIndex, length, 1, isDisabled) : null;
+    case "ArrowDown":
+      return vertical ? findNextIndex(currentIndex, length, 1, isDisabled) : null;
+    case "ArrowLeft":
+      return horizontal ? findNextIndex(currentIndex, length, -1, isDisabled) : null;
+    case "ArrowUp":
+      return vertical ? findNextIndex(currentIndex, length, -1, isDisabled) : null;
+    case "Home":
+      return findFirstIndex(length, isDisabled, currentIndex);
+    case "End":
+      return findLastIndex(length, isDisabled, currentIndex);
+    default:
+      return null;
+  }
+}
+function getFocusableIndex(selectedIndex, length, isDisabled) {
+  if (length === 0)
+    return -1;
+  if (selectedIndex >= 0 && selectedIndex < length)
+    return selectedIndex;
+  return findFirstIndex(length, isDisabled, 0);
+}
+
+// src/components/segmented-control/segmented-control-state.svelte.ts
+var [getSegmentedControlContext, setSegmentedControlContext] = createContext();
+
+class SegmentedControlController {
+  #registrations = [];
+  #version = 0;
+  #options;
+  constructor(options) {
+    this.#options = options;
+  }
+  get segments() {
+    this.#version;
+    return inDocumentOrder(this.#registrations);
+  }
+  get selectionMode() {
+    return this.#options.selectionMode();
+  }
+  get variant() {
+    return this.#options.variant();
+  }
+  get controlDisabled() {
+    return this.#options.controlDisabled();
+  }
+  register(registration) {
+    this.#registrations.push(registration);
+    this.#version += 1;
+    return () => {
+      const index = this.#registrations.indexOf(registration);
+      if (index >= 0)
+        this.#registrations.splice(index, 1);
+      this.#version += 1;
+    };
+  }
+  isSelected(value) {
+    const current = this.#options.getValue();
+    if (this.#options.selectionMode() === "multiple") {
+      if (!current || typeof current === "string")
+        return false;
+      return current.has(value);
+    }
+    return current === value;
+  }
+  isFocusable(value) {
+    if (this.#options.selectionMode() !== "single") {
+      const segment = this.segments.find((entry) => entry.value === value);
+      if (!segment)
+        return false;
+      return !segment.disabled && !this.#options.controlDisabled();
+    }
+    const focusableValue = this.#computeFocusableValue();
+    return focusableValue === value;
+  }
+  #computeFocusableValue() {
+    const segments = this.segments;
+    if (segments.length === 0)
+      return null;
+    const current = this.#options.getValue();
+    const isMultiple = this.#options.selectionMode() === "multiple";
+    if (!isMultiple && typeof current === "string") {
+      const selectedSegment = segments.find((segment) => segment.value === current);
+      if (selectedSegment && !selectedSegment.disabled && !this.#options.controlDisabled()) {
+        return selectedSegment.value;
+      }
+    }
+    if (this.#options.controlDisabled())
+      return null;
+    const firstEnabled = segments.find((segment) => !segment.disabled);
+    return firstEnabled?.value ?? null;
+  }
+  toggle(value) {
+    if (this.#options.controlDisabled())
+      return;
+    const segment = this.segments.find((entry) => entry.value === value);
+    if (!segment || segment.disabled)
+      return;
+    if (this.#options.selectionMode() === "multiple") {
+      const set = this.#options.getValue();
+      if (!set || typeof set === "string")
+        return;
+      if (set.has(value))
+        set.delete(value);
+      else
+        set.add(value);
+      return;
+    }
+    const current = this.#options.getValue();
+    if (current === value) {
+      if (!this.#options.disallowEmptySelection()) {
+        this.#options.setValue(undefined);
+      }
+      return;
+    }
+    this.#options.setValue(value);
+    this.#options.onChange?.(value);
+  }
+  handleKeydown(event) {
+    if (this.#options.controlDisabled())
+      return;
+    if (this.#options.selectionMode() !== "single")
+      return;
+    const segments = this.segments;
+    if (segments.length === 0)
+      return;
+    const focusedSegment = typeof document === "undefined" ? null : segments.find((segment) => segment.node === document.activeElement) ?? null;
+    const value = this.#options.getValue();
+    const currentValue = focusedSegment?.value ?? (typeof value === "string" ? value : null);
+    const currentIndex = currentValue === null ? segments.findIndex((segment) => !segment.disabled) : segments.findIndex((segment) => segment.value === currentValue);
+    const safeCurrentIndex = currentIndex >= 0 ? currentIndex : getFocusableIndex(-1, segments.length, (index) => segments[index]?.disabled ?? false);
+    if (safeCurrentIndex < 0)
+      return;
+    const orientation = this.#options.orientation();
+    const nextIndex = handleRovingKeydown(event, safeCurrentIndex, segments.length, {
+      isDisabled: (index) => segments[index]?.disabled ?? false,
+      vertical: true,
+      horizontal: orientation !== "vertical"
+    });
+    if (nextIndex === null)
+      return;
+    event.preventDefault();
+    if (nextIndex === safeCurrentIndex)
+      return;
+    const nextSegment = segments[nextIndex];
+    if (!nextSegment)
+      return;
+    this.toggle(nextSegment.value);
+    nextSegment.node.focus();
+  }
+}
+
+// src/components/segment/segment.svelte
+function Segment($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      value,
+      disabled = false,
+      controls,
+      leading,
+      trailing,
+      children,
+      class: customClassName,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    const context = getSegmentedControlContext();
+    const registerSegment = (node) => {
+      return untrack(() => context.register({
+        node,
+        get value() {
+          return value;
+        },
+        get disabled() {
+          return disabled || context.controlDisabled;
+        },
+        get controls() {
+          return controls;
+        }
+      }));
+    };
+    const isSelected = $6.derived(() => context.isSelected(value));
+    const isFocusable = $6.derived(() => context.isFocusable(value));
+    const effectiveDisabled = $6.derived(() => disabled || context.controlDisabled);
+    const role = $6.derived(() => context.selectionMode === "multiple" ? undefined : context.variant === "tablist" ? "tab" : "radio");
+    $$renderer2.push(`<button${$6.attributes({
+      ...rest,
+      type: "button",
+      role: role(),
+      "data-cinder-segment-value": value,
+      "aria-checked": role() === "radio" ? isSelected() : undefined,
+      "aria-selected": role() === "tab" ? isSelected() : undefined,
+      "aria-pressed": context.selectionMode === "multiple" ? isSelected() : undefined,
+      "aria-controls": role() === "tab" ? controls : undefined,
+      "aria-disabled": effectiveDisabled() ? "true" : undefined,
+      disabled: context.selectionMode === "multiple" ? effectiveDisabled() : undefined,
+      tabindex: isFocusable() ? 0 : -1,
+      class: $6.clsx(classNames("cinder-segmented-control-option", customClassName)),
+      "data-cinder-selected": isSelected() ? "" : undefined,
+      "data-cinder-pressed": context.selectionMode === "multiple" && isSelected() ? "" : undefined
+    })}>`);
+    if (leading) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<span class="cinder-segmented-control-option-icon" aria-hidden="true">`);
+      leading($$renderer2);
+      $$renderer2.push(`<!----></span>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    children?.($$renderer2);
+    $$renderer2.push(`<!----> `);
+    if (trailing) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<span class="cinder-segmented-control-option-trailing" aria-hidden="true">`);
+      trailing($$renderer2);
+      $$renderer2.push(`<!----></span>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></button>`);
+  });
+}
+
+// src/components/segmented-control/segmented-control.svelte
+import * as $7 from "svelte/internal/server";
+function Segmented_control($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      id,
+      value = undefined,
+      label,
+      hideLabel = false,
+      disabled = false,
+      size = "md",
+      density,
+      orientation = "horizontal",
+      detached = false,
+      fullWidth = false,
+      variant = "radiogroup",
+      selectionMode = "single",
+      disallowEmptySelection = true,
+      class: customClassName,
+      onchange,
+      children,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    const controller = new SegmentedControlController({
+      selectionMode: () => selectionMode,
+      variant: () => variant,
+      orientation: () => orientation,
+      controlDisabled: () => disabled,
+      disallowEmptySelection: () => disallowEmptySelection,
+      getValue: () => value,
+      setValue: (next) => {
+        value = next;
+      },
+      onChange: (selected) => onchange?.(selected)
+    });
+    const contextValue = {
+      get selectionMode() {
+        return selectionMode;
+      },
+      get variant() {
+        return variant;
+      },
+      get controlDisabled() {
+        return disabled;
+      },
+      register: (registration) => controller.register(registration),
+      isSelected: (segmentValue) => controller.isSelected(segmentValue),
+      isFocusable: (segmentValue) => controller.isFocusable(segmentValue),
+      toggle: (segmentValue) => controller.toggle(segmentValue)
+    };
+    setSegmentedControlContext(contextValue);
+    const groupRole = $7.derived(() => selectionMode === "multiple" ? "group" : variant === "tablist" ? "tablist" : "radiogroup");
+    const effectiveSize = $7.derived(() => density === "toolbar" ? "sm" : size);
+    $$renderer2.push(`<div class="cinder-segmented-control-container"><span${$7.attr("id", `${id}-label`)}${$7.attr_class($7.clsx(classNames("cinder-segmented-control-label", hideLabel && "cinder-sr-only")))}>${$7.escape(label)}</span> <div${$7.attributes({
+      ...rest,
+      id,
+      role: groupRole(),
+      "aria-labelledby": `${id}-label`,
+      "aria-disabled": disabled ? "true" : undefined,
+      "aria-orientation": selectionMode === "single" ? orientation : undefined,
+      "data-cinder-orientation": orientation,
+      "data-cinder-size": effectiveSize(),
+      "data-cinder-density": density === "toolbar" ? "toolbar" : undefined,
+      "data-cinder-selection-mode": selectionMode,
+      "data-cinder-detached": detached ? "" : undefined,
+      "data-cinder-full-width": fullWidth ? "" : undefined,
+      "data-cinder-variant": variant,
+      class: $7.clsx(classNames("cinder-segmented-control", customClassName))
+    })}>`);
+    children($$renderer2);
+    $$renderer2.push(`<!----></div></div>`);
+    $7.bind_props($$props, { value });
+  });
+}
+
+// src/components/markdown-editor/editor-skeleton.svelte
+import * as $8 from "svelte/internal/server";
+function Editor_skeleton($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { lines = 8, class: className, $$slots, $$events, ...rest } = $$props;
+    const SHIMMER_WIDTHS = [68, 84, 56, 92, 72, 80, 60, 88];
+    const lineWidths = $8.derived(() => Array.from({ length: lines }, (_, i) => {
+      if (i === 0)
+        return 45;
+      if (i === lines - 1)
+        return 30;
+      return SHIMMER_WIDTHS[i % SHIMMER_WIDTHS.length] ?? 68;
+    }));
+    $$renderer2.push(`<div${$8.attributes({
+      class: $8.clsx(classNames("editor-skeleton", "surface", className)),
+      role: "status",
+      "aria-label": "Loading editor",
+      ...rest
+    }, "svelte-1h3fabh")}><span class="sr-only svelte-1h3fabh">Loading editor...</span> <div class="skeleton-content svelte-1h3fabh"><!--[-->`);
+    const each_array = $8.ensure_array_like(lineWidths());
+    for (let i = 0, $$length = each_array.length;i < $$length; i++) {
+      let width = each_array[i];
+      $$renderer2.push(`<div class="skeleton-line svelte-1h3fabh"${$8.attr_style("", { "--skeleton-line-width": `${$8.stringify(width)}%` })}></div>`);
+    }
+    $$renderer2.push(`<!--]--></div></div>`);
+  });
+}
+
+// src/components/markdown-editor/editor-toolbar/editor-toolbar.svelte
+import * as $36 from "svelte/internal/server";
+
+// ../../node_modules/lucide-svelte/dist/icons/bold.svelte
+import * as $10 from "svelte/internal/server";
+
+// ../../node_modules/lucide-svelte/dist/Icon.svelte
+import * as $9 from "svelte/internal/server";
+
+// ../../node_modules/lucide-svelte/dist/defaultAttributes.js
+var defaultAttributes = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: 24,
+  height: 24,
+  viewBox: "0 0 24 24",
+  fill: "none",
+  stroke: "currentColor",
+  "stroke-width": 2,
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round"
+};
+var defaultAttributes_default = defaultAttributes;
+
+// ../../node_modules/lucide-svelte/dist/Icon.svelte
+function Icon($$renderer, $$props) {
+  const $$sanitized_props = $9.sanitize_props($$props);
+  const $$restProps = $9.rest_props($$sanitized_props, [
+    "name",
+    "color",
+    "size",
+    "strokeWidth",
+    "absoluteStrokeWidth",
+    "iconNode"
+  ]);
+  $$renderer.component(($$renderer2) => {
+    let name = $9.fallback($$props["name"], undefined);
+    let color = $9.fallback($$props["color"], "currentColor");
+    let size = $9.fallback($$props["size"], 24);
+    let strokeWidth = $9.fallback($$props["strokeWidth"], 2);
+    let absoluteStrokeWidth = $9.fallback($$props["absoluteStrokeWidth"], false);
+    let iconNode = $9.fallback($$props["iconNode"], () => [], true);
+    const mergeClasses = (...classes) => classes.filter((className, index, array) => {
+      return Boolean(className) && array.indexOf(className) === index;
+    }).join(" ");
+    $$renderer2.push(`<svg${$9.attributes({
+      ...defaultAttributes_default,
+      ...$$restProps,
+      width: size,
+      height: size,
+      stroke: color,
+      "stroke-width": absoluteStrokeWidth ? Number(strokeWidth) * 24 / Number(size) : strokeWidth,
+      class: $9.clsx(mergeClasses("lucide-icon", "lucide", name ? `lucide-${name}` : "", $$sanitized_props.class))
+    }, undefined, undefined, undefined, 3)}><!--[-->`);
+    const each_array = $9.ensure_array_like(iconNode);
+    for (let $$index = 0, $$length = each_array.length;$$index < $$length; $$index++) {
+      let [tag, attrs] = each_array[$$index];
+      $9.element($$renderer2, tag, () => {
+        $$renderer2.push(`${$9.attributes({ ...attrs }, undefined, undefined, undefined, 3)}`);
+      });
+    }
+    $$renderer2.push(`<!--]--><!--[-->`);
+    $9.slot($$renderer2, $$props, "default", {}, null);
+    $$renderer2.push(`<!--]--></svg>`);
+    $9.bind_props($$props, {
+      name,
+      color,
+      size,
+      strokeWidth,
+      absoluteStrokeWidth,
+      iconNode
+    });
+  });
+}
+
+// ../../node_modules/lucide-svelte/dist/icons/bold.svelte
+function Bold($$renderer, $$props) {
+  const $$sanitized_props = $10.sanitize_props($$props);
+  const iconNode = [
+    [
+      "path",
+      {
+        d: "M6 12h9a4 4 0 0 1 0 8H7a1 1 0 0 1-1-1V5a1 1 0 0 1 1-1h7a4 4 0 0 1 0 8"
+      }
+    ]
+  ];
+  Icon($$renderer, $10.spread_props([
+    { name: "bold" },
+    $$sanitized_props,
+    {
+      iconNode,
+      children: ($$renderer2) => {
+        $$renderer2.push(`<!--[-->`);
+        $10.slot($$renderer2, $$props, "default", {}, null);
+        $$renderer2.push(`<!--]-->`);
+      },
+      $$slots: { default: true }
+    }
+  ]));
+}
+// ../../node_modules/lucide-svelte/dist/icons/code.svelte
+import * as $11 from "svelte/internal/server";
+function Code($$renderer, $$props) {
+  const $$sanitized_props = $11.sanitize_props($$props);
+  const iconNode = [
+    ["polyline", { points: "16 18 22 12 16 6" }],
+    ["polyline", { points: "8 6 2 12 8 18" }]
+  ];
+  Icon($$renderer, $11.spread_props([
+    { name: "code" },
+    $$sanitized_props,
+    {
+      iconNode,
+      children: ($$renderer2) => {
+        $$renderer2.push(`<!--[-->`);
+        $11.slot($$renderer2, $$props, "default", {}, null);
+        $$renderer2.push(`<!--]-->`);
+      },
+      $$slots: { default: true }
+    }
+  ]));
+}
+// ../../node_modules/lucide-svelte/dist/icons/heading-1.svelte
+import * as $12 from "svelte/internal/server";
+function Heading_1($$renderer, $$props) {
+  const $$sanitized_props = $12.sanitize_props($$props);
+  const iconNode = [
+    ["path", { d: "M4 12h8" }],
+    ["path", { d: "M4 18V6" }],
+    ["path", { d: "M12 18V6" }],
+    ["path", { d: "m17 12 3-2v8" }]
+  ];
+  Icon($$renderer, $12.spread_props([
+    { name: "heading-1" },
+    $$sanitized_props,
+    {
+      iconNode,
+      children: ($$renderer2) => {
+        $$renderer2.push(`<!--[-->`);
+        $12.slot($$renderer2, $$props, "default", {}, null);
+        $$renderer2.push(`<!--]-->`);
+      },
+      $$slots: { default: true }
+    }
+  ]));
+}
+// ../../node_modules/lucide-svelte/dist/icons/heading-2.svelte
+import * as $13 from "svelte/internal/server";
+function Heading_2($$renderer, $$props) {
+  const $$sanitized_props = $13.sanitize_props($$props);
+  const iconNode = [
+    ["path", { d: "M4 12h8" }],
+    ["path", { d: "M4 18V6" }],
+    ["path", { d: "M12 18V6" }],
+    ["path", { d: "M21 18h-4c0-4 4-3 4-6 0-1.5-2-2.5-4-1" }]
+  ];
+  Icon($$renderer, $13.spread_props([
+    { name: "heading-2" },
+    $$sanitized_props,
+    {
+      iconNode,
+      children: ($$renderer2) => {
+        $$renderer2.push(`<!--[-->`);
+        $13.slot($$renderer2, $$props, "default", {}, null);
+        $$renderer2.push(`<!--]-->`);
+      },
+      $$slots: { default: true }
+    }
+  ]));
+}
+// ../../node_modules/lucide-svelte/dist/icons/heading-3.svelte
+import * as $14 from "svelte/internal/server";
+function Heading_3($$renderer, $$props) {
+  const $$sanitized_props = $14.sanitize_props($$props);
+  const iconNode = [
+    ["path", { d: "M4 12h8" }],
+    ["path", { d: "M4 18V6" }],
+    ["path", { d: "M12 18V6" }],
+    [
+      "path",
+      { d: "M17.5 10.5c1.7-1 3.5 0 3.5 1.5a2 2 0 0 1-2 2" }
+    ],
+    ["path", { d: "M17 17.5c2 1.5 4 .3 4-1.5a2 2 0 0 0-2-2" }]
+  ];
+  Icon($$renderer, $14.spread_props([
+    { name: "heading-3" },
+    $$sanitized_props,
+    {
+      iconNode,
+      children: ($$renderer2) => {
+        $$renderer2.push(`<!--[-->`);
+        $14.slot($$renderer2, $$props, "default", {}, null);
+        $$renderer2.push(`<!--]-->`);
+      },
+      $$slots: { default: true }
+    }
+  ]));
+}
+// ../../node_modules/lucide-svelte/dist/icons/italic.svelte
+import * as $15 from "svelte/internal/server";
+function Italic($$renderer, $$props) {
+  const $$sanitized_props = $15.sanitize_props($$props);
+  const iconNode = [
+    ["line", { x1: "19", x2: "10", y1: "4", y2: "4" }],
+    ["line", { x1: "14", x2: "5", y1: "20", y2: "20" }],
+    ["line", { x1: "15", x2: "9", y1: "4", y2: "20" }]
+  ];
+  Icon($$renderer, $15.spread_props([
+    { name: "italic" },
+    $$sanitized_props,
+    {
+      iconNode,
+      children: ($$renderer2) => {
+        $$renderer2.push(`<!--[-->`);
+        $15.slot($$renderer2, $$props, "default", {}, null);
+        $$renderer2.push(`<!--]-->`);
+      },
+      $$slots: { default: true }
+    }
+  ]));
+}
+// ../../node_modules/lucide-svelte/dist/icons/link.svelte
+import * as $16 from "svelte/internal/server";
+function Link($$renderer, $$props) {
+  const $$sanitized_props = $16.sanitize_props($$props);
+  const iconNode = [
+    [
+      "path",
+      {
+        d: "M10 13a5 5 0 0 0 7.54.54l3-3a5 5 0 0 0-7.07-7.07l-1.72 1.71"
+      }
+    ],
+    [
+      "path",
+      {
+        d: "M14 11a5 5 0 0 0-7.54-.54l-3 3a5 5 0 0 0 7.07 7.07l1.71-1.71"
+      }
+    ]
+  ];
+  Icon($$renderer, $16.spread_props([
+    { name: "link" },
+    $$sanitized_props,
+    {
+      iconNode,
+      children: ($$renderer2) => {
+        $$renderer2.push(`<!--[-->`);
+        $16.slot($$renderer2, $$props, "default", {}, null);
+        $$renderer2.push(`<!--]-->`);
+      },
+      $$slots: { default: true }
+    }
+  ]));
+}
+// ../../node_modules/lucide-svelte/dist/icons/list.svelte
+import * as $17 from "svelte/internal/server";
+function List($$renderer, $$props) {
+  const $$sanitized_props = $17.sanitize_props($$props);
+  const iconNode = [
+    ["path", { d: "M3 12h.01" }],
+    ["path", { d: "M3 18h.01" }],
+    ["path", { d: "M3 6h.01" }],
+    ["path", { d: "M8 12h13" }],
+    ["path", { d: "M8 18h13" }],
+    ["path", { d: "M8 6h13" }]
+  ];
+  Icon($$renderer, $17.spread_props([
+    { name: "list" },
+    $$sanitized_props,
+    {
+      iconNode,
+      children: ($$renderer2) => {
+        $$renderer2.push(`<!--[-->`);
+        $17.slot($$renderer2, $$props, "default", {}, null);
+        $$renderer2.push(`<!--]-->`);
+      },
+      $$slots: { default: true }
+    }
+  ]));
+}
+// ../../node_modules/lucide-svelte/dist/icons/list-ordered.svelte
+import * as $18 from "svelte/internal/server";
+function List_ordered($$renderer, $$props) {
+  const $$sanitized_props = $18.sanitize_props($$props);
+  const iconNode = [
+    ["path", { d: "M10 12h11" }],
+    ["path", { d: "M10 18h11" }],
+    ["path", { d: "M10 6h11" }],
+    ["path", { d: "M4 10h2" }],
+    ["path", { d: "M4 6h1v4" }],
+    ["path", { d: "M6 18H4c0-1 2-2 2-3s-1-1.5-2-1" }]
+  ];
+  Icon($$renderer, $18.spread_props([
+    { name: "list-ordered" },
+    $$sanitized_props,
+    {
+      iconNode,
+      children: ($$renderer2) => {
+        $$renderer2.push(`<!--[-->`);
+        $18.slot($$renderer2, $$props, "default", {}, null);
+        $$renderer2.push(`<!--]-->`);
+      },
+      $$slots: { default: true }
+    }
+  ]));
+}
+// ../../node_modules/lucide-svelte/dist/icons/pilcrow.svelte
+import * as $19 from "svelte/internal/server";
+function Pilcrow($$renderer, $$props) {
+  const $$sanitized_props = $19.sanitize_props($$props);
+  const iconNode = [
+    ["path", { d: "M13 4v16" }],
+    ["path", { d: "M17 4v16" }],
+    ["path", { d: "M19 4H9.5a4.5 4.5 0 0 0 0 9H13" }]
+  ];
+  Icon($$renderer, $19.spread_props([
+    { name: "pilcrow" },
+    $$sanitized_props,
+    {
+      iconNode,
+      children: ($$renderer2) => {
+        $$renderer2.push(`<!--[-->`);
+        $19.slot($$renderer2, $$props, "default", {}, null);
+        $$renderer2.push(`<!--]-->`);
+      },
+      $$slots: { default: true }
+    }
+  ]));
+}
+// ../../node_modules/lucide-svelte/dist/icons/quote.svelte
+import * as $20 from "svelte/internal/server";
+function Quote($$renderer, $$props) {
+  const $$sanitized_props = $20.sanitize_props($$props);
+  const iconNode = [
+    [
+      "path",
+      {
+        d: "M16 3a2 2 0 0 0-2 2v6a2 2 0 0 0 2 2 1 1 0 0 1 1 1v1a2 2 0 0 1-2 2 1 1 0 0 0-1 1v2a1 1 0 0 0 1 1 6 6 0 0 0 6-6V5a2 2 0 0 0-2-2z"
+      }
+    ],
+    [
+      "path",
+      {
+        d: "M5 3a2 2 0 0 0-2 2v6a2 2 0 0 0 2 2 1 1 0 0 1 1 1v1a2 2 0 0 1-2 2 1 1 0 0 0-1 1v2a1 1 0 0 0 1 1 6 6 0 0 0 6-6V5a2 2 0 0 0-2-2z"
+      }
+    ]
+  ];
+  Icon($$renderer, $20.spread_props([
+    { name: "quote" },
+    $$sanitized_props,
+    {
+      iconNode,
+      children: ($$renderer2) => {
+        $$renderer2.push(`<!--[-->`);
+        $20.slot($$renderer2, $$props, "default", {}, null);
+        $$renderer2.push(`<!--]-->`);
+      },
+      $$slots: { default: true }
+    }
+  ]));
+}
+// ../../node_modules/lucide-svelte/dist/icons/redo-2.svelte
+import * as $21 from "svelte/internal/server";
+function Redo_2($$renderer, $$props) {
+  const $$sanitized_props = $21.sanitize_props($$props);
+  const iconNode = [
+    ["path", { d: "m15 14 5-5-5-5" }],
+    [
+      "path",
+      {
+        d: "M20 9H9.5A5.5 5.5 0 0 0 4 14.5A5.5 5.5 0 0 0 9.5 20H13"
+      }
+    ]
+  ];
+  Icon($$renderer, $21.spread_props([
+    { name: "redo-2" },
+    $$sanitized_props,
+    {
+      iconNode,
+      children: ($$renderer2) => {
+        $$renderer2.push(`<!--[-->`);
+        $21.slot($$renderer2, $$props, "default", {}, null);
+        $$renderer2.push(`<!--]-->`);
+      },
+      $$slots: { default: true }
+    }
+  ]));
+}
+// ../../node_modules/lucide-svelte/dist/icons/strikethrough.svelte
+import * as $22 from "svelte/internal/server";
+function Strikethrough($$renderer, $$props) {
+  const $$sanitized_props = $22.sanitize_props($$props);
+  const iconNode = [
+    ["path", { d: "M16 4H9a3 3 0 0 0-2.83 4" }],
+    ["path", { d: "M14 12a4 4 0 0 1 0 8H6" }],
+    ["line", { x1: "4", x2: "20", y1: "12", y2: "12" }]
+  ];
+  Icon($$renderer, $22.spread_props([
+    { name: "strikethrough" },
+    $$sanitized_props,
+    {
+      iconNode,
+      children: ($$renderer2) => {
+        $$renderer2.push(`<!--[-->`);
+        $22.slot($$renderer2, $$props, "default", {}, null);
+        $$renderer2.push(`<!--]-->`);
+      },
+      $$slots: { default: true }
+    }
+  ]));
+}
+// ../../node_modules/lucide-svelte/dist/icons/undo-2.svelte
+import * as $23 from "svelte/internal/server";
+function Undo_2($$renderer, $$props) {
+  const $$sanitized_props = $23.sanitize_props($$props);
+  const iconNode = [
+    ["path", { d: "M9 14 4 9l5-5" }],
+    [
+      "path",
+      {
+        d: "M4 9h10.5a5.5 5.5 0 0 1 5.5 5.5a5.5 5.5 0 0 1-5.5 5.5H11"
+      }
+    ]
+  ];
+  Icon($$renderer, $23.spread_props([
+    { name: "undo-2" },
+    $$sanitized_props,
+    {
+      iconNode,
+      children: ($$renderer2) => {
+        $$renderer2.push(`<!--[-->`);
+        $23.slot($$renderer2, $$props, "default", {}, null);
+        $$renderer2.push(`<!--]-->`);
+      },
+      $$slots: { default: true }
+    }
+  ]));
+}
+// src/components/markdown-editor/editor-toolbar/editor-toolbar.svelte
+import {
+  toggleBold,
+  toggleItalic,
+  toggleCode,
+  toggleStrikethrough,
+  toggleBulletList,
+  toggleOrderedList,
+  toggleBlockquote,
+  setHeading,
+  setParagraph,
+  getShortcutDisplay
+} from "@lostgradient/cinder/editor/component-runtime";
+
+// src/components/toolbar/toolbar.svelte
+import * as $25 from "svelte/internal/server";
+import { untrack as untrack2 } from "svelte";
+import { on } from "svelte/events";
+
+// src/utilities/use-mutation-observer.svelte.ts
+import * as $24 from "svelte/internal/server";
+function useMutationObserver(onMutate, options = {}) {
+  const {
+    childList,
+    attributes: attributes7,
+    characterData,
+    subtree,
+    attributeFilter,
+    attributeOldValue,
+    characterDataOldValue,
+    enabled = () => true
+  } = options;
+  const init = {};
+  if (childList !== undefined)
+    init.childList = childList;
+  if (attributes7 !== undefined)
+    init.attributes = attributes7;
+  if (characterData !== undefined)
+    init.characterData = characterData;
+  if (subtree !== undefined)
+    init.subtree = subtree;
+  if (attributeFilter !== undefined)
+    init.attributeFilter = attributeFilter;
+  if (attributeOldValue !== undefined)
+    init.attributeOldValue = attributeOldValue;
+  if (characterDataOldValue !== undefined)
+    init.characterDataOldValue = characterDataOldValue;
+  if (init.childList === undefined && init.attributes === undefined && init.characterData === undefined) {
+    init.childList = true;
+  }
+  return (node) => {
+    if (typeof MutationObserver === "undefined") {
+      return () => {};
+    }
+    let observer = null;
+    const disconnectObserver = () => {
+      observer?.disconnect();
+      observer = null;
+    };
+    return () => {
+      disconnectObserver();
+    };
+  };
+}
+
+// src/components/toolbar/toolbar.svelte
+function Toolbar($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const focusableSelector = [
+      "button",
+      "a[href]",
+      "input",
+      "select",
+      "textarea",
+      "[tabindex]",
+      "[data-cinder-toolbar-item]"
+    ].join(",");
+    let {
+      class: className,
+      orientation = "horizontal",
+      children,
+      onkeydown: consumerOnKeyDown,
+      onfocusin: consumerOnFocusIn,
+      role: _role,
+      "aria-orientation": _ariaOrientation,
+      "aria-label": ariaLabel,
+      "aria-labelledby": ariaLabelledBy,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    let rootElement = null;
+    let toolbarItems = [];
+    let activeItem = null;
+    const originalTabIndexes = new WeakMap;
+    let previousManagedItems = new Set;
+    let lastWarnedNameSource = "";
+    function isHTMLElement(value) {
+      return value instanceof HTMLElement;
+    }
+    function isHiddenInput(element2) {
+      return element2 instanceof HTMLInputElement && element2.type === "hidden";
+    }
+    function isEditableTarget(element2) {
+      if (element2 instanceof HTMLTextAreaElement)
+        return true;
+      if (element2 instanceof HTMLInputElement) {
+        return ![
+          "button",
+          "checkbox",
+          "file",
+          "hidden",
+          "image",
+          "radio",
+          "range",
+          "reset",
+          "submit"
+        ].includes(element2.type);
+      }
+      return element2.isContentEditable;
+    }
+    function isSpinButtonLike(element2) {
+      if (element2.getAttribute("role") === "spinbutton")
+        return true;
+      if (!(element2 instanceof HTMLInputElement))
+        return false;
+      return element2.closest(".cinder-number-input") !== null;
+    }
+    function hasCollapsedSelectionAtBoundary(element2, direction) {
+      if (!(element2 instanceof HTMLInputElement || element2 instanceof HTMLTextAreaElement))
+        return false;
+      if (typeof element2.selectionStart !== "number" || typeof element2.selectionEnd !== "number")
+        return false;
+      if (element2.selectionStart !== element2.selectionEnd)
+        return false;
+      const valueLength = element2.value.length;
+      return direction === -1 ? element2.selectionStart === 0 : element2.selectionEnd === valueLength;
+    }
+    function placeCaret(element2, placement) {
+      if (!(element2 instanceof HTMLInputElement || element2 instanceof HTMLTextAreaElement))
+        return;
+      if (typeof element2.setSelectionRange !== "function")
+        return;
+      const position = placement === "end" ? element2.value.length : 0;
+      element2.setSelectionRange(position, position);
+    }
+    function isCssHidden(element2) {
+      const elementStyle = getComputedStyle(element2);
+      if (elementStyle.display === "none" || elementStyle.visibility === "hidden")
+        return true;
+      let current = element2.parentElement;
+      while (current) {
+        if (getComputedStyle(current).display === "none")
+          return true;
+        current = current.parentElement;
+      }
+      return false;
+    }
+    function isDisabledByFieldset(element2) {
+      const disabledFieldset = element2.closest("fieldset[disabled]");
+      if (!disabledFieldset)
+        return false;
+      const firstLegend = disabledFieldset.querySelector("legend");
+      return firstLegend ? !firstLegend.contains(element2) : true;
+    }
+    function isEligibleToolbarItem(element2) {
+      if (!rootElement || element2 === rootElement)
+        return false;
+      if (!rootElement.contains(element2))
+        return false;
+      if (isHiddenInput(element2))
+        return false;
+      if (element2.hasAttribute("hidden"))
+        return false;
+      if (element2.getAttribute("aria-hidden") === "true")
+        return false;
+      if (element2.getAttribute("aria-disabled") === "true")
+        return false;
+      if ("disabled" in element2 && typeof element2.disabled === "boolean") {
+        if (element2.disabled)
+          return false;
+      }
+      if (element2.closest('[hidden],[aria-hidden="true"],[data-cinder-toolbar-exclude]'))
+        return false;
+      if (element2.closest("[inert]"))
+        return false;
+      if (isDisabledByFieldset(element2))
+        return false;
+      if (isCssHidden(element2))
+        return false;
+      const authoredTabIndex = element2.getAttribute("tabindex");
+      if (authoredTabIndex === "-1" && !previousManagedItems.has(element2) && !element2.hasAttribute("data-cinder-toolbar-item")) {
+        return false;
+      }
+      return true;
+    }
+    function getToolbarItems() {
+      if (!rootElement)
+        return [];
+      return Array.from(rootElement.querySelectorAll(focusableSelector)).filter((element2) => isEligibleToolbarItem(element2));
+    }
+    function getActiveIndex(items, preferredItem) {
+      if (preferredItem) {
+        const preferredIndex = items.indexOf(preferredItem);
+        if (preferredIndex >= 0)
+          return preferredIndex;
+      }
+      return getFocusableIndex(-1, items.length);
+    }
+    function restoreDepartedItems(nextItems) {
+      const nextItemSet = new Set(nextItems);
+      for (const item of previousManagedItems) {
+        if (nextItemSet.has(item))
+          continue;
+        const original = originalTabIndexes.get(item);
+        if (original === null)
+          item.removeAttribute("tabindex");
+        else if (original !== undefined)
+          item.setAttribute("tabindex", original);
+        originalTabIndexes.delete(item);
+      }
+      previousManagedItems = nextItemSet;
+    }
+    function syncToolbarItems(preferredItem = activeItem) {
+      const items = getToolbarItems();
+      restoreDepartedItems(items);
+      if (items.length === 0) {
+        toolbarItems = [];
+        activeItem = null;
+        return;
+      }
+      for (const item of items) {
+        if (!originalTabIndexes.has(item)) {
+          originalTabIndexes.set(item, item.getAttribute("tabindex"));
+        }
+      }
+      const activeIndex = getActiveIndex(items, preferredItem);
+      const resolvedActiveItem = activeIndex >= 0 ? items[activeIndex] ?? null : null;
+      for (const [index, item] of items.entries()) {
+        const nextTabIndex = index === activeIndex ? 0 : -1;
+        if (item.tabIndex !== nextTabIndex) {
+          item.tabIndex = nextTabIndex;
+        }
+      }
+      toolbarItems = items;
+      activeItem = resolvedActiveItem;
+    }
+    function moveFocus(nextIndex, caretPlacement) {
+      const nextItem = toolbarItems[nextIndex];
+      if (!nextItem)
+        return;
+      activeItem = nextItem;
+      syncToolbarItems(nextItem);
+      nextItem.focus();
+      placeCaret(nextItem, caretPlacement);
+    }
+    function getCurrentToolbarIndex(target) {
+      return toolbarItems.indexOf(target);
+    }
+    function handleEditableEscape(target) {
+      if (!isEditableTarget(target))
+        return false;
+      const currentIndex = getCurrentToolbarIndex(target);
+      if (currentIndex < 0)
+        return false;
+      const nextIndex = currentIndex < toolbarItems.length - 1 ? currentIndex + 1 : currentIndex > 0 ? currentIndex - 1 : -1;
+      if (nextIndex < 0)
+        return false;
+      moveFocus(nextIndex, nextIndex > currentIndex ? "start" : "end");
+      return true;
+    }
+    function handleToolbarKeyDown(event) {
+      consumerOnKeyDown?.(event);
+      if (event.defaultPrevented)
+        return;
+      if (!isHTMLElement(event.target))
+        return;
+      const target = event.target.closest(focusableSelector);
+      if (!target || !toolbarItems.includes(target))
+        return;
+      const currentIndex = getCurrentToolbarIndex(target);
+      if (currentIndex < 0)
+        return;
+      const horizontal = orientation !== "vertical";
+      const targetIsEditable = isEditableTarget(target);
+      if (event.key === "Escape" && targetIsEditable) {
+        if (!handleEditableEscape(target))
+          return;
+        event.preventDefault();
+        event.stopPropagation();
+        return;
+      }
+      if ((event.key === "Home" || event.key === "End") && targetIsEditable) {
+        return;
+      }
+      if (horizontal && (event.key === "ArrowLeft" || event.key === "ArrowRight")) {
+        if (targetIsEditable && !hasCollapsedSelectionAtBoundary(target, event.key === "ArrowLeft" ? -1 : 1)) {
+          return;
+        }
+      }
+      if (!horizontal && (event.key === "ArrowUp" || event.key === "ArrowDown")) {
+        if (targetIsEditable || isSpinButtonLike(target))
+          return;
+      }
+      if (horizontal && (event.key === "ArrowUp" || event.key === "ArrowDown")) {
+        return;
+      }
+      if (!horizontal && (event.key === "ArrowLeft" || event.key === "ArrowRight")) {
+        return;
+      }
+      const nextIndex = handleRovingKeydown(event, currentIndex, toolbarItems.length, { horizontal, vertical: !horizontal });
+      if (nextIndex === null || nextIndex === currentIndex)
+        return;
+      event.preventDefault();
+      event.stopPropagation();
+      moveFocus(nextIndex, event.key === "ArrowLeft" || event.key === "ArrowUp" || event.key === "End" ? "end" : "start");
+    }
+    function handleToolbarFocusIn(event) {
+      consumerOnFocusIn?.(event);
+      if (!isHTMLElement(event.target))
+        return;
+      const target = event.target.closest(focusableSelector);
+      if (!target || !isEligibleToolbarItem(target))
+        return;
+      syncToolbarItems(target);
+    }
+    function resolveAccessibleNameSource() {
+      const inlineLabel = ariaLabel?.trim() ?? "";
+      const labelledBy = ariaLabelledBy?.trim() ?? "";
+      return inlineLabel || labelledBy;
+    }
+    function hasResolvedLabelledByText() {
+      if (!rootElement || !ariaLabelledBy)
+        return false;
+      const identifiers = ariaLabelledBy.split(/\s+/).map((value) => value.trim()).filter(Boolean);
+      if (identifiers.length === 0)
+        return false;
+      return identifiers.every((identifier) => {
+        const element2 = document.getElementById(identifier);
+        return element2 !== null && (element2.textContent?.trim().length ?? 0) > 0;
+      });
+    }
+    function warnAboutAccessibleName() {
+      if (!rootElement)
+        return;
+      const warningKey = `${ariaLabel ?? ""}|${ariaLabelledBy ?? ""}`;
+      if (warningKey === lastWarnedNameSource)
+        return;
+      const inlineLabel = ariaLabel?.trim() ?? "";
+      if (inlineLabel.length > 0)
+        return;
+      if (ariaLabelledBy?.trim() && hasResolvedLabelledByText())
+        return;
+      lastWarnedNameSource = warningKey;
+      devWarn("[cinder/Toolbar] rendered without a resolvable accessible name. Pass a non-empty `aria-label` or `aria-labelledby` that points to non-empty text.");
+    }
+    function toolbarSetup(node) {
+      rootElement = node;
+      syncToolbarItems(untrack2(() => activeItem));
+      const cleanupKeyboardListener = on(node, "keydown", handleToolbarKeyDown, { capture: true });
+      const cleanupFocusInListener = on(node, "focusin", handleToolbarFocusIn);
+      const detachMutationObserver = useMutationObserver(() => {
+        syncToolbarItems(activeItem);
+        warnAboutAccessibleName();
+      }, {
+        subtree: true,
+        childList: true,
+        attributes: true,
+        attributeFilter: [
+          "aria-disabled",
+          "aria-hidden",
+          "aria-label",
+          "aria-labelledby",
+          "class",
+          "data-cinder-toolbar-exclude",
+          "data-cinder-toolbar-item",
+          "disabled",
+          "hidden",
+          "inert",
+          "style",
+          "type"
+        ]
+      })(node);
+      warnAboutAccessibleName();
+      return () => {
+        cleanupKeyboardListener();
+        cleanupFocusInListener();
+        detachMutationObserver?.();
+        rootElement = null;
+        restoreDepartedItems([]);
+      };
+    }
+    $$renderer2.push(`<div${$25.attributes({
+      ...rest,
+      role: "toolbar",
+      "aria-label": ariaLabel,
+      "aria-labelledby": ariaLabelledBy,
+      "aria-orientation": orientation === "vertical" ? "vertical" : undefined,
+      class: $25.clsx(classNames("cinder-toolbar", className)),
+      "data-cinder-orientation": orientation,
+      "data-cinder-name-source": resolveAccessibleNameSource()
+    })}>`);
+    children($$renderer2);
+    $$renderer2.push(`<!----></div>`);
+  });
+}
+
+// src/components/markdown-editor/editor-toolbar/toolbar-button.svelte
+import * as $28 from "svelte/internal/server";
+
+// src/components/tooltip/tooltip.svelte
+import * as $27 from "svelte/internal/server";
+
+// src/_internal/anchored-overlay.svelte.ts
+import * as $26 from "svelte/internal/server";
+var DEFAULT_PLACEMENT = "bottom-start";
+function createAnchoredOverlay(options) {
+  let positionReady = false;
+  let positionStyle = "";
+  let resolvedPlacement = options.placement?.() ?? DEFAULT_PLACEMENT;
+  let arrowStyle = "";
+  return {
+    get positionReady() {
+      return positionReady;
+    },
+    get positionStyle() {
+      return positionStyle;
+    },
+    get resolvedPlacement() {
+      return resolvedPlacement;
+    },
+    get arrowStyle() {
+      return arrowStyle;
+    }
+  };
+}
+
+// src/components/tooltip/tooltip.svelte
+function Tooltip($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const tooltipId = $27.props_id($$renderer2);
+    let {
+      text,
+      placement = "top",
+      describe = true,
+      class: className,
+      children
+    } = $$props;
+    const FOCUSABLE_SELECTOR2 = [
+      "button:not([disabled])",
+      "a[href]",
+      "area[href]",
+      "input:not([disabled])",
+      "select:not([disabled])",
+      "textarea:not([disabled])",
+      "summary",
+      "iframe",
+      "object",
+      "embed",
+      "audio[controls]",
+      "video[controls]",
+      '[contenteditable]:not([contenteditable="false"])',
+      '[tabindex]:not([tabindex="-1"])'
+    ].join(", ");
+    let visible = false;
+    let showTimer;
+    let hasPendingShow = false;
+    let wrapperElement = undefined;
+    let tooltipElement = undefined;
+    let anchorElement = null;
+    function show() {
+      clearTimeout(showTimer);
+      hasPendingShow = true;
+      showTimer = setTimeout(() => {
+        showTimer = undefined;
+        hasPendingShow = false;
+        visible = true;
+      }, 100);
+    }
+    function hide() {
+      clearTimeout(showTimer);
+      showTimer = undefined;
+      hasPendingShow = false;
+      visible = false;
+    }
+    function handleMouseEnter() {
+      show();
+    }
+    function handleMouseLeave() {
+      hide();
+    }
+    function handleFocusIn() {
+      show();
+    }
+    function handleFocusOut() {
+      hide();
+    }
+    function handleKeydown(event) {
+      if (event.key === "Escape") {
+        hide();
+      }
+    }
+    function isFocusableCandidate2(element2) {
+      if (element2.matches(":disabled"))
+        return false;
+      return !element2.closest('[hidden], [inert], [aria-hidden="true"]');
+    }
+    function resolveAnchorElement(container) {
+      const candidates = container.querySelectorAll(FOCUSABLE_SELECTOR2);
+      for (const candidate of candidates) {
+        if (isFocusableCandidate2(candidate))
+          return candidate;
+      }
+      return container;
+    }
+    function syncAriaDescribedBy(focusable) {
+      const existing = focusable.getAttribute("aria-describedby");
+      const ids = existing ? existing.split(" ").filter(Boolean) : [];
+      if (!ids.includes(tooltipId)) {
+        focusable.setAttribute("aria-describedby", [...ids, tooltipId].join(" "));
+      }
+      return () => {
+        const current = focusable.getAttribute("aria-describedby");
+        if (!current)
+          return;
+        const remaining = current.split(" ").filter((id) => id !== tooltipId).join(" ");
+        if (remaining) {
+          focusable.setAttribute("aria-describedby", remaining);
+        } else {
+          focusable.removeAttribute("aria-describedby");
+        }
+      };
+    }
+    const attachWrapper = (element2) => {
+      wrapperElement = element2;
+      const focusable = resolveAnchorElement(element2);
+      anchorElement = focusable;
+      const teardownAriaDescribedBy = describe ? syncAriaDescribedBy(focusable) : undefined;
+      return () => {
+        teardownAriaDescribedBy?.();
+        if (wrapperElement === element2)
+          wrapperElement = undefined;
+        if (anchorElement === focusable)
+          anchorElement = null;
+      };
+    };
+    const tooltipPortalAttachment = createPortalAttachment({
+      target: () => document.body,
+      source: () => anchorElement ?? wrapperElement ?? null,
+      inheritAttributes: true
+    });
+    const anchoredOverlay = createAnchoredOverlay({
+      open: () => visible,
+      anchor: () => anchorElement,
+      panel: () => tooltipElement,
+      placement: () => placement,
+      offset: () => 8,
+      widthMode: () => "none"
+    });
+    const isTooltipExposed = $27.derived(() => visible && anchoredOverlay.positionReady);
+    $$renderer2.push(`<span${$27.attr_class($27.clsx(classNames("cinder-tooltip-wrapper", className)))} role="presentation"${$27.attr("data-cinder-placement", visible ? anchoredOverlay.resolvedPlacement : placement)}>`);
+    children($$renderer2);
+    $$renderer2.push(`<!----> <span${$27.attr("id", tooltipId)} role="tooltip" class="cinder-tooltip"${$27.attr("aria-hidden", !isTooltipExposed())}${$27.attr("data-cinder-placement", visible ? anchoredOverlay.resolvedPlacement : placement)}${$27.attr("data-cinder-position-ready", anchoredOverlay.positionReady)}${$27.attr_style(anchoredOverlay.positionStyle)}>${$27.escape(text)}</span></span>`);
+  });
+}
+
+// src/components/markdown-editor/editor-toolbar/toolbar-button.svelte
+function Toolbar_button($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      icon: Icon2,
+      label,
+      toggle = false,
+      pressed = false,
+      shortcut,
+      disabled = false,
+      class: className,
+      onclick,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    const tooltipLabel = $28.derived(() => shortcut ? `${label} (${shortcut})` : label);
+    Tooltip($$renderer2, {
+      text: tooltipLabel(),
+      placement: "bottom",
+      children: ($$renderer3) => {
+        $$renderer3.push(`<button${$28.attributes({
+          type: "button",
+          class: $28.clsx(classNames("toolbar-button", className)),
+          "aria-label": label,
+          "aria-pressed": toggle ? pressed : undefined,
+          "data-active": toggle && pressed ? "" : undefined,
+          disabled,
+          ...rest
+        }, "svelte-143lto0")}>`);
+        if (Icon2) {
+          $$renderer3.push("<!--[-->");
+          Icon2($$renderer3, { class: "icon-sm" });
+          $$renderer3.push("<!--]-->");
+        } else {
+          $$renderer3.push("<!--[!-->");
+          $$renderer3.push("<!--]-->");
+        }
+        $$renderer3.push(`</button>`);
+      },
+      $$slots: { default: true }
+    });
+  });
+}
+
+// src/components/markdown-editor/editor-toolbar/toolbar-separator.svelte
+import * as $29 from "svelte/internal/server";
+function Toolbar_separator($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { class: className, $$slots, $$events, ...rest } = $$props;
+    $$renderer2.push(`<div${$29.attributes({
+      class: $29.clsx(classNames("toolbar-separator", className)),
+      role: "separator",
+      "aria-orientation": "vertical",
+      "aria-hidden": "true",
+      ...rest
+    }, "svelte-1v2jo71")}></div>`);
+  });
+}
+
+// src/components/markdown-editor/editor-toolbar/toolbar-dropdown.svelte
+import * as $35 from "svelte/internal/server";
+
+// ../../node_modules/lucide-svelte/dist/icons/check.svelte
+import * as $30 from "svelte/internal/server";
+function Check($$renderer, $$props) {
+  const $$sanitized_props = $30.sanitize_props($$props);
+  const iconNode = [["path", { d: "M20 6 9 17l-5-5" }]];
+  Icon($$renderer, $30.spread_props([
+    { name: "check" },
+    $$sanitized_props,
+    {
+      iconNode,
+      children: ($$renderer2) => {
+        $$renderer2.push(`<!--[-->`);
+        $30.slot($$renderer2, $$props, "default", {}, null);
+        $$renderer2.push(`<!--]-->`);
+      },
+      $$slots: { default: true }
+    }
+  ]));
+}
+// src/components/dropdown/dropdown.svelte
+import * as $31 from "svelte/internal/server";
+
+// src/_internal/overlay.ts
+var escapeStack = [];
+function pushEscapeHandler(handler) {
+  escapeStack.push(handler);
+  if (escapeStack.length === 1 && typeof window !== "undefined") {
+    window.addEventListener("keydown", onEscapeKeydown, { capture: true });
+  }
+  let released = false;
+  return () => {
+    if (released)
+      return;
+    released = true;
+    const index = escapeStack.lastIndexOf(handler);
+    if (index !== -1)
+      escapeStack.splice(index, 1);
+    if (escapeStack.length === 0 && typeof window !== "undefined") {
+      window.removeEventListener("keydown", onEscapeKeydown, { capture: true });
+    }
+  };
+}
+function onEscapeKeydown(event) {
+  if (event.key !== "Escape")
+    return;
+  const handler = escapeStack.at(-1);
+  if (!handler)
+    return;
+  handler();
+}
+var scrollLockCount = 0;
+var originalBodyOverflow = null;
+function lockBodyScroll() {
+  if (typeof document === "undefined")
+    return () => {};
+  if (scrollLockCount === 0) {
+    originalBodyOverflow = document.body.style.overflow;
+    document.body.style.overflow = "hidden";
+  }
+  scrollLockCount += 1;
+  let released = false;
+  return () => {
+    if (released)
+      return;
+    released = true;
+    scrollLockCount = Math.max(0, scrollLockCount - 1);
+    if (scrollLockCount === 0) {
+      document.body.style.overflow = originalBodyOverflow ?? "";
+      originalBodyOverflow = null;
+    }
+  };
+}
+function captureFocus() {
+  if (typeof document === "undefined")
+    return null;
+  const active = document.activeElement;
+  if (active && active !== document.body && active instanceof HTMLElement) {
+    return active;
+  }
+  return null;
+}
+
+// src/utilities/attachments.ts
+function createClickOutside(options) {
+  const { handler, enabled = true, eventType = "click", capture = true, ignoreRefs } = options;
+  return (node) => {
+    function handleEvent(event) {
+      const isEnabled = typeof enabled === "function" ? enabled() : enabled;
+      if (!isEnabled)
+        return;
+      const target = event.target;
+      if (!(target instanceof Node)) {
+        handler();
+        return;
+      }
+      if (node.contains(target))
+        return;
+      if (ignoreRefs) {
+        for (const ref of ignoreRefs) {
+          const element2 = ref();
+          if (element2 && element2.contains(target))
+            return;
+        }
+      }
+      handler();
+    }
+    document.addEventListener(eventType, handleEvent, capture);
+    return () => {
+      document.removeEventListener(eventType, handleEvent, capture);
+    };
+  };
+}
+function overflowFade() {
+  return (node) => {
+    if (typeof ResizeObserver === "undefined") {
+      node.removeAttribute("data-cinder-overflows");
+      return;
+    }
+    const update = () => {
+      const overflows = node.scrollHeight - node.clientHeight > 1;
+      const atBottom = node.scrollTop + node.clientHeight >= node.scrollHeight - 1;
+      node.toggleAttribute("data-cinder-overflows", overflows && !atBottom);
+    };
+    const requestFrame = typeof requestAnimationFrame === "function" ? requestAnimationFrame : (callback) => window.setTimeout(() => callback(performance.now()));
+    const cancelFrame = typeof cancelAnimationFrame === "function" ? cancelAnimationFrame : (handle) => window.clearTimeout(handle);
+    let frame = 0;
+    const scheduleUpdate = () => {
+      if (frame)
+        return;
+      frame = requestFrame(() => {
+        frame = 0;
+        update();
+      });
+    };
+    const resizeObserver = new ResizeObserver(scheduleUpdate);
+    const observedElements = new Set;
+    const observeElement = (element2) => {
+      if (observedElements.has(element2))
+        return;
+      resizeObserver.observe(element2);
+      observedElements.add(element2);
+    };
+    const syncObservedElements = () => {
+      const currentElements = new Set([node, ...node.querySelectorAll("*")]);
+      for (const element2 of observedElements) {
+        if (!currentElements.has(element2)) {
+          resizeObserver.unobserve(element2);
+          observedElements.delete(element2);
+        }
+      }
+      for (const element2 of currentElements) {
+        observeElement(element2);
+      }
+    };
+    syncObservedElements();
+    const mutationObserver = typeof MutationObserver === "undefined" ? null : new MutationObserver(() => {
+      syncObservedElements();
+      scheduleUpdate();
+    });
+    mutationObserver?.observe(node, {
+      childList: true,
+      subtree: true,
+      characterData: true,
+      attributes: true,
+      attributeFilter: ["hidden", "class", "style", "aria-hidden"]
+    });
+    node.addEventListener("scroll", scheduleUpdate, { passive: true });
+    update();
+    return () => {
+      if (frame)
+        cancelFrame(frame);
+      resizeObserver.disconnect();
+      observedElements.clear();
+      mutationObserver?.disconnect();
+      node.removeEventListener("scroll", scheduleUpdate);
+    };
+  };
+}
+
+// src/components/dropdown/dropdown.context.ts
+import { createContext as createContext2 } from "svelte";
+var [getDropdownContextStrict, setDropdownContext] = createContext2();
+var getDropdownContext = getDropdownContextStrict;
+var [getDropdownRegisterStrict, setDropdownRegister] = createContext2();
+var getDropdownRegister = getDropdownRegisterStrict;
+var [getDropdownRegisterTriggerStrict, setDropdownRegisterTrigger] = createContext2();
+var getDropdownRegisterTrigger = getDropdownRegisterTriggerStrict;
+var [getDropdownSetOpenStrict, setDropdownSetOpen] = createContext2();
+var getDropdownSetOpen = getDropdownSetOpenStrict;
+
+// src/components/dropdown/dropdown.svelte
+function Dropdown($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const generatedId = $31.props_id($$renderer2);
+    let {
+      id = generatedId,
+      open = false,
+      placement = "bottom-start",
+      class: customClassName,
+      trigger,
+      children,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    let compoundMenuElement = null;
+    let compoundTriggerElement = null;
+    let compoundOpen = false;
+    let supportsPopover = false;
+    const menuId = `${generatedId}-menu`;
+    let menuElement = undefined;
+    let triggerWrapper = undefined;
+    const compoundMenuId = $31.derived(() => `${id}-menu`);
+    const usesLegacySnippetApi = $31.derived(() => Boolean(trigger));
+    function closeCompoundMenu() {
+      compoundMenuElement?.hidePopover?.();
+      compoundOpen = false;
+    }
+    function registerCompoundMenu(element2) {
+      compoundMenuElement = element2;
+    }
+    function registerCompoundTrigger(element2) {
+      compoundTriggerElement = element2;
+    }
+    function focusCompoundTrigger() {
+      compoundTriggerElement?.focus();
+    }
+    function setCompoundOpen(nextOpen) {
+      compoundOpen = nextOpen;
+    }
+    setDropdownContext({
+      get menuId() {
+        return compoundMenuId();
+      },
+      get isOpen() {
+        return compoundOpen;
+      },
+      get supportsPopover() {
+        return supportsPopover;
+      },
+      get anchorElement() {
+        return compoundTriggerElement;
+      },
+      get fallbackPlacement() {
+        return "bottom-end";
+      },
+      get widthMode() {
+        return "menu";
+      },
+      get initialFocus() {
+        return;
+      },
+      close: closeCompoundMenu,
+      focusTrigger: focusCompoundTrigger
+    });
+    setDropdownRegister(registerCompoundMenu);
+    setDropdownRegisterTrigger(registerCompoundTrigger);
+    setDropdownSetOpen(setCompoundOpen);
+    function handleKeydown(event) {
+      if (event.defaultPrevented)
+        return;
+      if (event.key === "Escape" && open) {
+        open = false;
+      } else if (event.key === "Escape" && compoundOpen) {
+        closeCompoundMenu();
+        focusCompoundTrigger();
+      }
+    }
+    const dismissOnOutsideClick = $31.derived(() => createClickOutside({
+      handler: () => {
+        open = false;
+        compoundOpen = false;
+      },
+      enabled: () => !supportsPopover && (open || compoundOpen),
+      ignoreRefs: [() => menuElement ?? null, () => compoundMenuElement ?? null],
+      capture: false
+    }));
+    function handlePopoverToggle(event) {
+      const toggleEvent = event;
+      open = toggleEvent.newState === "open";
+    }
+    $$renderer2.push(`<div${$31.attributes({
+      id,
+      class: $31.clsx(classNames("cinder-dropdown", customClassName)),
+      "data-cinder-placement": placement,
+      ...rest
+    })}>`);
+    if (usesLegacySnippetApi()) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<div class="cinder-dropdown__trigger" role="presentation"${$31.attr_style(`anchor-name: --${menuId};`)}>`);
+      if (trigger) {
+        $$renderer2.push("<!--[0-->");
+        trigger($$renderer2);
+        $$renderer2.push(`<!---->`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--></div> `);
+      if (supportsPopover) {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`<div${$31.attr("id", menuId)} class="cinder-dropdown__menu" popover="auto" role="menu"${$31.attr("data-cinder-placement", placement)}${$31.attr_style(`position-anchor: --${menuId};`)}>`);
+        if (children) {
+          $$renderer2.push("<!--[0-->");
+          children($$renderer2);
+          $$renderer2.push(`<!---->`);
+        } else {
+          $$renderer2.push("<!--[-1-->");
+        }
+        $$renderer2.push(`<!--]--></div>`);
+      } else if (open) {
+        $$renderer2.push("<!--[1-->");
+        $$renderer2.push(`<div${$31.attr("id", menuId)} class="cinder-dropdown__menu" role="menu"${$31.attr("data-cinder-placement", placement)}>`);
+        if (children) {
+          $$renderer2.push("<!--[0-->");
+          children($$renderer2);
+          $$renderer2.push(`<!---->`);
+        } else {
+          $$renderer2.push("<!--[-1-->");
+        }
+        $$renderer2.push(`<!--]--></div>`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]-->`);
+    } else if (children) {
+      $$renderer2.push("<!--[1-->");
+      children($$renderer2);
+      $$renderer2.push(`<!---->`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></div>`);
+    $31.bind_props($$props, { open });
+  });
+}
+
+// src/components/dropdown-trigger/dropdown-trigger.svelte
+import * as $32 from "svelte/internal/server";
+function Dropdown_trigger($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      class: customClassName,
+      showCaret = true,
+      children,
+      onclick,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    const context = getDropdownContext();
+    const registerTrigger = getDropdownRegisterTrigger();
+    const setOpen = getDropdownSetOpen();
+    let triggerElement = null;
+    function handleClick(event) {
+      if (typeof onclick === "function") {
+        onclick(event);
+      }
+      if (!event.defaultPrevented && !context.supportsPopover) {
+        setOpen(!context.isOpen);
+      }
+    }
+    $$renderer2.push(`<button${$32.attributes({
+      type: "button",
+      class: $32.clsx(classNames("cinder-dropdown-trigger", customClassName)),
+      style: `anchor-name: --${context.menuId};`,
+      "aria-haspopup": "menu",
+      "aria-expanded": context.isOpen,
+      "aria-controls": context.menuId,
+      popovertarget: context.supportsPopover ? context.menuId : undefined,
+      ...rest
+    })}>`);
+    if (children) {
+      $$renderer2.push("<!--[0-->");
+      children($$renderer2);
+      $$renderer2.push(`<!---->`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    if (showCaret) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<svg class="cinder-dropdown-trigger__caret" aria-hidden="true" focusable="false" viewBox="0 0 20 20" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M6 8l4 4 4-4"></path></svg>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></button>`);
+  });
+}
+
+// src/components/dropdown-menu/dropdown-menu.svelte
+import * as $33 from "svelte/internal/server";
+import { tick } from "svelte";
+function Dropdown_menu($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { class: customClassName, children, $$slots, $$events, ...rest } = $$props;
+    const context = getDropdownContext();
+    const registerMenu = getDropdownRegister();
+    const setOpen = getDropdownSetOpen();
+    let menuElement = null;
+    let focusedFallbackOpen = false;
+    const anchoredFallback = createAnchoredOverlay({
+      open: () => context.isOpen && !context.supportsPopover && Boolean(context.anchorElement),
+      anchor: () => context.anchorElement,
+      panel: () => menuElement,
+      placement: () => context.fallbackPlacement ?? "bottom-end",
+      offset: () => 4,
+      widthMode: () => context.widthMode ?? "menu"
+    });
+    const fallbackPortalAttachment = createPortalAttachment({
+      target: () => typeof document === "undefined" ? null : document.body,
+      source: () => context.anchorElement,
+      inheritAttributes: true,
+      disabled: () => context.supportsPopover
+    });
+    function getOwnedMenuItems() {
+      if (!menuElement)
+        return [];
+      return Array.from(menuElement.querySelectorAll('[role="menuitem"]:not([data-disabled])')).filter((item) => item.closest('[role="menu"]') === menuElement);
+    }
+    function focusMenuItem(index) {
+      const items = getOwnedMenuItems();
+      if (!items.length) {
+        menuElement?.focus();
+        return;
+      }
+      const resolvedIndex = index < 0 ? items.length - 1 : index;
+      const item = items.at(resolvedIndex);
+      item?.focus();
+    }
+    function handleKeydown(event) {
+      const target = event.target instanceof HTMLElement ? event.target : null;
+      if (target?.closest('[role="menu"]') !== menuElement)
+        return;
+      if (event.key === "Escape") {
+        event.preventDefault();
+        event.stopPropagation();
+        setOpen(false);
+        context.focusTrigger();
+        return;
+      }
+      const itemsArray = getOwnedMenuItems();
+      if (!itemsArray.length)
+        return;
+      const currentIndex = itemsArray.findIndex((item) => item === document.activeElement);
+      if (event.key === "ArrowDown") {
+        event.preventDefault();
+        event.stopPropagation();
+        focusMenuItem(currentIndex < itemsArray.length - 1 ? currentIndex + 1 : 0);
+      } else if (event.key === "ArrowUp") {
+        event.preventDefault();
+        event.stopPropagation();
+        focusMenuItem(currentIndex > 0 ? currentIndex - 1 : itemsArray.length - 1);
+      } else if (event.key === "Home") {
+        event.preventDefault();
+        event.stopPropagation();
+        focusMenuItem(0);
+      } else if (event.key === "End") {
+        event.preventDefault();
+        event.stopPropagation();
+        focusMenuItem(itemsArray.length - 1);
+      }
+    }
+    function handleToggle(event) {
+      const isOpenNow = event.newState === "open";
+      setOpen(isOpenNow);
+      if (isOpenNow) {
+        if (context.initialFocus === "none")
+          return;
+        tick().then(() => focusMenuItem(context.initialFocus === "last" ? -1 : 0));
+      }
+    }
+    if (context.supportsPopover || context.isOpen) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<div${$33.attributes({
+        id: context.menuId,
+        popover: context.supportsPopover ? "auto" : undefined,
+        class: $33.clsx(classNames("cinder-_floating-surface", "cinder-dropdown-menu", customClassName)),
+        style: context.supportsPopover ? `position-anchor: --${context.menuId};` : context.anchorElement ? anchoredFallback.positionStyle : undefined,
+        role: "menu",
+        "aria-orientation": "vertical",
+        "data-cinder-position-ready": !context.supportsPopover && context.anchorElement ? anchoredFallback.positionReady : undefined,
+        tabindex: -1,
+        ...rest
+      })}>`);
+      if (children) {
+        $$renderer2.push("<!--[0-->");
+        children($$renderer2);
+        $$renderer2.push(`<!---->`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--></div>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]-->`);
+  });
+}
+
+// src/components/dropdown-item/dropdown-item.svelte
+import * as $34 from "svelte/internal/server";
+function Dropdown_item($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      variant = "default",
+      inset = false,
+      disabled,
+      closeOnSelect = true,
+      class: customClassName,
+      onclick,
+      children,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    const context = getDropdownContext();
+    function handleClick(event) {
+      if (disabled)
+        return;
+      if (typeof onclick === "function") {
+        onclick(event);
+      }
+      if (closeOnSelect) {
+        context.close();
+      }
+    }
+    $$renderer2.push(`<button${$34.attributes({
+      ...rest,
+      type: "button",
+      role: "menuitem",
+      class: $34.clsx(classNames("cinder-_option-row", "cinder-dropdown-item", inset && "cinder-dropdown-item--inset", customClassName)),
+      "data-cinder-variant": variant,
+      tabindex: -1,
+      "data-disabled": disabled ? "" : undefined,
+      "aria-disabled": disabled ? "true" : undefined
+    })}>`);
+    if (children) {
+      $$renderer2.push("<!--[0-->");
+      children($$renderer2);
+      $$renderer2.push(`<!---->`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></button>`);
+  });
+}
+
+// src/components/markdown-editor/editor-toolbar/toolbar-dropdown.svelte
+function Toolbar_dropdown($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      id,
+      value,
+      options,
+      disabled = false,
+      onchange,
+      class: className
+    } = $$props;
+    const currentOption = $35.derived(() => options.find((opt) => opt.type === value) ?? options[0]);
+    function handleSelect(type) {
+      onchange?.(type);
+    }
+    Dropdown($$renderer2, {
+      id,
+      children: ($$renderer3) => {
+        Dropdown_trigger($$renderer3, {
+          class: classNames("toolbar-dropdown-trigger", className),
+          disabled,
+          "aria-label": `Block type: ${currentOption()?.label ?? "Paragraph"}`,
+          children: ($$renderer4) => {
+            if (currentOption()) {
+              $$renderer4.push("<!--[0-->");
+              if (currentOption.icon) {
+                $$renderer4.push("<!--[-->");
+                currentOption.icon($$renderer4, { class: "icon-sm" });
+                $$renderer4.push("<!--]-->");
+              } else {
+                $$renderer4.push("<!--[!-->");
+                $$renderer4.push("<!--]-->");
+              }
+            } else {
+              $$renderer4.push("<!--[-1-->");
+            }
+            $$renderer4.push(`<!--]--> <span class="toolbar-dropdown-label svelte-1v28aut">${$35.escape(currentOption()?.label ?? "Paragraph")}</span>`);
+          },
+          $$slots: { default: true }
+        });
+        $$renderer3.push(`<!----> `);
+        Dropdown_menu($$renderer3, {
+          children: ($$renderer4) => {
+            $$renderer4.push(`<!--[-->`);
+            const each_array = $35.ensure_array_like(options);
+            for (let $$index = 0, $$length = each_array.length;$$index < $$length; $$index++) {
+              let option = each_array[$$index];
+              const isActive = option.type === value;
+              Dropdown_item($$renderer4, {
+                onclick: () => handleSelect(option.type),
+                "data-active": isActive ? "" : undefined,
+                children: ($$renderer5) => {
+                  if (option.icon) {
+                    $$renderer5.push("<!--[-->");
+                    option.icon($$renderer5, { class: "icon-sm" });
+                    $$renderer5.push("<!--]-->");
+                  } else {
+                    $$renderer5.push("<!--[!-->");
+                    $$renderer5.push("<!--]-->");
+                  }
+                  $$renderer5.push(` <span class="dropdown-item-label svelte-1v28aut">${$35.escape(option.label)}</span> `);
+                  if (isActive) {
+                    $$renderer5.push("<!--[0-->");
+                    Check($$renderer5, { class: "icon-sm dropdown-item-check" });
+                  } else {
+                    $$renderer5.push("<!--[-1-->");
+                  }
+                  $$renderer5.push(`<!--]-->`);
+                },
+                $$slots: { default: true }
+              });
+            }
+            $$renderer4.push(`<!--]-->`);
+          },
+          $$slots: { default: true }
+        });
+        $$renderer3.push(`<!---->`);
+      },
+      $$slots: { default: true }
+    });
+  });
+}
+
+// src/components/markdown-editor/editor-toolbar/editor-toolbar.svelte
+function Editor_toolbar($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      id,
+      editorId,
+      editorContext,
+      activeMarks,
+      activeBlockType,
+      canUndo = false,
+      canRedo = false,
+      disabled = false,
+      onLinkClick,
+      onUndo,
+      onRedo,
+      actions,
+      class: className,
+      "aria-label": _ariaLabel,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    const blockTypeOptions = [
+      { type: "paragraph", label: "Paragraph", icon: Pilcrow },
+      { type: "heading1", label: "Heading 1", icon: Heading_1 },
+      { type: "heading2", label: "Heading 2", icon: Heading_2 },
+      { type: "heading3", label: "Heading 3", icon: Heading_3 },
+      { type: "blockquote", label: "Quote", icon: Quote }
+    ];
+    const currentBlockType = $36.derived(() => {
+      if (activeBlockType.type === "heading") {
+        switch (activeBlockType.headingLevel) {
+          case 1:
+            return "heading1";
+          case 2:
+            return "heading2";
+          case 3:
+            return "heading3";
+          default:
+            return "paragraph";
+        }
+      }
+      if (activeBlockType.type === "blockquote")
+        return "blockquote";
+      return "paragraph";
+    });
+    function handleBold() {
+      if (editorContext)
+        toggleBold(editorContext);
+    }
+    function handleItalic() {
+      if (editorContext)
+        toggleItalic(editorContext);
+    }
+    function handleCode() {
+      if (editorContext)
+        toggleCode(editorContext);
+    }
+    function handleStrikethrough() {
+      if (editorContext)
+        toggleStrikethrough(editorContext);
+    }
+    function handleLink(event) {
+      const triggerElement = event.currentTarget;
+      if (triggerElement instanceof HTMLElement) {
+        onLinkClick?.(triggerElement);
+      }
+    }
+    function handleBulletList() {
+      if (editorContext)
+        toggleBulletList(editorContext);
+    }
+    function handleOrderedList() {
+      if (editorContext)
+        toggleOrderedList(editorContext);
+    }
+    function handleBlockquote() {
+      if (editorContext)
+        toggleBlockquote(editorContext);
+    }
+    function handleBlockTypeChange(type) {
+      if (!editorContext)
+        return;
+      switch (type) {
+        case "paragraph":
+          setParagraph(editorContext);
+          break;
+        case "heading1":
+          setHeading(editorContext, 1);
+          break;
+        case "heading2":
+          setHeading(editorContext, 2);
+          break;
+        case "heading3":
+          setHeading(editorContext, 3);
+          break;
+        case "blockquote":
+          toggleBlockquote(editorContext);
+          break;
+      }
+    }
+    Toolbar($$renderer2, $36.spread_props([
+      {
+        id,
+        "aria-label": "Formatting toolbar",
+        "aria-controls": editorId,
+        "aria-disabled": disabled || undefined,
+        class: classNames("editor-toolbar", className)
+      },
+      rest,
+      {
+        children: ($$renderer3) => {
+          $$renderer3.push(`<div class="toolbar-group svelte-1m9m099" role="group" aria-label="History">`);
+          Toolbar_button($$renderer3, {
+            icon: Undo_2,
+            label: "Undo",
+            shortcut: getShortcutDisplay("Mod-z"),
+            disabled: disabled || !canUndo,
+            onclick: () => onUndo?.(),
+            "data-testid": "toolbar-undo"
+          });
+          $$renderer3.push(`<!----> `);
+          Toolbar_button($$renderer3, {
+            icon: Redo_2,
+            label: "Redo",
+            shortcut: getShortcutDisplay("Mod-Shift-z"),
+            disabled: disabled || !canRedo,
+            onclick: () => onRedo?.(),
+            "data-testid": "toolbar-redo"
+          });
+          $$renderer3.push(`<!----></div> `);
+          Toolbar_separator($$renderer3, {});
+          $$renderer3.push(`<!----> <div class="toolbar-group svelte-1m9m099" role="group" aria-label="Block type">`);
+          Toolbar_dropdown($$renderer3, {
+            id: `${id}-block-type`,
+            value: currentBlockType(),
+            options: blockTypeOptions,
+            disabled,
+            onchange: handleBlockTypeChange
+          });
+          $$renderer3.push(`<!----></div> `);
+          Toolbar_separator($$renderer3, {});
+          $$renderer3.push(`<!----> <div class="toolbar-group svelte-1m9m099" role="group" aria-label="Text formatting">`);
+          Toolbar_button($$renderer3, {
+            icon: Bold,
+            label: "Bold",
+            shortcut: getShortcutDisplay("Mod-b"),
+            toggle: true,
+            pressed: activeMarks.bold,
+            disabled,
+            onclick: handleBold,
+            "data-testid": "toolbar-bold"
+          });
+          $$renderer3.push(`<!----> `);
+          Toolbar_button($$renderer3, {
+            icon: Italic,
+            label: "Italic",
+            shortcut: getShortcutDisplay("Mod-i"),
+            toggle: true,
+            pressed: activeMarks.italic,
+            disabled,
+            onclick: handleItalic,
+            "data-testid": "toolbar-italic"
+          });
+          $$renderer3.push(`<!----> `);
+          Toolbar_button($$renderer3, {
+            icon: Code,
+            label: "Inline Code",
+            shortcut: getShortcutDisplay("Mod-e"),
+            toggle: true,
+            pressed: activeMarks.code,
+            disabled,
+            onclick: handleCode,
+            "data-testid": "toolbar-code"
+          });
+          $$renderer3.push(`<!----> `);
+          Toolbar_button($$renderer3, {
+            icon: Strikethrough,
+            label: "Strikethrough",
+            shortcut: getShortcutDisplay("Mod-Shift-s"),
+            toggle: true,
+            pressed: activeMarks.strikethrough,
+            disabled,
+            onclick: handleStrikethrough,
+            "data-testid": "toolbar-strikethrough"
+          });
+          $$renderer3.push(`<!----></div> `);
+          Toolbar_separator($$renderer3, {});
+          $$renderer3.push(`<!----> <div class="toolbar-group svelte-1m9m099" role="group" aria-label="Links">`);
+          Toolbar_button($$renderer3, {
+            icon: Link,
+            label: "Insert Link",
+            shortcut: getShortcutDisplay("Mod-k"),
+            toggle: true,
+            pressed: activeMarks.link,
+            disabled,
+            onclick: handleLink,
+            "data-testid": "toolbar-link"
+          });
+          $$renderer3.push(`<!----></div> `);
+          Toolbar_separator($$renderer3, {});
+          $$renderer3.push(`<!----> <div class="toolbar-group svelte-1m9m099" role="group" aria-label="Lists">`);
+          Toolbar_button($$renderer3, {
+            icon: List,
+            label: "Bullet List",
+            shortcut: getShortcutDisplay("Mod-Shift-8"),
+            toggle: true,
+            pressed: activeBlockType.type === "listItem" && activeBlockType.listType === "bullet",
+            disabled,
+            onclick: handleBulletList,
+            "data-testid": "toolbar-bullet-list"
+          });
+          $$renderer3.push(`<!----> `);
+          Toolbar_button($$renderer3, {
+            icon: List_ordered,
+            label: "Ordered List",
+            shortcut: getShortcutDisplay("Mod-Shift-7"),
+            toggle: true,
+            pressed: activeBlockType.type === "listItem" && activeBlockType.listType === "ordered",
+            disabled,
+            onclick: handleOrderedList,
+            "data-testid": "toolbar-ordered-list"
+          });
+          $$renderer3.push(`<!----></div> `);
+          Toolbar_separator($$renderer3, {});
+          $$renderer3.push(`<!----> <div class="toolbar-group svelte-1m9m099" role="group" aria-label="Block operations">`);
+          Toolbar_button($$renderer3, {
+            icon: Quote,
+            label: "Blockquote",
+            shortcut: getShortcutDisplay("Mod-Shift-9"),
+            toggle: true,
+            pressed: activeBlockType.type === "blockquote",
+            disabled,
+            onclick: handleBlockquote,
+            "data-testid": "toolbar-blockquote"
+          });
+          $$renderer3.push(`<!----></div> `);
+          if (actions) {
+            $$renderer3.push("<!--[0-->");
+            $$renderer3.push(`<div class="toolbar-spacer svelte-1m9m099"></div> `);
+            actions($$renderer3);
+            $$renderer3.push(`<!---->`);
+          } else {
+            $$renderer3.push("<!--[-1-->");
+          }
+          $$renderer3.push(`<!--]-->`);
+        },
+        $$slots: { default: true }
+      }
+    ]));
+  });
+}
+// src/components/markdown-editor/editor-toolbar/link-popover.svelte
+import * as $41 from "svelte/internal/server";
+
+// src/components/button/button.svelte
+import * as $37 from "svelte/internal/server";
+function Button($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const {
+      variant = "secondary",
+      size = "md",
+      fullWidth = false,
+      loading = false,
+      iconOnly = false,
+      leadingIcon,
+      trailingIcon,
+      children,
+      label,
+      class: customClassName,
+      href,
+      onclick: consumerOnClick,
+      "aria-disabled": consumerAriaDisabled,
+      "aria-busy": consumerAriaBusy,
+      "aria-label": ariaLabel,
+      "aria-labelledby": ariaLabelledBy,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    const mergedClassName = $37.derived(() => classNames("cinder-button", customClassName));
+    const dataAttributes = $37.derived(() => ({
+      "data-cinder-variant": variant,
+      "data-cinder-size": size,
+      "data-cinder-full-width": fullWidth ? "" : undefined,
+      "data-cinder-loading": loading ? "" : undefined,
+      "data-cinder-icon-only": iconOnly ? "" : undefined
+    }));
+    const resolvedAriaDisabled = $37.derived(() => loading ? "true" : consumerAriaDisabled);
+    const resolvedAriaBusy = $37.derived(() => loading ? "true" : consumerAriaBusy);
+    const resolvedAriaLabel = $37.derived(() => typeof ariaLabel === "string" && ariaLabel.trim().length > 0 ? ariaLabel : undefined);
+    const resolvedAriaLabelledBy = $37.derived(() => typeof ariaLabelledBy === "string" && ariaLabelledBy.trim().length > 0 ? ariaLabelledBy : undefined);
+    const anchorAttributes = rest;
+    const buttonAttributes = rest;
+    const anchorTabIndex = $37.derived(() => rest.tabindex);
+    const buttonType = $37.derived(() => rest.type);
+    const buttonDisabled = $37.derived(() => rest.disabled ?? false);
+    function handleClick(event) {
+      if (loading) {
+        event.preventDefault();
+        return;
+      }
+      if (typeof consumerOnClick === "function") {
+        consumerOnClick(event);
+      }
+    }
+    function buttonContent($$renderer3) {
+      if (leadingIcon) {
+        $$renderer3.push("<!--[0-->");
+        $$renderer3.push(`<span class="cinder-button__icon" aria-hidden="true">`);
+        leadingIcon($$renderer3);
+        $$renderer3.push(`<!----></span>`);
+      } else {
+        $$renderer3.push("<!--[-1-->");
+      }
+      $$renderer3.push(`<!--]--> `);
+      if (iconOnly) {
+        $$renderer3.push("<!--[0-->");
+        if (!resolvedAriaLabel() && !resolvedAriaLabelledBy() && label) {
+          $$renderer3.push("<!--[0-->");
+          $$renderer3.push(`<span class="cinder-sr-only">${$37.escape(label)}</span>`);
+        } else {
+          $$renderer3.push("<!--[-1-->");
+        }
+        $$renderer3.push(`<!--]--> `);
+        if (children) {
+          $$renderer3.push("<!--[0-->");
+          $$renderer3.push(`<span class="cinder-button__icon" aria-hidden="true">`);
+          children($$renderer3);
+          $$renderer3.push(`<!----></span>`);
+        } else {
+          $$renderer3.push("<!--[-1-->");
+        }
+        $$renderer3.push(`<!--]-->`);
+      } else if (children) {
+        $$renderer3.push("<!--[1-->");
+        children($$renderer3);
+        $$renderer3.push(`<!---->`);
+      } else {
+        $$renderer3.push("<!--[-1-->");
+        $$renderer3.push(`${$37.escape(label)}`);
+      }
+      $$renderer3.push(`<!--]--> `);
+      if (trailingIcon) {
+        $$renderer3.push("<!--[0-->");
+        $$renderer3.push(`<span class="cinder-button__icon" aria-hidden="true">`);
+        trailingIcon($$renderer3);
+        $$renderer3.push(`<!----></span>`);
+      } else {
+        $$renderer3.push("<!--[-1-->");
+      }
+      $$renderer3.push(`<!--]-->`);
+    }
+    if (href !== undefined) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<a${$37.attributes({
+        ...anchorAttributes,
+        href: loading ? undefined : href,
+        tabindex: loading ? -1 : anchorTabIndex(),
+        class: $37.clsx(mergedClassName()),
+        ...dataAttributes(),
+        "aria-disabled": resolvedAriaDisabled(),
+        "aria-busy": resolvedAriaBusy(),
+        "aria-label": resolvedAriaLabel(),
+        "aria-labelledby": resolvedAriaLabelledBy()
+      })}>`);
+      buttonContent($$renderer2);
+      $$renderer2.push(`<!----></a>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      $$renderer2.push(`<button${$37.attributes({
+        ...buttonAttributes,
+        type: buttonType() ?? "button",
+        class: $37.clsx(mergedClassName()),
+        ...dataAttributes(),
+        disabled: buttonDisabled() || loading,
+        "aria-disabled": resolvedAriaDisabled(),
+        "aria-busy": resolvedAriaBusy(),
+        "aria-label": resolvedAriaLabel(),
+        "aria-labelledby": resolvedAriaLabelledBy()
+      })}>`);
+      buttonContent($$renderer2);
+      $$renderer2.push(`<!----></button>`);
+    }
+    $$renderer2.push(`<!--]-->`);
+  });
+}
+
+// src/components/input/input.svelte
+import * as $38 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 as createContext3 } 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] = createContext3();
+function setFormFieldContext(context) {
+  setFormFieldContextRaw(context);
+}
+var getFormFieldContext = optionalContext(getFormFieldContextStrict);
+
+// src/components/input/input.svelte
+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 = "",
+      label,
+      description,
+      error,
+      disabled,
+      required,
+      type = "text",
+      class: className,
+      leading,
+      trailing,
+      leadingInteractive = false,
+      trailingInteractive = false,
+      "aria-describedby": consumerDescribedBy,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    const context = getFormFieldContext();
+    const defaultDescriptionId = $38.derived(() => describeId(id, !!description));
+    const defaultErrorId = $38.derived(() => errorId(id, !!error));
+    const ownDescriptionId = $38.derived(() => description && defaultDescriptionId() === context?.descriptionId ? `${id}-input-description` : defaultDescriptionId());
+    const ownErrorId = $38.derived(() => error && defaultErrorId() === context?.errorId ? `${id}-input-error` : defaultErrorId());
+    const resolvedDescriptionId = $38.derived(() => ownDescriptionId() ?? context?.descriptionId);
+    const resolvedErrorId = $38.derived(() => ownErrorId() ?? context?.errorId);
+    const describedBy = $38.derived(() => composeDescribedBy(resolvedDescriptionId(), resolvedErrorId(), consumerDescribedBy));
+    const resolvedAriaInvalid = $38.derived(() => error ? ariaInvalid(true) : context?.invalid ?? rest["aria-invalid"] ?? ariaInvalid(false));
+    const resolvedRequired = $38.derived(() => required ?? context?.required ?? false);
+    const resolvedDisabled = $38.derived(() => disabled ?? context?.disabled ?? false);
+    const isNativeDateInput = $38.derived(() => type === "date");
+    const rendersNativeDateIcon = $38.derived(() => isNativeDateInput() && !trailing);
+    const hasTrailing = $38.derived(() => !!trailing || isNativeDateInput());
+    const hasGroupWrapper = $38.derived(() => !!leading || hasTrailing());
+    const isInvalid = $38.derived(() => resolvedAriaInvalid() === "true" || resolvedAriaInvalid() === true);
+    function inputElement($$renderer3) {
+      $$renderer3.push(`<input${$38.attributes({
+        id,
+        type,
+        disabled: resolvedDisabled(),
+        required: resolvedRequired(),
+        value,
+        class: $38.clsx(classNames("cinder-input", className)),
+        "data-cinder-native-date": rendersNativeDateIcon() ? "" : undefined,
+        "aria-invalid": resolvedAriaInvalid(),
+        "aria-describedby": describedBy(),
+        ...rest
+      }, undefined, undefined, undefined, 4)}/>`);
+    }
+    $$renderer2.push(`<div class="cinder-input-field">`);
+    if (label) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<label${$38.attr("for", id)} class="cinder-input-field__label"${$38.attr("data-disabled", resolvedDisabled() || undefined)}>${$38.escape(label)}</label>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    if (hasGroupWrapper()) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<div class="cinder-input-group"${$38.attr("data-leading", leading ? "" : undefined)}${$38.attr("data-trailing", hasTrailing() ? "" : undefined)}${$38.attr("data-native-date", rendersNativeDateIcon() ? "" : undefined)}${$38.attr("data-disabled", resolvedDisabled() ? "" : undefined)}${$38.attr("data-invalid", isInvalid() ? "" : undefined)}>`);
+      if (leading) {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`<span class="cinder-input-group__leading cinder-_truncate"${$38.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"${$38.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${$38.attr("id", ownDescriptionId())} class="cinder-input-field__description">${$38.escape(description)}</p>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    if (error) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<p${$38.attr("id", ownErrorId())} class="cinder-input-field__error" aria-live="polite">${$38.escape(error)}</p>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></div>`);
+    $38.bind_props($$props, { value });
+  });
+}
+
+// ../../node_modules/lucide-svelte/dist/icons/unlink.svelte
+import * as $39 from "svelte/internal/server";
+function Unlink($$renderer, $$props) {
+  const $$sanitized_props = $39.sanitize_props($$props);
+  const iconNode = [
+    [
+      "path",
+      {
+        d: "m18.84 12.25 1.72-1.71h-.02a5.004 5.004 0 0 0-.12-7.07 5.006 5.006 0 0 0-6.95 0l-1.72 1.71"
+      }
+    ],
+    [
+      "path",
+      {
+        d: "m5.17 11.75-1.71 1.71a5.004 5.004 0 0 0 .12 7.07 5.006 5.006 0 0 0 6.95 0l1.71-1.71"
+      }
+    ],
+    ["line", { x1: "8", x2: "8", y1: "2", y2: "5" }],
+    ["line", { x1: "2", x2: "5", y1: "8", y2: "8" }],
+    ["line", { x1: "16", x2: "16", y1: "19", y2: "22" }],
+    ["line", { x1: "19", x2: "22", y1: "16", y2: "16" }]
+  ];
+  Icon($$renderer, $39.spread_props([
+    { name: "unlink" },
+    $$sanitized_props,
+    {
+      iconNode,
+      children: ($$renderer2) => {
+        $$renderer2.push(`<!--[-->`);
+        $39.slot($$renderer2, $$props, "default", {}, null);
+        $$renderer2.push(`<!--]-->`);
+      },
+      $$slots: { default: true }
+    }
+  ]));
+}
+// ../../node_modules/lucide-svelte/dist/icons/x.svelte
+import * as $40 from "svelte/internal/server";
+function X($$renderer, $$props) {
+  const $$sanitized_props = $40.sanitize_props($$props);
+  const iconNode = [
+    ["path", { d: "M18 6 6 18" }],
+    ["path", { d: "m6 6 12 12" }]
+  ];
+  Icon($$renderer, $40.spread_props([
+    { name: "x" },
+    $$sanitized_props,
+    {
+      iconNode,
+      children: ($$renderer2) => {
+        $$renderer2.push(`<!--[-->`);
+        $40.slot($$renderer2, $$props, "default", {}, null);
+        $$renderer2.push(`<!--]-->`);
+      },
+      $$slots: { default: true }
+    }
+  ]));
+}
+// src/components/markdown-editor/editor-toolbar/link-popover.svelte
+function Link_popover($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      id,
+      mode = "insert",
+      initialUrl = "",
+      initialText = "",
+      hasSelection = false,
+      class: className,
+      anchorElement = null,
+      onclose,
+      oninsert,
+      onremove
+    } = $$props;
+    let popoverElement = null;
+    const anchoredOverlay = createAnchoredOverlay({
+      open: () => Boolean(anchorElement),
+      anchor: () => anchorElement,
+      panel: () => popoverElement,
+      placement: () => "bottom-start",
+      offset: () => 8,
+      widthMode: () => "content"
+    });
+    let url = initialUrl;
+    let text = initialText;
+    const ALLOWED_PROTOCOLS = [
+      "http:",
+      "https:",
+      "mailto:",
+      "tel:",
+      "ftp:",
+      "ftps:",
+      "sms:"
+    ];
+    const DANGEROUS_SCHEMES = ["javascript:", "data:", "vbscript:"];
+    const urlError = $41.derived(() => {
+      if (!url.trim())
+        return;
+      const trimmedUrl = url.trim().toLowerCase();
+      for (const scheme of DANGEROUS_SCHEMES) {
+        if (trimmedUrl.startsWith(scheme)) {
+          return "This URL scheme is not allowed";
+        }
+      }
+      if (trimmedUrl.startsWith("/") || trimmedUrl.startsWith("#")) {
+        return;
+      }
+      for (const protocol of ALLOWED_PROTOCOLS) {
+        if (trimmedUrl.startsWith(protocol)) {
+          return;
+        }
+      }
+      try {
+        new URL(url);
+        return;
+      } catch {
+        try {
+          new URL(`https://${url}`);
+          return;
+        } catch {
+          return "Please enter a valid URL";
+        }
+      }
+    });
+    const canSubmit = $41.derived(() => url.trim() && !urlError() && (hasSelection || text.trim()));
+    function handleKeyDown(event) {
+      if (event.key === "Escape" && !event.defaultPrevented) {
+        event.preventDefault();
+        onclose?.();
+      }
+      if (event.key === "Enter" && canSubmit() && !event.isComposing) {
+        event.preventDefault();
+        handleSubmit();
+      }
+    }
+    function handleSubmit() {
+      if (!canSubmit())
+        return;
+      let normalizedUrl = url.trim();
+      const lowerUrl = normalizedUrl.toLowerCase();
+      const hasProtocol = lowerUrl.startsWith("/") || lowerUrl.startsWith("#") || ALLOWED_PROTOCOLS.some((protocol) => lowerUrl.startsWith(protocol));
+      if (!hasProtocol) {
+        normalizedUrl = `https://${normalizedUrl}`;
+      }
+      oninsert?.(normalizedUrl, hasSelection ? undefined : text.trim());
+    }
+    function handleRemove() {
+      onremove?.();
+    }
+    let $$settled = true;
+    let $$inner_renderer;
+    function $$render_inner($$renderer3) {
+      $$renderer3.push(`<div${$41.attr("id", id)} role="dialog" aria-modal="true"${$41.attr("aria-labelledby", `${id}-title`)} tabindex="-1"${$41.attr_class($41.clsx(classNames("link-popover", className)), "svelte-13b14j2")}${$41.attr_style(anchorElement ? anchoredOverlay.positionStyle : undefined)}${$41.attr("data-position-ready", anchorElement ? anchoredOverlay.positionReady : undefined)}${$41.attr("inert", anchorElement && !anchoredOverlay.positionReady ? true : undefined, true)}><header class="link-popover-header svelte-13b14j2"><h2${$41.attr("id", `${id}-title`)} class="link-popover-title svelte-13b14j2">`);
+      Link($$renderer3, { class: "icon-sm" });
+      $$renderer3.push(`<!----> ${$41.escape(mode === "insert" ? "Insert Link" : "Edit Link")}</h2> <button type="button" class="link-popover-close svelte-13b14j2" aria-label="Close">`);
+      X($$renderer3, { class: "icon-sm" });
+      $$renderer3.push(`<!----></button></header> <div class="link-popover-content svelte-13b14j2">`);
+      Input($$renderer3, {
+        id: `${id}-url`,
+        label: "URL",
+        type: "url",
+        placeholder: "https://example.com",
+        error: urlError() ?? "",
+        required: true,
+        get value() {
+          return url;
+        },
+        set value($$value) {
+          url = $$value;
+          $$settled = false;
+        }
+      });
+      $$renderer3.push(`<!----> `);
+      if (!hasSelection) {
+        $$renderer3.push("<!--[0-->");
+        Input($$renderer3, {
+          id: `${id}-text`,
+          label: "Link text",
+          placeholder: "Display text",
+          required: true,
+          get value() {
+            return text;
+          },
+          set value($$value) {
+            text = $$value;
+            $$settled = false;
+          }
+        });
+      } else {
+        $$renderer3.push("<!--[-1-->");
+      }
+      $$renderer3.push(`<!--]--></div> <footer class="link-popover-footer svelte-13b14j2"><div class="link-popover-actions svelte-13b14j2">`);
+      if (mode === "edit") {
+        $$renderer3.push("<!--[0-->");
+        Button($$renderer3, {
+          variant: "ghost",
+          size: "sm",
+          onclick: handleRemove,
+          children: ($$renderer4) => {
+            Unlink($$renderer4, { class: "icon-sm" });
+            $$renderer4.push(`<!----> Remove`);
+          },
+          $$slots: { default: true }
+        });
+      } else {
+        $$renderer3.push("<!--[-1-->");
+      }
+      $$renderer3.push(`<!--]--></div> <div class="link-popover-primary-actions svelte-13b14j2">`);
+      Button($$renderer3, {
+        variant: "secondary",
+        size: "sm",
+        onclick: onclose,
+        children: ($$renderer4) => {
+          $$renderer4.push(`<!---->Cancel`);
+        },
+        $$slots: { default: true }
+      });
+      $$renderer3.push(`<!----> `);
+      Button($$renderer3, {
+        variant: "primary",
+        size: "sm",
+        onclick: handleSubmit,
+        disabled: !canSubmit(),
+        children: ($$renderer4) => {
+          $$renderer4.push(`<!---->${$41.escape(mode === "insert" ? "Insert" : "Update")}`);
+        },
+        $$slots: { default: true }
+      });
+      $$renderer3.push(`<!----></div></footer></div>`);
+    }
+    do {
+      $$settled = true;
+      $$inner_renderer = $$renderer2.copy();
+      $$render_inner($$inner_renderer);
+    } while (!$$settled);
+    $$renderer2.subsume($$inner_renderer);
+  });
+}
+// src/components/markdown-editor/markdown-editor.svelte
+function Markdown_editor($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      id,
+      label = "Markdown editor",
+      value = "",
+      mode = "wysiwyg",
+      showModeToggle = false,
+      modeLabel = "Editor mode",
+      readonly = false,
+      placeholder = "Start writing...",
+      showToolbar = true,
+      class: className,
+      onchange,
+      onReady,
+      onmodechange,
+      onSelectionChange,
+      onCommentShortcut,
+      plugins = [],
+      placeholderCompletion,
+      placeholderDecoration,
+      toolbar,
+      toolbarActions,
+      toolbarLeading,
+      snapshotMode = false,
+      "aria-describedby": ariaDescribedby,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    let wrapperElement = null;
+    const escapedPlaceholder = $42.derived(() => placeholder.replace(/'/g, "\\'"));
+    let editorState = null;
+    let isInitializing = true;
+    let pipelineUtilities = null;
+    let isInternalUpdate = false;
+    function normalizeSafely(markdown) {
+      try {
+        return pipelineUtilities?.normalize(markdown) ?? normalizeForEditor(markdown);
+      } catch (error) {
+        devWarn("Failed to normalize markdown, using raw value:", error);
+        return markdown;
+      }
+    }
+    function normalizeForEditor(markdown) {
+      if (!markdown.trim())
+        return `
+`;
+      return markdown.replace(/\r\n?/g, `
+`).replace(/^(\s*)[*+] /gm, "$1- ").replace(/^([-*+] .*)$\n\n(?=[-*+] )/gm, `$1
+`).replace(/^(\d+\. .*)$\n\n(?=\d+\. )/gm, `$1
+`).replace(/\n{3,}/g, `
+
+`).replace(/^\n+/, "").replace(/\n+$/, `
+`);
+    }
+    let selectionVersion = 0;
+    let historyUtilities = null;
+    const editorContext = $42.derived(() => editorState?.editor?.ctx ?? null);
+    const activeMarks = $42.derived(() => {
+      if (!editorContext()) {
+        return {
+          bold: false,
+          italic: false,
+          code: false,
+          strikethrough: false,
+          link: false
+        };
+      }
+      return getActiveMarks(editorContext());
+    });
+    const activeBlockType = $42.derived(() => {
+      if (!editorContext()) {
+        return { type: "paragraph" };
+      }
+      return getActiveBlockType(editorContext());
+    });
+    const canUndo = $42.derived(() => {
+      const view = editorState?.view;
+      if (!view || historyUtilities === null)
+        return false;
+      return historyUtilities.undoDepth(view.state) > 0;
+    });
+    const canRedo = $42.derived(() => {
+      const view = editorState?.view;
+      if (!view || historyUtilities === null)
+        return false;
+      return historyUtilities.redoDepth(view.state) > 0;
+    });
+    const toolbarVisible = $42.derived(() => showToolbar && !readonly && false_default && (mode === "wysiwyg" || showModeToggle));
+    const toolbarContext = $42.derived(() => ({
+      editorContext: editorContext(),
+      activeMarks: activeMarks(),
+      activeBlockType: activeBlockType(),
+      canUndo: canUndo(),
+      canRedo: canRedo(),
+      readonly
+    }));
+    let linkPopoverOpen = false;
+    let linkPopoverAnchorElement = null;
+    const linkPopoverMode = $42.derived(() => {
+      if (!editorContext())
+        return "insert";
+      const existingUrl = getLinkAtCursor(editorContext());
+      return existingUrl ? "edit" : "insert";
+    });
+    const linkPopoverInitialUrl = $42.derived(() => {
+      if (!editorContext())
+        return "";
+      return getLinkAtCursor(editorContext()) ?? "";
+    });
+    const linkPopoverHasSelection = $42.derived(() => {
+      if (!editorContext())
+        return false;
+      return !isSelectionCollapsed(editorContext());
+    });
+    const linkPopoverInitialText = $42.derived(() => {
+      if (!editorContext())
+        return "";
+      if (!isSelectionCollapsed(editorContext()))
+        return "";
+      return getLinkTextAtCursor(editorContext()) ?? "";
+    });
+    const lastKnownLinkRange = $42.derived(() => {
+      if (!editorContext())
+        return null;
+      const url = getLinkAtCursor(editorContext());
+      if (!url)
+        return null;
+      return getLinkRangeAtCursor(editorContext());
+    });
+    let capturedLinkRange = null;
+    function resolveLinkPopoverAnchor() {
+      if (editorState?.view) {
+        try {
+          const view = editorState.view;
+          const from = view.state.selection.from;
+          const probe = view.coordsAtPos(from);
+          if (probe && probe.top > 0) {
+            return {
+              ...view.dom instanceof HTMLElement ? { contextElement: view.dom } : {},
+              getBoundingClientRect: () => {
+                try {
+                  const coords = view.coordsAtPos(view.state.selection.from);
+                  return {
+                    x: coords.left,
+                    y: coords.top,
+                    width: coords.right - coords.left,
+                    height: coords.bottom - coords.top,
+                    top: coords.top,
+                    right: coords.right,
+                    bottom: coords.bottom,
+                    left: coords.left
+                  };
+                } catch {
+                  return view.dom.getBoundingClientRect();
+                }
+              }
+            };
+          }
+        } catch {}
+        const viewDom = editorState.view.dom;
+        if (viewDom instanceof HTMLElement)
+          return viewDom;
+      }
+      if (wrapperElement)
+        return wrapperElement;
+      return null;
+    }
+    function handleLinkClick(triggerElement) {
+      capturedLinkRange = lastKnownLinkRange();
+      linkPopoverAnchorElement = triggerElement;
+      linkPopoverOpen = true;
+    }
+    function handleLinkPopoverClose() {
+      linkPopoverOpen = false;
+      linkPopoverAnchorElement = null;
+      editorState?.focus();
+    }
+    function handleLinkInsert(url, text) {
+      if (!editorContext())
+        return;
+      if (text) {
+        const existingLinkUrl = getLinkAtCursor(editorContext());
+        if (existingLinkUrl) {
+          updateLinkAtCursor(editorContext(), text, url);
+        } else {
+          insertLinkAtCursor(editorContext(), text, url);
+        }
+      } else {
+        applyLinkToSelection(editorContext(), url);
+      }
+      linkPopoverOpen = false;
+      linkPopoverAnchorElement = null;
+      editorState?.focus();
+    }
+    function handleLinkRemove() {
+      if (!editorContext())
+        return;
+      removeLink(editorContext(), capturedLinkRange ?? undefined);
+      linkPopoverOpen = false;
+      capturedLinkRange = null;
+      linkPopoverAnchorElement = null;
+      editorState?.focus();
+    }
+    function handleUndo() {
+      if (!editorContext() || !canUndo())
+        return;
+      undoCommand(editorContext());
+    }
+    function handleRedo() {
+      if (!editorContext() || !canRedo())
+        return;
+      redoCommand(editorContext());
+    }
+    const editorAttachment = createEditorAttachment({
+      getInitialValue: () => normalizeSafely(value),
+      getReadonly: () => readonly,
+      getAriaLabel: () => label,
+      debounceMs: DEFAULT_DEBOUNCE_MS,
+      getPlugins: () => plugins,
+      getPlaceholderCompletion: () => placeholderCompletion,
+      getPlaceholderDecoration: () => placeholderDecoration,
+      onReady: (state) => {
+        editorState = state;
+        isInitializing = false;
+        onReady?.();
+      },
+      onChange: (markdown) => {
+        isInternalUpdate = true;
+        value = markdown;
+        onchange?.(markdown);
+        selectionVersion++;
+        queueMicrotask(() => {
+          isInternalUpdate = false;
+        });
+      },
+      onSelectionChange: (selection) => {
+        selectionVersion++;
+        onSelectionChange?.(selection);
+      },
+      onLinkShortcut: () => {
+        capturedLinkRange = lastKnownLinkRange();
+        linkPopoverAnchorElement = resolveLinkPopoverAnchor();
+        linkPopoverOpen = true;
+      },
+      onCommentShortcut: () => onCommentShortcut?.()
+    });
+    let previousMode = mode;
+    function focus() {
+      editorState?.focus();
+    }
+    function getMarkdown() {
+      return editorState?.getMarkdown() ?? value;
+    }
+    function setMarkdown(content) {
+      if (editorState) {
+        editorState.setMarkdown(content);
+      } else {
+        value = content;
+      }
+    }
+    function getAst() {
+      const markdown = getMarkdown();
+      if (pipelineUtilities === null) {
+        throw new Error("Markdown pipeline is not ready yet.");
+      }
+      return pipelineUtilities.parseOrThrow(markdown);
+    }
+    function getSelection() {
+      if (!editorState?.view)
+        return null;
+      const { from, to } = editorState.view.state.selection;
+      return { from, to, isCollapsed: from === to };
+    }
+    function getView() {
+      return editorState?.view ?? null;
+    }
+    function getEditor() {
+      return editorState?.editor ?? null;
+    }
+    onDestroy(() => {
+      editorState?.clearPendingTimers();
+      editorState = null;
+    });
+    let $$settled = true;
+    let $$inner_renderer;
+    function $$render_inner($$renderer3) {
+      $$renderer3.push(`<div${$42.attributes({
+        class: $42.clsx(classNames("markdown-editor-wrapper", className)),
+        "data-initializing": isInitializing || undefined,
+        "data-ready": !isInitializing ? true : undefined,
+        "data-mode": mode,
+        "data-has-toolbar": toolbarVisible() || undefined,
+        "data-snapshot-mode": snapshotMode || undefined,
+        ...rest
+      }, "svelte-1mxvqjb")}>`);
+      if (toolbarVisible()) {
+        $$renderer3.push("<!--[0-->");
+        if (toolbar) {
+          $$renderer3.push("<!--[0-->");
+          toolbar($$renderer3, toolbarContext());
+          $$renderer3.push(`<!---->`);
+        } else {
+          $$renderer3.push("<!--[-1-->");
+          $$renderer3.push(`<div class="editor-toolbar-wrapper svelte-1mxvqjb">`);
+          if (toolbarLeading) {
+            $$renderer3.push("<!--[0-->");
+            $$renderer3.push(`<div class="toolbar-leading svelte-1mxvqjb">`);
+            toolbarLeading($$renderer3, toolbarContext());
+            $$renderer3.push(`<!----></div>`);
+          } else {
+            $$renderer3.push("<!--[-1-->");
+          }
+          $$renderer3.push(`<!--]--> `);
+          Editor_toolbar($$renderer3, {
+            id: `${id}-toolbar`,
+            editorId: id,
+            editorContext: editorContext(),
+            activeMarks: activeMarks(),
+            activeBlockType: activeBlockType(),
+            canUndo: canUndo(),
+            canRedo: canRedo(),
+            disabled: !editorContext(),
+            onLinkClick: handleLinkClick,
+            onUndo: handleUndo,
+            onRedo: handleRedo
+          });
+          $$renderer3.push(`<!----> `);
+          if (toolbarActions) {
+            $$renderer3.push("<!--[0-->");
+            $$renderer3.push(`<div class="toolbar-actions svelte-1mxvqjb">`);
+            toolbarActions($$renderer3, toolbarContext());
+            $$renderer3.push(`<!----></div>`);
+          } else {
+            $$renderer3.push("<!--[-1-->");
+          }
+          $$renderer3.push(`<!--]--> `);
+          if (showModeToggle) {
+            $$renderer3.push("<!--[0-->");
+            $$renderer3.push(`<div class="toolbar-mode-toggle svelte-1mxvqjb">`);
+            Segmented_control($$renderer3, {
+              id: `${id}-mode-toggle`,
+              selectionMode: "single",
+              size: "sm",
+              label: modeLabel,
+              hideLabel: true,
+              get value() {
+                return mode;
+              },
+              set value($$value) {
+                mode = $$value;
+                $$settled = false;
+              },
+              children: ($$renderer4) => {
+                Segment($$renderer4, {
+                  value: "wysiwyg",
+                  children: ($$renderer5) => {
+                    $$renderer5.push(`<!---->Rich`);
+                  },
+                  $$slots: { default: true }
+                });
+                $$renderer4.push(`<!----> `);
+                Segment($$renderer4, {
+                  value: "source",
+                  children: ($$renderer5) => {
+                    $$renderer5.push(`<!---->Raw`);
+                  },
+                  $$slots: { default: true }
+                });
+                $$renderer4.push(`<!---->`);
+              },
+              $$slots: { default: true }
+            });
+            $$renderer3.push(`<!----></div>`);
+          } else {
+            $$renderer3.push("<!--[-1-->");
+          }
+          $$renderer3.push(`<!--]--></div>`);
+        }
+        $$renderer3.push(`<!--]-->`);
+      } else {
+        $$renderer3.push("<!--[-1-->");
+      }
+      $$renderer3.push(`<!--]--> `);
+      if (false_default) {
+        $$renderer3.push("<!--[0-->");
+        if (mode === "wysiwyg") {
+          $$renderer3.push("<!--[0-->");
+          $$renderer3.push(`<div${$42.attr("id", id)} class="cinder-markdown-content prose markdown-editor surface svelte-1mxvqjb"${$42.attr("data-readonly", readonly || undefined)} role="application"${$42.attr("aria-label", label || "Markdown editor")} tabindex="0"${$42.attr_style("", {
+            "--editor-placeholder": `'${$42.stringify(escapedPlaceholder())}'`
+          })}></div>`);
+        } else {
+          $$renderer3.push("<!--[-1-->");
+          $$renderer3.push(`<textarea${$42.attr("id", id)} class="markdown-editor surface source-mode svelte-1mxvqjb"${$42.attr("placeholder", placeholder)}${$42.attr("readonly", readonly || undefined, true)}${$42.attr("aria-label", label)}${$42.attr("aria-describedby", ariaDescribedby)}>`);
+          const $$body = $42.escape(value);
+          if ($$body) {
+            $$renderer3.push(`${$$body}`);
+          } else {}
+          $$renderer3.push(`</textarea>`);
+        }
+        $$renderer3.push(`<!--]-->`);
+      } else {
+        $$renderer3.push("<!--[-1-->");
+        Editor_skeleton($$renderer3, { class: "markdown-editor" });
+      }
+      $$renderer3.push(`<!--]--> `);
+      if (linkPopoverOpen && mode === "wysiwyg") {
+        $$renderer3.push("<!--[0-->");
+        Link_popover($$renderer3, {
+          id: `${id}-link-popover`,
+          mode: linkPopoverMode(),
+          initialUrl: linkPopoverInitialUrl(),
+          initialText: linkPopoverInitialText(),
+          hasSelection: linkPopoverHasSelection(),
+          anchorElement: linkPopoverAnchorElement,
+          onclose: handleLinkPopoverClose,
+          oninsert: handleLinkInsert,
+          onremove: handleLinkRemove
+        });
+      } else {
+        $$renderer3.push("<!--[-1-->");
+      }
+      $$renderer3.push(`<!--]--></div>`);
+    }
+    do {
+      $$settled = true;
+      $$inner_renderer = $$renderer2.copy();
+      $$render_inner($$inner_renderer);
+    } while (!$$settled);
+    $$renderer2.subsume($$inner_renderer);
+    $42.bind_props($$props, {
+      value,
+      mode,
+      focus,
+      getMarkdown,
+      setMarkdown,
+      getAst,
+      getSelection,
+      getView,
+      getEditor
+    });
+  });
+}
+
+// src/components/markdown-editor/index.ts
+var markdown_editor_default = Markdown_editor;
+export {
+  markdown_editor_default as default,
+  Markdown_editor as MarkdownEditor
+};
+
+//# debugId=A1E79F71598F339464756E2164756E21