@lostgradient/cinder 0.4.1 → 0.5.0

package/dist/components/table-header-cell/index.js

@@ -1,4 +1,34 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  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: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
   this[name] = __returnValue.bind(null, newValue);
@@ -133,4 +163,4 @@ export {
   Table_header_cell as TableHeaderCell
 };
 
-//# debugId=311EFEA83A1B7EFB64756E2164756E21
+//# debugId=8E8740B7EED0D9BC64756E2164756E21

package/dist/components/table-header-cell/table-header-cell.css.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/table-header-cell/table-header-cell.schema.js

@@ -1,4 +1,34 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  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: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
   this[name] = __returnValue.bind(null, newValue);
@@ -64,4 +94,4 @@ export {
   table_header_cell_schema_default as default
 };
 
-//# debugId=E2B5F33FA6F3329164756E2164756E21
+//# debugId=06BA1B19769A7D5764756E2164756E21

package/dist/components/table-header-cell/table-header-cell.variables.js

@@ -1,4 +1,34 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  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: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
   this[name] = __returnValue.bind(null, newValue);
@@ -28,4 +58,4 @@ export {
   table_header_cell_variables_default as default
 };
 
-//# debugId=326D8FDA211ACECE64756E2164756E21
+//# debugId=17FB89EDDA37A4FC64756E2164756E21

package/dist/components/table-of-contents/index.d.ts

@@ -0,0 +1,5 @@
+import './table-of-contents.css';
+import TableOfContents from './table-of-contents.svelte';
+export default TableOfContents;
+export type { TableOfContentsItem, TableOfContentsProps } from './table-of-contents.types.ts';
+export { TableOfContents };

package/dist/components/table-of-contents/index.js

