@bendyline/squisq 0.1.1 → 1.0.1

package/dist/chunk-VP5SZTZ2.js

@@ -0,0 +1,792 @@
+import {
+  SeededRandom,
+  hashString
+} from "./chunk-FVTQSNR7.js";
+import {
+  estimateNarrationDuration
+} from "./chunk-3E5F2XMR.js";
+
+// src/generate/contentExtractor.ts
+var STAT_PATTERNS = [
+  /\b(roughly |about |approximately |nearly |over |under |more than |less than )?([\d,]+(?:\.\d+)?)\s*%/gi,
+  /\b([\d,]+(?:\.\d+)?)\s*(million|billion|trillion|thousand|hundred)\b/gi,
+  /\b([\d,]+(?:\.\d+)?)\s*(miles?|feet|ft|meters?|m|kilometers?|km|acres?|square miles?|sq mi|hectares?)\b/gi,
+  /\b([\d,]+(?:\.\d+)?)\s*(x|times)\b/gi,
+  /\b([$€£¥])\s*([\d,]+(?:\.\d+)?)\s*(million|billion|thousand)?\b/gi,
+  /\b(\d+)(st|nd|rd|th)\s+(largest|smallest|oldest|newest|most|least)/gi
+];
+var DATE_PATTERNS = [
+  /\b(January|February|March|April|May|June|July|August|September|October|November|December)\s+(\d{1,2},?\s+)?(\d{4})\b/gi,
+  /\b(\d{4})s\b|\b(\d{1,2})(st|nd|rd|th)\s+century\b/gi,
+  /\b(from\s+)?(\d{4})\s*(to|–|-|through)\s*(\d{4})\b/gi,
+  /\b(in|by|since|after|before|during)\s+(\d{4})\b/gi
+];
+var QUOTE_PATTERNS = [
+  /"([^"]{15,200})"/g,
+  /\u201c([^\u201d]{15,200})\u201d/g,
+  /(\w+(?:\s+\w+)?)\s+(?:said|stated|wrote|noted|observed|commented),?\s*"([^"]+)"/gi
+];
+var COMPARISON_PATTERNS = [
+  /from\s+(.{2,30})\s+to\s+(.{2,30})/gi,
+  /(.{2,30})\s+(?:vs\.?|versus)\s+(.{2,30})/gi,
+  /(.{2,30})\s+compared\s+to\s+(.{2,30})/gi
+];
+var FACT_INDICATORS = [
+  "largest",
+  "smallest",
+  "oldest",
+  "newest",
+  "first",
+  "last",
+  "most",
+  "least",
+  "only",
+  "unique",
+  "rare",
+  "famous",
+  "important",
+  "significant",
+  "notable",
+  "remarkable",
+  "extraordinary",
+  "crucial",
+  "essential",
+  "critical",
+  "major",
+  "key",
+  "discovered",
+  "founded",
+  "established",
+  "created",
+  "built",
+  "invented",
+  "developed",
+  "introduced",
+  "pioneered",
+  "transformed",
+  "revolutionized",
+  "changed",
+  "shaped"
+];
+var SOMBER_INDICATORS = [
+  "disaster",
+  "tragedy",
+  "death",
+  "died",
+  "killed",
+  "destroyed",
+  "devastated",
+  "collapsed",
+  "lost",
+  "abandoned",
+  "declined",
+  "war",
+  "battle",
+  "conflict",
+  "earthquake",
+  "fire",
+  "flood"
+];
+var CELEBRATORY_INDICATORS = [
+  "celebration",
+  "victory",
+  "success",
+  "achievement",
+  "triumph",
+  "opened",
+  "completed",
+  "inaugurated",
+  "launched",
+  "won",
+  "record",
+  "breakthrough",
+  "milestone",
+  "golden",
+  "grand"
+];
+var IMPACT_VERBS = [
+  "check",
+  "watch",
+  "stop",
+  "prepare",
+  "imagine",
+  "consider",
+  "look",
+  "listen",
+  "notice",
+  "remember",
+  "discover",
+  "explore",
+  "visit",
+  "try",
+  "experience",
+  "avoid",
+  "beware",
+  "enjoy"
+];
+var LIST_PATTERNS = [
+  /(?:including|such as|namely|like|features?|offers?)\s+([^.]{10,150})/gi,
+  /(?:three|four|five|six|several|many|various)\s+(?:main|key|primary|notable|popular|important)?\s*\w+(?:\s+\w+)?:\s*([^.]{10,150})/gi
+];
+var DEFINITION_PATTERNS = [
+  /\b([A-Z][a-z]+(?:\s+[A-Z]?[a-z]+){0,3})\s+is\s+(?:a|an|the)\s+([^.]{10,120})/g,
+  /known\s+as\s+([A-Z][a-z]+(?:\s+[A-Z]?[a-z]+){0,3}),\s+([^.]{10,120})/gi,
+  /\b([A-Z][a-z]+(?:\s+[A-Z]?[a-z]+){0,3})\s+refers?\s+to\s+([^.]{10,120})/g,
+  /called\s+([A-Z][a-z]+(?:\s+[A-Z]?[a-z]+){0,3}),?\s+(?:which|meaning|a)\s+([^.]{10,120})/gi
+];
+function extractContent(text, options = {}) {
+  const {
+    minConfidence = 0.3,
+    types = ["stat", "date", "quote", "comparison", "fact", "impactLine", "list", "definition"],
+    maxPerType
+  } = options;
+  const elements = [];
+  if (types.includes("stat")) elements.push(...extractStats(text));
+  if (types.includes("date")) elements.push(...extractDates(text));
+  if (types.includes("quote")) elements.push(...extractQuotes(text));
+  if (types.includes("comparison")) elements.push(...extractComparisons(text));
+  if (types.includes("fact")) elements.push(...extractFacts(text));
+  if (types.includes("impactLine")) elements.push(...extractImpactLines(text));
+  if (types.includes("list")) elements.push(...extractLists(text));
+  if (types.includes("definition")) elements.push(...extractDefinitions(text));
+  let filtered = elements.filter((e) => e.confidence >= minConfidence);
+  if (maxPerType !== void 0) {
+    const byType = /* @__PURE__ */ new Map();
+    for (const elem of filtered) {
+      const list = byType.get(elem.type) || [];
+      list.push(elem);
+      byType.set(elem.type, list);
+    }
+    filtered = [];
+    for (const [, list] of byType) {
+      list.sort((a, b) => b.confidence - a.confidence);
+      filtered.push(...list.slice(0, maxPerType));
+    }
+  }
+  filtered.sort((a, b) => a.sourcePosition - b.sourcePosition);
+  filtered = deduplicateOverlapping(filtered);
+  return {
+    elements: filtered,
+    sourceLength: text.length,
+    stats: {
+      statCount: filtered.filter((e) => e.type === "stat").length,
+      dateCount: filtered.filter((e) => e.type === "date").length,
+      quoteCount: filtered.filter((e) => e.type === "quote").length,
+      comparisonCount: filtered.filter((e) => e.type === "comparison").length,
+      factCount: filtered.filter((e) => e.type === "fact").length,
+      impactLineCount: filtered.filter((e) => e.type === "impactLine").length,
+      listCount: filtered.filter((e) => e.type === "list").length,
+      definitionCount: filtered.filter((e) => e.type === "definition").length,
+      totalCount: filtered.length
+    }
+  };
+}
+function extractStats(text) {
+  const elements = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const pattern of STAT_PATTERNS) {
+    pattern.lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+      const position = match.index;
+      if (seen.has(position)) continue;
+      seen.add(position);
+      const context = getSentenceContext(text, position, match[0].length);
+      const value = match[0].trim();
+      elements.push({
+        type: "stat",
+        text: context.sentence,
+        confidence: calculateStatConfidence(value, context.sentence),
+        sourcePosition: context.start,
+        endPosition: context.end,
+        data: { type: "stat", value, description: cleanDescription(context.sentence, value) }
+      });
+    }
+  }
+  return elements;
+}
+function extractDates(text) {
+  const elements = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const pattern of DATE_PATTERNS) {
+    pattern.lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+      const position = match.index;
+      if (seen.has(position)) continue;
+      seen.add(position);
+      const context = getSentenceContext(text, position, match[0].length);
+      const dateStr = match[0].trim();
+      elements.push({
+        type: "date",
+        text: context.sentence,
+        confidence: calculateDateConfidence(dateStr, context.sentence),
+        sourcePosition: context.start,
+        endPosition: context.end,
+        data: {
+          type: "date",
+          date: dateStr,
+          description: cleanDescription(context.sentence, dateStr),
+          mood: detectMood(context.sentence)
+        }
+      });
+    }
+  }
+  return elements;
+}
+function extractQuotes(text) {
+  const elements = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const pattern of QUOTE_PATTERNS) {
+    pattern.lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+      const position = match.index;
+      if (seen.has(position)) continue;
+      seen.add(position);
+      const quote = match.length > 2 ? match[2] : match[1];
+      const attribution = match.length > 2 ? match[1] : void 0;
+      if (quote.length < 15 || quote.length > 200) continue;
+      elements.push({
+        type: "quote",
+        text: match[0],
+        confidence: calculateQuoteConfidence(quote),
+        sourcePosition: position,
+        endPosition: position + match[0].length,
+        data: { type: "quote", quote: quote.trim(), attribution: attribution?.trim() }
+      });
+    }
+  }
+  return elements;
+}
+function extractComparisons(text) {
+  const elements = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const pattern of COMPARISON_PATTERNS) {
+    pattern.lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+      const position = match.index;
+      if (seen.has(position)) continue;
+      seen.add(position);
+      const left = match[1].trim();
+      const right = match[2].trim();
+      if (left.length < 2 || left.length > 30) continue;
+      if (right.length < 2 || right.length > 30) continue;
+      const context = getSentenceContext(text, position, match[0].length);
+      elements.push({
+        type: "comparison",
+        text: context.sentence,
+        confidence: 0.6,
+        sourcePosition: context.start,
+        endPosition: context.end,
+        data: { type: "comparison", left: { label: left }, right: { label: right } }
+      });
+    }
+  }
+  return elements;
+}
+function forEachSentenceSpan(text, callback) {
+  const sentenceRegex = /[^.!?]+[.!?]*/g;
+  let match;
+  while ((match = sentenceRegex.exec(text)) !== null) {
+    const raw = match[0];
+    const rawStart = match.index;
+    const rawEnd = rawStart + raw.length;
+    let leading = 0;
+    while (leading < raw.length && /\s/.test(raw[leading])) {
+      leading++;
+    }
+    let trailing = 0;
+    while (trailing < raw.length - leading && /[\s.!?]/.test(raw[raw.length - 1 - trailing])) {
+      trailing++;
+    }
+    const start = rawStart + leading;
+    const end = rawEnd - trailing;
+    if (end <= start) continue;
+    const trimmed = text.slice(start, end);
+    if (!trimmed) continue;
+    callback(trimmed, start, end);
+  }
+}
+function extractFacts(text) {
+  const elements = [];
+  forEachSentenceSpan(text, (trimmed, start, end) => {
+    if (trimmed.length <= 20) return;
+    const score = scoreSentenceAsFact(trimmed);
+    if (score < 0.4) return;
+    elements.push({
+      type: "fact",
+      text: trimmed,
+      confidence: score,
+      sourcePosition: start,
+      endPosition: end,
+      data: { type: "fact", fact: trimmed }
+    });
+  });
+  return elements;
+}
+function extractImpactLines(text) {
+  const elements = [];
+  forEachSentenceSpan(text, (trimmed, start, end) => {
+    if (trimmed.length < 8 || trimmed.length > 60) return;
+    let score = 0.3;
+    const lower = trimmed.toLowerCase();
+    for (const verb of IMPACT_VERBS) {
+      if (lower.startsWith(verb)) {
+        score += 0.25;
+        break;
+      }
+    }
+    if (end < text.length && text[end] === "!") score += 0.15;
+    if (trimmed.length < 30) score += 0.1;
+    if (trimmed.includes(",")) score -= 0.1;
+    if (/^(and|but|or|the|a|an)\b/i.test(trimmed)) score -= 0.15;
+    if (score < 0.5) return;
+    elements.push({
+      type: "impactLine",
+      text: trimmed,
+      confidence: Math.min(1, score),
+      sourcePosition: start,
+      endPosition: end,
+      data: { type: "impactLine", text: trimmed }
+    });
+  });
+  return elements;
+}
+function extractLists(text) {
+  const elements = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const pattern of LIST_PATTERNS) {
+    pattern.lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+      const position = match.index;
+      if (seen.has(position)) continue;
+      seen.add(position);
+      const listContent = match[1].trim();
+      const items = listContent.split(/,\s*(?:and|or)\s+|,\s+|\s+and\s+|\s+or\s+/).map((item) => item.trim()).filter((item) => item.length >= 2 && item.length <= 60);
+      if (items.length < 3 || items.length > 5) continue;
+      const context = getSentenceContext(text, position, match[0].length);
+      elements.push({
+        type: "list",
+        text: context.sentence,
+        confidence: 0.65,
+        sourcePosition: context.start,
+        endPosition: context.end,
+        data: { type: "list", items }
+      });
+    }
+  }
+  return elements;
+}
+function extractDefinitions(text) {
+  const elements = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const pattern of DEFINITION_PATTERNS) {
+    pattern.lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+      const position = match.index;
+      if (seen.has(position)) continue;
+      seen.add(position);
+      const term = match[1].trim();
+      const definition = match[2].trim();
+      if (term.length < 3 || term.length > 30) continue;
+      if (definition.length < 10 || definition.length > 120) continue;
+      const context = getSentenceContext(text, position, match[0].length);
+      elements.push({
+        type: "definition",
+        text: context.sentence,
+        confidence: 0.6,
+        sourcePosition: context.start,
+        endPosition: context.end,
+        data: { type: "definition", term, definition }
+      });
+    }
+  }
+  return elements;
+}
+function getSentenceContext(text, matchStart, matchLength) {
+  let start = matchStart;
+  while (start > 0 && !/[.!?]/.test(text[start - 1])) start--;
+  while (start < matchStart && /\s/.test(text[start])) start++;
+  let end = matchStart + matchLength;
+  while (end < text.length && !/[.!?]/.test(text[end])) end++;
+  if (end < text.length) end++;
+  return { sentence: text.slice(start, end).trim(), start, end };
+}
+function calculateStatConfidence(value, context) {
+  let score = 0.5;
+  if (value.includes("%")) score += 0.2;
+  if (/million|billion|trillion/i.test(value)) score += 0.15;
+  if (/increased|decreased|grew|dropped|rose|fell/i.test(context)) score += 0.15;
+  if (context.length < 30) score -= 0.2;
+  return Math.min(1, Math.max(0, score));
+}
+function calculateDateConfidence(date, context) {
+  let score = 0.5;
+  if (/January|February|March|April|May|June|July|August|September|October|November|December/i.test(
+    date
+  ))
+    score += 0.2;
+  if (/founded|established|built|opened|discovered|created/i.test(context)) score += 0.2;
+  if (/happened|occurred|took place|began|ended/i.test(context)) score += 0.15;
+  return Math.min(1, Math.max(0, score));
+}
+function calculateQuoteConfidence(quote) {
+  let score = 0.5;
+  if (quote.length >= 30 && quote.length <= 150) score += 0.2;
+  if (/\b(I|we|our|my)\b/i.test(quote)) score += 0.1;
+  if (!/[.!?]$/.test(quote)) score -= 0.1;
+  return Math.min(1, Math.max(0, score));
+}
+function scoreSentenceAsFact(sentence) {
+  let score = 0.3;
+  const lower = sentence.toLowerCase();
+  for (const indicator of FACT_INDICATORS) {
+    if (lower.includes(indicator)) {
+      score += 0.1;
+      break;
+    }
+  }
+  const properNouns = sentence.match(/\b[A-Z][a-z]+\b/g);
+  if (properNouns && properNouns.length >= 2) score += 0.15;
+  if (/\d/.test(sentence)) score += 0.1;
+  if (sentence.endsWith("?")) score -= 0.3;
+  if (sentence.length > 200) score -= 0.15;
+  return Math.min(1, Math.max(0, score));
+}
+function detectMood(sentence) {
+  const lower = sentence.toLowerCase();
+  for (const word of SOMBER_INDICATORS) {
+    if (lower.includes(word)) return "somber";
+  }
+  for (const word of CELEBRATORY_INDICATORS) {
+    if (lower.includes(word)) return "celebratory";
+  }
+  return "neutral";
+}
+function cleanDescription(sentence, value) {
+  const prepositionPatterns = [
+    new RegExp(`\\b[Ii]n\\s+${escapeRegex(value)}[,.]?\\s*`, "g"),
+    new RegExp(`\\b[Oo]n\\s+${escapeRegex(value)}[,.]?\\s*`, "g"),
+    new RegExp(`\\b[Dd]uring\\s+${escapeRegex(value)}[,.]?\\s*`, "g"),
+    new RegExp(`\\b[Bb]y\\s+${escapeRegex(value)}[,.]?\\s*`, "g"),
+    new RegExp(`\\b[Ss]ince\\s+${escapeRegex(value)}[,.]?\\s*`, "g"),
+    new RegExp(`\\b[Ff]rom\\s+${escapeRegex(value)}[,.]?\\s*`, "g")
+  ];
+  let desc = sentence;
+  for (const pattern of prepositionPatterns) {
+    desc = desc.replace(pattern, "");
+  }
+  if (desc === sentence) {
+    desc = sentence.replace(value, "").trim();
+  }
+  desc = desc.replace(/^[,:\-–—]+\s*/, "").replace(/\s*[,:\-–—]+$/, "");
+  desc = desc.replace(
+    /\s+(?:of|on|in|at|by|to|for|from|with|about|over|under|between|than|into|onto|upon)\s*([,.])/gi,
+    "$1"
+  );
+  desc = desc.replace(
+    /\s+(?:for|of|to|in|at|by|with|from|about|over|under|between|than|into|onto|upon)\s*[.!?]?\s*$/i,
+    "."
+  );
+  desc = desc.replace(/\s{2,}/g, " ").replace(/\s+([,.])/g, "$1");
+  desc = desc.charAt(0).toUpperCase() + desc.slice(1);
+  return desc.trim();
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var TYPE_SPECIFICITY = {
+  stat: 5,
+  date: 4,
+  quote: 3,
+  definition: 3,
+  comparison: 2,
+  list: 2,
+  impactLine: 2,
+  fact: 1
+};
+function deduplicateOverlapping(elements) {
+  if (elements.length <= 1) return elements;
+  const toRemove = /* @__PURE__ */ new Set();
+  for (let i = 0; i < elements.length; i++) {
+    if (toRemove.has(i)) continue;
+    const a = elements[i];
+    for (let j = i + 1; j < elements.length; j++) {
+      if (toRemove.has(j)) continue;
+      const b = elements[j];
+      if (elementsOverlap(a, b)) {
+        const aSpec = TYPE_SPECIFICITY[a.type];
+        const bSpec = TYPE_SPECIFICITY[b.type];
+        if (aSpec >= bSpec) {
+          toRemove.add(j);
+        } else {
+          toRemove.add(i);
+          break;
+        }
+      }
+    }
+  }
+  return elements.filter((_, index) => !toRemove.has(index));
+}
+function elementsOverlap(a, b) {
+  if (a.sourcePosition === b.sourcePosition) return true;
+  if (a.sourcePosition <= b.sourcePosition && a.endPosition >= b.endPosition) return true;
+  if (b.sourcePosition <= a.sourcePosition && b.endPosition >= a.endPosition) return true;
+  const overlapStart = Math.max(a.sourcePosition, b.sourcePosition);
+  const overlapEnd = Math.min(a.endPosition, b.endPosition);
+  if (overlapEnd > overlapStart) {
+    const overlapLength = overlapEnd - overlapStart;
+    const minLength = Math.min(a.endPosition - a.sourcePosition, b.endPosition - b.sourcePosition);
+    if (overlapLength > minLength * 0.5) return true;
+  }
+  return false;
+}
+function stripMarkdown(markdown) {
+  return markdown.replace(/```[\s\S]*?```/g, "").replace(/!\[([^\]]*)\]\([^)]+\)/g, "").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/^#{1,6}\s+/gm, "").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/\*([^*]+)\*/g, "$1").replace(/__([^_]+)__/g, "$1").replace(/_([^_]+)_/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/^>\s+/gm, "").replace(/^[-*_]{3,}$/gm, "").replace(/\n{3,}/g, "\n\n").trim();
+}
+
+// src/generate/templateMapper.ts
+function mapElementToBlock(element, options) {
+  const base = {
+    id: options.id,
+    duration: options.duration,
+    audioSegment: options.audioSegment,
+    sourceStartTime: options.sourceStartTime,
+    sourceDuration: options.sourceDuration
+  };
+  switch (element.data.type) {
+    case "stat":
+      return mapStat(element.data, base, options);
+    case "date":
+      return mapDate(element.data, base, options);
+    case "quote":
+      return mapQuote(element.data, base, options);
+    case "comparison":
+      return mapComparison(element.data, base, options);
+    case "fact":
+      return mapFact(element.data, base, options);
+    case "impactLine":
+      return mapImpactLine(element.data, base, options);
+    case "list":
+      return mapList(element.data, base, options);
+    case "definition":
+      return mapDefinition(element.data, base, options);
+  }
+}
+function mapStat(data, base, opts) {
+  return {
+    ...base,
+    template: "statHighlight",
+    stat: data.value,
+    description: data.description,
+    colorScheme: opts.colorScheme,
+    accentImage: opts.accentImage
+  };
+}
+function mapDate(data, base, opts) {
+  return {
+    ...base,
+    template: "dateEvent",
+    date: data.date,
+    description: data.description,
+    mood: data.mood,
+    accentImage: opts.accentImage
+  };
+}
+function mapQuote(data, base, opts) {
+  return {
+    ...base,
+    template: "quoteBlock",
+    quote: data.quote,
+    attribution: data.attribution,
+    accentImage: opts.accentImage
+  };
+}
+function mapComparison(data, base, opts) {
+  return {
+    ...base,
+    template: "twoColumn",
+    left: data.left,
+    right: data.right,
+    header: data.header,
+    leftColor: opts.colorScheme
+  };
+}
+function mapFact(data, base, opts) {
+  return {
+    ...base,
+    template: "factCard",
+    fact: data.fact,
+    explanation: data.explanation ?? "",
+    accentImage: opts.accentImage
+  };
+}
+function mapImpactLine(data, base, opts) {
+  return {
+    ...base,
+    template: "fullBleedQuote",
+    text: data.text,
+    colorScheme: opts.colorScheme
+  };
+}
+function mapList(data, base, opts) {
+  return {
+    ...base,
+    template: "listBlock",
+    items: data.items,
+    title: data.title,
+    colorScheme: opts.colorScheme,
+    accentImage: opts.accentImage
+  };
+}
+function mapDefinition(data, base, opts) {
+  return {
+    ...base,
+    template: "definitionCard",
+    term: data.term,
+    definition: data.definition,
+    origin: data.origin,
+    colorScheme: opts.colorScheme,
+    accentImage: opts.accentImage
+  };
+}
+
+// src/generate/slideshowGenerator.ts
+var DEFAULT_COLOR_SCHEMES = ["blue", "green", "purple", "orange", "red"];
+var DEFAULT_AMBIENT_MOTIONS = [
+  "zoomIn",
+  "zoomOut",
+  "panLeft",
+  "panRight"
+];
+var DEFAULT_ACCENT_POSITIONS = ["left-strip", "right-strip", "bottom-strip"];
+function generateSlideshow(text, images = [], options = {}) {
+  const {
+    seed,
+    title,
+    subtitle,
+    duration: explicitDuration,
+    targetSlides,
+    colorSchemes = DEFAULT_COLOR_SCHEMES,
+    ambientMotions = DEFAULT_AMBIENT_MOTIONS,
+    accentPositions = DEFAULT_ACCENT_POSITIONS,
+    minSlideDuration = 4,
+    maxSlideDuration = 15,
+    themeId,
+    isMarkdown = false,
+    minConfidence = 0.3
+  } = options;
+  const plainText = isMarkdown ? stripMarkdown(text) : text;
+  const rng = new SeededRandom(seed ?? hashString(plainText));
+  const totalDuration = explicitDuration ?? estimateNarrationDuration(plainText);
+  const extraction = extractContent(plainText, { minConfidence });
+  const allElements = extraction.elements;
+  const slideBudget = targetSlides ?? computeSlideBudget(totalDuration, allElements.length);
+  const imageSlotCount = images.length > 0 ? Math.max(1, Math.round(slideBudget * 0.4)) : 0;
+  const contentSlotCount = Math.max(0, slideBudget - imageSlotCount - (title ? 1 : 0));
+  const sorted = [...allElements].sort((a, b) => b.confidence - a.confidence);
+  const selected = sorted.slice(0, contentSlotCount);
+  selected.sort((a, b) => a.sourcePosition - b.sourcePosition);
+  const blocks = [];
+  let slideIndex = 0;
+  let colorIdx = 0;
+  let accentIdx = 0;
+  const totalSlideCount = (title ? 1 : 0) + selected.length + Math.min(imageSlotCount, images.length);
+  const perSlide = totalSlideCount > 0 ? Math.min(maxSlideDuration, Math.max(minSlideDuration, totalDuration / totalSlideCount)) : minSlideDuration;
+  if (title) {
+    const titleBlock = {
+      id: `slide-${slideIndex++}`,
+      template: "titleBlock",
+      title,
+      subtitle,
+      duration: Math.min(perSlide, 6),
+      audioSegment: 0
+    };
+    blocks.push(titleBlock);
+  }
+  const standaloneImages = images.slice(0, Math.min(imageSlotCount, images.length));
+  const accentPool = images.length > standaloneImages.length ? images.slice(standaloneImages.length) : [...images];
+  const imageInterval = standaloneImages.length > 0 ? Math.max(1, Math.floor(selected.length / (standaloneImages.length + 1))) : Infinity;
+  let imgIdx = 0;
+  let sinceImage = 0;
+  for (let i = 0; i < selected.length; i++) {
+    if (sinceImage >= imageInterval && imgIdx < standaloneImages.length) {
+      blocks.push(
+        createImageSlide(standaloneImages[imgIdx], slideIndex++, perSlide, rng, ambientMotions)
+      );
+      imgIdx++;
+      sinceImage = 0;
+    }
+    const element = selected[i];
+    let accentImage;
+    if (accentPool.length > 0) {
+      const img = accentPool[i % accentPool.length];
+      accentImage = {
+        src: img.src,
+        alt: img.alt ?? "",
+        position: accentPositions[accentIdx % accentPositions.length],
+        ambientMotion: rng.pickRequired(ambientMotions),
+        credit: img.credit,
+        license: img.license
+      };
+      accentIdx++;
+    }
+    const block = mapElementToBlock(element, {
+      id: `slide-${slideIndex++}`,
+      duration: perSlide,
+      audioSegment: 0,
+      colorScheme: colorSchemes[colorIdx % colorSchemes.length],
+      accentImage
+    });
+    blocks.push(block);
+    colorIdx++;
+    sinceImage++;
+  }
+  while (imgIdx < standaloneImages.length) {
+    blocks.push(
+      createImageSlide(standaloneImages[imgIdx], slideIndex++, perSlide, rng, ambientMotions)
+    );
+    imgIdx++;
+  }
+  const doc = {
+    articleId: title ?? "slideshow",
+    duration: totalDuration,
+    blocks,
+    audio: {
+      segments: [{ src: "", name: "main", duration: totalDuration, startTime: 0 }]
+    },
+    themeId
+  };
+  return doc;
+}
+function computeSlideBudget(duration, elementCount) {
+  const byDuration = Math.round(duration / 60 * 5);
+  const budget = Math.min(byDuration, elementCount + 4);
+  return Math.max(3, Math.min(12, budget));
+}
+function createImageSlide(img, index, duration, rng, motions) {
+  return {
+    id: `slide-${index}`,
+    template: "imageWithCaption",
+    imageSrc: img.src,
+    imageAlt: img.alt ?? "",
+    caption: img.alt,
+    duration,
+    audioSegment: 0,
+    ambientMotion: rng.pickRequired(motions),
+    imageCredit: img.credit,
+    imageLicense: img.license
+  };
+}
+
+export {
+  extractContent,
+  stripMarkdown,
+  mapElementToBlock,
+  generateSlideshow
+};
+//# sourceMappingURL=chunk-VP5SZTZ2.js.map