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

package/dist/slide/index.js

@@ -0,0 +1,714 @@
+import { useState, useEffect, useRef, useMemo } from 'react';
+import { z } from 'zod';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+// src/components/primitives/slide/slide.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();
+var slideInput = 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: jsx2, jsxs: jsxs2 } = await import('react/jsx-runtime');
+  const { toJsxRuntime } = await import('hast-util-to-jsx-runtime');
+  return toJsxRuntime(tree, {
+    Fragment,
+    jsx: jsx2,
+    jsxs: jsxs2,
+    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 };
+}
+
+// src/components/primitives/slide/themes/index.ts
+var slideThemes = ["default", "violet-forge"];
+function isSlideTheme(value) {
+  return typeof value === "string" && slideThemes.includes(value);
+}
+var rawSchema = z.toJSONSchema(slideFrontmatter, {
+  unrepresentable: "any"
+});
+if (rawSchema.properties) {
+  rawSchema.properties.backgroundImage = {
+    type: "string",
+    format: "uri",
+    maxLength: 5e5,
+    pattern: "^https?://",
+    description: "Slide background image URL. Only http(s) schemes are accepted; data: URLs are rejected at runtime (use a hosted image)."
+  };
+}
+var slideFrontmatterJsonSchema = rawSchema;
+
+export { MAX_RAW_FRONTMATTER, Slide, collectTagCounts, composePlugins, extractFrontmatter, getSlideSanitizeSchema, hastToReact, isSlideTheme, mdastToHast, parseBody, parseSlide, sanitizeHast, slideFrontmatter, slideFrontmatterJsonSchema, slideInput, slideTheme, slideThemes, useSlideFit, validateSlide };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map