@bendyline/squisq 2.4.2 → 2.4.4

package/dist/chunk-24SENDJY.js

@@ -0,0 +1,750 @@
+import {
+  defaultPageStyle
+} from "./chunk-GAZKTT4R.js";
+import {
+  FONT_FALLBACKS,
+  THEME_SCHEMA_VERSION,
+  assertTheme,
+  createTheme,
+  deriveScale,
+  isHex,
+  oklchDarken,
+  oklchLighten,
+  oklchSetChroma,
+  pickContrastingText,
+  relativeLuminance,
+  resolveFontFamily,
+  withAlpha
+} from "./chunk-SBAX4ZPO.js";
+
+// src/schemas/Doc.ts
+function calculateDuration(audio) {
+  return audio.segments.reduce((sum, seg) => sum + seg.duration, 0);
+}
+function getSegmentAtTime(audio, time) {
+  let elapsed = 0;
+  for (let i = 0; i < audio.segments.length; i++) {
+    elapsed += audio.segments[i].duration;
+    if (time < elapsed) return i;
+  }
+  return audio.segments.length - 1;
+}
+function getBlockAtTime(blocks, time) {
+  for (let i = blocks.length - 1; i >= 0; i--) {
+    const block = blocks[i];
+    if (time >= block.startTime && time < block.startTime + block.duration) {
+      return block;
+    }
+  }
+  return blocks[0] || null;
+}
+function getCaptionAtTime(captions, time) {
+  if (!captions || !captions.phrases.length) return null;
+  for (const phrase of captions.phrases) {
+    if (time >= phrase.startTime && time < phrase.endTime) {
+      return phrase;
+    }
+  }
+  return null;
+}
+
+// src/schemas/validateDoc.ts
+var LAYER_TYPES = /* @__PURE__ */ new Set([
+  "image",
+  "text",
+  "shape",
+  "path",
+  "map",
+  "video",
+  "table",
+  "tree",
+  "mermaid"
+]);
+function validateDocSchema(value) {
+  const issues = [];
+  if (!isRecord(value)) {
+    add(issues, "$", "must be an object", value);
+    return issues;
+  }
+  requiredString(value, "articleId", "articleId", issues);
+  requiredFiniteNumber(value, "duration", "duration", issues, { min: 0 });
+  const blocks = requiredArray(value, "blocks", "blocks", issues);
+  if (blocks) validateBlocks(blocks, "blocks", issues);
+  const audio = requiredRecord(value, "audio", "audio", issues);
+  if (audio) {
+    const segments = requiredArray(audio, "segments", "audio.segments", issues);
+    if (segments) validateAudioSegments(segments, issues);
+  }
+  optionalString(value, "themeId", "themeId", issues);
+  optionalRecord(value, "frontmatter", "frontmatter", issues);
+  optionalRecord(value, "persistentLayers", "persistentLayers", issues);
+  optionalRecord(value, "meta", "meta", issues);
+  optionalArray(value, "customTemplates", "customTemplates", issues);
+  optionalArray(value, "customThemes", "customThemes", issues);
+  if (value.startBlock !== void 0) validateStartBlock(value.startBlock, issues);
+  if (value.captions !== void 0) validateCaptions(value.captions, issues);
+  if (value.diagnostics !== void 0) validateDiagnostics(value.diagnostics, issues);
+  if (value.documentMedia !== void 0) {
+    validateMediaArray(value.documentMedia, "documentMedia", issues);
+  }
+  return issues;
+}
+function assertDocSchema(value) {
+  const issues = validateDocSchema(value);
+  if (issues.length === 0) return;
+  const detail = issues.map((issue) => `${issue.path} ${issue.message}`).join("; ");
+  throw new TypeError(`Invalid squisq Doc: ${detail}`);
+}
+function validateBlocks(values, path, issues) {
+  for (let index = 0; index < values.length; index += 1) {
+    const blockPath = `${path}[${index}]`;
+    const block = values[index];
+    if (!isRecord(block)) {
+      add(issues, blockPath, "must be an object", block);
+      continue;
+    }
+    requiredString(block, "id", `${blockPath}.id`, issues);
+    requiredFiniteNumber(block, "startTime", `${blockPath}.startTime`, issues, { min: 0 });
+    requiredFiniteNumber(block, "duration", `${blockPath}.duration`, issues, { min: 0 });
+    requiredInteger(block, "audioSegment", `${blockPath}.audioSegment`, issues, 0);
+    optionalString(block, "sourceBlockId", `${blockPath}.sourceBlockId`, issues);
+    optionalStringArray(block, "sourceBlockIds", `${blockPath}.sourceBlockIds`, issues);
+    optionalFiniteNumber(block, "sourceCharOffset", `${blockPath}.sourceCharOffset`, issues, {
+      min: 0
+    });
+    optionalString(block, "template", `${blockPath}.template`, issues);
+    optionalString(block, "title", `${blockPath}.title`, issues);
+    optionalBoolean(block, "autoTemplate", `${blockPath}.autoTemplate`, issues);
+    optionalFiniteNumber(block, "x", `${blockPath}.x`, issues);
+    optionalFiniteNumber(block, "y", `${blockPath}.y`, issues);
+    optionalStringArray(block, "classes", `${blockPath}.classes`, issues);
+    optionalStringRecord(block, "metadata", `${blockPath}.metadata`, issues);
+    optionalStringRecord(block, "templateOverrides", `${blockPath}.templateOverrides`, issues);
+    optionalRecord(block, "templateData", `${blockPath}.templateData`, issues);
+    optionalArray(block, "contents", `${blockPath}.contents`, issues);
+    if (block.layers !== void 0) validateLayers(block.layers, `${blockPath}.layers`, issues);
+    if (block.children !== void 0) {
+      if (Array.isArray(block.children)) {
+        validateBlocks(block.children, `${blockPath}.children`, issues);
+      } else {
+        add(issues, `${blockPath}.children`, "must be an array", block.children);
+      }
+    }
+    if (block.connectsTo !== void 0) {
+      validateConnections(block.connectsTo, `${blockPath}.connectsTo`, issues);
+    }
+    if (block.media !== void 0) {
+      validateMediaArray(block.media, `${blockPath}.media`, issues);
+    }
+  }
+}
+function validateLayers(value, path, issues) {
+  if (!Array.isArray(value)) {
+    add(issues, path, "must be an array", value);
+    return;
+  }
+  for (let index = 0; index < value.length; index += 1) {
+    const layerPath = `${path}[${index}]`;
+    const layer = value[index];
+    if (!isRecord(layer)) {
+      add(issues, layerPath, "must be an object", layer);
+      continue;
+    }
+    requiredString(layer, "id", `${layerPath}.id`, issues);
+    const type = requiredString(layer, "type", `${layerPath}.type`, issues);
+    if (type && !LAYER_TYPES.has(type)) {
+      issues.push({
+        path: `${layerPath}.type`,
+        message: `must be a known layer type (got ${quote(type)})`
+      });
+    }
+    validatePosition(layer.position, `${layerPath}.position`, issues);
+    const content = requiredRecord(layer, "content", `${layerPath}.content`, issues);
+    if (content && type) validateLayerContent(type, content, `${layerPath}.content`, issues);
+    if (layer.animation !== void 0 && !isRecord(layer.animation)) {
+      add(issues, `${layerPath}.animation`, "must be an object", layer.animation);
+    }
+  }
+}
+function validateLayerContent(type, content, path, issues) {
+  switch (type) {
+    case "image":
+      requiredString(content, "src", `${path}.src`, issues);
+      requiredString(content, "alt", `${path}.alt`, issues);
+      break;
+    case "text":
+      requiredString(content, "text", `${path}.text`, issues);
+      requiredRecord(content, "style", `${path}.style`, issues);
+      break;
+    case "shape":
+      requiredString(content, "shape", `${path}.shape`, issues);
+      break;
+    case "path":
+      requiredString(content, "d", `${path}.d`, issues);
+      break;
+    case "map": {
+      const center = requiredRecord(content, "center", `${path}.center`, issues);
+      if (center) {
+        requiredFiniteNumber(center, "lat", `${path}.center.lat`, issues);
+        requiredFiniteNumber(center, "lng", `${path}.center.lng`, issues);
+      }
+      requiredFiniteNumber(content, "zoom", `${path}.zoom`, issues);
+      requiredString(content, "style", `${path}.style`, issues);
+      break;
+    }
+    case "video":
+      requiredString(content, "src", `${path}.src`, issues);
+      requiredString(content, "alt", `${path}.alt`, issues);
+      requiredFiniteNumber(content, "clipStart", `${path}.clipStart`, issues, { min: 0 });
+      requiredFiniteNumber(content, "clipEnd", `${path}.clipEnd`, issues, { min: 0 });
+      break;
+    case "table":
+      requiredStringArray(content, "headers", `${path}.headers`, issues);
+      validateStringRows(content.rows, `${path}.rows`, issues);
+      requiredRecord(content, "style", `${path}.style`, issues);
+      break;
+    case "tree":
+      requiredArray(content, "items", `${path}.items`, issues);
+      requiredRecord(content, "style", `${path}.style`, issues);
+      break;
+    case "mermaid":
+      requiredString(content, "source", `${path}.source`, issues);
+      break;
+  }
+}
+function validatePosition(value, path, issues) {
+  if (!isRecord(value)) {
+    add(issues, path, "must be an object", value);
+    return;
+  }
+  requiredPositionValue(value, "x", `${path}.x`, issues);
+  requiredPositionValue(value, "y", `${path}.y`, issues);
+  optionalPositionValue(value, "width", `${path}.width`, issues);
+  optionalPositionValue(value, "height", `${path}.height`, issues);
+}
+function validateAudioSegments(values, issues) {
+  for (let index = 0; index < values.length; index += 1) {
+    const path = `audio.segments[${index}]`;
+    const segment = values[index];
+    if (!isRecord(segment)) {
+      add(issues, path, "must be an object", segment);
+      continue;
+    }
+    requiredString(segment, "src", `${path}.src`, issues);
+    requiredString(segment, "name", `${path}.name`, issues);
+    requiredFiniteNumber(segment, "duration", `${path}.duration`, issues, { min: 0 });
+    requiredFiniteNumber(segment, "startTime", `${path}.startTime`, issues, { min: 0 });
+  }
+}
+function validateConnections(value, path, issues) {
+  if (!Array.isArray(value)) {
+    add(issues, path, "must be an array", value);
+    return;
+  }
+  for (let index = 0; index < value.length; index += 1) {
+    const itemPath = `${path}[${index}]`;
+    const connection = value[index];
+    if (!isRecord(connection)) {
+      add(issues, itemPath, "must be an object", connection);
+      continue;
+    }
+    requiredString(connection, "target", `${itemPath}.target`, issues);
+    optionalString(connection, "type", `${itemPath}.type`, issues);
+  }
+}
+function validateMediaArray(value, path, issues) {
+  if (!Array.isArray(value)) {
+    add(issues, path, "must be an array", value);
+    return;
+  }
+  for (let index = 0; index < value.length; index += 1) {
+    const clipPath = `${path}[${index}]`;
+    const clip = value[index];
+    if (!isRecord(clip)) {
+      add(issues, clipPath, "must be an object", clip);
+      continue;
+    }
+    requiredString(clip, "id", `${clipPath}.id`, issues);
+    requiredString(clip, "src", `${clipPath}.src`, issues);
+    requiredString(clip, "kind", `${clipPath}.kind`, issues);
+    requiredFiniteNumber(clip, "startAt", `${clipPath}.startAt`, issues, { min: 0 });
+    requiredString(clip, "anchor", `${clipPath}.anchor`, issues);
+    optionalFiniteNumber(clip, "clipStart", `${clipPath}.clipStart`, issues, { min: 0 });
+    optionalFiniteNumber(clip, "clipEnd", `${clipPath}.clipEnd`, issues, { min: 0 });
+  }
+}
+function validateStartBlock(value, issues) {
+  if (!isRecord(value)) {
+    add(issues, "startBlock", "must be an object", value);
+    return;
+  }
+  requiredString(value, "title", "startBlock.title", issues);
+  optionalString(value, "heroSrc", "startBlock.heroSrc", issues);
+  optionalString(value, "heroAlt", "startBlock.heroAlt", issues);
+  optionalString(value, "subtitle", "startBlock.subtitle", issues);
+}
+function validateCaptions(value, issues) {
+  if (!isRecord(value)) {
+    add(issues, "captions", "must be an object", value);
+    return;
+  }
+  requiredInteger(value, "version", "captions.version", issues, 0);
+  const phrases = requiredArray(value, "phrases", "captions.phrases", issues);
+  if (!phrases) return;
+  for (let index = 0; index < phrases.length; index += 1) {
+    const path = `captions.phrases[${index}]`;
+    const phrase = phrases[index];
+    if (!isRecord(phrase)) {
+      add(issues, path, "must be an object", phrase);
+      continue;
+    }
+    requiredString(phrase, "text", `${path}.text`, issues);
+    requiredFiniteNumber(phrase, "startTime", `${path}.startTime`, issues, { min: 0 });
+    requiredFiniteNumber(phrase, "endTime", `${path}.endTime`, issues, { min: 0 });
+    requiredInteger(phrase, "audioSegment", `${path}.audioSegment`, issues, 0);
+  }
+}
+function validateDiagnostics(value, issues) {
+  if (!Array.isArray(value)) {
+    add(issues, "diagnostics", "must be an array", value);
+    return;
+  }
+  for (let index = 0; index < value.length; index += 1) {
+    const path = `diagnostics[${index}]`;
+    const diagnostic = value[index];
+    if (!isRecord(diagnostic)) {
+      add(issues, path, "must be an object", diagnostic);
+      continue;
+    }
+    requiredString(diagnostic, "severity", `${path}.severity`, issues);
+    requiredString(diagnostic, "code", `${path}.code`, issues);
+    requiredString(diagnostic, "message", `${path}.message`, issues);
+  }
+}
+function validateStringRows(value, path, issues) {
+  if (!Array.isArray(value)) {
+    add(issues, path, "must be an array", value);
+    return;
+  }
+  for (let index = 0; index < value.length; index += 1) {
+    if (!Array.isArray(value[index]) || value[index].some((cell) => typeof cell !== "string")) {
+      add(issues, `${path}[${index}]`, "must be an array of strings", value[index]);
+    }
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requiredRecord(object, key, path, issues) {
+  const value = object[key];
+  if (!isRecord(value)) {
+    add(issues, path, "must be an object", value);
+    return void 0;
+  }
+  return value;
+}
+function optionalRecord(object, key, path, issues) {
+  if (object[key] !== void 0 && !isRecord(object[key])) {
+    add(issues, path, "must be an object", object[key]);
+  }
+}
+function requiredArray(object, key, path, issues) {
+  const value = object[key];
+  if (!Array.isArray(value)) {
+    add(issues, path, "must be an array", value);
+    return void 0;
+  }
+  return value;
+}
+function optionalArray(object, key, path, issues) {
+  if (object[key] !== void 0 && !Array.isArray(object[key])) {
+    add(issues, path, "must be an array", object[key]);
+  }
+}
+function requiredString(object, key, path, issues) {
+  const value = object[key];
+  if (typeof value !== "string") {
+    add(issues, path, "must be a string", value);
+    return void 0;
+  }
+  return value;
+}
+function optionalString(object, key, path, issues) {
+  if (object[key] !== void 0 && typeof object[key] !== "string") {
+    add(issues, path, "must be a string", object[key]);
+  }
+}
+function requiredStringArray(object, key, path, issues) {
+  const value = object[key];
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    add(issues, path, "must be an array of strings", value);
+  }
+}
+function optionalStringArray(object, key, path, issues) {
+  if (object[key] !== void 0) requiredStringArray(object, key, path, issues);
+}
+function optionalStringRecord(object, key, path, issues) {
+  const value = object[key];
+  if (value === void 0) return;
+  if (!isRecord(value) || Object.values(value).some((item) => typeof item !== "string")) {
+    add(issues, path, "must be an object whose values are strings", value);
+  }
+}
+function requiredFiniteNumber(object, key, path, issues, rule = {}) {
+  const value = object[key];
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    add(issues, path, "must be a finite number", value);
+  } else if (rule.min !== void 0 && value < rule.min) {
+    issues.push({ path, message: `must be at least ${rule.min} (got ${value})` });
+  }
+}
+function optionalFiniteNumber(object, key, path, issues, rule = {}) {
+  if (object[key] !== void 0) requiredFiniteNumber(object, key, path, issues, rule);
+}
+function requiredInteger(object, key, path, issues, min) {
+  const value = object[key];
+  if (!Number.isSafeInteger(value) || value < min) {
+    add(issues, path, `must be an integer of at least ${min}`, value);
+  }
+}
+function optionalBoolean(object, key, path, issues) {
+  if (object[key] !== void 0 && typeof object[key] !== "boolean") {
+    add(issues, path, "must be a boolean", object[key]);
+  }
+}
+function requiredPositionValue(object, key, path, issues) {
+  const value = object[key];
+  if ((typeof value !== "number" || !Number.isFinite(value)) && typeof value !== "string") {
+    add(issues, path, "must be a finite number or string", value);
+  }
+}
+function optionalPositionValue(object, key, path, issues) {
+  if (object[key] !== void 0) requiredPositionValue(object, key, path, issues);
+}
+function add(issues, path, message, value) {
+  const missing = value === void 0 ? " (field is missing)" : ` (got ${describe(value)})`;
+  issues.push({ path, message: `${message}${missing}` });
+}
+function describe(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "an array";
+  if (typeof value === "string") return quote(value);
+  if (typeof value === "number" && Number.isNaN(value)) return "NaN";
+  return typeof value;
+}
+function quote(value) {
+  return JSON.stringify(value);
+}
+
+// src/schemas/pipStyle.ts
+var DEFAULT_SHADOW = "0 0.75em 2em rgba(0, 0, 0, 0.34)";
+var DERIVED_BORDER_WIDTH = "max(1px, 0.12vw)";
+function cssLength(value) {
+  return typeof value === "number" ? `${value}px` : value;
+}
+function resolveRadius(theme) {
+  const explicit = theme.style.pip?.cornerRadius;
+  if (explicit != null) {
+    if (typeof explicit === "number") return explicit <= 0 ? "0" : `${explicit}px`;
+    return explicit;
+  }
+  const br = theme.style.borderRadius ?? 0;
+  if (br <= 0) return "0";
+  return `${Math.min(28, Math.max(6, Math.round(br)))}%`;
+}
+function resolveBorder(theme) {
+  const border = theme.style.pip?.border;
+  if (border === "none") return "none";
+  if (border && typeof border === "object") {
+    const width = border.width == null ? DERIVED_BORDER_WIDTH : cssLength(border.width);
+    const color = border.color ?? withAlpha(theme.colors.text, 0.35);
+    return `${width} solid ${color}`;
+  }
+  return `${DERIVED_BORDER_WIDTH} solid ${withAlpha(theme.colors.text, 0.35)}`;
+}
+function resolveShadow(theme) {
+  const shadow = theme.style.pip?.shadow;
+  if (shadow === false || shadow === "none") return "none";
+  if (typeof shadow === "string") return shadow;
+  return DEFAULT_SHADOW;
+}
+function pipStyleVars(theme) {
+  return {
+    "--squisq-pip-radius": resolveRadius(theme),
+    "--squisq-pip-border": resolveBorder(theme),
+    "--squisq-pip-shadow": resolveShadow(theme)
+  };
+}
+
+// src/schemas/themeCompile.ts
+var STARTER_BODY_FONT = { stackId: "system-sans" };
+var STARTER_TITLE_FONT = { stackId: "system-serif" };
+var STARTER_MONO_FONT = { stackId: "system-mono" };
+var STARTER_COLOR_SCHEMES = {
+  blue: { bg: "#1a365d", text: "#63b3ed", accent: "#90cdf4" },
+  green: { bg: "#22543d", text: "#9ae6b4", accent: "#68d391" },
+  purple: { bg: "#44337a", text: "#d6bcfa", accent: "#b794f4" },
+  red: { bg: "#742a2a", text: "#fc8181", accent: "#feb2b2" },
+  orange: { bg: "#744210", text: "#fbd38d", accent: "#f6ad55" },
+  teal: { bg: "#234e52", text: "#81e6d9", accent: "#4fd1c5" }
+};
+var STARTER_THEME = {
+  schemaVersion: THEME_SCHEMA_VERSION,
+  id: "custom",
+  name: "Custom Theme",
+  description: "Customizer starter \u2014 gets overridden by user choices.",
+  colors: {
+    primary: "#3182ce",
+    secondary: "#4a5568",
+    background: "#1a202c",
+    backgroundLight: "#2d3748",
+    text: "#f7fafc",
+    textMuted: "#a0aec0",
+    highlight: "#4299e1",
+    warning: "#fc8181"
+  },
+  typography: {
+    bodyFont: STARTER_BODY_FONT,
+    titleFont: STARTER_TITLE_FONT,
+    monoFont: STARTER_MONO_FONT,
+    titleWeight: "bold"
+  },
+  style: {
+    textShadow: true,
+    overlayOpacity: 0.45,
+    animationSpeed: 1,
+    borderRadius: 6
+  },
+  renderStyle: {
+    name: "standard",
+    defaultTextAnimation: "fadeIn",
+    defaultImageAnimation: "slowZoom",
+    ambientMotion: true,
+    defaultTransition: { type: "fade", duration: 0.7 }
+  },
+  colorSchemes: STARTER_COLOR_SCHEMES
+};
+function deriveColorPalette(seeds, partialColors = {}, opts = {}) {
+  const spread = opts.contrast === "high" ? 0.22 : opts.contrast === "subtle" ? 0.08 : 0.15;
+  const primary = seeds.primary;
+  const secondary = seeds.secondary ?? oklchSetChroma(oklchLighten(primary, 0.05), 0.5);
+  const accent = seeds.accent ?? oklchLighten(primary, spread);
+  const bgSeed = partialColors.background ?? seeds.background;
+  let background;
+  if (bgSeed) {
+    background = bgSeed;
+  } else {
+    background = relativeLuminance(primary) > 0.5 ? "#0a0a0a" : "#1a202c";
+  }
+  const isLightSurface = relativeLuminance(background) > 0.5;
+  const backgroundLight = partialColors.backgroundLight ?? (isLightSurface ? oklchDarken(background, 0.04) : oklchLighten(background, 0.04));
+  const text = partialColors.text ?? seeds.text ?? pickContrastingText(background, "#f7fafc", "#1a202c");
+  const textMuted = partialColors.textMuted ?? (isLightSurface ? oklchLighten(text, 0.25) : oklchDarken(text, 0.25));
+  const highlight = partialColors.highlight ?? accent;
+  const warning = partialColors.warning ?? "#fc8181";
+  return {
+    primary: partialColors.primary ?? primary,
+    secondary: partialColors.secondary ?? secondary,
+    background,
+    backgroundLight,
+    text,
+    textMuted,
+    highlight,
+    warning
+  };
+}
+function accentToColorScheme(accent) {
+  if (!isHex(accent)) return { bg: "#1a202c", text: "#e2e8f0", accent: "#63b3ed" };
+  const scale = deriveScale(accent, 0.3);
+  return { bg: scale.darker2, text: scale.lighter2, accent: scale.base };
+}
+function compileTheme(partial, opts = {}) {
+  const base = opts.base ?? STARTER_THEME;
+  const merged = createTheme(base, partial);
+  merged.schemaVersion = THEME_SCHEMA_VERSION;
+  if (opts.base && !merged.basedOn) merged.basedOn = opts.base.id;
+  const partialTypography = partial.typography;
+  if (partialTypography) {
+    if (partialTypography.titleFont !== void 0) {
+      merged.typography.titleFont = partialTypography.titleFont;
+    }
+    if (partialTypography.bodyFont !== void 0) {
+      merged.typography.bodyFont = partialTypography.bodyFont;
+    }
+    if (partialTypography.monoFont !== void 0) {
+      merged.typography.monoFont = partialTypography.monoFont;
+    }
+  }
+  if (partial.colorSchemes !== void 0) {
+    merged.colorSchemes = partial.colorSchemes;
+  }
+  if (merged.seedColors) {
+    const partialColors = partial.colors ?? {};
+    merged.colors = deriveColorPalette(merged.seedColors, partialColors, {
+      contrast: opts.contrast
+    });
+  }
+  if (!merged.pageStyle) {
+    merged.pageStyle = defaultPageStyle(merged);
+  }
+  return assertTheme(merged, `compiled theme "${merged.id}"`);
+}
+function parseTheme(json) {
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Invalid theme JSON: ${msg}`);
+  }
+  return assertTheme(parsed, "parsed theme");
+}
+function serializeTheme(theme) {
+  return JSON.stringify(theme, null, 2);
+}
+
+// src/schemas/mermaidTheme.ts
+var MERMAID_CHART_COLOR_COUNT = 12;
+function uniqueColors(colors) {
+  return colors.filter((color, index) => color && colors.indexOf(color) === index);
+}
+function chartPalette(theme) {
+  const schemes = Object.values(theme.colorSchemes);
+  const seeds = uniqueColors([
+    theme.colors.primary,
+    theme.colors.secondary,
+    theme.colors.highlight,
+    ...schemes.map((scheme) => scheme.accent),
+    theme.colors.warning,
+    ...schemes.map((scheme) => scheme.bg),
+    theme.colors.textMuted,
+    theme.colors.backgroundLight
+  ]);
+  const fallback = theme.colors.primary;
+  return Array.from(
+    { length: MERMAID_CHART_COLOR_COUNT },
+    (_, index) => seeds[index % Math.max(1, seeds.length)] ?? fallback
+  );
+}
+function textOn(theme, background) {
+  return pickContrastingText(background, theme.colors.text, theme.colors.background);
+}
+function buildMermaidThemeVariables(theme) {
+  const { colors } = theme;
+  const primaryText = textOn(theme, colors.primary);
+  const secondaryText = textOn(theme, colors.secondary);
+  const highlightText = textOn(theme, colors.highlight);
+  const palette = chartPalette(theme);
+  const variables = {
+    darkMode: relativeLuminance(colors.background) < 0.5,
+    background: colors.background,
+    fontFamily: resolveFontFamily(theme.typography.bodyFont, FONT_FALLBACKS.sans),
+    primaryColor: colors.primary,
+    primaryTextColor: primaryText,
+    primaryBorderColor: colors.highlight,
+    secondaryColor: colors.secondary,
+    secondaryTextColor: secondaryText,
+    secondaryBorderColor: colors.primary,
+    tertiaryColor: colors.backgroundLight,
+    tertiaryTextColor: colors.text,
+    tertiaryBorderColor: colors.textMuted,
+    textColor: colors.text,
+    titleColor: colors.text,
+    lineColor: colors.textMuted,
+    arrowheadColor: colors.textMuted,
+    defaultLinkColor: colors.textMuted,
+    mainBkg: colors.primary,
+    nodeBkg: colors.primary,
+    nodeTextColor: primaryText,
+    nodeBorder: colors.highlight,
+    clusterBkg: colors.backgroundLight,
+    clusterBorder: colors.secondary,
+    edgeLabelBackground: colors.background,
+    actorBkg: colors.backgroundLight,
+    actorBorder: colors.primary,
+    actorTextColor: colors.text,
+    actorLineColor: colors.textMuted,
+    signalColor: colors.textMuted,
+    signalTextColor: colors.text,
+    labelBoxBkgColor: colors.backgroundLight,
+    labelBoxBorderColor: colors.secondary,
+    labelTextColor: colors.text,
+    loopTextColor: colors.text,
+    activationBkgColor: colors.secondary,
+    activationBorderColor: colors.primary,
+    sequenceNumberColor: primaryText,
+    noteBkgColor: colors.highlight,
+    noteBorderColor: colors.primary,
+    noteTextColor: highlightText,
+    sectionBkgColor: colors.backgroundLight,
+    altSectionBkgColor: colors.background,
+    sectionBkgColor2: colors.primary,
+    taskBkgColor: colors.primary,
+    taskBorderColor: colors.highlight,
+    taskTextColor: primaryText,
+    taskTextLightColor: colors.text,
+    taskTextDarkColor: colors.text,
+    taskTextOutsideColor: colors.text,
+    taskTextClickableColor: colors.highlight,
+    activeTaskBkgColor: colors.secondary,
+    activeTaskBorderColor: colors.highlight,
+    doneTaskBkgColor: colors.backgroundLight,
+    doneTaskBorderColor: colors.textMuted,
+    critBkgColor: colors.warning,
+    critBorderColor: colors.highlight,
+    todayLineColor: colors.warning,
+    gridColor: colors.textMuted,
+    pieTitleTextColor: colors.text,
+    pieSectionTextColor: colors.text,
+    pieLegendTextColor: colors.text,
+    pieStrokeColor: colors.background,
+    pieOuterStrokeColor: colors.textMuted,
+    quadrantPointFill: colors.highlight,
+    quadrantPointTextFill: highlightText,
+    quadrantXAxisTextFill: colors.text,
+    quadrantYAxisTextFill: colors.text,
+    quadrantTitleFill: colors.text,
+    requirementBackground: colors.backgroundLight,
+    requirementBorderColor: colors.primary,
+    requirementTextColor: colors.text,
+    relationColor: colors.textMuted,
+    relationLabelBackground: colors.background,
+    relationLabelColor: colors.text,
+    commitLabelColor: colors.text,
+    commitLabelBackground: colors.backgroundLight,
+    tagLabelColor: primaryText,
+    tagLabelBackground: colors.primary,
+    tagLabelBorder: colors.highlight
+  };
+  palette.forEach((color, index) => {
+    const label = textOn(theme, color);
+    variables[`cScale${index}`] = color;
+    variables[`cScaleInv${index}`] = label;
+    variables[`cScaleLabel${index}`] = label;
+    variables[`cScalePeer${index}`] = label;
+    variables[`pie${index + 1}`] = color;
+    if (index < 8) {
+      variables[`git${index}`] = color;
+      variables[`gitInv${index}`] = label;
+      variables[`gitBranchLabel${index}`] = label;
+    }
+  });
+  return variables;
+}
+
+export {
+  calculateDuration,
+  getSegmentAtTime,
+  getBlockAtTime,
+  getCaptionAtTime,
+  validateDocSchema,
+  assertDocSchema,
+  pipStyleVars,
+  STARTER_THEME,
+  deriveColorPalette,
+  accentToColorScheme,
+  compileTheme,
+  parseTheme,
+  serializeTheme,
+  buildMermaidThemeVariables
+};