@usetheo/ui 0.1.0-next.0 → 0.1.0-next.1

package/dist/slide-deck/index.js

@@ -0,0 +1,1797 @@
+import { createContext, useContext, useRef, useState, useEffect, useCallback, useMemo, useReducer, useId } from 'react';
+import { z } from 'zod';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+// src/components/composites/slide-deck/slide-deck.tsx
+
+// src/components/primitives/slide/alerts.ts
+var ALERT_RE = /^\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION)\][ \t]*(?:\r?\n|$)/i;
+function detectAlerts(tree) {
+  for (const node of tree.children) {
+    if (node.type !== "blockquote") continue;
+    transformIfAlert(node);
+  }
+  return tree;
+}
+function transformIfAlert(node) {
+  const firstChild = node.children[0];
+  if (!firstChild || firstChild.type !== "paragraph") return;
+  const paragraph = firstChild;
+  const firstInline = paragraph.children[0];
+  if (!firstInline || firstInline.type !== "text") return;
+  const text = firstInline;
+  const match = ALERT_RE.exec(text.value);
+  if (!match) return;
+  const matched = match[1];
+  if (!matched) return;
+  const type = matched.toLowerCase();
+  text.value = text.value.replace(ALERT_RE, "");
+  if (text.value === "" && paragraph.children.length > 1) {
+    paragraph.children.shift();
+  }
+  node.data = {
+    ...node.data,
+    hName: "aside",
+    hProperties: {
+      ...node.data?.hProperties ?? {},
+      className: ["theo-slide-alert"],
+      "data-theo-slide-alert-type": type
+    }
+  };
+}
+
+// src/components/primitives/slide/marpit-bg.ts
+var BG_ALT_RE = /^bg(?:\s+(\w+))?/i;
+var VALID_MODIFIERS = /* @__PURE__ */ new Set(["cover", "fit", "left", "right"]);
+function extractMarpitBackgrounds(tree) {
+  let background;
+  const filteredChildren = tree.children.filter((node) => {
+    if (node.type !== "paragraph") return true;
+    const p = node;
+    if (p.children.length !== 1) return true;
+    const child = p.children[0];
+    if (!child || child.type !== "image") return true;
+    const img = child;
+    const match = BG_ALT_RE.exec(img.alt ?? "");
+    if (!match) return true;
+    if (!background) {
+      const modifierRaw = match[1]?.toLowerCase();
+      const modifier = modifierRaw && VALID_MODIFIERS.has(modifierRaw) ? modifierRaw : void 0;
+      background = {
+        url: img.url,
+        modifier
+      };
+    }
+    return false;
+  });
+  return {
+    tree: { ...tree, children: filteredChildren },
+    background
+  };
+}
+
+// src/components/primitives/slide/plugin.ts
+function composePlugins(plugins) {
+  return {
+    async runMdast(tree, errors) {
+      let current = tree;
+      for (const p of plugins) {
+        if (!p.mdastTransform) continue;
+        const previous = current;
+        try {
+          const result = await p.mdastTransform(current);
+          if (!result || result.type !== "root") {
+            throw new Error("mdastTransform returned non-Root node");
+          }
+          current = result;
+        } catch (e) {
+          current = previous;
+          errors.push(makePluginError(p.name, "mdastTransform", e));
+        }
+      }
+      return current;
+    },
+    async runHast(tree, errors) {
+      let current = tree;
+      for (const p of plugins) {
+        if (!p.hastTransform) continue;
+        const previous = current;
+        try {
+          const result = await p.hastTransform(current);
+          if (!result || result.type !== "root") {
+            throw new Error("hastTransform returned non-Root node");
+          }
+          current = result;
+        } catch (e) {
+          current = previous;
+          errors.push(makePluginError(p.name, "hastTransform", e));
+        }
+      }
+      return current;
+    },
+    mergedComponents() {
+      const out = {};
+      for (const p of plugins) {
+        if (p.components) Object.assign(out, p.components);
+      }
+      return out;
+    },
+    mergedSanitizeExtensions() {
+      const tagNames = /* @__PURE__ */ new Set();
+      const attributes = {};
+      for (const p of plugins) {
+        const ext = p.sanitizeSchemaExtension;
+        if (!ext) continue;
+        if (ext.tagNames) {
+          for (const tag of ext.tagNames) tagNames.add(tag);
+        }
+        if (ext.attributes) {
+          for (const [tag, attrs] of Object.entries(ext.attributes)) {
+            if (!attributes[tag]) attributes[tag] = /* @__PURE__ */ new Set();
+            for (const a of attrs) attributes[tag].add(a);
+          }
+        }
+      }
+      const mergedAttrs = {};
+      for (const [tag, set] of Object.entries(attributes)) {
+        mergedAttrs[tag] = Array.from(set);
+      }
+      return {
+        tagNames: Array.from(tagNames),
+        attributes: mergedAttrs
+      };
+    }
+  };
+}
+function makePluginError(name, hook, e) {
+  const msg = e instanceof Error ? e.message : String(e);
+  return {
+    code: "PLUGIN_ERROR",
+    path: [],
+    message: `Plugin '${name}' failed in ${hook}: ${msg}`,
+    got: name
+  };
+}
+
+// src/components/primitives/slide/sanitize.ts
+var cachedBuiltSchema;
+var TIER_1_TAG_NAMES = ["aside"];
+var TIER_1_ATTRIBUTES = {
+  aside: ["className", "data-theo-slide-alert-type"],
+  "*": ["className"]
+};
+async function getSlideSanitizeSchema(extensions) {
+  const baseline = await getBaselineSchema();
+  if (!extensions || extensions.tagNames.length === 0 && Object.keys(extensions.attributes).length === 0) {
+    return baseline;
+  }
+  return mergeSchema(baseline, extensions);
+}
+async function getBaselineSchema() {
+  if (cachedBuiltSchema) return cachedBuiltSchema;
+  const { defaultSchema } = await import('hast-util-sanitize');
+  cachedBuiltSchema = mergeSchema(defaultSchema, {
+    tagNames: TIER_1_TAG_NAMES,
+    attributes: TIER_1_ATTRIBUTES
+  });
+  return cachedBuiltSchema;
+}
+function mergeSchema(base, extensions) {
+  const baseTagNames = base.tagNames ?? [];
+  const tagSet = new Set(baseTagNames);
+  for (const t of extensions.tagNames) tagSet.add(t);
+  const baseAttrs = base.attributes ?? {};
+  const mergedAttrs = { ...baseAttrs };
+  for (const [tag, attrs] of Object.entries(extensions.attributes)) {
+    const baseline = mergedAttrs[tag] ?? [];
+    const seen = /* @__PURE__ */ new Set();
+    const combined = [];
+    for (const a of baseline) {
+      const key = typeof a === "string" ? a : JSON.stringify(a);
+      if (!seen.has(key)) {
+        seen.add(key);
+        combined.push(a);
+      }
+    }
+    for (const a of attrs) {
+      if (!seen.has(a)) {
+        seen.add(a);
+        combined.push(a);
+      }
+    }
+    mergedAttrs[tag] = combined;
+  }
+  return {
+    ...base,
+    tagNames: Array.from(tagSet),
+    attributes: mergedAttrs
+  };
+}
+function collectTagCounts(tree) {
+  const counts = /* @__PURE__ */ new Map();
+  const walk = (node) => {
+    if (node.type === "element") {
+      const tag = node.tagName;
+      counts.set(tag, (counts.get(tag) ?? 0) + 1);
+    }
+    const children = node.children;
+    if (Array.isArray(children)) {
+      for (const child of children) {
+        if (child && typeof child === "object" && "type" in child) {
+          walk(child);
+        }
+      }
+    }
+  };
+  walk(tree);
+  return counts;
+}
+var slideTheme = z.enum(["default", "violet-forge"]);
+var slideLayout = z.enum([
+  "default",
+  "title",
+  "two-column",
+  "image-right",
+  "image-left",
+  "code-output",
+  "section"
+]);
+var cssColor = z.string().max(64);
+var langTag = z.string().regex(/^[a-z]{2,3}(-[A-Za-z0-9]{2,8})*$/, "Expected BCP-47 language tag").max(35);
+var SAFE_URL_SCHEMES = ["http://", "https://"];
+function sanitizeBgUrl(input) {
+  try {
+    const trimmed = input.trim();
+    const url = trimmed.startsWith("url(") ? trimmed.replace(/^url\(\s*['"]?/, "").replace(/['"]?\s*\)$/, "") : trimmed;
+    const lower = url.toLowerCase();
+    if (lower.startsWith("javascript:") || lower.startsWith("vbscript:")) return null;
+    if (lower.startsWith("data:")) return null;
+    if (!SAFE_URL_SCHEMES.some((s) => lower.startsWith(s))) return null;
+    new URL(url);
+    return url;
+  } catch {
+    return null;
+  }
+}
+var slideFrontmatter = z.object({
+  theme: slideTheme.optional(),
+  /** Rich-content T2: built-in layout (CSS grid). */
+  layout: slideLayout.optional(),
+  /** Rich-content T3: background URL (sanitized: http(s) only). */
+  backgroundImage: z.string().max(5e5).transform((v) => {
+    if (!v) return void 0;
+    const sanitized = sanitizeBgUrl(v);
+    return sanitized ?? void 0;
+  }).optional(),
+  /** Rich-content T3: CSS gradient string (validated by prefix). */
+  backgroundGradient: z.string().max(500).regex(
+    /^(linear|radial|conic)-gradient\(/i,
+    "Must start with linear-/radial-/conic-gradient("
+  ).optional(),
+  /** Rich-content T5: header overlay text (plain, ≤ 200 chars). */
+  header: z.string().max(200).optional(),
+  /** Rich-content T5: footer overlay text (plain, ≤ 200 chars). */
+  footer: z.string().max(200).optional(),
+  /** Rich-content T5: pagination — `true` shows page number, `"skip"` hides. */
+  paginate: z.union([z.boolean(), z.literal("skip"), z.literal("hold")]).optional(),
+  lang: langTag.optional(),
+  color: cssColor.optional(),
+  backgroundColor: cssColor.optional()
+}).strict();
+z.object({
+  frontmatter: slideFrontmatter,
+  body: z.string().max(5e4)
+});
+
+// src/components/primitives/slide/frontmatter.ts
+var MAX_RAW_FRONTMATTER = 10240;
+var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/;
+var BOM = "\uFEFF";
+function extractFrontmatter(md) {
+  const normalized = md.startsWith(BOM) ? md.slice(1) : md;
+  const match = FRONTMATTER_RE.exec(normalized);
+  if (!match) {
+    return { rawFrontmatter: null, body: normalized };
+  }
+  const raw = match[1] ?? "";
+  const body = match[2] ?? "";
+  if (raw.length > MAX_RAW_FRONTMATTER) {
+    return { rawFrontmatter: raw, body, tooLarge: true };
+  }
+  return { rawFrontmatter: raw, body };
+}
+
+// src/components/primitives/slide/validate.ts
+var MAX_BODY = 5e4;
+function valueAtPath(input, path) {
+  let cursor = input;
+  for (const segment of path) {
+    if (cursor === null || typeof cursor !== "object") return void 0;
+    cursor = cursor[segment];
+  }
+  return cursor;
+}
+function formatZodIssue(issue, input, pathPrefix) {
+  const error = {
+    path: [...pathPrefix, ...issue.path],
+    message: issue.message,
+    code: "INVALID_FRONTMATTER"
+  };
+  if ("received" in issue && issue.received !== void 0) {
+    error.got = issue.received;
+  } else if (issue.path.length > 0) {
+    const value = valueAtPath(input, issue.path);
+    if (value !== void 0) error.got = value;
+  }
+  return error;
+}
+async function detectMultiSlide(body) {
+  const { fromMarkdown } = await import('mdast-util-from-markdown');
+  const tree = fromMarkdown(body);
+  const hrIdx = tree.children.findIndex((n) => n.type === "thematicBreak");
+  if (hrIdx === -1) {
+    return { multi: false, firstSlideBody: body };
+  }
+  const firstHr = tree.children[hrIdx];
+  const offset = firstHr?.position?.start.offset;
+  if (typeof offset !== "number") {
+    return { multi: true, firstSlideBody: body };
+  }
+  return { multi: true, firstSlideBody: body.slice(0, offset) };
+}
+async function validateSlide(markdown) {
+  const errors = [];
+  const extracted = extractFrontmatter(markdown);
+  if (extracted.tooLarge) {
+    errors.push({
+      code: "FRONTMATTER_TOO_LARGE",
+      path: [],
+      message: `Raw frontmatter exceeds ${10240} bytes.`,
+      got: extracted.rawFrontmatter?.length
+    });
+    return { ok: false, errors };
+  }
+  let frontmatter = {};
+  if (extracted.rawFrontmatter !== null) {
+    let parsed;
+    try {
+      const yaml = await import('yaml');
+      parsed = yaml.parse(extracted.rawFrontmatter);
+    } catch (e) {
+      errors.push({
+        code: "INVALID_FRONTMATTER",
+        path: [],
+        message: e instanceof Error ? e.message : "YAML parse failed.",
+        got: extracted.rawFrontmatter
+      });
+      return { ok: false, errors };
+    }
+    if (parsed === null || parsed === void 0) {
+      frontmatter = {};
+    } else if (typeof parsed !== "object" || Array.isArray(parsed)) {
+      errors.push({
+        code: "INVALID_FRONTMATTER",
+        path: [],
+        message: "Frontmatter must be a YAML mapping (object).",
+        got: parsed
+      });
+      return { ok: false, errors };
+    } else {
+      const result = slideFrontmatter.safeParse(parsed);
+      if (!result.success) {
+        for (const issue of result.error.issues) {
+          errors.push(formatZodIssue(issue, parsed, []));
+        }
+        return { ok: false, errors };
+      }
+      frontmatter = result.data;
+    }
+  }
+  let body = extracted.body;
+  if (body.length > MAX_BODY) {
+    errors.push({
+      code: "CONTENT_TOO_LARGE",
+      path: ["body"],
+      message: `Body exceeds ${MAX_BODY} characters.`,
+      got: body.length
+    });
+    return { ok: false, errors };
+  }
+  const multi = await detectMultiSlide(body);
+  if (multi.multi) {
+    body = multi.firstSlideBody;
+    errors.push({
+      code: "MULTIPLE_SLIDES",
+      path: ["body"],
+      message: "Input contains a top-level thematic break (---). <Slide> renders single-slide markdown only. Only the first slide was rendered."
+    });
+  }
+  return { ok: true, input: { frontmatter, body }, errors };
+}
+
+// src/components/primitives/slide/parse.ts
+async function parseBody(body) {
+  const [{ fromMarkdown }, { gfmFromMarkdown }, { gfm }] = await Promise.all([
+    import('mdast-util-from-markdown'),
+    import('mdast-util-gfm'),
+    import('micromark-extension-gfm')
+  ]);
+  return fromMarkdown(body, {
+    extensions: [gfm()],
+    mdastExtensions: [gfmFromMarkdown()]
+  });
+}
+async function mdastToHast(tree) {
+  const { toHast } = await import('mdast-util-to-hast');
+  const hast = toHast(tree, { allowDangerousHtml: false });
+  if (!hast || hast.type !== "root") {
+    return { type: "root", children: hast ? [hast] : [] };
+  }
+  return hast;
+}
+async function sanitizeHast(tree, extensions) {
+  const schema = await getSlideSanitizeSchema(extensions);
+  const { sanitize } = await import('hast-util-sanitize');
+  const preCount = collectTagCounts(tree);
+  const safe = sanitize(tree, schema);
+  const safeRoot = safe.type === "root" ? safe : { type: "root", children: [safe] };
+  const postCount = collectTagCounts(safeRoot);
+  const bannedTags = [];
+  for (const [tag, before] of preCount) {
+    const after = postCount.get(tag) ?? 0;
+    if (after < before) {
+      bannedTags.push(tag);
+    }
+  }
+  return { tree: safeRoot, bannedTags };
+}
+async function hastToReact(tree, components) {
+  const { Fragment, jsx: jsx7, jsxs: jsxs6 } = await import('react/jsx-runtime');
+  const { toJsxRuntime } = await import('hast-util-to-jsx-runtime');
+  return toJsxRuntime(tree, {
+    Fragment,
+    jsx: jsx7,
+    jsxs: jsxs6,
+    components
+  });
+}
+async function parseSlide(markdown, opts = {}) {
+  const errors = [];
+  let frontmatter = {};
+  let body = markdown;
+  let truncated = false;
+  const validation = await validateSlide(markdown);
+  if (validation.ok) {
+    frontmatter = validation.input.frontmatter;
+    body = validation.input.body;
+    errors.push(...validation.errors);
+    truncated = validation.errors.some((e) => e.code === "MULTIPLE_SLIDES");
+  } else {
+    errors.push(...validation.errors);
+    body = markdown;
+  }
+  const compose = composePlugins(opts.plugins ?? []);
+  const rawMdast = await parseBody(body);
+  detectAlerts(rawMdast);
+  const { tree: mdastNoBg, background: marpitBg } = extractMarpitBackgrounds(rawMdast);
+  let extractedBackground;
+  if (marpitBg) {
+    const safeUrl = sanitizeBgUrl(marpitBg.url);
+    if (safeUrl) {
+      extractedBackground = { url: safeUrl, modifier: marpitBg.modifier };
+    } else {
+      errors.push({
+        code: "MARPIT_BG_UNSAFE_URL",
+        path: [],
+        message: "Marpit ![bg](url) rejected: unsafe scheme or malformed URL.",
+        got: marpitBg.url.slice(0, 80)
+      });
+    }
+  }
+  const transformedMdast = await compose.runMdast(mdastNoBg, errors);
+  const rawHast = await mdastToHast(transformedMdast);
+  const transformedHast = await compose.runHast(rawHast, errors);
+  const sanitizeExtensions = compose.mergedSanitizeExtensions();
+  const { tree: safeTree, bannedTags } = await sanitizeHast(transformedHast, sanitizeExtensions);
+  for (const tag of bannedTags) {
+    errors.push({
+      code: "BANNED_TAG",
+      path: ["body"],
+      message: `Tag <${tag}> was stripped by the slide sanitizer.`,
+      got: tag
+    });
+  }
+  const mergedComponents = {
+    ...opts.components ?? {},
+    ...compose.mergedComponents()
+  };
+  const tree = await hastToReact(safeTree, mergedComponents);
+  return { frontmatter, tree, errors, truncated, extractedBackground };
+}
+function useSlideFit(ref, canvasW, canvasH, opts = {}) {
+  const { minScale = 0.1, maxScale = 4 } = opts;
+  const [scale, setScale] = useState(1);
+  useEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    if (typeof ResizeObserver === "undefined") {
+      const { width, height } = el.getBoundingClientRect();
+      if (width > 0 && height > 0) {
+        const raw = Math.min(width / canvasW, height / canvasH);
+        setScale(Math.max(minScale, Math.min(raw, maxScale)));
+      }
+      return;
+    }
+    const update = () => {
+      const { width, height } = el.getBoundingClientRect();
+      if (width <= 0 || height <= 0) return;
+      const raw = Math.min(width / canvasW, height / canvasH);
+      const clamped = Math.max(minScale, Math.min(raw, maxScale));
+      if (Number.isFinite(clamped)) setScale(clamped);
+    };
+    update();
+    const ro = new ResizeObserver(update);
+    ro.observe(el);
+    return () => ro.disconnect();
+  }, [ref, canvasW, canvasH, minScale, maxScale]);
+  return scale;
+}
+var ASPECT_PRESETS = {
+  "16:9": { width: 1280, height: 720 },
+  "4:3": { width: 960, height: 720 }
+};
+function resolveCanvas(ar) {
+  if (!ar || ar === "16:9") return ASPECT_PRESETS["16:9"];
+  if (ar === "4:3") return ASPECT_PRESETS["4:3"];
+  if (ar.width <= 0 || ar.height <= 0 || !Number.isFinite(ar.width) || !Number.isFinite(ar.height)) {
+    return { ...ASPECT_PRESETS["16:9"], invalid: true };
+  }
+  return ar;
+}
+var Slide = ({
+  markdown,
+  theme = "default",
+  aspectRatio = "16:9",
+  minScale,
+  maxScale,
+  onValidationError,
+  components,
+  plugins,
+  className,
+  "aria-label": ariaLabel = "Slide"
+}) => {
+  const containerRef = useRef(null);
+  const canvas = useMemo(() => resolveCanvas(aspectRatio), [aspectRatio]);
+  const scale = useSlideFit(containerRef, canvas.width, canvas.height, {
+    minScale,
+    maxScale
+  });
+  const [parsed, setParsed] = useState(null);
+  useEffect(() => {
+    if (canvas.invalid && onValidationError) {
+      onValidationError([
+        {
+          code: "INVALID_ASPECT_RATIO",
+          path: ["aspectRatio"],
+          message: "aspectRatio width/height must be positive finite numbers; falling back to 16:9.",
+          got: aspectRatio
+        }
+      ]);
+    }
+  }, [canvas.invalid, onValidationError, aspectRatio]);
+  const versionRef = useRef(0);
+  useEffect(() => {
+    const myVersion = ++versionRef.current;
+    let cancelled = false;
+    parseSlide(markdown, { components, plugins }).then(
+      (result) => {
+        if (cancelled || myVersion !== versionRef.current) return;
+        setParsed(result);
+        if (result.errors.length > 0 && onValidationError) {
+          onValidationError(result.errors);
+        }
+      },
+      (err) => {
+        if (cancelled || myVersion !== versionRef.current) return;
+        if (onValidationError) {
+          onValidationError([
+            {
+              code: "INVALID_FRONTMATTER",
+              path: [],
+              message: err instanceof Error ? err.message : "parseSlide rejected."
+            }
+          ]);
+        }
+        setParsed({
+          frontmatter: {},
+          tree: emptyFragment(),
+          errors: [],
+          truncated: false
+        });
+      }
+    );
+    return () => {
+      cancelled = true;
+    };
+  }, [markdown, components, plugins, onValidationError]);
+  const treeNode = parsed?.tree ?? null;
+  const slideThemeAttr = theme;
+  const fm = parsed?.frontmatter ?? {};
+  const layout = fm.layout;
+  const bgUrl = fm.backgroundImage ?? parsed?.extractedBackground?.url;
+  const bgModifier = parsed?.extractedBackground?.modifier;
+  const bgGradient = fm.backgroundGradient;
+  const headerText = fm.header;
+  const footerText = fm.footer;
+  const paginateValue = fm.paginate;
+  const showPaginate = paginateValue === true;
+  const backgroundImageStyle = bgGradient ? bgGradient : bgUrl ? `url("${bgUrl}")` : void 0;
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      ref: containerRef,
+      className: ["theo-slide-host", className].filter(Boolean).join(" "),
+      "data-theo-slide-host": true,
+      style: {
+        position: "relative",
+        overflow: "hidden",
+        width: "100%",
+        height: "100%"
+      },
+      children: /* @__PURE__ */ jsxs(
+        "section",
+        {
+          "aria-roledescription": "slide",
+          "aria-label": ariaLabel,
+          className: "theo-slide",
+          "data-theo-slide-theme": slideThemeAttr,
+          "data-theo-slide-layout": layout ?? "default",
+          "data-theo-slide-bg-modifier": bgModifier,
+          style: {
+            position: "absolute",
+            top: "50%",
+            left: "50%",
+            width: canvas.width,
+            height: canvas.height,
+            transform: `translate(-50%, -50%) scale(${scale})`,
+            transformOrigin: "center",
+            padding: "var(--theo-slide-padding, 64px)",
+            color: "inherit",
+            // Background fills the canvas. When neither image nor gradient is set,
+            // the slide inherits the parent surface (same pattern as Whiteboard).
+            background: "transparent",
+            // Only set backgroundImage + ancillary props when one is provided —
+            // otherwise the shorthand `background: transparent` is preserved as-is
+            // (important for the inherit-from-parent guarantee).
+            ...backgroundImageStyle ? {
+              backgroundImage: backgroundImageStyle,
+              backgroundSize: bgModifier === "fit" ? "contain" : "cover",
+              backgroundPosition: "center",
+              backgroundRepeat: "no-repeat"
+            } : {},
+            fontFamily: "var(--theo-slide-font-family, system-ui, -apple-system, 'Segoe UI', sans-serif)",
+            fontSize: "var(--theo-slide-font-base, 28px)",
+            lineHeight: 1.5,
+            boxSizing: "border-box",
+            overflow: "hidden"
+          },
+          children: [
+            headerText ? /* @__PURE__ */ jsx("div", { className: "theo-slide-header", "aria-hidden": "true", children: headerText }) : null,
+            treeNode,
+            footerText ? /* @__PURE__ */ jsx("div", { className: "theo-slide-footer", "aria-hidden": "true", children: footerText }) : null,
+            showPaginate ? /* @__PURE__ */ jsx("div", { className: "theo-slide-paginate", "aria-hidden": "true", children: "1" }) : null
+          ]
+        }
+      )
+    }
+  );
+};
+function emptyFragment() {
+  return { type: "span", props: { children: null }, key: null };
+}
+var DeckContext = createContext(null);
+function useDeckContext() {
+  const ctx = useContext(DeckContext);
+  if (!ctx) {
+    throw new Error(
+      "SlideDeck sub-components must be used inside <SlideDeck>. Wrap them in <SlideDeck slides={...}>."
+    );
+  }
+  return ctx;
+}
+var Controls = ({ className }) => {
+  const { state, dispatch } = useDeckContext();
+  const atStart = state.currentIndex <= 0;
+  const atEnd = state.currentIndex >= state.totalSlides - 1;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: ["theo-slide-deck-controls", className].filter(Boolean).join(" "),
+      "data-theo-slide-deck-controls": true,
+      style: {
+        display: "flex",
+        alignItems: "center",
+        gap: 8
+      },
+      children: [
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            "aria-label": "Previous slide",
+            disabled: atStart,
+            onClick: () => dispatch({ type: "PREV_SLIDE" }),
+            className: "theo-slide-deck-controls-prev",
+            children: "\u2190"
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "span",
+          {
+            "aria-live": "polite",
+            className: "theo-slide-deck-controls-indicator",
+            style: { fontVariantNumeric: "tabular-nums", minWidth: 64, textAlign: "center" },
+            children: state.totalSlides === 0 ? "0 / 0" : `${state.currentIndex + 1} / ${state.totalSlides}`
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            "aria-label": "Next slide",
+            disabled: atEnd,
+            onClick: () => dispatch({ type: "NEXT_SLIDE" }),
+            className: "theo-slide-deck-controls-next",
+            children: "\u2192"
+          }
+        )
+      ]
+    }
+  );
+};
+
+// src/components/composites/slide-deck/fragments.ts
+var FRAGMENT_MARKER_RE = /^\s*\*\s+\S/gm;
+function countFragmentsInMarkdown(markdown) {
+  if (!markdown) return 0;
+  const stripped = markdown.replace(/```[\s\S]*?```/g, "");
+  const matches = stripped.match(FRAGMENT_MARKER_RE);
+  return matches ? matches.length : 0;
+}
+function formatElapsed(ms) {
+  const s = Math.floor(ms / 1e3);
+  const mm = Math.floor(s / 60).toString().padStart(2, "0");
+  const ss = (s % 60).toString().padStart(2, "0");
+  return `${mm}:${ss}`;
+}
+var PresenterView = ({ className }) => {
+  const { state, slides } = useDeckContext();
+  const startedAt = useRef(null);
+  const [elapsed, setElapsed] = useState(0);
+  useEffect(() => {
+    if (state.presenterMode) {
+      if (startedAt.current === null) {
+        startedAt.current = Date.now();
+      }
+      const interval = window.setInterval(() => {
+        if (startedAt.current !== null) {
+          setElapsed(Date.now() - startedAt.current);
+        }
+      }, 1e3);
+      return () => window.clearInterval(interval);
+    }
+    startedAt.current = null;
+    setElapsed(0);
+    return void 0;
+  }, [state.presenterMode]);
+  if (!state.presenterMode) return null;
+  const current = slides[state.currentIndex];
+  const next = slides[state.currentIndex + 1];
+  const notes = current?.notes;
+  return /* @__PURE__ */ jsxs(
+    "aside",
+    {
+      className: ["theo-slide-deck-presenter", className].filter(Boolean).join(" "),
+      "data-theo-slide-deck-presenter": true,
+      "aria-label": "Presenter view",
+      style: {
+        display: "grid",
+        gridTemplateColumns: "1fr 1fr",
+        gridTemplateRows: "auto 1fr",
+        gap: 16,
+        padding: 16,
+        background: "color-mix(in srgb, currentColor 6%, transparent)",
+        borderRadius: 8
+      },
+      children: [
+        /* @__PURE__ */ jsxs(
+          "header",
+          {
+            style: {
+              gridColumn: "1 / -1",
+              display: "flex",
+              justifyContent: "space-between",
+              alignItems: "center"
+            },
+            children: [
+              /* @__PURE__ */ jsx("h3", { style: { margin: 0, fontSize: 14, fontWeight: 600 }, children: "Presenter view" }),
+              /* @__PURE__ */ jsx(
+                "span",
+                {
+                  "aria-label": "Elapsed time",
+                  style: { fontVariantNumeric: "tabular-nums", fontSize: 14 },
+                  children: formatElapsed(elapsed)
+                }
+              )
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs("section", { "aria-label": "Current slide preview", children: [
+          /* @__PURE__ */ jsx("h4", { style: { margin: "0 0 8px", fontSize: 12, opacity: 0.7 }, children: "Current" }),
+          /* @__PURE__ */ jsx(
+            "div",
+            {
+              style: {
+                aspectRatio: "16 / 9",
+                overflow: "hidden",
+                border: "1px solid rgba(127,127,127,0.3)",
+                borderRadius: 6
+              },
+              children: current ? /* @__PURE__ */ jsx(Slide, { markdown: current.markdown, "aria-label": "Current slide" }) : null
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs("section", { "aria-label": "Next slide preview", children: [
+          /* @__PURE__ */ jsx("h4", { style: { margin: "0 0 8px", fontSize: 12, opacity: 0.7 }, children: "Next" }),
+          /* @__PURE__ */ jsx(
+            "div",
+            {
+              style: {
+                aspectRatio: "16 / 9",
+                overflow: "hidden",
+                border: "1px solid rgba(127,127,127,0.3)",
+                borderRadius: 6,
+                opacity: next ? 1 : 0.4
+              },
+              children: next ? /* @__PURE__ */ jsx(Slide, { markdown: next.markdown, "aria-label": "Next slide" }) : /* @__PURE__ */ jsx("div", { style: { padding: 16, fontSize: 14, opacity: 0.6 }, children: "End of deck" })
+            }
+          )
+        ] }),
+        notes ? /* @__PURE__ */ jsxs(
+          "section",
+          {
+            "aria-label": "Speaker notes",
+            style: {
+              gridColumn: "1 / -1",
+              background: "color-mix(in srgb, currentColor 8%, transparent)",
+              padding: 12,
+              borderRadius: 6,
+              fontSize: 14,
+              whiteSpace: "pre-wrap"
+            },
+            children: [
+              /* @__PURE__ */ jsx("strong", { children: "Notes: " }),
+              notes
+            ]
+          }
+        ) : null
+      ]
+    }
+  );
+};
+
+// src/components/composites/slide-deck/print-styles.ts
+var STYLE_ID = "theo-slide-deck-print-styles";
+var PRINT_CSS = `
+@media print {
+  @page {
+    size: 1280px 720px;
+    margin: 0;
+  }
+  body > * {
+    visibility: hidden;
+  }
+  .theo-slide-deck-print-container,
+  .theo-slide-deck-print-container * {
+    visibility: visible;
+  }
+  .theo-slide-deck-print-container {
+    position: absolute;
+    inset: 0;
+  }
+  .theo-slide-deck-print-slide {
+    page-break-after: always;
+    break-after: page;
+    width: 1280px;
+    height: 720px;
+    overflow: hidden;
+  }
+  .theo-slide-deck-print-slide:last-child {
+    page-break-after: auto;
+    break-after: auto;
+  }
+}
+`;
+function injectPrintStyles() {
+  if (typeof document === "undefined") {
+    throw new Error("injectPrintStyles requires a document (browser env)");
+  }
+  let style = document.getElementById(STYLE_ID);
+  if (!style) {
+    style = document.createElement("style");
+    style.id = STYLE_ID;
+    style.textContent = PRINT_CSS;
+    document.head.appendChild(style);
+  }
+  return style;
+}
+function removePrintStyles() {
+  if (typeof document === "undefined") return;
+  const style = document.getElementById(STYLE_ID);
+  if (style) style.remove();
+}
+function printDeck(opts = {}) {
+  if (typeof window === "undefined" || typeof document === "undefined") return;
+  injectPrintStyles();
+  const cleanup = () => {
+    removePrintStyles();
+    window.removeEventListener("afterprint", cleanup);
+    opts.onAfterPrint?.();
+  };
+  window.addEventListener("afterprint", cleanup);
+  window.print();
+}
+var ProgressBar = ({ className }) => {
+  const { state } = useDeckContext();
+  const value = state.totalSlides === 0 ? 0 : state.currentIndex + 1;
+  const max = Math.max(1, state.totalSlides);
+  return /* @__PURE__ */ jsx(
+    "progress",
+    {
+      className: ["theo-slide-deck-progress", className].filter(Boolean).join(" "),
+      "data-theo-slide-deck-progress": true,
+      value,
+      max,
+      "aria-label": "Slide progress"
+    }
+  );
+};
+var SlideNumber = ({ className }) => {
+  const { state } = useDeckContext();
+  if (state.totalSlides === 0) return null;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: ["theo-slide-deck-slide-number", className].filter(Boolean).join(" "),
+      "data-theo-slide-deck-slide-number": true,
+      "aria-hidden": "true",
+      style: {
+        position: "absolute",
+        bottom: 12,
+        right: 16,
+        fontVariantNumeric: "tabular-nums",
+        fontSize: 14,
+        opacity: 0.6
+      },
+      children: [
+        state.currentIndex + 1,
+        " / ",
+        state.totalSlides
+      ]
+    }
+  );
+};
+
+// src/components/composites/slide-deck/notes.ts
+var NOTES_RE = /<!--\s*notes?:\s*([\s\S]*?)\s*-->/gi;
+function extractNotes(md) {
+  const matches = [...md.matchAll(NOTES_RE)];
+  if (matches.length === 0) {
+    return { body: md, notes: void 0 };
+  }
+  const notes = matches.map((m) => (m[1] ?? "").trim()).filter((s) => s.length > 0).join("\n\n");
+  const body = md.replace(NOTES_RE, "").trim();
+  return { body, notes: notes.length > 0 ? notes : void 0 };
+}
+
+// src/components/composites/slide-deck/split-deck.ts
+async function splitDeck(markdown) {
+  const { body: bodyAfterFM } = extractFrontmatter(markdown);
+  if (bodyAfterFM.trim().length === 0) {
+    return [];
+  }
+  const { fromMarkdown } = await import('mdast-util-from-markdown');
+  const tree = fromMarkdown(bodyAfterFM);
+  const breakOffsets = [];
+  for (const node of tree.children) {
+    if (node.type === "thematicBreak") {
+      const start = node.position?.start.offset;
+      const end = node.position?.end.offset;
+      if (typeof start === "number" && typeof end === "number") {
+        breakOffsets.push(start);
+        breakOffsets.push(end);
+      }
+    }
+  }
+  if (breakOffsets.length === 0) {
+    const { body, notes } = extractNotes(bodyAfterFM);
+    if (body.trim().length === 0 && !notes) return [];
+    return [{ markdown: body, notes }];
+  }
+  const slides = [];
+  const positions = [0];
+  for (let i = 0; i < breakOffsets.length; i += 2) {
+    const start = breakOffsets[i];
+    const end = breakOffsets[i + 1];
+    if (typeof start === "number") positions.push(start);
+    if (typeof end === "number") positions.push(end);
+  }
+  positions.push(bodyAfterFM.length);
+  for (let i = 0; i < positions.length - 1; i += 2) {
+    const start = positions[i];
+    const end = positions[i + 1];
+    if (typeof start !== "number" || typeof end !== "number") continue;
+    const chunk = bodyAfterFM.slice(start, end).trim();
+    if (chunk.length === 0) continue;
+    const { body, notes } = extractNotes(chunk);
+    if (body.trim().length === 0 && !notes) continue;
+    slides.push({ markdown: body, notes });
+  }
+  return slides;
+}
+var CANVAS_W = 1280;
+var CANVAS_H = 720;
+var ThumbnailItem = ({
+  markdown,
+  index,
+  isCurrent,
+  scale,
+  eager,
+  onSelect,
+  registerRef
+}) => {
+  const [revealed, setRevealed] = useState(eager);
+  const setRef = useCallback(
+    (el) => {
+      registerRef(index, el);
+      if (eager) return;
+      if (!el) return;
+      if (typeof IntersectionObserver === "undefined") {
+        setRevealed(true);
+        return;
+      }
+      const io = new IntersectionObserver(
+        (entries) => {
+          for (const entry of entries) {
+            if (entry.isIntersecting) {
+              setRevealed(true);
+              io.disconnect();
+              break;
+            }
+          }
+        },
+        { rootMargin: "200px" }
+      );
+      io.observe(el);
+    },
+    [index, eager, registerRef]
+  );
+  const w = Math.round(CANVAS_W * scale);
+  const h = Math.round(CANVAS_H * scale);
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      ref: setRef,
+      type: "button",
+      onClick: () => onSelect(index),
+      "data-theo-slide-deck-thumbnail": true,
+      "data-current": isCurrent || void 0,
+      "aria-label": `Slide ${index + 1}`,
+      "aria-current": isCurrent ? "page" : void 0,
+      className: "theo-slide-deck-thumbnail",
+      style: {
+        width: w,
+        height: h,
+        padding: 0,
+        border: isCurrent ? "2px solid currentColor" : "1px solid rgba(127,127,127,0.3)",
+        borderRadius: 6,
+        overflow: "hidden",
+        position: "relative",
+        cursor: "pointer",
+        flexShrink: 0,
+        background: "transparent"
+      },
+      children: /* @__PURE__ */ jsx(
+        "div",
+        {
+          style: {
+            width: CANVAS_W,
+            height: CANVAS_H,
+            transform: `scale(${scale})`,
+            transformOrigin: "top left",
+            pointerEvents: "none"
+          },
+          children: revealed ? /* @__PURE__ */ jsx(Slide, { markdown, "aria-label": `Thumbnail ${index + 1}` }) : /* @__PURE__ */ jsx(
+            "div",
+            {
+              "data-theo-slide-deck-thumbnail-placeholder": true,
+              style: {
+                width: "100%",
+                height: "100%",
+                background: "rgba(127,127,127,0.08)"
+              }
+            }
+          )
+        }
+      )
+    }
+  );
+};
+var Thumbnails = ({ className, scale = 0.18 }) => {
+  const { state, dispatch, slides } = useDeckContext();
+  const refs = useRef(/* @__PURE__ */ new Map());
+  const registerRef = useCallback((index, el) => {
+    if (el) {
+      refs.current.set(index, el);
+    } else {
+      refs.current.delete(index);
+    }
+  }, []);
+  const onSelect = useCallback(
+    (index) => {
+      dispatch({ type: "JUMP_TO", index });
+    },
+    [dispatch]
+  );
+  useEffect(() => {
+    const el = refs.current.get(state.currentIndex);
+    if (el && "scrollIntoView" in el) {
+      el.scrollIntoView({ behavior: "smooth", block: "nearest", inline: "nearest" });
+    }
+  }, [state.currentIndex]);
+  const eagerAll = useMemo(() => typeof IntersectionObserver === "undefined", []);
+  return /* @__PURE__ */ jsx(
+    "ul",
+    {
+      className: ["theo-slide-deck-thumbnails", className].filter(Boolean).join(" "),
+      "data-theo-slide-deck-thumbnails": true,
+      "aria-label": "Slide thumbnails",
+      style: {
+        display: "flex",
+        flexDirection: "column",
+        gap: 8,
+        overflowY: "auto",
+        padding: 8,
+        listStyle: "none",
+        margin: 0
+      },
+      children: slides.map((slide, index) => /* @__PURE__ */ jsx("li", { children: /* @__PURE__ */ jsx(
+        ThumbnailItem,
+        {
+          markdown: slide.markdown,
+          index,
+          isCurrent: index === state.currentIndex,
+          scale,
+          eager: eagerAll || index < 3,
+          onSelect,
+          registerRef
+        }
+      ) }, `${slide.id ?? index}-${index}`))
+    }
+  );
+};
+function readHashIndex(hash) {
+  if (!hash || hash === "#" || hash === "#/") return void 0;
+  const match = hash.match(/^#\/(\d+)/);
+  if (!match) return void 0;
+  const oneBased = Number.parseInt(match[1] ?? "", 10);
+  if (!Number.isFinite(oneBased) || oneBased < 1) return void 0;
+  return oneBased - 1;
+}
+function readInitialHash() {
+  if (typeof window === "undefined") return void 0;
+  return readHashIndex(window.location.hash);
+}
+function formatHash(zeroBasedIndex) {
+  return `#/${zeroBasedIndex + 1}`;
+}
+function useDeckHashRouting(dispatch, opts) {
+  const { enabled = true, totalSlides, currentIndex } = opts;
+  useEffect(() => {
+    if (!enabled) return;
+    if (typeof window === "undefined") return;
+    const handler = () => {
+      const idx = readHashIndex(window.location.hash);
+      if (typeof idx !== "number") return;
+      const clamped = Math.max(0, Math.min(idx, Math.max(0, totalSlides - 1)));
+      dispatch({ type: "JUMP_TO", index: clamped });
+    };
+    window.addEventListener("hashchange", handler);
+    return () => window.removeEventListener("hashchange", handler);
+  }, [enabled, totalSlides, dispatch]);
+  useEffect(() => {
+    if (!enabled) return;
+    if (typeof window === "undefined") return;
+    const targetHash = formatHash(currentIndex);
+    if (window.location.hash === targetHash) return;
+    window.history.replaceState(null, "", targetHash);
+  }, [enabled, currentIndex]);
+}
+function isEditableTarget(target) {
+  if (!(target instanceof HTMLElement)) return false;
+  const tag = target.tagName;
+  if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT") return true;
+  if (target.isContentEditable) return true;
+  return false;
+}
+function useDeckKeyboard(dispatch, opts) {
+  const { enabled = true, totalSlides, onToggleFullscreen, onPrint } = opts;
+  useEffect(() => {
+    if (!enabled) return;
+    const handler = (event) => {
+      if (isEditableTarget(event.target)) return;
+      const key = event.key;
+      const isPrintCombo = (event.ctrlKey || event.metaKey) && (key === "p" || key === "P");
+      if (isPrintCombo) {
+        event.preventDefault();
+        onPrint?.();
+        return;
+      }
+      switch (key) {
+        case "ArrowRight":
+        case " ":
+        case "Spacebar":
+        case "PageDown":
+          dispatch({ type: "NEXT_SLIDE" });
+          break;
+        case "ArrowLeft":
+        case "PageUp":
+          dispatch({ type: "PREV_SLIDE" });
+          break;
+        case "Home":
+          dispatch({ type: "JUMP_TO", index: 0 });
+          break;
+        case "End":
+          dispatch({ type: "JUMP_TO", index: Math.max(0, totalSlides - 1) });
+          break;
+        case "Escape":
+          dispatch({ type: "SET_FULLSCREEN", value: false });
+          break;
+        case "f":
+        case "F":
+          onToggleFullscreen?.();
+          break;
+        case "n":
+        case "N":
+        case "p":
+        case "P":
+          dispatch({ type: "TOGGLE_PRESENTER" });
+          break;
+        default:
+          return;
+      }
+    };
+    document.addEventListener("keydown", handler);
+    return () => document.removeEventListener("keydown", handler);
+  }, [enabled, totalSlides, dispatch, onToggleFullscreen, onPrint]);
+}
+function deckReducer(state, action) {
+  switch (action.type) {
+    case "NEXT_SLIDE": {
+      if (state.currentFragment < state.totalFragmentsInCurrent) {
+        return { ...state, currentFragment: state.currentFragment + 1 };
+      }
+      const next = Math.min(state.currentIndex + 1, Math.max(0, state.totalSlides - 1));
+      if (next === state.currentIndex) return state;
+      return {
+        ...state,
+        currentIndex: next,
+        currentFragment: 0,
+        transitionDirection: "next"
+      };
+    }
+    case "PREV_SLIDE": {
+      if (state.currentFragment > 0) {
+        return { ...state, currentFragment: state.currentFragment - 1 };
+      }
+      const prev = Math.max(state.currentIndex - 1, 0);
+      if (prev === state.currentIndex) return state;
+      return {
+        ...state,
+        currentIndex: prev,
+        currentFragment: 0,
+        transitionDirection: "prev"
+      };
+    }
+    case "JUMP_TO": {
+      const clamped = Math.max(0, Math.min(action.index, Math.max(0, state.totalSlides - 1)));
+      if (clamped === state.currentIndex) return state;
+      return {
+        ...state,
+        currentIndex: clamped,
+        currentFragment: 0,
+        transitionDirection: "none"
+      };
+    }
+    case "NEXT_FRAGMENT": {
+      if (state.currentFragment >= state.totalFragmentsInCurrent) return state;
+      return { ...state, currentFragment: state.currentFragment + 1 };
+    }
+    case "PREV_FRAGMENT": {
+      if (state.currentFragment <= 0) return state;
+      return { ...state, currentFragment: state.currentFragment - 1 };
+    }
+    case "RESET_FRAGMENTS":
+      return { ...state, currentFragment: 0 };
+    case "TOGGLE_PRESENTER":
+      return { ...state, presenterMode: !state.presenterMode };
+    case "SET_FULLSCREEN":
+      return state.fullscreen === action.value ? state : { ...state, fullscreen: action.value };
+    case "UPDATE_TOTAL_SLIDES": {
+      const next = Math.max(0, action.total);
+      const clampedIdx = Math.max(0, Math.min(state.currentIndex, Math.max(0, next - 1)));
+      return { ...state, totalSlides: next, currentIndex: clampedIdx };
+    }
+    case "UPDATE_TOTAL_FRAGMENTS":
+      return { ...state, totalFragmentsInCurrent: Math.max(0, action.total) };
+    case "TRANSITION_END":
+      return state.transitionDirection === "none" ? state : { ...state, transitionDirection: "none" };
+  }
+}
+function initDeckState(init) {
+  const total = Math.max(0, init.totalSlides);
+  let idx = init.initialIndex ?? 0;
+  if (init.initFromHash) {
+    const fromHash = init.initFromHash();
+    if (typeof fromHash === "number" && Number.isFinite(fromHash)) {
+      idx = fromHash;
+    }
+  }
+  const clamped = Math.max(0, Math.min(idx, Math.max(0, total - 1)));
+  return {
+    currentIndex: clamped,
+    currentFragment: 0,
+    presenterMode: false,
+    fullscreen: false,
+    transitionDirection: "none",
+    totalSlides: total,
+    totalFragmentsInCurrent: 0
+  };
+}
+function useDeckState(opts) {
+  const [state, dispatch] = useReducer(deckReducer, opts, initDeckState);
+  return [state, dispatch];
+}
+var SWIPE_THRESHOLD_PX = 50;
+var SWIPE_VELOCITY_PX_PER_MS = 0.3;
+function useDeckSwipe(ref, dispatch, opts = {}) {
+  const { enabled = true } = opts;
+  useEffect(() => {
+    if (!enabled) return;
+    const el = ref.current;
+    if (!el) return;
+    let tracked = null;
+    const onPointerDown = (e) => {
+      if (tracked !== null) return;
+      tracked = {
+        pointerId: e.pointerId,
+        startX: e.clientX,
+        startY: e.clientY,
+        startedAt: e.timeStamp
+      };
+    };
+    const onPointerUp = (e) => {
+      if (!tracked || e.pointerId !== tracked.pointerId) return;
+      const dx = e.clientX - tracked.startX;
+      const dy = e.clientY - tracked.startY;
+      const dt = Math.max(1, e.timeStamp - tracked.startedAt);
+      tracked = null;
+      const absDx = Math.abs(dx);
+      const absDy = Math.abs(dy);
+      const velocity = absDx / dt;
+      if (absDx < absDy * 2) return;
+      if (absDx < SWIPE_THRESHOLD_PX) return;
+      if (velocity < SWIPE_VELOCITY_PX_PER_MS) return;
+      if (dx < 0) {
+        dispatch({ type: "NEXT_SLIDE" });
+      } else if (dx > 0) {
+        dispatch({ type: "PREV_SLIDE" });
+      }
+    };
+    const onPointerCancel = (e) => {
+      if (tracked && e.pointerId === tracked.pointerId) {
+        tracked = null;
+      }
+    };
+    el.addEventListener("pointerdown", onPointerDown);
+    el.addEventListener("pointerup", onPointerUp);
+    el.addEventListener("pointercancel", onPointerCancel);
+    return () => {
+      el.removeEventListener("pointerdown", onPointerDown);
+      el.removeEventListener("pointerup", onPointerUp);
+      el.removeEventListener("pointercancel", onPointerCancel);
+    };
+  }, [enabled, ref, dispatch]);
+}
+function isFullscreenSupported() {
+  if (typeof document === "undefined") return false;
+  const doc = document;
+  const el = document.documentElement;
+  return Boolean(el.requestFullscreen ?? el.webkitRequestFullscreen) && Boolean(doc.exitFullscreen ?? doc.webkitExitFullscreen);
+}
+function currentFullscreenElement() {
+  if (typeof document === "undefined") return null;
+  const doc = document;
+  return document.fullscreenElement ?? doc.webkitFullscreenElement ?? null;
+}
+function useFullscreen(ref) {
+  const supported = isFullscreenSupported();
+  const [isFullscreen, setFullscreen] = useState(false);
+  useEffect(() => {
+    if (!supported) return;
+    const handler = () => {
+      setFullscreen(currentFullscreenElement() !== null);
+    };
+    document.addEventListener("fullscreenchange", handler);
+    document.addEventListener("webkitfullscreenchange", handler);
+    return () => {
+      document.removeEventListener("fullscreenchange", handler);
+      document.removeEventListener("webkitfullscreenchange", handler);
+    };
+  }, [supported]);
+  const toggle = useCallback(async () => {
+    if (!supported) return;
+    const el = ref.current;
+    if (!el) return;
+    const doc = document;
+    try {
+      if (currentFullscreenElement()) {
+        await (doc.exitFullscreen?.() ?? doc.webkitExitFullscreen?.());
+      } else {
+        await (el.requestFullscreen?.() ?? el.webkitRequestFullscreen?.());
+      }
+    } catch {
+    }
+  }, [ref, supported]);
+  return { isFullscreen, toggle, isSupported: supported };
+}
+function generateDeckId() {
+  if (typeof crypto !== "undefined" && "randomUUID" in crypto) {
+    return crypto.randomUUID();
+  }
+  return `deck-${Math.random().toString(36).slice(2, 10)}`;
+}
+var SlideDeckBase = ({
+  slides: slidesInput,
+  initialIndex = 0,
+  transition = "fade",
+  enableKeyboard = true,
+  enableTouch = true,
+  enableHashRouting = true,
+  deckId: deckIdProp,
+  onIndexChange,
+  children,
+  className,
+  "aria-label": ariaLabel = "Slide deck",
+  plugins
+}) => {
+  const generatedId = useId();
+  const deckId = deckIdProp ?? generatedId ?? generateDeckId();
+  const rootRef = useRef(null);
+  const [parsedSlides, setParsedSlides] = useState(() => {
+    return Array.isArray(slidesInput) ? slidesInput : [];
+  });
+  useEffect(() => {
+    if (Array.isArray(slidesInput)) {
+      setParsedSlides(slidesInput);
+      return;
+    }
+    let cancelled = false;
+    splitDeck(slidesInput).then(
+      (result) => {
+        if (!cancelled) setParsedSlides(result);
+      },
+      () => {
+        if (!cancelled) setParsedSlides([]);
+      }
+    );
+    return () => {
+      cancelled = true;
+    };
+  }, [slidesInput]);
+  const [state, dispatch] = useDeckState({
+    initialIndex,
+    totalSlides: parsedSlides.length,
+    initFromHash: enableHashRouting ? readInitialHash : void 0
+  });
+  const previousLengthRef = useRef(0);
+  useEffect(() => {
+    const length = parsedSlides.length;
+    dispatch({ type: "UPDATE_TOTAL_SLIDES", total: length });
+    if (previousLengthRef.current === 0 && length > 0) {
+      let target = initialIndex;
+      if (enableHashRouting) {
+        const hashIdx = readInitialHash();
+        if (typeof hashIdx === "number") target = hashIdx;
+      }
+      if (target > 0) {
+        dispatch({ type: "JUMP_TO", index: target });
+      }
+    }
+    previousLengthRef.current = length;
+  }, [parsedSlides.length, dispatch, initialIndex, enableHashRouting]);
+  useEffect(() => {
+    const current = parsedSlides[state.currentIndex];
+    const count = current ? countFragmentsInMarkdown(current.markdown) : 0;
+    dispatch({ type: "UPDATE_TOTAL_FRAGMENTS", total: count });
+  }, [parsedSlides, state.currentIndex, dispatch]);
+  const fullscreen = useFullscreen(rootRef);
+  useEffect(() => {
+    dispatch({ type: "SET_FULLSCREEN", value: fullscreen.isFullscreen });
+  }, [fullscreen.isFullscreen, dispatch]);
+  useEffect(() => {
+    if (state.transitionDirection === "none") return;
+    const t = setTimeout(() => dispatch({ type: "TRANSITION_END" }), 300);
+    return () => clearTimeout(t);
+  }, [state.transitionDirection, dispatch]);
+  const onPrint = useCallback(() => {
+    printDeck();
+  }, []);
+  useDeckKeyboard(dispatch, {
+    enabled: enableKeyboard,
+    totalSlides: parsedSlides.length,
+    onToggleFullscreen: fullscreen.toggle,
+    onPrint
+  });
+  useDeckSwipe(rootRef, dispatch, { enabled: enableTouch });
+  useDeckHashRouting(dispatch, {
+    enabled: enableHashRouting,
+    totalSlides: parsedSlides.length,
+    currentIndex: state.currentIndex
+  });
+  const lastIndexRef = useRef(state.currentIndex);
+  useEffect(() => {
+    if (lastIndexRef.current !== state.currentIndex) {
+      lastIndexRef.current = state.currentIndex;
+      onIndexChange?.(state.currentIndex, parsedSlides[state.currentIndex]);
+    }
+  }, [state.currentIndex, parsedSlides, onIndexChange]);
+  const contextValue = useMemo(
+    () => ({
+      state,
+      dispatch,
+      slides: parsedSlides,
+      transition,
+      deckId,
+      plugins,
+      toggleFullscreen: fullscreen.toggle,
+      print: onPrint
+    }),
+    [state, dispatch, parsedSlides, transition, deckId, plugins, fullscreen.toggle, onPrint]
+  );
+  return /* @__PURE__ */ jsx(DeckContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ref: rootRef,
+      "aria-roledescription": "slide deck",
+      "aria-label": ariaLabel,
+      "data-theo-slide-deck": true,
+      "data-theo-slide-deck-fullscreen": state.fullscreen ? "true" : void 0,
+      className: ["theo-slide-deck", className].filter(Boolean).join(" "),
+      style: { position: "relative", width: "100%", height: "100%" },
+      children: [
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            role: "status",
+            "aria-live": "polite",
+            "aria-atomic": "true",
+            style: {
+              position: "absolute",
+              width: 1,
+              height: 1,
+              padding: 0,
+              margin: -1,
+              overflow: "hidden",
+              clip: "rect(0,0,0,0)",
+              whiteSpace: "nowrap",
+              border: 0
+            },
+            children: parsedSlides.length > 0 ? `Slide ${state.currentIndex + 1} of ${parsedSlides.length}` : "Empty deck"
+          }
+        ),
+        children ?? /* @__PURE__ */ jsx(DefaultDeckLayout, {}),
+        /* @__PURE__ */ jsx(PrintContainer, { slides: parsedSlides, plugins })
+      ]
+    }
+  ) });
+};
+var SlidesView = ({ className }) => {
+  const { state, slides, transition, plugins } = useDeckContext();
+  const current = slides[state.currentIndex];
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: ["theo-slide-deck-slide-frame", className].filter(Boolean).join(" "),
+      "data-theo-slide-deck-transition": transition,
+      "data-theo-slide-deck-direction": state.transitionDirection,
+      style: {
+        position: "relative",
+        width: "100%",
+        height: "100%",
+        minHeight: 0,
+        overflow: "hidden"
+      },
+      children: current ? /* @__PURE__ */ jsx(
+        "div",
+        {
+          "data-theo-slide-deck-slide-state": "incoming",
+          style: { position: "absolute", inset: 0 },
+          children: /* @__PURE__ */ jsx(
+            Slide,
+            {
+              markdown: current.markdown,
+              plugins,
+              "aria-label": `Slide ${state.currentIndex + 1}`
+            }
+          )
+        },
+        state.currentIndex
+      ) : /* @__PURE__ */ jsx(
+        "div",
+        {
+          "data-theo-slide-deck-empty": true,
+          style: {
+            display: "grid",
+            placeItems: "center",
+            height: "100%",
+            opacity: 0.6,
+            fontSize: 14
+          },
+          children: "Empty deck"
+        }
+      )
+    }
+  );
+};
+var PresenterButton = ({ className }) => {
+  const { state, dispatch } = useDeckContext();
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      type: "button",
+      onClick: () => dispatch({ type: "TOGGLE_PRESENTER" }),
+      "aria-pressed": state.presenterMode,
+      "aria-label": state.presenterMode ? "Close presenter view" : "Open presenter view",
+      className: ["theo-slide-deck-presenter-button", className].filter(Boolean).join(" "),
+      children: state.presenterMode ? "Close presenter" : "Presenter"
+    }
+  );
+};
+var FullscreenButton = ({ className }) => {
+  const { state, toggleFullscreen } = useDeckContext();
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      type: "button",
+      onClick: () => void toggleFullscreen(),
+      "aria-pressed": state.fullscreen,
+      "aria-label": state.fullscreen ? "Exit fullscreen" : "Enter fullscreen",
+      className: ["theo-slide-deck-fullscreen-button", className].filter(Boolean).join(" "),
+      children: state.fullscreen ? "Exit fullscreen" : "Fullscreen"
+    }
+  );
+};
+var PrintButton = ({ className }) => {
+  const { print } = useDeckContext();
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      type: "button",
+      onClick: () => print(),
+      "aria-label": "Print or save deck as PDF",
+      className: ["theo-slide-deck-print-button", className].filter(Boolean).join(" "),
+      children: "Print"
+    }
+  );
+};
+var PrintContainer = ({
+  slides,
+  plugins
+}) => {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: "theo-slide-deck-print-container",
+      "aria-hidden": "true",
+      style: {
+        position: "absolute",
+        inset: 0,
+        pointerEvents: "none",
+        visibility: "hidden"
+      },
+      children: slides.map((slide, index) => /* @__PURE__ */ jsx(
+        "div",
+        {
+          className: "theo-slide-deck-print-slide",
+          style: { width: 1280, height: 720 },
+          children: /* @__PURE__ */ jsx(
+            Slide,
+            {
+              markdown: slide.markdown,
+              plugins,
+              "aria-label": `Print slide ${index + 1}`
+            }
+          )
+        },
+        `print-${slide.id ?? index}`
+      ))
+    }
+  );
+};
+var DefaultDeckLayout = () => {
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "theo-slide-deck-default-layout",
+      style: {
+        display: "grid",
+        gridTemplateColumns: "1fr",
+        gridTemplateRows: "1fr auto",
+        gap: 8,
+        height: "100%"
+      },
+      children: [
+        /* @__PURE__ */ jsx(SlidesView, {}),
+        /* @__PURE__ */ jsxs(
+          "div",
+          {
+            style: {
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "space-between",
+              gap: 8,
+              padding: "4px 8px",
+              flexWrap: "wrap"
+            },
+            children: [
+              /* @__PURE__ */ jsx(Controls, {}),
+              /* @__PURE__ */ jsx(ProgressBar, {}),
+              /* @__PURE__ */ jsxs("div", { style: { display: "flex", gap: 4 }, children: [
+                /* @__PURE__ */ jsx(PresenterButton, {}),
+                /* @__PURE__ */ jsx(FullscreenButton, {}),
+                /* @__PURE__ */ jsx(PrintButton, {})
+              ] })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx(SlideNumber, {}),
+        /* @__PURE__ */ jsx(PresenterView, {})
+      ]
+    }
+  );
+};
+var SlideDeck = SlideDeckBase;
+SlideDeck.Slides = SlidesView;
+SlideDeck.Controls = Controls;
+SlideDeck.ProgressBar = ProgressBar;
+SlideDeck.SlideNumber = SlideNumber;
+SlideDeck.Thumbnails = Thumbnails;
+SlideDeck.PresenterView = PresenterView;
+SlideDeck.PresenterButton = PresenterButton;
+SlideDeck.FullscreenButton = FullscreenButton;
+SlideDeck.PrintButton = PrintButton;
+var slideDeckSlide = z.object({
+  /** Markdown content of this slide. Capped at 50 KB (same as Slide body). */
+  markdown: z.string().max(5e4),
+  /** Optional id for hash routing (defaults to numeric index, 1-based). */
+  id: z.string().regex(/^[a-z0-9-]+$/, "id must be lowercase kebab-case").max(64).optional(),
+  /** Speaker notes (plain text extracted from <!-- notes: ... --> comments). */
+  notes: z.string().max(5e3).optional()
+});
+var slideDeckInput = z.union([z.string().max(5e5), z.array(slideDeckSlide).max(500)]);
+var slideDeckTransition = z.enum(["none", "fade", "slide"]);
+
+export { Controls, DeckContext, PresenterView, ProgressBar, SlideDeck, SlideNumber, Thumbnails, countFragmentsInMarkdown, deckReducer, extractNotes, formatHash, injectPrintStyles, printDeck, readHashIndex, readInitialHash, removePrintStyles, slideDeckInput, slideDeckSlide, slideDeckTransition, splitDeck, useDeckContext, useDeckHashRouting, useDeckKeyboard, useDeckState, useDeckSwipe, useFullscreen };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map