@@ -0,0 +1,563 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  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: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/components/table-of-contents/index.ts
+import"@lostgradient/cinder/table-of-contents/styles";
+
+// src/components/table-of-contents/table-of-contents.svelte
+import"svelte/internal/disclose-version";
+import * as $2 from "svelte/internal/client";
+
+// src/utilities/class-names.ts
+function classNames(...parts) {
+  return parts.filter((part) => typeof part === "string" && part.length > 0).join(" ");
+}
+
+// src/utilities/use-reduced-motion.svelte.ts
+import * as $ from "svelte/internal/client";
+import { MediaQuery } from "svelte/reactivity";
+function useReducedMotion() {
+  if (typeof window === "undefined" || typeof window.matchMedia !== "function") {
+    return { current: false };
+  }
+  const query = new MediaQuery("(prefers-reduced-motion: reduce)", false);
+  return {
+    get current() {
+      return query.current;
+    }
+  };
+}
+
+// src/components/table-of-contents/table-of-contents.svelte
+var root_3 = $2.from_html(`<li class="cinder-table-of-contents__item"><a> </a> <!></li>`);
+var root_2 = $2.from_html(`<ul></ul>`);
+var root_1 = $2.from_html(`<nav><!></nav>`);
+function Table_of_contents($$anchor, $$props) {
+  $2.push($$props, true);
+  let ariaLabel = $2.prop($$props, "ariaLabel", 3, "On this page"), headingSelector = $2.prop($$props, "headingSelector", 3, "h2, h3, h4"), observeRootMargin = $2.prop($$props, "observeRootMargin", 3, "0% 0% -70% 0%"), rest = $2.rest_props($$props, [
+    "$$slots",
+    "$$events",
+    "$$legacy",
+    "ariaLabel",
+    "class",
+    "items",
+    "target",
+    "headingSelector",
+    "observeRootMargin",
+    "aria-label",
+    "aria-labelledby"
+  ]);
+  const reducedMotion = useReducedMotion();
+  let activeId = $2.state(null);
+  let derivedHeadingItems = $2.state($2.proxy([]));
+  const normalizedItems = $2.derived(() => $$props.items === undefined ? $2.get(derivedHeadingItems) : normalizeExplicitItems($$props.items));
+  const validatedAriaLabel = $2.derived(() => {
+    const trimmed = ariaLabel().trim();
+    if (trimmed === "") {
+      throw new Error("TableOfContents requires a non-empty ariaLabel.");
+    }
+    return trimmed;
+  });
+  function normalizeItem(raw) {
+    const id = raw.id.trim();
+    const label = raw.label.trim();
+    if (id === "" || label === "") {
+      return null;
+    }
+    const normalizedChildren = raw.children?.map((child2) => normalizeItem(child2)).filter(isNonNullable) ?? [];
+    const normalized = { id, label, children: normalizedChildren };
+    if (typeof raw.level === "number" && Number.isFinite(raw.level)) {
+      normalized.level = raw.level;
+    }
+    return normalized;
+  }
+  function normalizeExplicitItems(source) {
+    return source?.map((item) => normalizeItem(item)).filter(isNonNullable) ?? [];
+  }
+  function isNonNullable(value) {
+    return value != null;
+  }
+  function slugifyHeading(text) {
+    return text.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-");
+  }
+  function resolveTargetElement(targetProp) {
+    if (typeof document === "undefined") {
+      return null;
+    }
+    if (typeof targetProp === "string") {
+      const selector = targetProp.trim();
+      if (selector === "") {
+        return null;
+      }
+      return document.querySelector(selector);
+    }
+    if (targetProp instanceof HTMLElement) {
+      return targetProp.isConnected ? targetProp : null;
+    }
+    return null;
+  }
+  function parseHeadingLevel(heading) {
+    const match = /^H([1-6])$/.exec(heading.tagName);
+    if (!match) {
+      return null;
+    }
+    return Number(match[1]);
+  }
+  function ensureHeadingId(heading, fallbackLabel, index, seenIds) {
+    const rawId = heading.id.trim();
+    const baseId = rawId !== "" ? rawId : slugifyHeading(fallbackLabel) || `section-${Math.max(index + 1, 1)}`;
+    let candidate = baseId;
+    let suffix = 2;
+    while (seenIds.has(candidate) || document.getElementById(candidate) !== null && document.getElementById(candidate) !== heading) {
+      candidate = `${baseId}-${suffix}`;
+      suffix += 1;
+    }
+    if (heading.id !== candidate) {
+      heading.id = candidate;
+    }
+    seenIds.add(candidate);
+    return candidate;
+  }
+  function deriveItemsFromHeadings(targetElement, selector) {
+    if (targetElement === null) {
+      return [];
+    }
+    const selectorToUse = selector.trim() === "" ? "h2, h3, h4" : selector;
+    const headings = [...targetElement.querySelectorAll(selectorToUse)];
+    const seenIds = new Set;
+    const parsed = headings.map((heading, index) => {
+      const label = heading.textContent?.trim() ?? "";
+      if (label === "") {
+        return null;
+      }
+      const level = parseHeadingLevel(heading);
+      if (level === null) {
+        return null;
+      }
+      const id = ensureHeadingId(heading, label, index, seenIds);
+      return { id, label, level };
+    }).filter(isNonNullable);
+    const nested = [];
+    const stack = [];
+    for (const heading of parsed) {
+      const item = {
+        id: heading.id,
+        label: heading.label,
+        level: heading.level,
+        children: []
+      };
+      while (stack.length > 0 && heading.level <= stack[stack.length - 1].level) {
+        stack.pop();
+      }
+      if (stack.length === 0) {
+        nested.push(item);
+      } else {
+        stack[stack.length - 1].item.children?.push(item);
+      }
+      stack.push({ level: heading.level, item });
+    }
+    return nested;
+  }
+  $2.user_effect(() => {
+    if ($$props.items !== undefined) {
+      $2.set(derivedHeadingItems, [], true);
+      return;
+    }
+    if (typeof window === "undefined" || typeof document === "undefined") {
+      $2.set(derivedHeadingItems, [], true);
+      return;
+    }
+    let targetObserver = null;
+    let targetParentObserver = null;
+    let documentObserver = null;
+    let retryTimer = null;
+    let pendingDocumentRefresh = null;
+    let observedTarget = null;
+    let observedTargetParent = null;
+    const clearRetryTimer = () => {
+      if (retryTimer !== null) {
+        clearTimeout(retryTimer);
+        retryTimer = null;
+      }
+    };
+    const clearPendingDocumentRefresh = () => {
+      if (pendingDocumentRefresh !== null) {
+        clearTimeout(pendingDocumentRefresh);
+        pendingDocumentRefresh = null;
+      }
+    };
+    const scheduleRetry = () => {
+      if (retryTimer !== null) {
+        return;
+      }
+      retryTimer = setTimeout(() => {
+        retryTimer = null;
+        refreshDerived();
+      }, 50);
+    };
+    const syncTargetObserver = (nextTarget) => {
+      if (observedTarget !== nextTarget) {
+        targetObserver?.disconnect();
+        targetObserver = null;
+        targetParentObserver?.disconnect();
+        targetParentObserver = null;
+        observedTarget = nextTarget;
+        observedTargetParent = nextTarget?.parentElement ?? null;
+      }
+      if (nextTarget !== null && targetObserver === null && typeof MutationObserver !== "undefined") {
+        targetObserver = new MutationObserver(() => {
+          refreshDerived();
+        });
+        targetObserver.observe(nextTarget, {
+          childList: true,
+          subtree: true,
+          characterData: true,
+          attributes: true
+        });
+      }
+      if (observedTargetParent !== null && targetParentObserver === null && typeof MutationObserver !== "undefined") {
+        targetParentObserver = new MutationObserver(() => {
+          refreshDerived();
+        });
+        targetParentObserver.observe(observedTargetParent, { childList: true });
+      }
+    };
+    const shouldDeriveFromTarget = typeof $$props.target === "string" && $$props.target.trim() !== "" || $$props.target instanceof HTMLElement;
+    const shouldWatchForTargetBySelector = typeof $$props.target === "string" && $$props.target.trim() !== "";
+    const shouldWatchTargetConnection = $$props.target instanceof HTMLElement;
+    if (!shouldDeriveFromTarget) {
+      $2.set(derivedHeadingItems, [], true);
+      return;
+    }
+    const refreshDerived = () => {
+      const targetElement = resolveTargetElement($$props.target);
+      syncTargetObserver(targetElement);
+      $2.set(derivedHeadingItems, deriveItemsFromHeadings(targetElement, headingSelector()), true);
+      if (targetElement !== null) {
+        clearRetryTimer();
+      } else if (shouldWatchForTargetBySelector && typeof MutationObserver === "undefined") {
+        scheduleRetry();
+      } else {
+        clearRetryTimer();
+      }
+    };
+    const scheduleDocumentRefreshCheck = () => {
+      if (!shouldWatchForTargetBySelector && !shouldWatchTargetConnection || pendingDocumentRefresh !== null) {
+        return;
+      }
+      if (observedTarget !== null && !document.contains(observedTarget)) {
+        refreshDerived();
+        return;
+      }
+      if (!shouldWatchForTargetBySelector) {
+        return;
+      }
+      if (observedTarget !== null && document.contains(observedTarget)) {
+        const latestTarget = resolveTargetElement($$props.target);
+        if (latestTarget === observedTarget) {
+          return;
+        }
+      } else if (observedTarget !== null) {
+        refreshDerived();
+        return;
+      }
+      pendingDocumentRefresh = setTimeout(() => {
+        pendingDocumentRefresh = null;
+        const latestTarget = resolveTargetElement($$props.target);
+        if (latestTarget !== observedTarget) {
+          refreshDerived();
+        }
+      }, 50);
+    };
+    if ((shouldWatchForTargetBySelector || shouldWatchTargetConnection) && typeof MutationObserver !== "undefined" && document.body !== null) {
+      documentObserver = new MutationObserver(() => {
+        scheduleDocumentRefreshCheck();
+      });
+      documentObserver.observe(document.body, { childList: true, subtree: true, attributes: true });
+    }
+    refreshDerived();
+    return () => {
+      clearRetryTimer();
+      clearPendingDocumentRefresh();
+      targetObserver?.disconnect();
+      targetParentObserver?.disconnect();
+      documentObserver?.disconnect();
+    };
+  });
+  function flattenIds(source) {
+    const ids = [];
+    const visit = (entries) => {
+      for (const entry of entries) {
+        ids.push(entry.id);
+        if ((entry.children?.length ?? 0) > 0) {
+          visit(entry.children ?? []);
+        }
+      }
+    };
+    visit(source);
+    return ids;
+  }
+  const observedIds = $2.derived(() => flattenIds($2.get(normalizedItems)));
+  function parseRootMarginToken(token, viewportHeight) {
+    if (token.endsWith("px")) {
+      const value = Number.parseFloat(token);
+      return Number.isFinite(value) ? value : 0;
+    }
+    if (token.endsWith("%")) {
+      const percent = Number.parseFloat(token);
+      return Number.isFinite(percent) ? viewportHeight * percent / 100 : 0;
+    }
+    return 0;
+  }
+  function parseActivationOffset(rootMargin, viewportHeight) {
+    const tokens = rootMargin.trim().split(/\s+/).filter((token) => token.length > 0);
+    const [topToken, rightToken = topToken, bottomToken = topToken] = tokens;
+    const resolvedTopToken = topToken ?? "0px";
+    const resolvedBottomToken = bottomToken ?? rightToken ?? resolvedTopToken;
+    const bottom = parseRootMarginToken(resolvedBottomToken, viewportHeight);
+    return viewportHeight + bottom;
+  }
+  function pickActiveId(orderedElements, activationOffset) {
+    let lastPassed = null;
+    let firstUpcoming = null;
+    for (const element of orderedElements) {
+      const top = element.getBoundingClientRect().top;
+      if (top <= activationOffset) {
+        lastPassed = { id: element.id, top };
+        continue;
+      }
+      if (firstUpcoming === null || top < firstUpcoming.top) {
+        firstUpcoming = { id: element.id, top };
+      }
+    }
+    return lastPassed?.id ?? firstUpcoming?.id ?? null;
+  }
+  $2.user_effect(() => {
+    if (typeof window === "undefined") {
+      return;
+    }
+    if ($2.get(observedIds).length === 0 || typeof IntersectionObserver === "undefined") {
+      $2.set(activeId, null);
+      return;
+    }
+    const collectObservedElements = () => $2.get(observedIds).map((id) => document.getElementById(id)).filter((element) => element instanceof HTMLElement);
+    let observedElements = collectObservedElements();
+    let pendingAnimationFrame = null;
+    const updateActiveId = () => {
+      if (observedElements.length === 0) {
+        $2.set(activeId, null);
+        return;
+      }
+      const elementsInDocumentOrder = [...observedElements].sort((a, b) => {
+        if (a === b) {
+          return 0;
+        }
+        const relation = a.compareDocumentPosition(b);
+        if ((relation & Node.DOCUMENT_POSITION_FOLLOWING) !== 0) {
+          return -1;
+        }
+        if ((relation & Node.DOCUMENT_POSITION_PRECEDING) !== 0) {
+          return 1;
+        }
+        return 0;
+      });
+      $2.set(activeId, pickActiveId(elementsInDocumentOrder, parseActivationOffset(observeRootMargin(), window.innerHeight)), true);
+    };
+    function scheduleActiveIdUpdate() {
+      if (typeof window.requestAnimationFrame !== "function") {
+        updateActiveId();
+        return;
+      }
+      if (pendingAnimationFrame !== null) {
+        return;
+      }
+      pendingAnimationFrame = window.requestAnimationFrame(() => {
+        pendingAnimationFrame = null;
+        updateActiveId();
+      });
+    }
+    const observer = new IntersectionObserver(() => {
+      scheduleActiveIdUpdate();
+    }, {
+      root: null,
+      rootMargin: observeRootMargin(),
+      threshold: [0, 1]
+    });
+    for (const element of observedElements) {
+      observer.observe(element);
+    }
+    function syncObservedElements() {
+      const nextObservedElements = collectObservedElements();
+      const unchanged = observedElements.length === nextObservedElements.length && observedElements.every((element, index) => element === nextObservedElements[index]);
+      if (unchanged) {
+        return;
+      }
+      observedElements = nextObservedElements;
+      observer.disconnect();
+      for (const element of observedElements) {
+        observer.observe(element);
+      }
+      scheduleActiveIdUpdate();
+    }
+    window.addEventListener("scroll", scheduleActiveIdUpdate, { passive: true });
+    window.addEventListener("resize", scheduleActiveIdUpdate);
+    let domObserver = null;
+    if (typeof MutationObserver !== "undefined" && document.body !== null) {
+      domObserver = new MutationObserver(() => {
+        syncObservedElements();
+      });
+      domObserver.observe(document.body, {
+        childList: true,
+        subtree: true,
+        attributes: true,
+        attributeFilter: ["id"]
+      });
+    }
+    updateActiveId();
+    return () => {
+      if (pendingAnimationFrame !== null && typeof window.cancelAnimationFrame === "function") {
+        window.cancelAnimationFrame(pendingAnimationFrame);
+      }
+      window.removeEventListener("scroll", scheduleActiveIdUpdate);
+      window.removeEventListener("resize", scheduleActiveIdUpdate);
+      domObserver?.disconnect();
+      observer.disconnect();
+    };
+  });
+  function handleItemClick(event, id) {
+    const element = document.getElementById(id);
+    if (element === null) {
+      return;
+    }
+    if (event.defaultPrevented || event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) {
+      return;
+    }
+    event.preventDefault();
+    $2.set(activeId, id, true);
+    element.scrollIntoView({
+      behavior: reducedMotion.current ? "auto" : "smooth",
+      block: "start"
+    });
+    const hash = `#${id}`;
+    if (window.location.hash !== hash) {
+      history.replaceState(null, "", hash);
+    }
+  }
+  var fragment = $2.comment();
+  var node = $2.first_child(fragment);
+  {
+    var consequent_1 = ($$anchor2) => {
+      var nav = root_1();
+      $2.attribute_effect(nav, ($0) => ({ class: $0, "aria-label": $2.get(validatedAriaLabel), ...rest }), [() => classNames("cinder-table-of-contents", $$props.class)]);
+      {
+        const renderItems = ($$anchor3, entries = $2.noop, $$arg1) => {
+          let nested = $2.derived_safe_equal(() => $2.fallback($$arg1?.(), false));
+          var ul = root_2();
+          $2.each(ul, 21, entries, (entry) => entry.id, ($$anchor4, entry) => {
+            var li = root_3();
+            var a_1 = $2.child(li);
+            var text_1 = $2.child(a_1, true);
+            $2.reset(a_1);
+            var node_1 = $2.sibling(a_1, 2);
+            {
+              var consequent = ($$anchor5) => {
+                renderItems($$anchor5, () => $2.get(entry).children ?? [], () => true);
+              };
+              $2.if(node_1, ($$render) => {
+                if (($2.get(entry).children?.length ?? 0) > 0)
+                  $$render(consequent);
+              });
+            }
+            $2.reset(li);
+            $2.template_effect(($0) => {
+              $2.set_attribute(li, "data-level", $2.get(entry).level);
+              $2.set_class(a_1, 1, $0);
+              $2.set_attribute(a_1, "href", "#" + $2.get(entry).id);
+              $2.set_attribute(a_1, "aria-current", $2.get(activeId) === $2.get(entry).id ? "location" : undefined);
+              $2.set_text(text_1, $2.get(entry).label);
+            }, [
+              () => $2.clsx(classNames("cinder-table-of-contents__link", $2.get(activeId) === $2.get(entry).id && "cinder-table-of-contents__link--active"))
+            ]);
+            $2.delegated("click", a_1, (event) => handleItemClick(event, $2.get(entry).id));
+            $2.append($$anchor4, li);
+          });
+          $2.reset(ul);
+          $2.template_effect(($0) => $2.set_class(ul, 1, $0), [
+            () => $2.clsx(classNames("cinder-table-of-contents__list", $2.get(nested) && "cinder-table-of-contents__list--nested"))
+          ]);
+          $2.append($$anchor3, ul);
+        };
+        var node_2 = $2.child(nav);
+        renderItems(node_2, () => $2.get(normalizedItems));
+        $2.reset(nav);
+      }
+      $2.append($$anchor2, nav);
+    };
+    $2.if(node, ($$render) => {
+      if ($2.get(normalizedItems).length > 0)
+        $$render(consequent_1);
+    });
+  }
+  $2.append($$anchor, fragment);
+  $2.pop();
+}
+$2.delegate(["click"]);
+
+// src/components/table-of-contents/index.ts
+var table_of_contents_default = Table_of_contents;
+export {
+  table_of_contents_default as default,
+  Table_of_contents as TableOfContents
+};
+
+//# debugId=465E30E69CA60C5D64756E2164756E21