js.documents 1.60.2 → 1.61.0

package/README.md

@@ -404,7 +404,7 @@ To run a single test file: `pnpm vitest run src/path/to/file.test.ts`.
 - **A `DocumentPackage` returned via `onDocument`/`ConversionResult.package` is a snapshot from that one conversion pass, not a live view** — its `layout` correlates with its `content` only as of the exact read+layout that produced it (`document-schema.js`'s own `DocumentPackageSchema` doc comment), so if a caller mutates the returned `content` afterwards, the `layout` sitting alongside it silently goes stale; nothing in this package (or `document-schema.js`) detects or rejects that.
 - **Building the six cross-format bridges surfaced two real, previously-undiscovered gaps in existing `populateParagraph` write paths, both now fixed.** `buildDocxPackage`'s `populateParagraph` (`src/edit/docx/content.ts`) never wrote a paragraph's own `list` membership back (`ContentParagraph.list`, docx's flat `numId`/`level` model) — only read, never written, since no existing caller had ever round-tripped a list-bearing paragraph through it. `buildOdtPackage`'s `populateParagraph` (`src/edit/odt/content.ts`) never wrote a paragraph's own `styleId` back at all (`readOdtContent`/`readOdfParagraph` in `odf.js` reads it unconditionally from `text:style-name`, but nothing on the write side ever set that attribute). Both are now fixed: `DocxParagraph.list` is set unconditionally alongside `styleId`/`alignment`, matching that function's own existing pattern; `OdtParagraph.styleId` is set conditionally alongside `alignment`, matching odt's own local convention. `buildOdtPackage` additionally gained `appendBlocks`/`appendListRun` (`src/edit/odt/content.ts`) — ODF has no flat per-paragraph list property to set the way docx does, so a run of consecutive `ContentParagraph`s sharing `list.numId` is grouped and written as a real, potentially multi-level `text:list`/`text:list-item` tree via `OdtList`/`OdtListItem`, the structural inverse of `odf.js`'s own list-reading (a fresh `text:list` per `numId` change, one level of nesting per `list.level` step, descending only one level at a time since ODF can only open a nested list from inside an existing item). Both gaps were invisible before this task specifically because nothing had previously round-tripped a list-bearing paragraph or a styled paragraph through `docx ⇄ odt` at all — the PDF-pivot conversions never exercised `buildDocxPackage`/`buildOdtPackage` on content read back from the OTHER format.
 - **A table shape inside an odp slide does not survive `odpToPptx`.** `buildPptxPackage`'s `appendShape` (`src/edit/pptx/content.ts`) silently drops any non-paragraph block found inside a shape's own text-box loop — a scope choice whose own comment ("PDF-reconstructed shapes never mix kinds") assumed its only caller was the PDF-reconstruction path, where that is true. `odpToPptx` is a second, non-PDF-reconstructed caller for which it is not: a real odp `draw:frame` containing a `table:table` directly (not inside a text box) reads as a `ContentShape` with a `'table'` block, and that block is silently dropped, leaving an empty pptx text box where the table was. Everything else on the same slide — a rotated shape, grouped shapes, an image, speaker notes — survives correctly (see `src/convert/bridges.test.ts`'s own dedicated fidelity-gap test, which proves both halves against the existing `minimalOdpBytes()` fixture). A real, tracked, bounded gap, not a silent one: closing it means teaching `buildPptxPackage`/`buildOdpPackage` to write a real table into a slide shape, a materially larger feature than this bridge's own scope.
-- **The `ods ⇄ xlsx` bridge inherits several real, format-boundary fidelity limits from `ooxml.js`'s brand-new `readXlsxContent`/`buildXlsxPackage`, on top of its own pivot-copy design.** xlsx has no `percentage`/`currency` cell type of its own (both are a plain numeric cell plus a number-format style neither this reader nor this writer interprets) — an ods `percentage`/`currency` cell survives the `odsToXlsx` hop with its numeric *value* intact but downgrades to a plain `number` *kind*, permanently (currency's own currency code is dropped outright). xlsx also has only one rare `t="d"` cell type covering BOTH date and time — an ods `time` cell survives as a `date`-kind cell carrying its original value string verbatim, but mislabelled; an ods `date` cell is unaffected (it was already the kind xlsx's own `t="d"` maps onto). A formula (`table:formula`/`<f>`) is carried completely verbatim in both directions — never parsed, translated, or evaluated by either this package's own reader or writer — but a REAL spreadsheet application does evaluate a workbook's own `<f>`/`table:formula` on open: confirmed against genuine LibreOffice 26.2, an ods formula authored in OpenFormula syntax (`of:=[.B2]*2`) becomes a formula ERROR (`Err:510`) when the bridged xlsx is opened in real Calc, even though the formula's own cached value is still present and correctly readable via `readXlsxContent` — going the other way is less fragile in practice only because a genuine xlsx formula (bare Excel A1 syntax, e.g. `B2*2`) happens to still parse under LibreOffice's own more lenient, backward-compatible ODF formula grammar, not because of anything this bridge does differently in either direction. Column widths survive the `odsToXlsx` hop within roughly a pixel of rounding tolerance (see `src/convert/bridges.test.ts`'s own `COLUMN_WIDTH_TOLERANCE_PT`) but are then dropped entirely on the return `xlsxToOds` hop — not a character-width-unit rounding loss, but `buildOdsPackage` not writing `ContentSheetColumn.widthPt` at all, a pre-existing, already-documented gap in that file's own module comment, unrelated to and unfixed by this bridge. A boolean cell written by `buildXlsxPackage` renders as a raw `1`/`0` rather than `TRUE`/`FALSE` when opened in real Excel/Calc, since that writer's own genuinely-minimal `xl/styles.xml` (one default cell format, no boolean-specific number format) has nothing else to apply — the underlying `{ kind: 'boolean', value: true }` is still read back correctly by `readXlsxContent` regardless; this is a real-application *display* gap, not a data-fidelity one. `readXlsxContent`'s own cell.value.kind never produces `'error'` from an odf.js-sourced document at all, for a structural reason rather than a bug: ODF's `office:value-type` enumeration has no `error` member, so `OdsCell.value`'s own write-side choice for a `kind: 'error'` cell is to write it as a genuine, non-empty `office:string-value` carrying the error's own text — an `xlsxToOds` → `odsToXlsx` round trip of a genuine xlsx `t="e"` error cell therefore turns it into a plain `string` cell carrying the identical text; the message survives, the `error` semantic does not.
+- **The `ods ⇄ xlsx` bridge inherits several real, format-boundary fidelity limits from `ooxml.js`'s brand-new `readXlsxContent`/`buildXlsxPackage`, on top of its own pivot-copy design.** xlsx has no `percentage`/`currency` cell type of its own (both are a plain numeric cell plus a number-format style neither this reader nor this writer interprets) — an ods `percentage`/`currency` cell survives the `odsToXlsx` hop with its numeric *value* intact but downgrades to a plain `number` *kind*, permanently (currency's own currency code is dropped outright). xlsx also has only one rare `t="d"` cell type covering BOTH date and time — an ods `time` cell survives as a `date`-kind cell carrying its original value string verbatim, but mislabelled; an ods `date` cell is unaffected (it was already the kind xlsx's own `t="d"` maps onto). A formula (`table:formula`/`<f>`) is carried completely verbatim in both directions — never parsed, translated, or evaluated by either this package's own reader or writer — but a REAL spreadsheet application does evaluate a workbook's own `<f>`/`table:formula` on open: confirmed against genuine LibreOffice 26.2, an ods formula authored in OpenFormula syntax (`of:=[.B2]*2`) becomes a formula ERROR (`Err:510`) when the bridged xlsx is opened in real Calc, even though the formula's own cached value is still present and correctly readable via `readXlsxContent` — going the other way is less fragile in practice only because a genuine xlsx formula (bare Excel A1 syntax, e.g. `B2*2`) happens to still parse under LibreOffice's own more lenient, backward-compatible ODF formula grammar, not because of anything this bridge does differently in either direction. Column widths survive the `odsToXlsx` hop within roughly a pixel of rounding tolerance (see `src/convert/bridges.test.ts`'s own `COLUMN_WIDTH_TOLERANCE_PT`) but are then dropped entirely on the return `xlsxToOds` hop — not a character-width-unit rounding loss, but `buildOdsPackage` not writing `ContentSheetColumn.widthPt` at all, a pre-existing, already-documented gap in that file's own module comment, unrelated to and unfixed by this bridge. A boolean cell written by `buildXlsxPackage` renders as a raw `1`/`0` rather than `TRUE`/`FALSE` when opened in real Excel/Calc, since that writer's own genuinely-minimal `xl/styles.xml` (one default cell format, no boolean-specific number format) has nothing else to apply — the underlying `{ kind: 'boolean', value: true }` is still read back correctly by `readXlsxContent` regardless; this is a real-application *display* gap, not a data-fidelity one. `readXlsxContent`'s own cell.value.kind never produces `'error'` from an odf.js-sourced document at all, for a structural reason rather than a bug, confirmed permanent rather than an open question: ODF's `office:value-type` enumeration simply has no `error` member — verified against real LibreOffice 26.2 output, a genuine `#DIV/0!` formula cell serializes as `office:value-type="string"` with an EMPTY `office:string-value`, the error text surviving only in the cell's own `text:p`/displayText, never in any `office:value-type`-driven wire value. The one place the string `"error"` appears anywhere in the format is LibreOffice's own `calcext:value-type="error"` extension attribute, a private, unstable vendor namespace outside the OASIS ODF 1.3 spec — the identical category of escape hatch `odf.js`'s own `typed/shared/table.ts` already declined for `loext:graphic-properties/@draw:fill-color` over the standard `fo:background-color`, and declined here for the same reason: this package's own convention is OASIS-spec-grounded, not vendor-extension-chasing, and a private namespace a future LibreOffice release can rename or drop is not a foundation to build a public API's data fidelity on. `OdsCell.value`'s own write-side choice for a `kind: 'error'` cell is consequently to write it as a genuine, non-empty `office:string-value` carrying the error's own text — an `xlsxToOds` → `odsToXlsx` round trip of a genuine xlsx `t="e"` error cell therefore turns it into a plain `string` cell carrying the identical text; the message survives, the `error` semantic does not, and no mechanism inside or outside the ODF spec can preserve it. This is a permanent format-boundary limitation, not a gap either `odf.js` or this package could close by implementing something — there is nothing standards-based left to implement.
 - **`odpToPdf`/`pdfToOdp` needed zero new layout code.** `readOdpContent` (`src/odf/odp/read.ts`) produces the identical `presentation` `ContentDocument` shape `readPptxContent` does, so it feeds `convertPresentationToLayout` unmodified — including the existing hidden-annotation speaker-notes mechanism below, which carries odp's `presentation:notes` through to the PDF with no new notes-handling code at all; `pdfToOdp` reuses `reconstructPresentation` unmodified too, the same architectural bet `pdfToOdt` already proved for `reconstructWordprocessing`. The genuinely new work for the reverse direction was the live-view editor itself (`src/edit/odp/*`) — see Architecture above.
 - **`OdpShape.rotationDeg` writes a real `draw:transform`, built on `odf.js`'s own transform machinery.** It is the write-side inverse of `odf.js`'s `resolveOdfShapeGeometry` (`typed/shared/transform.ts`), built on that module's own exported `applyOdfTransform` rather than a hand-rolled rotation matrix, so it inherits that module's own empirically-verified rotate/translate composition order and sign convention by construction. Unlike `PptxShape` (see the `colSpan`/`rowSpan` gotcha below, which pptx still has and odp does not), `buildOdpPackage` writes a rotated shape's rotation back correctly — verified both by this package's own tests and by opening a fresh, editor-built `.odp` in actual LibreOffice.
 - **`readPdf` tracks general vector paths, not just axis-aligned rectangles — pdf-codec's own capability, with a direct consequence for this package's `pdfToOds`/`reconstructDrawing`.** A stroked-and-filled rect, any ellipse, and any plain line each come back from a real PDF round trip as a generic `LayoutPath` rather than their original kind (see pdf-codec's own `interpret.ts` gotcha for the exact fast-path boundary and the ISO 32000-1 operators involved). This is the shared infrastructure both `pdfToOds` and `reconstructDrawing` need; both now use it. A direct, practical consequence for `pdfToOds`: `readPdf` never reconstructs a `'line'` kind item at all, so a gridline written by `sheets.ts`'s own `renderGridlines` always comes back from a real PDF round trip as a generic, single-subpath, single-line-segment, stroke-only `LayoutPath` — `reconstructSpreadsheet`'s own gridline-lattice detection accepts both shapes (a genuine `LayoutLine` item and this stroked-single-segment `LayoutPath` shape) for exactly this reason.
@@ -445,7 +445,7 @@ To run a single test file: `pnpm vitest run src/path/to/file.test.ts`.
 - **A token element's (`mi`/`mn`/`mo`/`mtext`) own box height comes from the font's nominal design ascent/descent, not a tight per-glyph ink bounding box.** `src/mathml/` never parses glyph outlines itself (no `glyf`/CFF charstring geometry extraction anywhere in this package — pdf-codec's own font parsing doesn't expose per-glyph ink bounds either, see its README), so every token run shares one uniform vertical extent regardless of which characters it actually contains. Accurate enough for box-model layout (spacing, baseline alignment, page placement) but not pixel-tight around an unusually tall or shallow glyph.
 - **The MathML operator dictionary (`src/mathml/operators.ts`) is a deliberately bounded ~60-entry table, not the MathML3 specification's own multi-thousand-entry, form-dependent (prefix/infix/postfix) one.** It covers arithmetic, relational, set/logic, calculus big-operators, fences, and punctuation — the operators real formulas overwhelmingly use — with one entry per character regardless of which position it appears in, falling back to a single sane infix-shaped default (thick-space spacing, no stretch/largeop/movablelimits) for anything else.
 - **`mover`/`munder`/`munderover` centre an over/under-script geometrically over the wider of the two boxes, not at the base glyph's own font-declared accent-attachment point (`MathTopAccentAttachment`, which the embedded font's `MathGlyphInfo` subtable DOES carry and this package DOES parse — see the CFF-embedding gotcha above — just not consumed here).** Visually correct for the common case of a single-character base (geometric centre ≈ optical centre for a roughly symmetric glyph); measurably different only for a multi-character or asymmetric base under a genuine `accent="true"` mark. A real, bounded simplification, not a data gap — the metric this would need is already being parsed for a different purpose.
-- **Greek `mathvariant` mapping covers the plain alphabet plus nabla (∇) and partial differential (∂), not the OpenType/Unicode Greek "symbol variant" set** (epsilon/theta/kappa/phi/rho/pi symbol glyphs — `ϵ`/`ϑ`/`ϰ`/`ϕ`/`ϱ`/`ϖ` styled to e.g. bold). Latin letters, digits, and the two named symbols above are fully covered, generated directly from Unicode's own `UnicodeData.txt` (see `src/mathml/variant.ts`'s own generation note) rather than transcribed by hand.
+- **Greek `mathvariant` mapping covers the plain alphabet, nabla (∇), partial differential (∂), and the six OpenType/Unicode Greek "symbol variant" glyphs** (lunate epsilon/theta/kappa/phi/rho/pi symbols — U+03F5/U+03D1/U+03F0/U+03D5/U+03F1/U+03D6 — styled to bold, italic, bold-italic, bold-sans-serif, and sans-serif-bold-italic; Unicode never assigned symbol-variant glyphs for plain sans-serif, script, fraktur, or double-struck). Every entry is generated directly from Unicode's own `UnicodeData.txt` (see `src/mathml/variant.ts`'s own generation note) rather than transcribed by hand.
 - **Embedded-formula detection inside odt/odp is genuinely new work with no `odf.js`-side equivalent (`readDrawFrameContent` doesn't recognise a `draw:object`-bearing `draw:frame` at all yet — see the `src/odf/` architecture entry above), and each format's own detection carries its own real, bounded scope narrowing.** For **odt** (`src/odf/odt/read.ts`): only a `draw:frame` that is a *direct child of `office:text`* is detected — a formula anchored inline inside a paragraph's own run content, or nested inside a `draw:g` group, is not. Detected formulas are appended to the **end** of the section's own `blocks` array, in the order their frames appear in the document, not interleaved at their true original position among the paragraphs/tables `odf.js`'s own reader already produced — true positional interleaving would need per-element block-count bookkeeping this adapter doesn't have (a `text:list`, for instance, unwraps into many `ContentParagraph` blocks from one raw XML element, so "one raw child = one block" doesn't hold in general). For **odp** (`src/odf/odp/read.ts`): only a top-level `draw:frame` on a `draw:page` with no `draw:g` sibling at all is detected (a slide containing any group is skipped entirely for formula detection, to avoid mismatching a formula onto the wrong shape) — but where it IS detected, position is exact, not appended: `odf.js`'s own `walkDrawShapes` already produces exactly one `ContentShape` per top-level `draw:frame` in document order, so the Nth frame maps precisely onto `shapes[N]`. **ods embedded-formula detection is not implemented at all** — `odf.js`'s `readOds` has no existing floating-drawing/anchor-resolution mechanism (`ContentSheetImage`/`ContentSheet.embeddedObjects` are both already-known, pre-existing unpopulated gaps this task does not newly create — see the `ContentSheetCellSchema` gotcha above for the sibling gap on the write side), so there is no `readDrawFrame`-equivalent entry point to hook a formula-frame scan onto the way odt/odp have; `src/layout/sheets.ts` accordingly has no formula-handling branch at all, with a comment marking why.
 - **A formula that isn't rendered as real MathML (an odm chapter's own embedded formula, or any formula crossing the `odtToDocx`/`docxToOdt`/`odpToPptx`/`pptxToOdp` bridges) survives only as its own plain-text placeholder** — the formula's StarMath annotation if it had one, or the literal `[formula]` otherwise (see `src/odf/formula/placeholder.ts`). `odmToPdf`'s own per-chapter `readOdtContent` call discards that chapter's own `formulas` map entirely (re-keying every formula's `sourcePath` against the final combined document's own renumbered block indices is a materially larger undertaking than this task's own scope, and `.odm` has no confirmed real-world test fixture to validate it against regardless — see the `odmToPdf` gotcha below). `buildDocxPackage` has no MathML-writing path of its own (OOXML's own math markup, OMML, is a different vocabulary this package does not write), so none of the ten cross-format bridges ever consult a formula's real MathML either, even when bridging between two formats that both, individually, support real formula rendering elsewhere in this package — for the two markdown bridges specifically, there is nothing to consult regardless, since markdown has no formula/embedded-object construct of its own for `readMarkdownContent` to detect in the first place.
 - **`sourcePath` traces a `LayoutItem` back to the `ContentDocument` node it came from, but only within one read+layout pass.** `ooxml.js`'s `readDocx`/`readPptx` stamp every `ContentRun`/`ContentImageBlock`/`ContentTable`/`ContentShape` with a positional path (`sections[0].blocks[2].runs[1]`, `slides[1].shapes[3].blocks[0]`); `convertWordprocessingToLayout`/`convertPresentationToLayout` copy that same string onto whichever `LayoutText`/`LayoutImage`/`LayoutLink`/`LayoutRect` item(s) it produces, so a positioned PDF-side item can be traced back to its semantic origin. When line-wrapping splits one run's word across a run boundary, every resulting fragment gets its own run's path (not a shared or merged one); when a single run is emergency-split across several lines or pages, every resulting fragment keeps that same one run's path unchanged. A table cell's background `LayoutRect` is attributed to its containing table's own `sourcePath`, since `ContentTableCell` carries none of its own. This is **not** an edit-tracking or incremental-relayout mechanism — the path is only valid against the exact `ContentDocument`/`Package` it was assigned from in that one read; editing the document, re-reading it, or reordering its blocks invalidates every previously-captured path, and nothing here recomputes or diffs paths across two versions of a document.

package/dist/edit/ods/cell.cjs

@@ -129,6 +129,11 @@ var OdsCell = class {
 				require_xml_edit.setAttr(this.node, DATE_VALUE_ATTR, value.value);
 				this.displayText = value.value;
 				break;
+			case "dateTime":
+				require_xml_edit.setAttr(this.node, VALUE_TYPE_ATTR, "date");
+				require_xml_edit.setAttr(this.node, DATE_VALUE_ATTR, value.value);
+				this.displayText = value.value;
+				break;
 			case "time":
 				require_xml_edit.setAttr(this.node, VALUE_TYPE_ATTR, "time");
 				require_xml_edit.setAttr(this.node, TIME_VALUE_ATTR, value.value);

package/dist/edit/ods/cell.js

@@ -128,6 +128,11 @@ var OdsCell = class {
 				setAttr(this.node, DATE_VALUE_ATTR, value.value);
 				this.displayText = value.value;
 				break;
+			case "dateTime":
+				setAttr(this.node, VALUE_TYPE_ATTR, "date");
+				setAttr(this.node, DATE_VALUE_ATTR, value.value);
+				this.displayText = value.value;
+				break;
 			case "time":
 				setAttr(this.node, VALUE_TYPE_ATTR, "time");
 				setAttr(this.node, TIME_VALUE_ATTR, value.value);

package/dist/edit/ods/content.cjs

@@ -9,8 +9,8 @@ function buildOdsPackage(content) {
 		const odsSheet = editor.addSheet(sheet.name);
 		odsSheet.printSettings = sheet.printSettings;
 		for (const cell of sheet.cells) appendCell(odsSheet, cell);
-		for (const column of sheet.columns) odsSheet.setColumnWidth(column.index, column.widthPt);
-		for (const row of sheet.rows) odsSheet.setRowHeight(row.index, row.heightPt);
+		for (const column of sheet.columns) if (column.widthPt !== void 0) odsSheet.setColumnWidth(column.index, column.widthPt);
+		for (const row of sheet.rows) if (row.heightPt !== void 0) odsSheet.setRowHeight(row.index, row.heightPt);
 	}
 	return editor.toPackage();
 }

package/dist/edit/ods/content.js

@@ -8,8 +8,8 @@ function buildOdsPackage(content) {
 		const odsSheet = editor.addSheet(sheet.name);
 		odsSheet.printSettings = sheet.printSettings;
 		for (const cell of sheet.cells) appendCell(odsSheet, cell);
-		for (const column of sheet.columns) odsSheet.setColumnWidth(column.index, column.widthPt);
-		for (const row of sheet.rows) odsSheet.setRowHeight(row.index, row.heightPt);
+		for (const column of sheet.columns) if (column.widthPt !== void 0) odsSheet.setColumnWidth(column.index, column.widthPt);
+		for (const row of sheet.rows) if (row.heightPt !== void 0) odsSheet.setRowHeight(row.index, row.heightPt);
 	}
 	return editor.toPackage();
 }

package/dist/hsqldb/script.cjs

@@ -20,6 +20,7 @@ function displayTextFor(value) {
 		case "boolean": return value.value ? "TRUE" : "FALSE";
 		case "date":
 		case "time":
+		case "dateTime":
 		case "string":
 		case "error": return value.value;
 		case "empty": return "";

package/dist/hsqldb/script.js

@@ -19,6 +19,7 @@ function displayTextFor(value) {
 		case "boolean": return value.value ? "TRUE" : "FALSE";
 		case "date":
 		case "time":
+		case "dateTime":
 		case "string":
 		case "error": return value.value;
 		case "empty": return "";

package/dist/layout/sheets.cjs

@@ -53,7 +53,7 @@ function resolveAxis(entries, start, end, defaultSizePt) {
 	let currentHidden = false;
 	for (let index = start; index <= end; index++) {
 		while (pointer < sorted.length && sorted[pointer].index <= index) {
-			currentSizePt = sorted[pointer].sizePt;
+			currentSizePt = sorted[pointer].sizePt ?? defaultSizePt;
 			currentHidden = sorted[pointer].hidden ?? false;
 			pointer++;
 		}
@@ -77,7 +77,7 @@ function computeHeaderGutter(printSettings, range, measurer) {
 	};
 }
 function resolveScale(printSettings, availableWidthPt, availableHeightPt, totalContentWidthPt, totalContentHeightPt) {
-	if (printSettings.scale !== void 0) return Math.max(printSettings.scale / 100, MINIMUM_SCALE);
+	if (printSettings.scalePercent !== void 0) return Math.max(printSettings.scalePercent / 100, MINIMUM_SCALE);
 	if (printSettings.fitToPages !== void 0) {
 		const budgetWidthPt = availableWidthPt * printSettings.fitToPages.width;
 		const budgetHeightPt = availableHeightPt * printSettings.fitToPages.height;
@@ -125,7 +125,7 @@ function cellStyledRuns(cell) {
 	}];
 }
 function isNumericLikeValue(kind) {
-	return kind === "number" || kind === "percentage" || kind === "currency" || kind === "date" || kind === "time";
+	return kind === "number" || kind === "percentage" || kind === "currency" || kind === "date" || kind === "time" || kind === "dateTime";
 }
 function defaultAlignmentForValue(kind) {
 	if (isNumericLikeValue(kind)) return "right";

package/dist/layout/sheets.js

@@ -54,7 +54,7 @@ function resolveAxis(entries, start, end, defaultSizePt) {
 	let currentHidden = false;
 	for (let index = start; index <= end; index++) {
 		while (pointer < sorted.length && sorted[pointer].index <= index) {
-			currentSizePt = sorted[pointer].sizePt;
+			currentSizePt = sorted[pointer].sizePt ?? defaultSizePt;
 			currentHidden = sorted[pointer].hidden ?? false;
 			pointer++;
 		}
@@ -78,7 +78,7 @@ function computeHeaderGutter(printSettings, range, measurer) {
 	};
 }
 function resolveScale(printSettings, availableWidthPt, availableHeightPt, totalContentWidthPt, totalContentHeightPt) {
-	if (printSettings.scale !== void 0) return Math.max(printSettings.scale / 100, MINIMUM_SCALE);
+	if (printSettings.scalePercent !== void 0) return Math.max(printSettings.scalePercent / 100, MINIMUM_SCALE);
 	if (printSettings.fitToPages !== void 0) {
 		const budgetWidthPt = availableWidthPt * printSettings.fitToPages.width;
 		const budgetHeightPt = availableHeightPt * printSettings.fitToPages.height;
@@ -126,7 +126,7 @@ function cellStyledRuns(cell) {
 	}];
 }
 function isNumericLikeValue(kind) {
-	return kind === "number" || kind === "percentage" || kind === "currency" || kind === "date" || kind === "time";
+	return kind === "number" || kind === "percentage" || kind === "currency" || kind === "date" || kind === "time" || kind === "dateTime";
 }
 function defaultAlignmentForValue(kind) {
 	if (isNumericLikeValue(kind)) return "right";

package/dist/markdown/read.cjs

@@ -1,10 +1,14 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let document_schema_js = require("document-schema.js");
 let markdown_codec = require("markdown-codec");
 //#region src/markdown/read.ts
 function readMarkdownContent(text, options) {
 	const { document } = (0, markdown_codec.readMarkdown)(text, options);
 	if (document.kind !== "wordprocessing") throw new Error("readMarkdown returned a non-wordprocessing ContentDocument");
-	return document;
+	return document_schema_js.ContentDocumentSchema.parse({
+		...document,
+		formatVersion: document_schema_js.CONTENT_FORMAT_VERSION
+	});
 }
 //#endregion
 exports.readMarkdownContent = readMarkdownContent;

package/dist/markdown/read.js

@@ -1,9 +1,13 @@
+import { CONTENT_FORMAT_VERSION, ContentDocumentSchema } from "document-schema.js";
 import { readMarkdown } from "markdown-codec";
 //#region src/markdown/read.ts
 function readMarkdownContent(text, options) {
 	const { document } = readMarkdown(text, options);
 	if (document.kind !== "wordprocessing") throw new Error("readMarkdown returned a non-wordprocessing ContentDocument");
-	return document;
+	return ContentDocumentSchema.parse({
+		...document,
+		formatVersion: CONTENT_FORMAT_VERSION
+	});
 }
 //#endregion
 export { readMarkdownContent };

package/dist/markdown/write.cjs

@@ -1,8 +1,41 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let markdown_codec = require("markdown-codec");
 //#region src/markdown/write.ts
+function toLegacyEmbeddedDocument(document) {
+	if (document.kind !== "wordprocessing") throw new markdown_codec.MarkdownUnsupportedDocumentKindError(document.kind);
+	return toLegacyWordprocessingDocument(document);
+}
+function toLegacyBlock(block) {
+	if (block.kind === "table") return {
+		...block,
+		rows: block.rows.map((row) => ({
+			...row,
+			cells: row.cells.map((cell) => ({
+				...cell,
+				blocks: cell.blocks.map(toLegacyBlock)
+			}))
+		}))
+	};
+	if (block.kind === "embeddedObject") return {
+		...block,
+		document: toLegacyEmbeddedDocument(block.document)
+	};
+	return block;
+}
+function toLegacyWordprocessingDocument(document) {
+	return {
+		kind: "wordprocessing",
+		formatVersion: 1,
+		metadata: document.metadata,
+		sections: document.sections.map((section) => ({
+			...section,
+			blocks: section.blocks.map(toLegacyBlock)
+		}))
+	};
+}
 function buildMarkdownText(document, options) {
-	return (0, markdown_codec.writeMarkdown)(document, options);
+	if (document.kind !== "wordprocessing") throw new markdown_codec.MarkdownUnsupportedDocumentKindError(document.kind);
+	return (0, markdown_codec.writeMarkdown)(toLegacyWordprocessingDocument(document), options);
 }
 //#endregion
 exports.buildMarkdownText = buildMarkdownText;

package/dist/markdown/write.js

@@ -1,7 +1,40 @@
-import { writeMarkdown } from "markdown-codec";
+import { MarkdownUnsupportedDocumentKindError, writeMarkdown } from "markdown-codec";
 //#region src/markdown/write.ts
+function toLegacyEmbeddedDocument(document) {
+	if (document.kind !== "wordprocessing") throw new MarkdownUnsupportedDocumentKindError(document.kind);
+	return toLegacyWordprocessingDocument(document);
+}
+function toLegacyBlock(block) {
+	if (block.kind === "table") return {
+		...block,
+		rows: block.rows.map((row) => ({
+			...row,
+			cells: row.cells.map((cell) => ({
+				...cell,
+				blocks: cell.blocks.map(toLegacyBlock)
+			}))
+		}))
+	};
+	if (block.kind === "embeddedObject") return {
+		...block,
+		document: toLegacyEmbeddedDocument(block.document)
+	};
+	return block;
+}
+function toLegacyWordprocessingDocument(document) {
+	return {
+		kind: "wordprocessing",
+		formatVersion: 1,
+		metadata: document.metadata,
+		sections: document.sections.map((section) => ({
+			...section,
+			blocks: section.blocks.map(toLegacyBlock)
+		}))
+	};
+}
 function buildMarkdownText(document, options) {
-	return writeMarkdown(document, options);
+	if (document.kind !== "wordprocessing") throw new MarkdownUnsupportedDocumentKindError(document.kind);
+	return writeMarkdown(toLegacyWordprocessingDocument(document), options);
 }
 //#endregion
 export { buildMarkdownText };

package/dist/mathml/layout.cjs

@@ -142,16 +142,23 @@ function layoutScripts(base, subscript, superscript, ctx) {
 		items
 	};
 }
-function layoutUnderOver(base, under, over, ctx) {
+function layoutUnderOver(base, under, over, ctx, accentAttachment = {}) {
 	const gapPt = ctx.metrics.stackGapMinPt;
 	const overHeightPt = over === void 0 ? 0 : gapPt + over.heightPt;
 	const underHeightPt = under === void 0 ? 0 : gapPt + under.heightPt;
 	const ascentPt = base.ascentPt + overHeightPt;
 	const descentPt = base.descentPt + underHeightPt;
 	const widthPt = Math.max(base.widthPt, under?.widthPt ?? 0, over?.widthPt ?? 0);
-	const items = [...require_mathml_compose.placeChild(base, (widthPt - base.widthPt) / 2, 0, ascentPt)];
-	if (over !== void 0) items.push(...require_mathml_compose.placeChild(over, (widthPt - over.widthPt) / 2, -(base.ascentPt + gapPt + over.descentPt), ascentPt));
-	if (under !== void 0) items.push(...require_mathml_compose.placeChild(under, (widthPt - under.widthPt) / 2, base.descentPt + gapPt + under.ascentPt, ascentPt));
+	const baseXPt = (widthPt - base.widthPt) / 2;
+	const items = [...require_mathml_compose.placeChild(base, baseXPt, 0, ascentPt)];
+	if (over !== void 0) {
+		const overXPt = accentAttachment.overXPt === void 0 ? (widthPt - over.widthPt) / 2 : baseXPt + accentAttachment.overXPt - over.widthPt / 2;
+		items.push(...require_mathml_compose.placeChild(over, overXPt, -(base.ascentPt + gapPt + over.descentPt), ascentPt));
+	}
+	if (under !== void 0) {
+		const underXPt = accentAttachment.underXPt === void 0 ? (widthPt - under.widthPt) / 2 : baseXPt + accentAttachment.underXPt - under.widthPt / 2;
+		items.push(...require_mathml_compose.placeChild(under, underXPt, base.descentPt + gapPt + under.ascentPt, ascentPt));
+	}
 	return {
 		widthPt,
 		ascentPt,
@@ -163,6 +170,26 @@ function layoutUnderOver(base, under, over, ctx) {
 function isMovableLimitsOperator(element) {
 	return require_mathml_nodes.elementLocalName(element) === "mo" && require_mathml_operators.operatorProperties(require_mathml_nodes.textContent(element).trim()).movablelimits;
 }
+function resolveTopAccentXPt(baseElement, ctx) {
+	const name = require_mathml_nodes.elementLocalName(baseElement);
+	let rawText;
+	let intrinsicDefault;
+	if (name === "mi") {
+		rawText = require_mathml_nodes.textContent(baseElement);
+		intrinsicDefault = miIntrinsicDefault(rawText);
+	} else if (name === "mn" || name === "mtext") {
+		rawText = require_mathml_nodes.textContent(baseElement);
+		intrinsicDefault = "normal";
+	} else if (name === "mo") {
+		rawText = require_mathml_nodes.textContent(baseElement).trim();
+		intrinsicDefault = "normal";
+	} else return;
+	const codePoints = [...require_mathml_variant.applyMathVariant(rawText, tokenVariant(baseElement, intrinsicDefault, ctx))];
+	if (codePoints.length !== 1) return;
+	const codePoint = codePoints[0]?.codePointAt(0);
+	if (codePoint === void 0) return;
+	return ctx.metrics.glyph(codePoint, ctx.sizePt)?.topAccentXPt;
+}
 function layoutUnderOverElement(element, kind, ctx) {
 	const children = require_mathml_nodes.elementChildren(element);
 	const baseElement = children[0];
@@ -176,9 +203,16 @@ function layoutUnderOverElement(element, kind, ctx) {
 	}
 	const base = layoutNode(baseElement, ctx);
 	const scriptCtx = scriptContext(ctx, false);
-	if (kind === "munder") return layoutUnderOver(base, children[1] === void 0 ? void 0 : layoutNode(children[1], scriptCtx), void 0, ctx);
-	if (kind === "mover") return layoutUnderOver(base, void 0, children[1] === void 0 ? void 0 : layoutNode(children[1], scriptCtx), ctx);
-	return layoutUnderOver(base, children[1] === void 0 ? void 0 : layoutNode(children[1], scriptCtx), children[2] === void 0 ? void 0 : layoutNode(children[2], scriptCtx), ctx);
+	const isAccent = require_mathml_nodes.attrValue(element, "accent") === "true";
+	const isAccentUnder = require_mathml_nodes.attrValue(element, "accentunder") === "true";
+	const topAccentXPt = isAccent || isAccentUnder ? resolveTopAccentXPt(baseElement, ctx) : void 0;
+	const accentAttachment = {
+		overXPt: isAccent ? topAccentXPt : void 0,
+		underXPt: isAccentUnder ? topAccentXPt : void 0
+	};
+	if (kind === "munder") return layoutUnderOver(base, children[1] === void 0 ? void 0 : layoutNode(children[1], scriptCtx), void 0, ctx, accentAttachment);
+	if (kind === "mover") return layoutUnderOver(base, void 0, children[1] === void 0 ? void 0 : layoutNode(children[1], scriptCtx), ctx, accentAttachment);
+	return layoutUnderOver(base, children[1] === void 0 ? void 0 : layoutNode(children[1], scriptCtx), children[2] === void 0 ? void 0 : layoutNode(children[2], scriptCtx), ctx, accentAttachment);
 }
 function layoutFraction(element, ctx) {
 	const children = require_mathml_nodes.elementChildren(element);

package/dist/mathml/layout.js

@@ -141,16 +141,23 @@ function layoutScripts(base, subscript, superscript, ctx) {
 		items
 	};
 }
-function layoutUnderOver(base, under, over, ctx) {
+function layoutUnderOver(base, under, over, ctx, accentAttachment = {}) {
 	const gapPt = ctx.metrics.stackGapMinPt;
 	const overHeightPt = over === void 0 ? 0 : gapPt + over.heightPt;
 	const underHeightPt = under === void 0 ? 0 : gapPt + under.heightPt;
 	const ascentPt = base.ascentPt + overHeightPt;
 	const descentPt = base.descentPt + underHeightPt;
 	const widthPt = Math.max(base.widthPt, under?.widthPt ?? 0, over?.widthPt ?? 0);
-	const items = [...placeChild(base, (widthPt - base.widthPt) / 2, 0, ascentPt)];
-	if (over !== void 0) items.push(...placeChild(over, (widthPt - over.widthPt) / 2, -(base.ascentPt + gapPt + over.descentPt), ascentPt));
-	if (under !== void 0) items.push(...placeChild(under, (widthPt - under.widthPt) / 2, base.descentPt + gapPt + under.ascentPt, ascentPt));
+	const baseXPt = (widthPt - base.widthPt) / 2;
+	const items = [...placeChild(base, baseXPt, 0, ascentPt)];
+	if (over !== void 0) {
+		const overXPt = accentAttachment.overXPt === void 0 ? (widthPt - over.widthPt) / 2 : baseXPt + accentAttachment.overXPt - over.widthPt / 2;
+		items.push(...placeChild(over, overXPt, -(base.ascentPt + gapPt + over.descentPt), ascentPt));
+	}
+	if (under !== void 0) {
+		const underXPt = accentAttachment.underXPt === void 0 ? (widthPt - under.widthPt) / 2 : baseXPt + accentAttachment.underXPt - under.widthPt / 2;
+		items.push(...placeChild(under, underXPt, base.descentPt + gapPt + under.ascentPt, ascentPt));
+	}
 	return {
 		widthPt,
 		ascentPt,
@@ -162,6 +169,26 @@ function layoutUnderOver(base, under, over, ctx) {
 function isMovableLimitsOperator(element) {
 	return elementLocalName(element) === "mo" && operatorProperties(textContent(element).trim()).movablelimits;
 }
+function resolveTopAccentXPt(baseElement, ctx) {
+	const name = elementLocalName(baseElement);
+	let rawText;
+	let intrinsicDefault;
+	if (name === "mi") {
+		rawText = textContent(baseElement);
+		intrinsicDefault = miIntrinsicDefault(rawText);
+	} else if (name === "mn" || name === "mtext") {
+		rawText = textContent(baseElement);
+		intrinsicDefault = "normal";
+	} else if (name === "mo") {
+		rawText = textContent(baseElement).trim();
+		intrinsicDefault = "normal";
+	} else return;
+	const codePoints = [...applyMathVariant(rawText, tokenVariant(baseElement, intrinsicDefault, ctx))];
+	if (codePoints.length !== 1) return;
+	const codePoint = codePoints[0]?.codePointAt(0);
+	if (codePoint === void 0) return;
+	return ctx.metrics.glyph(codePoint, ctx.sizePt)?.topAccentXPt;
+}
 function layoutUnderOverElement(element, kind, ctx) {
 	const children = elementChildren(element);
 	const baseElement = children[0];
@@ -175,9 +202,16 @@ function layoutUnderOverElement(element, kind, ctx) {
 	}
 	const base = layoutNode(baseElement, ctx);
 	const scriptCtx = scriptContext(ctx, false);
-	if (kind === "munder") return layoutUnderOver(base, children[1] === void 0 ? void 0 : layoutNode(children[1], scriptCtx), void 0, ctx);
-	if (kind === "mover") return layoutUnderOver(base, void 0, children[1] === void 0 ? void 0 : layoutNode(children[1], scriptCtx), ctx);
-	return layoutUnderOver(base, children[1] === void 0 ? void 0 : layoutNode(children[1], scriptCtx), children[2] === void 0 ? void 0 : layoutNode(children[2], scriptCtx), ctx);
+	const isAccent = attrValue(element, "accent") === "true";
+	const isAccentUnder = attrValue(element, "accentunder") === "true";
+	const topAccentXPt = isAccent || isAccentUnder ? resolveTopAccentXPt(baseElement, ctx) : void 0;
+	const accentAttachment = {
+		overXPt: isAccent ? topAccentXPt : void 0,
+		underXPt: isAccentUnder ? topAccentXPt : void 0
+	};
+	if (kind === "munder") return layoutUnderOver(base, children[1] === void 0 ? void 0 : layoutNode(children[1], scriptCtx), void 0, ctx, accentAttachment);
+	if (kind === "mover") return layoutUnderOver(base, void 0, children[1] === void 0 ? void 0 : layoutNode(children[1], scriptCtx), ctx, accentAttachment);
+	return layoutUnderOver(base, children[1] === void 0 ? void 0 : layoutNode(children[1], scriptCtx), children[2] === void 0 ? void 0 : layoutNode(children[2], scriptCtx), ctx, accentAttachment);
 }
 function layoutFraction(element, ctx) {
 	const children = elementChildren(element);

package/dist/mathml/variant.cjs

@@ -824,7 +824,13 @@ const GREEK_VARIANTS = {
 			120538
 		],
 		nabla: 120513,
-		partial: 120539
+		partial: 120539,
+		epsilon: 120540,
+		theta: 120541,
+		kappa: 120542,
+		phi: 120543,
+		rho: 120544,
+		pi: 120545
 	},
 	italic: {
 		upper: [
@@ -880,7 +886,13 @@ const GREEK_VARIANTS = {
 			120596
 		],
 		nabla: 120571,
-		partial: 120597
+		partial: 120597,
+		epsilon: 120598,
+		theta: 120599,
+		kappa: 120600,
+		phi: 120601,
+		rho: 120602,
+		pi: 120603
 	},
 	"bold-italic": {
 		upper: [
@@ -936,7 +948,13 @@ const GREEK_VARIANTS = {
 			120654
 		],
 		nabla: 120629,
-		partial: 120655
+		partial: 120655,
+		epsilon: 120656,
+		theta: 120657,
+		kappa: 120658,
+		phi: 120659,
+		rho: 120660,
+		pi: 120661
 	},
 	"bold-sans-serif": {
 		upper: [
@@ -992,7 +1010,13 @@ const GREEK_VARIANTS = {
 			120712
 		],
 		nabla: 120687,
-		partial: 120713
+		partial: 120713,
+		epsilon: 120714,
+		theta: 120715,
+		kappa: 120716,
+		phi: 120717,
+		rho: 120718,
+		pi: 120719
 	},
 	"sans-serif-bold-italic": {
 		upper: [
@@ -1048,9 +1072,23 @@ const GREEK_VARIANTS = {
 			120770
 		],
 		nabla: 120745,
-		partial: 120771
+		partial: 120771,
+		epsilon: 120772,
+		theta: 120773,
+		kappa: 120774,
+		phi: 120775,
+		rho: 120776,
+		pi: 120777
 	}
 };
+const GREEK_SYMBOL_BASES = /* @__PURE__ */ new Map([
+	[1013, "epsilon"],
+	[977, "theta"],
+	[1008, "kappa"],
+	[981, "phi"],
+	[1009, "rho"],
+	[982, "pi"]
+]);
 const DIGIT_VARIANTS = {
 	bold: [
 		120782,
@@ -1124,6 +1162,11 @@ function mapMathVariant(codePoint, variant) {
 	if (greekLowerIndex !== -1) return GREEK_VARIANTS[variant]?.lower[greekLowerIndex] ?? codePoint;
 	if (codePoint === 8711) return GREEK_VARIANTS[variant]?.nabla ?? codePoint;
 	if (codePoint === 8706) return GREEK_VARIANTS[variant]?.partial ?? codePoint;
+	const symbolField = GREEK_SYMBOL_BASES.get(codePoint);
+	if (symbolField !== void 0) {
+		const entry = GREEK_VARIANTS[variant];
+		return entry === void 0 ? codePoint : entry[symbolField];
+	}
 	return codePoint;
 }
 function applyMathVariant(text, variant) {

package/dist/mathml/variant.js

@@ -823,7 +823,13 @@ const GREEK_VARIANTS = {
 			120538
 		],
 		nabla: 120513,
-		partial: 120539
+		partial: 120539,
+		epsilon: 120540,
+		theta: 120541,
+		kappa: 120542,
+		phi: 120543,
+		rho: 120544,
+		pi: 120545
 	},
 	italic: {
 		upper: [
@@ -879,7 +885,13 @@ const GREEK_VARIANTS = {
 			120596
 		],
 		nabla: 120571,
-		partial: 120597
+		partial: 120597,
+		epsilon: 120598,
+		theta: 120599,
+		kappa: 120600,
+		phi: 120601,
+		rho: 120602,
+		pi: 120603
 	},
 	"bold-italic": {
 		upper: [
@@ -935,7 +947,13 @@ const GREEK_VARIANTS = {
 			120654
 		],
 		nabla: 120629,
-		partial: 120655
+		partial: 120655,
+		epsilon: 120656,
+		theta: 120657,
+		kappa: 120658,
+		phi: 120659,
+		rho: 120660,
+		pi: 120661
 	},
 	"bold-sans-serif": {
 		upper: [
@@ -991,7 +1009,13 @@ const GREEK_VARIANTS = {
 			120712
 		],
 		nabla: 120687,
-		partial: 120713
+		partial: 120713,
+		epsilon: 120714,
+		theta: 120715,
+		kappa: 120716,
+		phi: 120717,
+		rho: 120718,
+		pi: 120719
 	},
 	"sans-serif-bold-italic": {
 		upper: [
@@ -1047,9 +1071,23 @@ const GREEK_VARIANTS = {
 			120770
 		],
 		nabla: 120745,
-		partial: 120771
+		partial: 120771,
+		epsilon: 120772,
+		theta: 120773,
+		kappa: 120774,
+		phi: 120775,
+		rho: 120776,
+		pi: 120777
 	}
 };
+const GREEK_SYMBOL_BASES = /* @__PURE__ */ new Map([
+	[1013, "epsilon"],
+	[977, "theta"],
+	[1008, "kappa"],
+	[981, "phi"],
+	[1009, "rho"],
+	[982, "pi"]
+]);
 const DIGIT_VARIANTS = {
 	bold: [
 		120782,
@@ -1123,6 +1161,11 @@ function mapMathVariant(codePoint, variant) {
 	if (greekLowerIndex !== -1) return GREEK_VARIANTS[variant]?.lower[greekLowerIndex] ?? codePoint;
 	if (codePoint === 8711) return GREEK_VARIANTS[variant]?.nabla ?? codePoint;
 	if (codePoint === 8706) return GREEK_VARIANTS[variant]?.partial ?? codePoint;
+	const symbolField = GREEK_SYMBOL_BASES.get(codePoint);
+	if (symbolField !== void 0) {
+		const entry = GREEK_VARIANTS[variant];
+		return entry === void 0 ? codePoint : entry[symbolField];
+	}
 	return codePoint;
 }
 function applyMathVariant(text, variant) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js.documents",
-  "version": "1.60.2",
+  "version": "1.61.0",
   "description": "Bidirectional docx/pptx <-> PDF conversion and a read+write editable OOXML document model, built on ooxml.js and Zod 4 codecs.",
   "type": "module",
   "repository": {
@@ -58,12 +58,12 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "document-schema.js": "^1.7.0",
+    "document-schema.js": "^2.0.0",
     "fflate": "^0.8.3",
     "markdown-codec": "github:ExaDev/markdown-codec#beda0a89d92fffd153d5dcd05d767b404b721cda",
-    "odf.js": "^1.10.3",
-    "ooxml.js": "^2.2.3",
-    "pdf-codec": "^1.1.3",
+    "odf.js": "^1.13.2",
+    "ooxml.js": "^2.5.2",
+    "pdf-codec": "^1.4.2",
     "zod": "^4.4.3"
   },
   "devDependencies": {