@pixerate/editor 0.24.0 → 0.25.0

package/dist/index.js

@@ -40,12 +40,15 @@ import {
   Autocorrect,
   BUILT_IN_IMPORT_ADAPTERS,
   Bookmark,
+  CHARACTER_STYLE_MARK_NAME,
   COMMENT_MARK_NAME,
+  CharacterStyle,
   ColorHighlighter,
   Comments,
   CrossReference,
   DEFAULT_AUTOCORRECT_EXCEPTIONS,
   DEFAULT_DOCX_MAX_IMAGE_SIZE,
+  DEFAULT_STYLES,
   DEFAULT_ZIP_MAX_ENTRIES,
   DEFAULT_ZIP_MAX_TOTAL_SIZE,
   DOCX_MIME_TYPES,
@@ -68,11 +71,15 @@ import {
   MAX_FIND_PATTERN_LENGTH,
   Markdown,
   Mention,
+  NORMAL_STYLE_ID,
   Outline,
+  ParagraphStyles,
   RichClipboard,
   SMILIE_REPLACEMENTS,
+  STYLE_ID_ATTRIBUTE,
   SlashCommands,
   SmilieReplacer,
+  StyleRegistry,
   TableOfContents,
   TemplateSuggestions,
   ZipArchive,
@@ -82,6 +89,7 @@ import {
   autocorrectPluginKey,
   buildOutlineTree,
   capitalizeSentenceRules,
+  captureSelectionFormat,
   commentsPluginKey,
   compareInEditor,
   compileFindPattern,
@@ -92,8 +100,10 @@ import {
   createImportContext,
   createMentionExtension,
   createOutlineStore,
+  createParagraphStylesStore,
   createRichTextPreset,
   createSearchBudget,
+  createStyleRegistry,
   crossReferencePluginKey,
   defaultAutocorrectRules,
   defaultImportRegistry,
@@ -125,7 +135,10 @@ import {
   getFindReplaceStore,
   getFootnotes,
   getImportAccept,
+  getMentionNodes,
   getOutline,
+  getParagraphStyleAt,
+  getStyleRegistry,
   getTableOfContentsEntries,
   handleImageInsertion,
   htmlImportAdapter,
@@ -136,10 +149,13 @@ import {
   insertImageNode,
   insertImportedDocument,
   isInsidePromptToken,
+  isParagraphStyleAvailable,
   isUnsafeZipPath,
+  isValidStyleId,
   markdownImportAdapter,
   navigateToHeading,
   outlinePluginKey,
+  paragraphStylesPluginKey,
   parseReplacement,
   plainTextImportAdapter,
   readZip,
@@ -147,7 +163,9 @@ import {
   removeImageNode,
   richClipboardPluginKey,
   rtfImportAdapter,
+  safeCSSValue,
   searchDocument,
+  setMentionRoleAt,
   smartQuoteRules,
   smilieAutocorrectRules,
   symbolRules,
@@ -160,13 +178,13 @@ import {
   validateFindPattern,
   writeRichClipboard,
   zipCrc32
-} from "./chunk-ITBSKI26.js";
+} from "./chunk-IXHSYOVY.js";
 import {
   compareDocuments,
   compareHtml,
   diffChanges,
   diffSequences
-} from "./chunk-FODNLX5N.js";
+} from "./chunk-NAXVVS5I.js";
 import {
   INSTRUCTION_REGEX,
   TEMPLATE_REGEX,
@@ -201,20 +219,37 @@ import {
   rtfToPlainText,
   sanitizeImportedHtml,
   serializeRichClipboardPayload
-} from "./chunk-3LV6RRPH.js";
+} from "./chunk-QGYDWPRM.js";
 import {
+  CONDITIONAL_FORMAT_ICON_SETS,
+  CONDITIONAL_FORMAT_PRESETS,
+  CONDITIONAL_FORMAT_STYLE_PRESETS,
+  CONDITIONAL_FORMAT_TIME_PERIODS,
+  ConditionalFormatEngine,
+  DATA_VALIDATION_ERROR_STYLE_OPTIONS,
+  DATA_VALIDATION_OPERATOR_OPTIONS,
+  DATA_VALIDATION_TYPE_OPTIONS,
   DEFAULT_COLUMN_WIDTH,
+  DEFAULT_CONDITIONAL_FORMAT_STYLE,
+  DEFAULT_DATA_VALIDATION_MESSAGE,
+  DEFAULT_DATA_VALIDATION_TITLE,
   DEFAULT_ROW_HEIGHT,
   DataSourceBinder,
   DependencyGraph,
+  EMPTY_CONDITIONAL_FORMAT_OVERLAY,
+  MAX_DEFINED_NAME_LENGTH,
+  MAX_SHEET_NAME_LENGTH,
   NUMBER_FORMAT_PRESETS,
   SPREADSHEET_CLIPBOARD_MIME,
   SPREADSHEET_IMPORT_ADAPTERS,
   SPREADSHEET_TABLE_ACTIONS,
   SpreadsheetController,
+  adjustRangeForStructuralChange,
+  adjustRangesForStructuralChange,
   aggregateValues,
   applyFormulaSuggestion,
   bindSpreadsheetTableActions,
+  blendConditionalFormatColors,
   buildSpreadsheetView,
   cellFormatForNumberFormat,
   clampMenuPosition,
@@ -222,44 +257,86 @@ import {
   compareCellValues,
   computeFillTarget,
   computeRowGroups,
+  conditionalFormatContrastColor,
+  conditionalFormatIconCount,
+  conditionalFormatNumber,
+  conditionalFormatStyleString,
+  copySheetName,
+  createConditionalFormatRule,
   createSpreadsheetClipboardData,
   csvImportAdapter,
+  defaultIconThresholds,
+  deleteSheetInFormula,
+  describeConditionalFormat,
+  describeDataValidation,
+  evaluateConditionalFormats,
   extractCellDependencies,
+  extractNameDependencies,
   fillSeries,
+  findDataValidation,
+  findInvalidCells,
+  forEachRangeCell,
   formatCellDisplay,
   formatCellForDisplay,
+  formatRuleRanges,
+  formatSheetPrefix,
   formatValueWithCode,
+  formulaIdentifiers,
+  getConditionalFormatCss,
+  getConditionalFormatIcon,
+  getDataBarCss,
   getFillDirection,
   getFormulaCaretContext,
   getFormulaHints,
+  getNameManagerRows,
   getRowSection,
+  getSheetTabMenuItems,
   getSpreadsheetMenuItems,
   getTableSections,
+  getValidationListValues,
   importFileIntoSpreadsheet,
   isBlankValue,
   isGeneralNumberFormat,
+  isLambdaDefinition,
   isSingleCellRange,
   mapFormulaReferences,
   matchesFilterRule,
+  matchesTimePeriod,
+  nextSheetName,
   normalizeRange,
   numberFormatForCellFormat,
   offsetFormulaReferences,
   parseHtmlTable,
+  parseRuleRanges,
+  quoteSheetName,
   rangeContains,
   rangeContainsRange,
+  rangesContain,
   rangesIntersect,
   readSpreadsheetClipboard,
   rebaseClipboardRows,
   registerSpreadsheetImportAdapters,
   remapFormulaReferences,
+  renameNameInFormula,
+  renameSheetInFormula,
   roundFloat,
   rowPassesFilters,
+  ruleAnchor,
+  ruleFormulaAt,
   runSpreadsheetMenuItem,
   serializeHtmlTable,
+  sheetDropIndex,
+  sheetNameNeedsQuotes,
   shiftFormulaReferences,
+  shiftRuleFormula,
+  subtractRange,
+  subtractRangeFromRanges,
   toNumber,
-  tsvImportAdapter
-} from "./chunk-U5KWZU4X.js";
+  tsvImportAdapter,
+  validateCellInput,
+  validateDefinedName,
+  validateSheetName
+} from "./chunk-RR7F5GUM.js";
 import {
   escapeCsvField,
   parseCsv,
@@ -278,7 +355,6 @@ import {
 } from "./chunk-2H7ZHPEJ.js";
 import {
   MARKDOWN_MENTION_SPLIT_REGEX,
-  MENTION_REGEX,
   escapeHtml,
   extractMentions,
   extractMentionsFromDoc,
@@ -293,13 +369,22 @@ import {
   preprocessMarkdownMentions,
   sanitizeHtml,
   stripMarkdownCode
-} from "./chunk-PGNZKFQS.js";
+} from "./chunk-ECCCYKGL.js";
+import {
+  MENTION_REGEX,
+  findTextMentions,
+  formatMentionText,
+  setMentionRoleInText
+} from "./chunk-O5RYH2PG.js";
 import {
   BLOCK_CHANGE_ATTRIBUTE,
   CommentStore,
   DELETION_MARK_NAME,
   FORMAT_CHANGE_MARK_NAME,
   INSERTION_MARK_NAME,
+  MOVE_FROM_CLASS,
+  MOVE_ID_ATTRIBUTE,
+  MOVE_TO_CLASS,
   TRACK_CHANGES_SKIP_META,
   TrackChanges,
   TrackChangesStore,
@@ -314,15 +399,19 @@ import {
   getTrackChangesStore,
   getTrackedChangeAt,
   getTrackedChanges,
+  isMoveSized,
   isTrackChangesEnabled,
   resolveTrackedChanges,
-  trackChangesPluginKey
-} from "./chunk-5S3Z4PPF.js";
+  trackChangesPluginKey,
+  trackedChangeLabel
+} from "./chunk-UAKDG62Z.js";
 import {
   FORMULA_ERRORS,
   FormulaEvaluator,
+  FormulaLambda,
   FormulaParser,
   MAX_FORMULA_ARRAY_SIZE,
+  MAX_LAMBDA_DEPTH,
   MAX_NUMBER_FORMAT_CODE_CHARS,
   NumberFormat,
   WHOLE_COLUMN_END_ROW,
@@ -344,6 +433,7 @@ import {
   getFormulaSignatureParts,
   indexToColName,
   isFormulaError,
+  isFormulaLambda,
   listFormulaFunctions,
   numberFormatColorToCss,
   numberToText,
@@ -360,7 +450,7 @@ import {
   tokenizeFormula,
   unregisterFormulaFunction,
   wildcardToRegExp
-} from "./chunk-3CN2WD3X.js";
+} from "./chunk-FH6F67DN.js";
 
 // src/controller.ts
 import { Editor } from "@tiptap/core";
@@ -600,10 +690,1026 @@ var FileImportController = class {
 function createFileImportController(getTarget, options) {
   return new FileImportController(getTarget, options);
 }
+function summarizeImportStructure(outcomes) {
+  const reports = outcomes.map((outcome) => outcome.result?.structure).filter((report) => !!report);
+  if (!reports.length) return null;
+  const modes = new Set(reports.map((report) => report.mode));
+  const sum = (pick) => reports.reduce((total, report) => total + pick(report), 0);
+  return {
+    files: reports.length,
+    mode: modes.size > 1 ? "mixed" : reports[0].mode,
+    headings: sum((r) => r.counts.headings),
+    lists: sum((r) => r.counts.lists),
+    tables: sum((r) => r.counts.tables),
+    paragraphs: sum((r) => r.counts.paragraphs),
+    multiColumnPages: sum((r) => r.multiColumnPages),
+    confidence: Math.round(sum((r) => r.confidence) / reports.length * 100) / 100
+  };
+}
+
+// src/import/pdf-layout.ts
+var MAX_COLS = 63;
+var MAX_TABLE_ROWS = 2e3;
+var MAX_RULES = 2e3;
+var MAX_DEPTH = 4;
+var BULLET_GLYPH_RE = /^[•◦▪▫●○■□‣⁃∙·➢►▶✓✔❖]\s*/;
+var BULLET_DASH_RE = /^[-–—*]\s+/;
+var ORDERED_RE = /^(?:\((\d{1,3}|[a-zA-Z]|[ivxlcIVXLC]{1,6})\)|(\d{1,3}|[a-zA-Z]|[ivxlcIVXLC]{1,6})[.)])\s+/;
+var MARKER_ONLY_RE = /^(?:[•◦▪▫●○■□‣⁃∙·➢►▶✓✔❖]|\(?(?:\d{1,3}|[a-zA-Z]|[ivxlcIVXLC]{1,6})[.)])$/;
+var PAGE_NUMBER_RE = /^(?:page\s+)?(?:\d{1,4}|[ivxlcdm]{1,7})(?:\s*(?:of|\/)\s*\d{1,4})?$/i;
+var DASHED_PAGE_NUMBER_RE = /^[-–—]\s*\d{1,4}\s*[-–—]$/;
+var SENTENCE_END_RE = /[.!?:;]["'”’)\]]?$/;
+var BOLD_FONT_RE = /bold|black|heavy|semibold|demi/i;
+var ITALIC_FONT_RE = /italic|oblique/i;
+function minOf(list, fn) {
+  let min = Infinity;
+  for (const item of list) min = Math.min(min, fn(item));
+  return min;
+}
+function maxOf(list, fn) {
+  let max = -Infinity;
+  for (const item of list) max = Math.max(max, fn(item));
+  return max;
+}
+function lowerBound(values, target) {
+  let lo = 0;
+  let hi = values.length;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    if (values[mid] < target) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
+function median(values) {
+  if (!values.length) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = sorted.length >> 1;
+  return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+var countWords = (text) => {
+  let words = 0;
+  let inWord = false;
+  for (let i = 0; i < text.length; i++) {
+    const space = text.charCodeAt(i) <= 32;
+    if (!space && !inWord) words++;
+    inWord = !space;
+  }
+  return words;
+};
+var collapse = (text) => text.replace(/\s+/g, " ").trim();
+function runSize(run) {
+  if (run.fontSize && run.fontSize > 0) return run.fontSize;
+  if (run.height && run.height > 0) return run.height;
+  return 10;
+}
+function buildFragments(runs) {
+  const items = runs.filter((run) => typeof run.text === "string" && run.text.trim() !== "" && Number.isFinite(run.x) && Number.isFinite(run.y)).map((run) => {
+    const size = runSize(run);
+    const width = run.width !== void 0 && run.width >= 0 ? run.width : run.text.length * size * 0.5;
+    return {
+      text: run.text,
+      x0: run.x,
+      x1: run.x + width,
+      y: run.y,
+      size,
+      bold: run.bold ?? BOLD_FONT_RE.test(run.fontName ?? ""),
+      italic: run.italic ?? ITALIC_FONT_RE.test(run.fontName ?? "")
+    };
+  });
+  items.sort((a, b) => b.y - a.y || a.x0 - b.x0);
+  const frags = [];
+  let i = 0;
+  while (i < items.length) {
+    const anchor = items[i];
+    let j = i + 1;
+    while (j < items.length && anchor.y - items[j].y <= Math.max(1, Math.min(anchor.size, items[j].size) * 0.5)) j++;
+    const row = items.slice(i, j).sort((a, b) => a.x0 - b.x0);
+    i = j;
+    let current = null;
+    const finish = () => {
+      if (!current) return;
+      let best = "";
+      let bestChars = -1;
+      current.styleChars.forEach((chars, key) => {
+        if (chars > bestChars) {
+          best = key;
+          bestChars = chars;
+        }
+      });
+      const [size, bold, italic] = best.split("|");
+      current.size = Number(size);
+      current.bold = bold === "1";
+      current.italic = italic === "1";
+      current.text = collapse(current.text);
+      current.words = countWords(current.text);
+      current.top = current.y + current.size * 0.8;
+      current.bottom = current.y - current.size * 0.2;
+      if (current.text) frags.push(current);
+      current = null;
+    };
+    for (const item of row) {
+      if (current) {
+        const gap = item.x0 - current.x1;
+        const em = Math.max(current.size, item.size);
+        const markerOnly = MARKER_ONLY_RE.test(collapse(current.text));
+        if (gap > em * (markerOnly ? 6 : 1)) finish();
+      }
+      if (!current) {
+        current = {
+          text: item.text,
+          x0: item.x0,
+          x1: item.x1,
+          y: item.y,
+          top: 0,
+          bottom: 0,
+          size: item.size,
+          bold: item.bold,
+          italic: item.italic,
+          words: 0,
+          styleChars: /* @__PURE__ */ new Map()
+        };
+      } else {
+        const gap = item.x0 - current.x1;
+        if (gap > Math.max(current.size, item.size) * 0.15 && !/\s$/.test(current.text) && !/^\s/.test(item.text)) {
+          current.text += " ";
+        }
+        current.text += item.text;
+        current.x1 = Math.max(current.x1, item.x1);
+      }
+      const key = `${Math.round(item.size * 2) / 2}|${item.bold ? 1 : 0}|${item.italic ? 1 : 0}`;
+      current.styleChars.set(key, (current.styleChars.get(key) ?? 0) + item.text.trim().length);
+    }
+    finish();
+  }
+  return frags;
+}
+function baselineRows(frags) {
+  const rows = [];
+  for (const frag of frags) {
+    const row = rows[rows.length - 1];
+    if (row && Math.abs(row[0].y - frag.y) <= Math.max(1, Math.min(row[0].size, frag.size) * 0.5)) row.push(frag);
+    else rows.push([frag]);
+  }
+  return rows;
+}
+var edgeKey = (row) => collapse(row.map((f) => f.text).join(" ")).toLowerCase().replace(/\d+/g, "#");
+function removeHeadersAndFooters(pages) {
+  const removed = { headers: 0, footers: 0, pageNumbers: 0 };
+  const pageRows = pages.map((frags) => baselineRows([...frags].sort((a, b) => b.y - a.y || a.x0 - b.x0)));
+  const counts = /* @__PURE__ */ new Map();
+  const candidates = [];
+  pageRows.forEach((rows, page) => {
+    const n = rows.length;
+    const picks = [];
+    for (let k = 0; k < Math.min(2, n); k++) picks.push([k, "top"]);
+    for (let k = Math.max(Math.min(2, n), n - 2); k < n; k++) picks.push([k, "bottom"]);
+    for (const [index, edge] of picks) {
+      const row = rows[index];
+      const extreme = edge === "top" ? index === 0 : index === n - 1;
+      const neighbour = edge === "top" ? rows[index + 1] : rows[index - 1];
+      const gap = neighbour ? Math.abs(row[0].y - neighbour[0].y) / row[0].size : Infinity;
+      candidates.push({ page, row, edge, extreme, gap });
+      const key = `${edge}:${edgeKey(row)}`;
+      if (!counts.has(key)) counts.set(key, /* @__PURE__ */ new Set());
+      counts.get(key).add(page);
+    }
+  });
+  const minPages = Math.max(2, Math.ceil(pages.length * 0.5));
+  const drop = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    const text = collapse(candidate.row.map((f) => f.text).join(" "));
+    const isPageNumber = candidate.extreme && (PAGE_NUMBER_RE.test(text) || DASHED_PAGE_NUMBER_RE.test(text));
+    const repeated = (counts.get(`${candidate.edge}:${edgeKey(candidate.row)}`)?.size ?? 0) >= minPages;
+    let kind = null;
+    if (isPageNumber && (pages.length > 1 || candidate.gap > 2.5)) kind = "pageNumbers";
+    else if (repeated && pages.length > 1) kind = candidate.edge === "top" ? "headers" : "footers";
+    if (!kind || candidate.row.some((f) => drop.has(f))) continue;
+    candidate.row.forEach((f) => drop.add(f));
+    removed[kind]++;
+  }
+  if (drop.size) {
+    pages.forEach((frags, index) => {
+      pages[index] = frags.filter((f) => !drop.has(f));
+    });
+  }
+  return removed;
+}
+function splitRules(rules) {
+  const h = [];
+  const v = [];
+  for (const rule of rules.slice(0, MAX_RULES)) {
+    const { x1, y1, x2, y2 } = rule;
+    if (![x1, y1, x2, y2].every(Number.isFinite)) continue;
+    const dx = Math.abs(x2 - x1);
+    const dy = Math.abs(y2 - y1);
+    if (dy <= 1.5 && dx >= 6) h.push({ y: (y1 + y2) / 2, x0: Math.min(x1, x2), x1: Math.max(x1, x2) });
+    else if (dx <= 1.5 && dy >= 6) v.push({ x: (x1 + x2) / 2, y0: Math.min(y1, y2), y1: Math.max(y1, y2) });
+  }
+  return { h, v };
+}
+function clusterValues(values, tol) {
+  const sorted = [...values].sort((a, b) => a - b);
+  const out = [];
+  for (const value of sorted) {
+    const cluster = out[out.length - 1];
+    if (cluster && value - cluster.last <= tol) {
+      cluster.sum += value;
+      cluster.n++;
+      cluster.last = value;
+    } else out.push({ sum: value, n: 1, last: value });
+  }
+  return out.map((c) => c.sum / c.n);
+}
+function find(parent, i) {
+  while (parent[i] !== i) {
+    parent[i] = parent[parent[i]];
+    i = parent[i];
+  }
+  return i;
+}
+var cellText = (frags, dehyphenate, stats) => {
+  const sorted = [...frags].sort((a, b) => b.y - a.y || a.x0 - b.x0);
+  let text = "";
+  let lastY = Infinity;
+  for (const frag of sorted) {
+    if (!text) text = frag.text;
+    else if (Math.abs(lastY - frag.y) > frag.size * 0.5) text = joinLines(text, frag.text, dehyphenate, stats);
+    else text += ` ${frag.text}`;
+    lastY = frag.y;
+  }
+  return collapse(text);
+};
+var NUMERIC_RE = /^[-+−(]?[$€£¥]?\s?\d[\d,.\s]*%?\)?$/;
+function headerRowCount(rowFrags) {
+  if (rowFrags.length < 2) return 0;
+  const cells = (row) => row.filter((cell) => cell.length > 0);
+  const first = cells(rowFrags[0]);
+  if (!first.length) return 0;
+  const rest = rowFrags.slice(1).flatMap(cells);
+  const allBold = (list) => list.length > 0 && list.every((cell) => cell.every((f) => f.bold));
+  if (allBold(first) && !allBold(rest)) return 1;
+  const numeric = (cell) => NUMERIC_RE.test(collapse(cell.map((f) => f.text).join(" ")));
+  if (first.every((cell) => !numeric(cell))) {
+    const columns = rowFrags[0].length;
+    for (let c = 0; c < columns; c++) {
+      const body = rowFrags.slice(1).map((row) => row[c]).filter((cell) => cell && cell.length > 0);
+      if (rowFrags[0][c].length && body.length >= 2 && body.every(numeric)) return 1;
+    }
+  }
+  const firstSize = maxOf(first.flat(), (f) => f.size);
+  const restSize = median(rest.flat().map((f) => f.size));
+  if (restSize > 0 && firstSize >= restSize * 1.1) return 1;
+  return 0;
+}
+function ruledTables(frags, rules, page, dehyphenate, stats) {
+  const consumed = /* @__PURE__ */ new Set();
+  const atoms = [];
+  const { h, v } = splitRules(rules);
+  if (h.length < 2) return { atoms, consumed };
+  const n = h.length + v.length;
+  const parent = Array.from({ length: n }, (_, i) => i);
+  const union = (a, b) => {
+    const ra = find(parent, a);
+    const rb = find(parent, b);
+    if (ra !== rb) parent[ra] = rb;
+  };
+  const tol = 2;
+  const vOrder = v.map((_, i) => i).sort((a, b) => v[a].x - v[b].x);
+  const vxs = vOrder.map((i) => v[i].x);
+  h.forEach((seg, hi) => {
+    let lo = 0;
+    let hiIdx = vxs.length;
+    while (lo < hiIdx) {
+      const mid = lo + hiIdx >> 1;
+      if (vxs[mid] < seg.x0 - tol) lo = mid + 1;
+      else hiIdx = mid;
+    }
+    for (let k = lo; k < vxs.length && vxs[k] <= seg.x1 + tol; k++) {
+      const vs = v[vOrder[k]];
+      if (seg.y >= vs.y0 - tol && seg.y <= vs.y1 + tol) union(hi, h.length + vOrder[k]);
+    }
+  });
+  const hOrder = h.map((_, i) => i).sort((a, b) => h[a].x0 - h[b].x0 || h[a].x1 - h[b].x1 || h[b].y - h[a].y);
+  for (let k = 1; k < hOrder.length; k++) {
+    const a = h[hOrder[k - 1]];
+    const b = h[hOrder[k]];
+    if (Math.abs(a.x0 - b.x0) <= 4 && Math.abs(a.x1 - b.x1) <= 4) union(hOrder[k - 1], hOrder[k]);
+  }
+  const groups = /* @__PURE__ */ new Map();
+  h.forEach((seg, i) => {
+    const root = find(parent, i);
+    if (!groups.has(root)) groups.set(root, { h: [], v: [] });
+    groups.get(root).h.push(seg);
+  });
+  v.forEach((seg, i) => {
+    const root = find(parent, h.length + i);
+    groups.get(root)?.v.push(seg);
+  });
+  const byY = [...frags].sort((a, b) => a.y - b.y);
+  const ys = byY.map((f) => f.y);
+  const inRange = (y0, y1) => {
+    let lo = 0;
+    let hi = ys.length;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (ys[mid] < y0) lo = mid + 1;
+      else hi = mid;
+    }
+    const out = [];
+    for (let k = lo; k < ys.length && ys[k] <= y1; k++) out.push(byY[k]);
+    return out;
+  };
+  groups.forEach((group) => {
+    const hys = clusterValues(group.h.map((s) => s.y), 1.5).sort((a, b) => b - a);
+    if (hys.length < 2) return;
+    const x0 = Math.min(...group.h.map((s) => s.x0), ...group.v.map((s) => s.x));
+    const x1 = Math.max(...group.h.map((s) => s.x1), ...group.v.map((s) => s.x));
+    const top = Math.max(hys[0], ...group.v.map((s) => s.y1));
+    const bottom = Math.min(hys[hys.length - 1], ...group.v.map((s) => s.y0));
+    const inside = inRange(bottom, top).filter((f) => {
+      if (consumed.has(f)) return false;
+      const cx = (f.x0 + f.x1) / 2;
+      return cx >= x0 - 1 && cx <= x1 + 1;
+    });
+    if (inside.length < 2) return;
+    const vxsGroup = clusterValues(group.v.map((s) => s.x), 1.5);
+    let table = null;
+    if (vxsGroup.length >= 3 || vxsGroup.length >= 2 && hys.length >= 3 && vxsGroup.some((x) => x > x0 + 4 && x < x1 - 4)) {
+      table = gridTable(inside, group, hys, vxsGroup, x0, x1, top, bottom, page, dehyphenate, stats);
+    }
+    if (!table) {
+      const result = alignedTable(inside, page, 2, dehyphenate, stats, hys.length >= 3 ? hys[1] : void 0);
+      if (result && !result.leftover.length && !result.before.length) table = { ...result.table, ruled: true, confidence: 0.85 };
+    }
+    if (!table) return;
+    inside.forEach((f) => consumed.add(f));
+    atoms.push({
+      text: "",
+      x0,
+      x1,
+      y: bottom,
+      top,
+      bottom,
+      size: median(inside.map((f) => f.size)),
+      bold: false,
+      italic: false,
+      words: 0,
+      table
+    });
+  });
+  return { atoms, consumed };
+}
+function gridTable(inside, group, hys, vxsIn, x0, x1, top, bottom, page, dehyphenate, stats) {
+  const xs = [...vxsIn];
+  if (xs[0] > x0 + 4) xs.unshift(x0);
+  if (xs[xs.length - 1] < x1 - 4) xs.push(x1);
+  const rowsY = [...hys];
+  if (rowsY[0] < top - 4) rowsY.unshift(top);
+  if (rowsY[rowsY.length - 1] > bottom + 4) rowsY.push(bottom);
+  const cols = xs.length - 1;
+  const rows = rowsY.length - 1;
+  if (cols < 2 || rows < 1 || cols > MAX_COLS || rows > MAX_TABLE_ROWS) return null;
+  const grid = Array.from({ length: rows }, () => Array.from({ length: cols }, () => []));
+  const ascRows = [...rowsY].reverse();
+  for (const frag of inside) {
+    const x = frag.x0 + Math.min(2, (frag.x1 - frag.x0) / 2);
+    const c = lowerBound(xs, x + 1e-9) - 1;
+    const yProbe = frag.y + frag.size * 0.3;
+    const r = rows - (lowerBound(ascRows, yProbe + 1e-9) - 1) - 1;
+    if (c >= 0 && c < cols && r >= 0 && r < rows) grid[r][c].push(frag);
+  }
+  const filled = grid.flat().filter((cell) => cell.length).length;
+  if (filled < 2 || rows < 2 && cols < 2) return null;
+  const vAt = xs.map(() => []);
+  for (const seg of group.v) {
+    const k = lowerBound(xs, seg.x - 2);
+    if (k < xs.length && Math.abs(xs[k] - seg.x) <= 2) vAt[k].push(seg);
+  }
+  const hAt = rowsY.map(() => []);
+  for (const seg of group.h) {
+    const k = rows - lowerBound(ascRows, seg.y - 2);
+    if (k >= 0 && k <= rows && Math.abs(rowsY[k] - seg.y) <= 2) hAt[k].push(seg);
+  }
+  const hasV = (k, y) => vAt[k].some((s) => y >= s.y0 - 2 && y <= s.y1 + 2);
+  const hasH = (k, x) => hAt[k].some((s) => x >= s.x0 - 2 && x <= s.x1 + 2);
+  const covered = grid.map((row) => row.map(() => false));
+  const header = headerRowCount(grid);
+  const out = [];
+  for (let r = 0; r < rows; r++) {
+    const midY = (rowsY[r] + rowsY[r + 1]) / 2;
+    const row = [];
+    for (let c = 0; c < cols; c++) {
+      if (covered[r][c]) continue;
+      let colSpan = 1;
+      while (c + colSpan < cols && !hasV(c + colSpan, midY) && !grid[r][c + colSpan].length && !covered[r][c + colSpan]) colSpan++;
+      let rowSpan = 1;
+      const midX = (xs[c] + xs[c + colSpan]) / 2;
+      while (r + rowSpan < rows && !hasH(r + rowSpan, midX) && !covered[r + rowSpan].slice(c, c + colSpan).some(Boolean) && grid[r + rowSpan].slice(c, c + colSpan).every((cell) => !cell.length)) {
+        rowSpan++;
+      }
+      for (let rr = r; rr < r + rowSpan; rr++) for (let cc = c; cc < c + colSpan; cc++) covered[rr][cc] = true;
+      row.push({ text: cellText(grid[r][c], dehyphenate, stats), colSpan, rowSpan, header: r < header });
+    }
+    out.push(row);
+  }
+  return { type: "table", page, confidence: 0.95, ruled: true, rows: out, columns: cols, headerRows: header };
+}
+function alignedTable(frags, page, minRows, dehyphenate, stats, headerRuleY) {
+  const sorted = [...frags].sort((a, b) => b.y - a.y || a.x0 - b.x0);
+  let rows = baselineRows(sorted).map((row) => row.sort((a, b) => a.x0 - b.x0));
+  if (rows.length < minRows) return null;
+  const multi = rows.filter((row) => row.length >= 2);
+  if (multi.length < Math.min(minRows, 2)) return null;
+  const spans = multi.flat().map((f) => [f.x0, f.x1]).sort((a, b) => a[0] - b[0]);
+  const merged = [];
+  for (const [a, b] of spans) {
+    const last = merged[merged.length - 1];
+    if (last && a <= last[1] + 1) last[1] = Math.max(last[1], b);
+    else merged.push([a, b]);
+  }
+  if (merged.length < 2 || merged.length > MAX_COLS) return null;
+  const edges = merged.map((m) => m[0]);
+  const cols = merged.length;
+  const colOf = (x) => {
+    let c = 0;
+    while (c + 1 < cols && x >= merged[c + 1][0] - 1) c++;
+    return c;
+  };
+  const spanOf = (f, c) => {
+    let span = 1;
+    while (c + span < cols && f.x1 > merged[c + span][0] + 2) span++;
+    return span;
+  };
+  const rowIsCells = (row) => {
+    if (row.length >= 2) return true;
+    const f = row[0];
+    const c = colOf(f.x0);
+    return spanOf(f, c) >= 2 && f.words <= 8 && Math.abs(f.x0 - edges[c]) <= Math.max(4, f.size * 0.6);
+  };
+  const before = [];
+  const leftover = [];
+  let first = 0;
+  let end = rows.length;
+  while (first < end && !rowIsCells(rows[first])) first++;
+  while (end > first && !rowIsCells(rows[end - 1])) end--;
+  rows.slice(0, first).forEach((row) => before.push(...row));
+  rows.slice(end).forEach((row) => leftover.push(...row));
+  rows = rows.slice(first, end);
+  if (rows.length < minRows || rows.length > MAX_TABLE_ROWS) return null;
+  const grid = [];
+  const spansGrid = [];
+  let prevRow = null;
+  for (const row of rows) {
+    const cells = Array.from({ length: cols }, () => []);
+    const spanRow = Array.from({ length: cols }, () => 1);
+    for (const f of row) {
+      const c = colOf(f.x0);
+      cells[c].push(f);
+      spanRow[c] = Math.max(spanRow[c], row.length === 1 ? spanOf(f, c) : 1);
+    }
+    const continuation = prevRow !== null && grid.length > 0 && cells[0].length === 0 && grid[grid.length - 1][0].length > 0 && cells.every((cell, c) => !cell.length || grid[grid.length - 1][c].length > 0) && minOf(prevRow, (f) => f.bottom) - maxOf(row, (f) => f.top) < row[0].size * 0.5;
+    if (continuation) {
+      cells.forEach((cell, c) => grid[grid.length - 1][c].push(...cell));
+    } else {
+      grid.push(cells);
+      spansGrid.push(spanRow);
+    }
+    prevRow = row;
+  }
+  if (grid.length < minRows) return null;
+  const full = grid.filter((cells) => cells.filter((c) => c.length).length >= 2).length;
+  if (full / grid.length < 0.6) return null;
+  const cellsWithText = grid.flat().filter((c) => c.length);
+  const meanWords = cellsWithText.reduce((sum, cell) => sum + cell.reduce((s, f) => s + f.words, 0), 0) / cellsWithText.length;
+  if (meanWords > 12) return null;
+  let header = headerRowCount(grid);
+  if (headerRuleY !== void 0) {
+    const above = rows.filter((row) => row[0].y > headerRuleY).length;
+    if (above > 0 && above < grid.length) header = Math.max(header, Math.min(above, grid.length - 1));
+  }
+  const out = grid.map((cells, r) => {
+    const row = [];
+    for (let c = 0; c < cols; ) {
+      const span = Math.min(spansGrid[r][c], cols - c);
+      row.push({ text: cellText(cells[c], dehyphenate, stats), colSpan: span, rowSpan: 1, header: r < header });
+      c += span;
+    }
+    return row;
+  });
+  const confidence = Math.min(
+    0.9,
+    0.5 + (grid.length >= 5 ? 0.1 : 0) + (cols >= 3 ? 0.1 : 0) + 0.2 * (full / grid.length) - (cols === 2 ? 0.05 : 0)
+  );
+  return {
+    table: { type: "table", page, confidence, ruled: false, rows: out, columns: cols, headerRows: header },
+    leftover,
+    before
+  };
+}
+function readingOrder(items, body, detectColumns, depth, columnPages) {
+  const byTop = [...items].sort((a, b) => b.top - a.top || a.x0 - b.x0);
+  if (!detectColumns || items.length < 2 || depth > MAX_DEPTH) return [{ kind: "flow", items: byTop }];
+  const left = minOf(items, (f) => f.x0);
+  const right = maxOf(items, (f) => f.x1);
+  const width = right - left;
+  const isNarrow = (f) => f.x1 - f.x0 < width * 0.55;
+  const narrow = items.filter(isNarrow);
+  const minGutter = Math.max(body * 0.9, 6);
+  const allowed = Math.max(1, Math.floor(narrow.length * 0.08));
+  const events = [];
+  for (const f of narrow) events.push([f.x0, 1], [f.x1, -1]);
+  events.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+  const candidates = [];
+  let depthNow = 0;
+  let seenContent = false;
+  let start = null;
+  for (const [x, delta] of events) {
+    depthNow += delta;
+    if (depthNow > allowed) {
+      if (start !== null && seenContent && x - start >= minGutter) candidates.push([start, x]);
+      start = null;
+      seenContent = true;
+    } else if (start === null) start = x;
+  }
+  const ends = narrow.map((f) => f.x1).sort((a, b) => a - b);
+  const starts = narrow.map((f) => f.x0).sort((a, b) => a - b);
+  const gutters = [];
+  for (const [a, b] of candidates) {
+    const endBelow = lowerBound(ends, b) - 1;
+    const left2 = endBelow >= 0 && ends[endBelow] > a ? ends[endBelow] : a;
+    const startAbove = lowerBound(starts, a + 1e-9);
+    const right2 = startAbove < starts.length && starts[startAbove] < b ? starts[startAbove] : b;
+    if (right2 - left2 < minGutter) continue;
+    const onLeft = lowerBound(ends, left2 + 1e-6);
+    const onRight = starts.length - lowerBound(starts, right2 - 1e-6);
+    const strays = narrow.length - onLeft - onRight;
+    if (strays < Math.min(onLeft, onRight)) gutters.push([left2, right2]);
+  }
+  if (!gutters.length) return [{ kind: "flow", items: byTop }];
+  const gutterEnds = gutters.map((g) => g[1]);
+  const crosses = (f) => {
+    const k = lowerBound(gutterEnds, f.x0 + 1 + 1e-9);
+    return k < gutters.length && f.x1 > gutters[k][0] + 1 && f.x0 < gutters[k][1] - 1;
+  };
+  const columnOf = (f) => lowerBound(gutterEnds, f.x0 + 1 + 1e-9);
+  const bands = [];
+  for (const f of byTop) {
+    const spanning = crosses(f);
+    const band = bands[bands.length - 1];
+    if (band && band.spanning === spanning) band.items.push(f);
+    else bands.push({ spanning, items: [f] });
+  }
+  const segments = [];
+  let sealed = false;
+  const pushFlow = (list) => {
+    if (!list.length) return;
+    const last = segments[segments.length - 1];
+    if (last && last.kind === "flow" && !sealed) last.items.push(...list);
+    else segments.push({ kind: "flow", items: list });
+    sealed = false;
+  };
+  let multiColumn = false;
+  const isShortSpan = (f) => !f.table && isNarrow(f) && f.words <= 8;
+  for (const band of bands) {
+    const last = segments[segments.length - 1];
+    if (band.spanning) {
+      const lead = band.items[0];
+      if (last && last.kind === "grid" && isShortSpan(lead) && minOf(last.items, (f) => f.bottom) - lead.top <= lead.size * 2) {
+        last.items.push(lead);
+        pushFlow(band.items.slice(1));
+      } else pushFlow(band.items);
+      continue;
+    }
+    const columns = Array.from({ length: gutters.length + 1 }, () => []);
+    band.items.forEach((f) => columns[columnOf(f)].push(f));
+    const used = columns.filter((c) => c.length);
+    if (used.length < 2) {
+      pushFlow(band.items);
+      continue;
+    }
+    const prose = used.every((col) => {
+      const text = col.filter((f) => !f.table);
+      if (text.length < 2) return text.length === 0;
+      const colLeft = minOf(text, (f) => f.x0);
+      const colRight = maxOf(text, (f) => f.x1);
+      const fill = text.reduce((sum, f) => sum + (f.x1 - f.x0), 0) / text.length / Math.max(1, colRight - colLeft);
+      const words = text.reduce((sum, f) => sum + f.words, 0) / text.length;
+      return fill >= 0.55 && words >= 3;
+    });
+    const tops = used.map((col) => [minOf(col, (f) => f.bottom), maxOf(col, (f) => f.top)]);
+    const overlapping = tops.every(([b, t], i) => i === 0 || Math.min(t, tops[0][1]) - Math.max(b, tops[0][0]) > 0);
+    if (prose && overlapping) {
+      multiColumn = true;
+      for (const col of used) segments.push(...readingOrder(col, body, detectColumns, depth + 1, columnPages));
+      sealed = true;
+      continue;
+    }
+    const pulled = [];
+    if (last && last.kind === "flow" && !sealed) {
+      const tail = last.items[last.items.length - 1];
+      if (isShortSpan(tail) && tail.bottom - maxOf(band.items, (f) => f.top) <= tail.size * 2) {
+        pulled.push(last.items.pop());
+        if (!last.items.length) segments.pop();
+      }
+    }
+    const prevSegment = segments[segments.length - 1];
+    if (prevSegment && prevSegment.kind === "grid" && (pulled.length || prevSegment === last)) {
+      prevSegment.items.push(...pulled, ...band.items);
+    } else segments.push({ kind: "grid", items: [...pulled, ...band.items] });
+    sealed = false;
+  }
+  if (multiColumn && depth === 0) columnPages.count++;
+  return segments;
+}
+function flowLines(items, page) {
+  const lines = [];
+  const sorted = [...items].sort((a, b) => b.top - a.top || a.x0 - b.x0);
+  for (const f of sorted) {
+    if (f.table) {
+      lines.push({ text: "", x0: f.x0, x1: f.x1, y: f.y, top: f.top, size: f.size, bold: false, page, table: f.table });
+      continue;
+    }
+    const last = lines[lines.length - 1];
+    if (last && !last.table && Math.abs(last.y - f.y) <= Math.min(last.size, f.size) * 0.5) {
+      last.text = `${last.text} ${f.text}`;
+      last.x0 = Math.min(last.x0, f.x0);
+      last.x1 = Math.max(last.x1, f.x1);
+    } else {
+      lines.push({ text: f.text, x0: f.x0, x1: f.x1, y: f.y, top: f.top, size: f.size, bold: f.bold, page });
+    }
+  }
+  return lines;
+}
+function joinLines(prev, next, dehyphenate, stats) {
+  if (prev.endsWith("\xAD")) {
+    stats.dehyphenated++;
+    return prev.slice(0, -1) + next;
+  }
+  if (dehyphenate && /[A-Za-zÀ-ɏ]-$/.test(prev) && /^[a-zß-ɏ]/.test(next)) {
+    stats.dehyphenated++;
+    return prev.slice(0, -1) + next;
+  }
+  return `${prev} ${next}`;
+}
+function listMarker(text) {
+  const glyph = BULLET_GLYPH_RE.exec(text);
+  if (glyph) return { kind: "glyph", rest: text.slice(glyph[0].length), ordered: false };
+  const dash = BULLET_DASH_RE.exec(text);
+  if (dash) return { kind: "dash", rest: text.slice(dash[0].length), ordered: false };
+  const ordered = ORDERED_RE.exec(text);
+  if (ordered) {
+    const token = ordered[1] ?? ordered[2];
+    const kind = /^\d+$/.test(token) ? "num" : /^[ivxlc]{2,}$/i.test(token) || /^i$/i.test(token) ? "roman" : "alpha";
+    return { kind, rest: text.slice(ordered[0].length), ordered: true, value: kind === "num" ? Number(token) : void 0 };
+  }
+  return null;
+}
+function headingStyle(line, next, segRight, ctx) {
+  if (!ctx.options.detectHeadings || line.table) return null;
+  const text = line.text;
+  const words = countWords(text);
+  if (text.length > 200 || words > 25 || !/\p{L}/u.test(text)) return null;
+  if (words > 15 && SENTENCE_END_RE.test(text)) return null;
+  const ratio = line.size / ctx.body;
+  if (ratio >= 1.15) {
+    const confidence = Math.min(0.95, 0.6 + (ratio - 1.15) * 0.8 + (line.bold ? 0.1 : 0));
+    return { key: Math.round(line.size * 2) / 2 + (line.bold ? 0.25 : 0), confidence, boldOnly: false };
+  }
+  const runsOn = !!next && !next.table && next.bold && Math.abs(next.size - line.size) < 0.5 && line.x1 >= segRight - 2 * line.size;
+  if (line.bold && !ctx.boldBody && !runsOn && ratio >= 0.95 && text.length <= 100 && !/[.,;]$/.test(text)) {
+    return { key: Math.round(line.size * 2) / 2 + 0.25, confidence: 0.6, boldOnly: true };
+  }
+  return null;
+}
+function buildBlocks(lines, ctx) {
+  const textLines = lines.filter((l) => !l.table);
+  const segLeft = textLines.length ? minOf(textLines, (l) => l.x0) : 0;
+  const segRight = textLines.length ? maxOf(textLines, (l) => l.x1) : 0;
+  const kindCounts = /* @__PURE__ */ new Map();
+  const markers = lines.map((line) => {
+    if (!ctx.options.detectLists || line.table) return null;
+    const marker = listMarker(line.text);
+    if (marker) kindCounts.set(marker.kind, (kindCounts.get(marker.kind) ?? 0) + 1);
+    return marker;
+  });
+  let list = null;
+  let listStack = [];
+  let lastItemLine = null;
+  let para = null;
+  let heading = null;
+  const closeAll = () => {
+    if (para) {
+      const last = para.lines[para.lines.length - 1];
+      const ended = SENTENCE_END_RE.test(last.text) || last.x1 < segRight - 3 * last.size;
+      ctx.open = ended ? null : { block: para.block, size: last.size, lastText: para.block.text };
+    } else ctx.open = null;
+    para = null;
+    list = null;
+    listStack = [];
+    lastItemLine = null;
+    heading = null;
+  };
+  lines.forEach((line, index) => {
+    const prev = index > 0 ? lines[index - 1] : null;
+    if (line.table) {
+      closeAll();
+      ctx.open = null;
+      ctx.blocks.push(line.table);
+      return;
+    }
+    const style = headingStyle(line, lines[index + 1], segRight, ctx);
+    if (style) {
+      if (heading && heading.key === style.key && heading.lines < 3 && prev === heading.line && prev.y - line.y <= line.size * 1.6) {
+        heading.block.text = joinLines(heading.block.text, line.text, ctx.options.dehyphenate, ctx.stats);
+        heading.line = line;
+        heading.lines++;
+        return;
+      }
+      closeAll();
+      ctx.open = null;
+      const block2 = { type: "heading", level: 1, text: line.text, page: line.page, confidence: style.confidence };
+      ctx.blocks.push(block2);
+      ctx.headings.push({ block: block2, key: style.key, boldOnly: style.boldOnly });
+      heading = { block: block2, line, key: style.key, lines: 1 };
+      return;
+    }
+    heading = null;
+    const marker = markers[index];
+    const validMarker = marker && (marker.kind === "glyph" || (kindCounts.get(marker.kind) ?? 0) >= 2) && marker.rest.trim() !== "";
+    if (validMarker) {
+      const gapOk = lastItemLine && lastItemLine.y - line.y <= Math.max(ctx.pitch(line.size) * 2.2, line.size * 2.4);
+      if (!list || !gapOk) {
+        closeAll();
+        ctx.open = null;
+        list = { type: "list", page: line.page, confidence: 0.6, items: [] };
+        ctx.blocks.push(list);
+        listStack = [line.x0];
+      }
+      const tol = line.size * 0.5;
+      while (listStack.length > 1 && line.x0 < listStack[listStack.length - 1] - tol) listStack.pop();
+      if (line.x0 > listStack[listStack.length - 1] + tol) listStack.push(line.x0);
+      else listStack[listStack.length - 1] = Math.min(listStack[listStack.length - 1], line.x0);
+      const prevDepth = list.items.length ? list.items[list.items.length - 1].depth : -1;
+      const depth = Math.min(listStack.length - 1, prevDepth + 1);
+      const item = {
+        text: collapse(marker.rest),
+        depth,
+        ordered: marker.ordered
+      };
+      if (marker.value !== void 0) item.start = marker.value;
+      list.items.push(item);
+      list.confidence = Math.min(0.95, (marker.kind === "glyph" ? 0.75 : 0.6) + 0.05 * list.items.length);
+      lastItemLine = line;
+      para = null;
+      return;
+    }
+    if (list && lastItemLine && prev) {
+      const markerX = listStack[listStack.length - 1];
+      const continues = line.x0 > markerX + line.size * 0.3 && line.x0 <= markerX + line.size * 5 && prev.y - line.y <= ctx.pitch(line.size) * ctx.options.paragraphGap;
+      if (continues) {
+        const item = list.items[list.items.length - 1];
+        item.text = joinLines(item.text, line.text, ctx.options.dehyphenate, ctx.stats);
+        lastItemLine = line;
+        return;
+      }
+      closeAll();
+    }
+    if (!para && ctx.open && index === 0 && /^[a-z]/.test(line.text) && Math.abs(ctx.open.size - line.size) <= line.size * 0.12) {
+      ctx.open.block.text = joinLines(ctx.open.block.text, line.text, ctx.options.dehyphenate, ctx.stats);
+      para = { block: ctx.open.block, lines: [line] };
+      ctx.open = null;
+      return;
+    }
+    if (para && prev && !prev.table) {
+      const last = para.lines[para.lines.length - 1];
+      const gap = last.y - line.y;
+      const sameSize = Math.abs(last.size - line.size) <= last.size * 0.12;
+      const closeEnough = gap > 0 && gap <= ctx.pitch(line.size) * ctx.options.paragraphGap;
+      const indentEm = line.size * 0.8;
+      const indented = line.x0 - segLeft >= indentEm && last.x0 - segLeft < indentEm && line.x0 - segLeft < line.size * 8;
+      const shortEnded = last.x1 < segRight - 3 * last.size && SENTENCE_END_RE.test(last.text);
+      if (sameSize && closeEnough && !indented && !shortEnded) {
+        para.block.text = joinLines(para.block.text, line.text, ctx.options.dehyphenate, ctx.stats);
+        para.lines.push(line);
+        return;
+      }
+    }
+    closeAll();
+    ctx.open = null;
+    const block = { type: "paragraph", text: line.text, page: line.page };
+    ctx.blocks.push(block);
+    para = { block, lines: [line] };
+  });
+  closeAll();
+}
+function assignHeadingLevels(headings) {
+  const keys = Array.from(new Set(headings.map((h) => h.key))).sort((a, b) => b - a);
+  const levelOf = new Map(keys.map((key, i) => [key, Math.min(6, i + 1)]));
+  headings.forEach((h) => {
+    h.block.level = levelOf.get(h.key);
+  });
+}
+var DEFAULTS = {
+  paragraphGap: 1.4,
+  removeHeadersAndFooters: true,
+  detectColumns: true,
+  detectHeadings: true,
+  detectLists: true,
+  detectTables: true,
+  dehyphenate: true
+};
+function analyzePdfLayout(pages, options = {}) {
+  const opts = { ...DEFAULTS };
+  Object.keys(options).forEach((key) => {
+    if (options[key] !== void 0) opts[key] = options[key];
+  });
+  const fragPages = pages.map((page) => buildFragments(page.runs ?? []));
+  const removed = opts.removeHeadersAndFooters ? removeHeadersAndFooters(fragPages) : { headers: 0, footers: 0, pageNumbers: 0 };
+  const bySize = /* @__PURE__ */ new Map();
+  let boldChars = 0;
+  let totalChars = 0;
+  fragPages.flat().forEach((f) => {
+    const key = Math.round(f.size * 2) / 2;
+    bySize.set(key, (bySize.get(key) ?? 0) + f.text.length);
+  });
+  let body = 10;
+  let bodyChars = -1;
+  bySize.forEach((chars, size) => {
+    if (chars > bodyChars) {
+      body = size;
+      bodyChars = chars;
+    }
+  });
+  fragPages.flat().forEach((f) => {
+    if (Math.abs(f.size - body) <= body * 0.05) {
+      totalChars += f.text.length;
+      if (f.bold) boldChars += f.text.length;
+    }
+  });
+  const pitches = /* @__PURE__ */ new Map();
+  fragPages.forEach((frags) => {
+    const rows = baselineRows([...frags].sort((a, b) => b.y - a.y || a.x0 - b.x0));
+    for (let k = 1; k < rows.length; k++) {
+      const a = rows[k - 1][0];
+      const b = rows[k][0];
+      if (Math.abs(a.size - b.size) > 0.5) continue;
+      const d = a.y - b.y;
+      if (d > 0 && d < a.size * 3) {
+        const key = Math.round(b.size * 2) / 2;
+        if (!pitches.has(key)) pitches.set(key, []);
+        pitches.get(key).push(d);
+      }
+    }
+  });
+  const pitchMedians = /* @__PURE__ */ new Map();
+  pitches.forEach((values, key) => pitchMedians.set(key, median(values)));
+  const stats = { dehyphenated: 0 };
+  const ctx = {
+    body,
+    boldBody: totalChars > 0 && boldChars / totalChars > 0.5,
+    pitch: (size) => {
+      const known = pitchMedians.get(Math.round(size * 2) / 2);
+      return known && known >= size * 0.9 ? known : size * 1.2;
+    },
+    options: opts,
+    stats,
+    blocks: [],
+    headings: [],
+    open: null
+  };
+  const columnPages = { count: 0 };
+  const items = [];
+  fragPages.forEach((frags, pageIndex) => {
+    const page = pageIndex + 1;
+    let flowFrags = frags;
+    const atoms = [];
+    if (opts.detectTables && pages[pageIndex].rules?.length) {
+      const ruled = ruledTables(frags, pages[pageIndex].rules, page, opts.dehyphenate, stats);
+      flowFrags = frags.filter((f) => !ruled.consumed.has(f));
+      atoms.push(...ruled.atoms);
+    }
+    const before = columnPages.count;
+    const segments = readingOrder([...flowFrags, ...atoms], body, opts.detectColumns, 0, columnPages);
+    if (columnPages.count > before) items.push({ type: "columns", page, confidence: 0.8, detail: "multi-column layout" });
+    const units = [];
+    let carry = [];
+    for (const segment of segments) {
+      if (segment.kind === "grid" && opts.detectTables) {
+        const result = alignedTable(segment.items.filter((f) => !f.table), page, 3, opts.dehyphenate, stats);
+        if (result) {
+          const last = units[units.length - 1];
+          if (result.before.length && last && last.kind === "flow") last.items.push(...carry, ...result.before);
+          else if (result.before.length || carry.length) units.push({ kind: "flow", items: [...carry, ...result.before] });
+          units.push({ kind: "table", table: result.table });
+          carry = [...segment.items.filter((f) => f.table), ...result.leftover];
+          continue;
+        }
+      }
+      units.push({ kind: "flow", items: [...carry, ...segment.items] });
+      carry = [];
+    }
+    if (carry.length) units.push({ kind: "flow", items: carry });
+    for (const unit of units) {
+      if (unit.kind === "table") {
+        ctx.open = null;
+        ctx.blocks.push(unit.table);
+      } else buildBlocks(flowLines(unit.items, page), ctx);
+    }
+  });
+  assignHeadingLevels(ctx.headings);
+  const counts = { headings: 0, lists: 0, tables: 0, paragraphs: 0 };
+  const confidences = [];
+  ctx.blocks.forEach((block) => {
+    if (block.type === "heading") {
+      counts.headings++;
+      confidences.push(block.confidence);
+      items.push({ type: "heading", page: block.page, confidence: block.confidence, detail: `H${block.level} "${truncate(block.text)}"` });
+    } else if (block.type === "list") {
+      counts.lists++;
+      confidences.push(block.confidence);
+      const depth = maxOf(block.items, (i) => i.depth) + 1;
+      items.push({
+        type: "list",
+        page: block.page,
+        confidence: block.confidence,
+        detail: `${block.items[0]?.ordered ? "numbered" : "bulleted"} list, ${block.items.length} items${depth > 1 ? `, ${depth} levels` : ""}`
+      });
+    } else if (block.type === "table") {
+      counts.tables++;
+      confidences.push(block.confidence);
+      items.push({
+        type: "table",
+        page: block.page,
+        confidence: block.confidence,
+        detail: `${block.rows.length}\xD7${block.columns} table${block.ruled ? " (ruled)" : ""}${block.headerRows ? ", header row" : ""}`
+      });
+    } else counts.paragraphs++;
+  });
+  items.sort((a, b) => a.page - b.page);
+  return {
+    blocks: ctx.blocks,
+    report: {
+      mode: "structured",
+      pages: pages.length,
+      counts,
+      multiColumnPages: columnPages.count,
+      confidence: confidences.length ? Math.round(confidences.reduce((a, b) => a + b, 0) / confidences.length * 100) / 100 : 1,
+      items,
+      removed,
+      dehyphenated: stats.dehyphenated
+    }
+  };
+}
+var truncate = (text) => text.length > 60 ? `${text.slice(0, 57)}\u2026` : text;
+function listHtml(items) {
+  let html = "";
+  const stack = [];
+  for (const item of items) {
+    const level = item.depth + 1;
+    while (stack.length > level) html += `</li></${stack.pop()}>`;
+    const tag = item.ordered ? "ol" : "ul";
+    if (stack.length === level) {
+      if (stack[stack.length - 1] !== tag) {
+        html += `</li></${stack.pop()}>`;
+      } else html += "</li>";
+    }
+    while (stack.length < level) {
+      const start = item.ordered && item.start !== void 0 && item.start !== 1 ? ` start="${item.start}"` : "";
+      html += `<${tag}${start}>`;
+      stack.push(tag);
+    }
+    html += `<li><p>${escapeHtml(item.text)}</p>`;
+  }
+  while (stack.length) html += `</li></${stack.pop()}>`;
+  return html;
+}
+function pdfLayoutBlocksToHtml(blocks) {
+  let html = "";
+  for (const block of blocks) {
+    if (block.type === "heading") html += `<h${block.level}>${escapeHtml(block.text)}</h${block.level}>`;
+    else if (block.type === "paragraph") html += `<p>${escapeHtml(block.text)}</p>`;
+    else if (block.type === "list") html += listHtml(block.items);
+    else {
+      html += "<table><tbody>";
+      for (const row of block.rows) {
+        html += "<tr>";
+        for (const cell of row) {
+          const tag = cell.header ? "th" : "td";
+          const attrs = `${cell.colSpan > 1 ? ` colspan="${cell.colSpan}"` : ""}${cell.rowSpan > 1 ? ` rowspan="${cell.rowSpan}"` : ""}`;
+          html += `<${tag}${attrs}><p>${escapeHtml(cell.text)}</p></${tag}>`;
+        }
+        html += "</tr>";
+      }
+      html += "</tbody></table>";
+    }
+  }
+  return html || "<p></p>";
+}
 
 // src/import/pdf.ts
 var isTextItem = (item) => typeof item.str === "string";
-function median(values) {
+function median2(values) {
   if (!values.length) return 0;
   const sorted = [...values].sort((a, b) => a - b);
   const mid = sorted.length >> 1;
@@ -646,7 +1752,7 @@ function pdfTextItemsToParagraphs(items, options = {}) {
     const gap = lines[i - 1].y - lines[i].y;
     if (gap > 0) gaps.push(gap);
   }
-  const typical = median(gaps);
+  const typical = median2(gaps);
   const factor = options.paragraphGap ?? 1.4;
   const paragraphs = [];
   let current = [];
@@ -673,6 +1779,228 @@ function pdfTextItemsToParagraphs(items, options = {}) {
   flush();
   return paragraphs;
 }
+function pdfTextItemsToRuns(items, font) {
+  const runs = [];
+  const cache = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    if (!isTextItem(item) || !item.str.trim()) continue;
+    const t = item.transform ?? [];
+    const fontSize = Math.hypot(t[2] ?? 0, t[3] ?? 0) || item.height || 10;
+    let info;
+    if (item.fontName && font) {
+      if (!cache.has(item.fontName)) cache.set(item.fontName, font(item.fontName));
+      info = cache.get(item.fontName);
+    }
+    runs.push({
+      text: item.str,
+      x: t[4] ?? 0,
+      y: t[5] ?? 0,
+      width: item.width,
+      fontSize,
+      fontName: info?.name ?? item.fontName,
+      bold: info?.bold,
+      italic: info?.italic
+    });
+  }
+  return runs;
+}
+var DEFAULT_OPS = {
+  save: 10,
+  restore: 11,
+  transform: 12,
+  moveTo: 13,
+  lineTo: 14,
+  curveTo: 15,
+  curveTo2: 16,
+  curveTo3: 17,
+  closePath: 18,
+  rectangle: 19,
+  stroke: 20,
+  closeStroke: 21,
+  fill: 22,
+  eoFill: 23,
+  fillStroke: 24,
+  eoFillStroke: 25,
+  closeFillStroke: 26,
+  closeEOFillStroke: 27,
+  endPath: 28,
+  constructPath: 91
+};
+var DRAW_OPS = { moveTo: 0, lineTo: 1, curveTo: 2, quadraticCurveTo: 3, closePath: 4 };
+var MAX_PAGE_RULES = 5e3;
+var IDENTITY = [1, 0, 0, 1, 0, 0];
+var multiply = (m, c) => [
+  m[0] * c[0] + m[1] * c[2],
+  m[0] * c[1] + m[1] * c[3],
+  m[2] * c[0] + m[3] * c[2],
+  m[2] * c[1] + m[3] * c[3],
+  m[4] * c[0] + m[5] * c[2] + c[4],
+  m[4] * c[1] + m[5] * c[3] + c[5]
+];
+var apply = (m, x, y) => [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];
+function pdfOperatorListToRules(list, opsTable) {
+  const OPS = { ...DEFAULT_OPS, ...opsTable ?? {} };
+  const stroking = /* @__PURE__ */ new Set([OPS.stroke, OPS.closeStroke, OPS.fillStroke, OPS.eoFillStroke, OPS.closeFillStroke, OPS.closeEOFillStroke]);
+  const filling = /* @__PURE__ */ new Set([OPS.fill, OPS.eoFill, OPS.fillStroke, OPS.eoFillStroke, OPS.closeFillStroke, OPS.closeEOFillStroke]);
+  const rules = [];
+  const stack = [];
+  let ctm = IDENTITY;
+  let lines = [];
+  let rects = [];
+  const num = (value) => typeof value === "number" && Number.isFinite(value) ? value : NaN;
+  const addLine = (x1, y1, x2, y2) => {
+    const [a, b] = apply(ctm, x1, y1);
+    const [c, d] = apply(ctm, x2, y2);
+    lines.push([a, b, c, d]);
+  };
+  const addRect = (x, y, w, h) => {
+    const corners = [apply(ctm, x, y), apply(ctm, x + w, y), apply(ctm, x + w, y + h), apply(ctm, x, y + h)];
+    const xs = corners.map((p) => p[0]);
+    const ys = corners.map((p) => p[1]);
+    rects.push([Math.min(...xs), Math.min(...ys), Math.max(...xs), Math.max(...ys)]);
+  };
+  const paint = (op) => {
+    const stroke = stroking.has(op);
+    const fill = filling.has(op);
+    if (stroke) {
+      for (const [x1, y1, x2, y2] of lines) rules.push({ x1, y1, x2, y2 });
+      for (const [x0, y0, x1, y1] of rects) {
+        rules.push({ x1: x0, y1: y0, x2: x1, y2: y0 }, { x1: x0, y1, x2: x1, y2: y1 });
+        rules.push({ x1: x0, y1: y0, x2: x0, y2: y1 }, { x1, y1: y0, x2: x1, y2: y1 });
+      }
+    } else if (fill) {
+      for (const [x0, y0, x1, y1] of rects) {
+        if (y1 - y0 <= 2 && x1 - x0 > 2) rules.push({ x1: x0, y1: (y0 + y1) / 2, x2: x1, y2: (y0 + y1) / 2 });
+        else if (x1 - x0 <= 2 && y1 - y0 > 2) rules.push({ x1: (x0 + x1) / 2, y1: y0, x2: (x0 + x1) / 2, y2: y1 });
+      }
+    }
+    lines = [];
+    rects = [];
+  };
+  const readPath = (subOps, subArgs) => {
+    let k = 0;
+    let cx = 0;
+    let cy = 0;
+    let sx = 0;
+    let sy = 0;
+    for (let i = 0; i < subOps.length; i++) {
+      const op = subOps[i];
+      if (op === OPS.moveTo) {
+        cx = sx = num(subArgs[k++]);
+        cy = sy = num(subArgs[k++]);
+      } else if (op === OPS.lineTo) {
+        const x = num(subArgs[k++]);
+        const y = num(subArgs[k++]);
+        addLine(cx, cy, x, y);
+        cx = x;
+        cy = y;
+      } else if (op === OPS.rectangle) {
+        addRect(num(subArgs[k++]), num(subArgs[k++]), num(subArgs[k++]), num(subArgs[k++]));
+      } else if (op === OPS.curveTo) {
+        k += 4;
+        cx = num(subArgs[k++]);
+        cy = num(subArgs[k++]);
+      } else if (op === OPS.curveTo2 || op === OPS.curveTo3) {
+        k += 2;
+        cx = num(subArgs[k++]);
+        cy = num(subArgs[k++]);
+      } else if (op === OPS.closePath) {
+        if (cx !== sx || cy !== sy) addLine(cx, cy, sx, sy);
+        cx = sx;
+        cy = sy;
+      }
+    }
+  };
+  const readDrawBuffer = (data) => {
+    let cx = 0;
+    let cy = 0;
+    let sx = 0;
+    let sy = 0;
+    for (let k = 0; k < data.length; ) {
+      const code = data[k++];
+      if (code === DRAW_OPS.moveTo) {
+        cx = sx = data[k++];
+        cy = sy = data[k++];
+      } else if (code === DRAW_OPS.lineTo) {
+        const x = data[k++];
+        const y = data[k++];
+        addLine(cx, cy, x, y);
+        cx = x;
+        cy = y;
+      } else if (code === DRAW_OPS.curveTo) {
+        k += 4;
+        cx = data[k++];
+        cy = data[k++];
+      } else if (code === DRAW_OPS.quadraticCurveTo) {
+        k += 2;
+        cx = data[k++];
+        cy = data[k++];
+      } else if (code === DRAW_OPS.closePath) {
+        if (cx !== sx || cy !== sy) addLine(cx, cy, sx, sy);
+        cx = sx;
+        cy = sy;
+      } else break;
+    }
+  };
+  for (let i = 0; i < list.fnArray.length && rules.length < MAX_PAGE_RULES; i++) {
+    const fn = list.fnArray[i];
+    const args = list.argsArray[i];
+    if (fn === OPS.save) stack.push(ctm);
+    else if (fn === OPS.restore) ctm = stack.pop() ?? IDENTITY;
+    else if (fn === OPS.transform && args && args.length >= 6) {
+      const m = Array.from({ length: 6 }, (_, k) => num(args[k]));
+      if (m.every(Number.isFinite)) ctm = multiply(m, ctm);
+    } else if (fn === OPS.constructPath && args) {
+      const first = args[0];
+      if (typeof first === "number") {
+        const buffers = args[1];
+        const data = buffers?.[0];
+        if (data && typeof data.length === "number") readDrawBuffer(data);
+        paint(first);
+      } else if (first && typeof first.length === "number") {
+        readPath(first, args[1] ?? []);
+      }
+    } else if (stroking.has(fn) || filling.has(fn)) paint(fn);
+    else if (fn === OPS.endPath) {
+      lines = [];
+      rects = [];
+    }
+  }
+  return rules.filter((rule) => [rule.x1, rule.y1, rule.x2, rule.y2].every(Number.isFinite));
+}
+function fontResolver(page, content) {
+  return (fontName) => {
+    let info;
+    try {
+      if (page.commonObjs && (!page.commonObjs.has || page.commonObjs.has(fontName))) {
+        const font = page.commonObjs.get(fontName);
+        if (font && typeof font === "object") {
+          info = {
+            name: typeof font.name === "string" ? font.name : void 0,
+            bold: font.bold || font.black ? true : void 0,
+            italic: font.italic ? true : void 0
+          };
+        }
+      }
+    } catch {
+    }
+    const family = content.styles?.[fontName]?.fontFamily;
+    if (!info?.name && family) info = { ...info, name: family };
+    return info;
+  };
+}
+function plainReport(paragraphs, pages) {
+  return {
+    mode: "plain",
+    pages,
+    counts: { headings: 0, lists: 0, tables: 0, paragraphs },
+    multiColumnPages: 0,
+    confidence: 1,
+    items: [],
+    removed: { headers: 0, footers: 0, pageNumbers: 0 },
+    dehyphenated: 0
+  };
+}
 function createPdfImportAdapter(pdfjs, options = {}) {
   return {
     id: options.id ?? "pdf",
@@ -681,22 +2009,47 @@ function createPdfImportAdapter(pdfjs, options = {}) {
     extensions: [".pdf"],
     target: "document",
     async import(_input, context) {
+      const call = context.options && typeof context.options === "object" ? context.options : {};
+      const opts = { ...options, ...call, layout: { ...options.layout, ...call.layout } };
+      const structured = opts.structure !== false;
       const data = new Uint8Array((await context.readArrayBuffer()).slice(0));
-      const doc = await pdfjs.getDocument({ ...options.documentParams, data }).promise;
+      const doc = await pdfjs.getDocument({ ...opts.documentParams, data }).promise;
       const paragraphs = [];
+      const layoutPages = [];
+      let pages = 0;
       try {
-        const pages = Math.min(doc.numPages, options.maxPages ?? Infinity);
+        pages = Math.min(doc.numPages, opts.maxPages ?? Infinity);
         for (let n = 1; n <= pages; n++) {
           const page = await doc.getPage(n);
-          const content = await page.getTextContent();
-          paragraphs.push(...pdfTextItemsToParagraphs(content.items, options));
+          if (!structured) {
+            const content = await page.getTextContent();
+            paragraphs.push(...pdfTextItemsToParagraphs(content.items, opts));
+          } else {
+            let rules = [];
+            if (opts.rulingLines !== false && typeof page.getOperatorList === "function") {
+              try {
+                rules = pdfOperatorListToRules(await page.getOperatorList(), pdfjs.OPS);
+              } catch {
+                rules = [];
+              }
+            }
+            const content = await page.getTextContent();
+            layoutPages.push({ runs: pdfTextItemsToRuns(content.items, fontResolver(page, content)), rules });
+          }
           page.cleanup?.();
         }
       } finally {
         await doc.destroy?.();
       }
-      const text = paragraphs.join("\n");
-      return { html: plainTextToParagraphHtml(text), text };
+      if (!structured) {
+        const text = paragraphs.join("\n");
+        return { html: plainTextToParagraphHtml(text), text, structure: plainReport(paragraphs.length, pages) };
+      }
+      const layout = { ...opts.layout };
+      if (layout.paragraphGap === void 0 && opts.paragraphGap !== void 0) layout.paragraphGap = opts.paragraphGap;
+      const { blocks, report } = analyzePdfLayout(layoutPages, layout);
+      const html = sanitizeImportedHtml(pdfLayoutBlocksToHtml(blocks));
+      return { html, text: htmlToPlainText(html), structure: report };
     }
   };
 }
@@ -795,15 +2148,29 @@ export {
   BLOCK_CHANGE_ATTRIBUTE,
   BUILT_IN_IMPORT_ADAPTERS,
   Bookmark,
+  CHARACTER_STYLE_MARK_NAME,
   COMMENT_MARK_NAME,
+  CONDITIONAL_FORMAT_ICON_SETS,
+  CONDITIONAL_FORMAT_PRESETS,
+  CONDITIONAL_FORMAT_STYLE_PRESETS,
+  CONDITIONAL_FORMAT_TIME_PERIODS,
+  CharacterStyle,
   ColorHighlighter,
   CommentStore,
   Comments,
+  ConditionalFormatEngine,
   CrossReference,
+  DATA_VALIDATION_ERROR_STYLE_OPTIONS,
+  DATA_VALIDATION_OPERATOR_OPTIONS,
+  DATA_VALIDATION_TYPE_OPTIONS,
   DEFAULT_AUTOCORRECT_EXCEPTIONS,
   DEFAULT_COLUMN_WIDTH,
+  DEFAULT_CONDITIONAL_FORMAT_STYLE,
+  DEFAULT_DATA_VALIDATION_MESSAGE,
+  DEFAULT_DATA_VALIDATION_TITLE,
   DEFAULT_DOCX_MAX_IMAGE_SIZE,
   DEFAULT_ROW_HEIGHT,
+  DEFAULT_STYLES,
   DEFAULT_ZIP_MAX_ENTRIES,
   DEFAULT_ZIP_MAX_TOTAL_SIZE,
   DELETION_MARK_NAME,
@@ -812,6 +2179,7 @@ export {
   DependencyGraph,
   DirtyTracker,
   DocumentCompare,
+  EMPTY_CONDITIONAL_FORMAT_OVERLAY,
   EMPTY_FIND_REPLACE_SNAPSHOT,
   EditorController,
   FIELD_ALIASES,
@@ -828,6 +2196,7 @@ export {
   FootnoteReference,
   Footnotes,
   FormulaEvaluator,
+  FormulaLambda,
   FormulaParser,
   GradientText,
   HistoryManager,
@@ -840,26 +2209,36 @@ export {
   MARKDOWN_MENTION_SPLIT_REGEX,
   MAX_DATA_SOURCE_FIELDS,
   MAX_DATA_SOURCE_RECORDS,
+  MAX_DEFINED_NAME_LENGTH,
   MAX_FIND_PATTERN_LENGTH,
   MAX_FORMULA_ARRAY_SIZE,
+  MAX_LAMBDA_DEPTH,
   MAX_MERGE_LENGTH,
   MAX_MERGE_OUTPUTS,
   MAX_NUMBER_FORMAT_CODE_CHARS,
+  MAX_SHEET_NAME_LENGTH,
   MENTION_REGEX,
+  MOVE_FROM_CLASS,
+  MOVE_ID_ATTRIBUTE,
+  MOVE_TO_CLASS,
   Markdown,
   Mention,
+  NORMAL_STYLE_ID,
   NUMBER_FORMAT_PRESETS,
   NumberFormat,
   Outline,
   PIXERATE_DOCUMENT_MIME,
+  ParagraphStyles,
   RichClipboard,
   SMILIE_REPLACEMENTS,
   SPREADSHEET_CLIPBOARD_MIME,
   SPREADSHEET_IMPORT_ADAPTERS,
   SPREADSHEET_TABLE_ACTIONS,
+  STYLE_ID_ATTRIBUTE,
   SlashCommands,
   SmilieReplacer,
   SpreadsheetController,
+  StyleRegistry,
   TEMPLATE_DEPTH_ERROR,
   TEMPLATE_LOOP_ERROR,
   TEMPLATE_REGEX,
@@ -875,18 +2254,23 @@ export {
   WHOLE_COLUMN_END_ROW,
   ZipArchive,
   ZipError,
+  adjustRangeForStructuralChange,
+  adjustRangesForStructuralChange,
   aggregateValues,
+  analyzePdfLayout,
   applyDocumentComparison,
   applyFormulaSuggestion,
   applyReplacements,
   autocorrectPluginKey,
   bindDirtyToHistory,
   bindSpreadsheetTableActions,
+  blendConditionalFormatColors,
   buildOutlineTree,
   buildSpreadsheetView,
   builtinNumberFormat,
   builtinNumberFormatId,
   capitalizeSentenceRules,
+  captureSelectionFormat,
   cellFormatForNumberFormat,
   checkFormulaArgumentCount,
   clampMenuPosition,
@@ -907,7 +2291,13 @@ export {
   computeOutline,
   computeRowGroups,
   conditionSubject,
+  conditionalFormatContrastColor,
+  conditionalFormatIconCount,
+  conditionalFormatNumber,
+  conditionalFormatStyleString,
+  copySheetName,
   createCommentStore,
+  createConditionalFormatRule,
   createDirtyTracker,
   createDocxImportAdapter,
   createEditor,
@@ -918,20 +2308,26 @@ export {
   createImportContext,
   createMentionExtension,
   createOutlineStore,
+  createParagraphStylesStore,
   createPdfImportAdapter,
   createReviewId,
   createRichTextPreset,
   createSearchBudget,
   createSpreadsheetClipboardData,
+  createStyleRegistry,
   createZipImportAdapter,
   crossReferencePluginKey,
   csvImportAdapter,
   dateValueToSerial,
   defaultAutocorrectRules,
+  defaultIconThresholds,
   defaultImportRegistry,
   defaultIsEqual,
+  deleteSheetInFormula,
   describeBlockChange,
+  describeConditionalFormat,
   describeConditionalTag,
+  describeDataValidation,
   describeFormatChange,
   describeFormulaError,
   detectDelimiter,
@@ -945,12 +2341,14 @@ export {
   escapeVariableText,
   evaluateCondition,
   evaluateConditionExpression,
+  evaluateConditionalFormats,
   evaluatePromptTokens,
   expandReplacement,
   extractCellDependencies,
   extractInstructionNames,
   extractMentions,
   extractMentionsFromDoc,
+  extractNameDependencies,
   extractTemplateNames,
   extractVariableNames,
   extractVariables,
@@ -959,22 +2357,30 @@ export {
   findAllMatches,
   findAutocorrection,
   findCommentRanges,
+  findDataValidation,
   findHexColors,
   findImportAdapter,
+  findInvalidCells,
   findReplacePluginKey,
+  findTextMentions,
   foldCodePoint,
   footnotesMarkdownIt,
   footnotesPluginKey,
+  forEachRangeCell,
   formatCellDisplay,
   formatCellForDisplay,
   formatComparisonOperand,
   formatConditionalTag,
   formatFindStatus,
   formatGeneralFit,
+  formatMentionText,
   formatNumberFormatValue,
   formatReviewTime,
+  formatRuleRanges,
+  formatSheetPrefix,
   formatTextFunction,
   formatValueWithCode,
+  formulaIdentifiers,
   fractionRules,
   getActiveHeading,
   getBookmarks,
@@ -983,7 +2389,10 @@ export {
   getCommentAuthor,
   getCommentIdsAt,
   getCommentStore,
+  getConditionalFormatCss,
+  getConditionalFormatIcon,
   getCrossReferenceTargets,
+  getDataBarCss,
   getDocumentStructureCommandItems,
   getEditorMarkdown,
   getEditorText,
@@ -999,11 +2408,16 @@ export {
   getFormulaSignatureParts,
   getImportAccept,
   getLatestVersion,
+  getMentionNodes,
+  getNameManagerRows,
   getOutline,
+  getParagraphStyleAt,
   getPromptDiagnostics,
   getRowSection,
   getSchemaSignature,
+  getSheetTabMenuItems,
   getSpreadsheetMenuItems,
+  getStyleRegistry,
   getSuppliedValue,
   getTableOfContentsEntries,
   getTableSections,
@@ -1011,6 +2425,7 @@ export {
   getTrackChangesStore,
   getTrackedChangeAt,
   getTrackedChanges,
+  getValidationListValues,
   getVariableFormFields,
   handleImageInsertion,
   htmlImportAdapter,
@@ -1026,12 +2441,17 @@ export {
   instructionRegex,
   isBlankValue,
   isFormulaError,
+  isFormulaLambda,
   isGeneralNumberFormat,
   isInsidePromptToken,
+  isLambdaDefinition,
+  isMoveSized,
+  isParagraphStyleAvailable,
   isPromptValueSet,
   isSingleCellRange,
   isTrackChangesEnabled,
   isUnsafeZipPath,
+  isValidStyleId,
   listFormulaFunctions,
   mapFormulaReferences,
   mapRawOffsetToResolved,
@@ -1041,8 +2461,10 @@ export {
   matchConditionalTags,
   matchFields,
   matchesFilterRule,
+  matchesTimePeriod,
   mergeRecords,
   navigateToHeading,
+  nextSheetName,
   normalizeFieldKey,
   normalizeFieldNames,
   normalizeRange,
@@ -1051,6 +2473,7 @@ export {
   numberToText,
   offsetFormulaReferences,
   outlinePluginKey,
+  paragraphStylesPluginKey,
   parseCellInput,
   parseCellReference,
   parseComparison,
@@ -1065,9 +2488,13 @@ export {
   parseRange,
   parseReplacement,
   parseRichClipboardPayload,
+  parseRuleRanges,
   parseTsv,
   parseVariableBody,
+  pdfLayoutBlocksToHtml,
+  pdfOperatorListToRules,
   pdfTextItemsToParagraphs,
+  pdfTextItemsToRuns,
   pickImportFiles,
   plainTextImportAdapter,
   plainTextToParagraphHtml,
@@ -1075,8 +2502,10 @@ export {
   plainTextToTipTapHtml,
   preprocessMarkdownFileLinks,
   preprocessMarkdownMentions,
+  quoteSheetName,
   rangeContains,
   rangeContainsRange,
+  rangesContain,
   rangesIntersect,
   readRichClipboard,
   readSpreadsheetClipboard,
@@ -1088,6 +2517,8 @@ export {
   registerSpreadsheetImportAdapters,
   remapFormulaReferences,
   removeImageNode,
+  renameNameInFormula,
+  renameSheetInFormula,
   resolvePrompt,
   resolveTemplates,
   resolveTemplatesWithMapping,
@@ -1098,7 +2529,10 @@ export {
   rowPassesFilters,
   rtfImportAdapter,
   rtfToPlainText,
+  ruleAnchor,
+  ruleFormulaAt,
   runSpreadsheetMenuItem,
+  safeCSSValue,
   sanitizeHtml,
   sanitizeImportedHtml,
   searchDocument,
@@ -1109,12 +2543,20 @@ export {
   serializeMergeOutputs,
   serializeRichClipboardPayload,
   serializeTsv,
+  setMentionRoleAt,
+  setMentionRoleInText,
+  sheetDropIndex,
+  sheetNameNeedsQuotes,
   shiftFormulaReferences,
+  shiftRuleFormula,
   smartQuoteRules,
   smilieAutocorrectRules,
   sortCompareValues,
   sortZipEntryNames,
   stripMarkdownCode,
+  subtractRange,
+  subtractRangeFromRanges,
+  summarizeImportStructure,
   symbolRules,
   syncFootnotes,
   tableOfContentsMarkdownIt,
@@ -1125,13 +2567,17 @@ export {
   tokenizePrompt,
   tokenizePromptWithDiagnostics,
   trackChangesPluginKey,
+  trackedChangeLabel,
   tsvImportAdapter,
   twoInitialCapitalsRules,
   unescapeVariableText,
   unregisterFormulaFunction,
   unregisterImportAdapter,
   updateImageSrc,
+  validateCellInput,
+  validateDefinedName,
   validateFindPattern,
+  validateSheetName,
   variableRegex,
   wildcardToRegExp,
   withoutDirty,