ooxml.js 3.1.0 → 4.0.0

package/README.md

@@ -50,7 +50,7 @@ graph TD
 
 ## Why
 
-Semantic typed models are lossy and one-directional: they cannot round-trip. True round-trip needs every part, relationship, and binary byte-for-byte at the content level. `ooxml.js` provides that lossless foundation, with typed reading views (`Document`/`Presentation`/`Workbook`) on top.
+Semantic typed models are lossy and one-directional: they cannot round-trip. True round-trip needs every part, relationship, and binary byte-for-byte at the content level. `ooxml.js` provides that lossless foundation, with typed per-format readers and writers on top — each available both as `document-schema.js`'s tree-form `DocumentPackage` and as the flat, content-level shape that tree decomposes.
 
 ## Getting started
 
@@ -70,7 +70,7 @@ npm install ooxml.js
 
 ## Compatibility
 
-Worker-isomorphic: runtime `src/` uses no Node-only APIs (no `node:*` imports, no bare Node builtins, no `Buffer` global), so the published package runs in Cloudflare Workers, Deno Deploy, browser bundlers, or any ES2024+ host — not just Node. This is enforced statically by an `eslint` guard (`no-restricted-imports`/`no-restricted-globals` in `eslint.config.ts`) that rejects any Node-only import in `src/`, and dynamically by the `workerd` test suite (`pnpm test:workers`) that exercises the xlsx decode path inside a Cloudflare Workers isolate on every CI run. The `engines.node >= 20` pin is the development and CI floor, not a runtime constraint on consumers.
+Worker-isomorphic: runtime `src/` uses no Node-only APIs (no `node:*` imports, no bare Node builtins, no `Buffer` global), so the published package runs in Cloudflare Workers, Deno Deploy, browser bundlers, or any ES2024+ host — not just Node. This is enforced statically by an `eslint` guard (`no-restricted-imports`/`no-restricted-globals` in `eslint.config.ts`) that rejects any Node-only import in `src/`, and dynamically by the `workerd` test suite (`pnpm test:workers`) that exercises the xlsx decode path, and the `DocumentPackage` assembly and write path on top of it, inside a Cloudflare Workers isolate on every CI run. The `engines.node >= 20` pin is the development and CI floor, not a runtime constraint on consumers.
 
 ## Usage
 
@@ -96,43 +96,80 @@ const pkg = z.decode(packageCodec, bytes);
 const out = z.encode(packageCodec, pkg);
 ```
 
-Typed views project `Package` into ergonomic models (lossy; read-only). `readDocx`/`readPptx` resolve the full style/theme cascade, so order, styling, and geometry come through, not just flattened text:
+### Typed readers and writers
 
-```ts
-import { decodePackage, readDocx } from 'ooxml.js';
+Above the lossless core sit typed readers that resolve a format's own cascades — the docx style cascade, pptx's placeholder → layout → master → theme inheritance, xlsx's style-index → number-format classification — so order, styling, and geometry come through, not just flattened text. Each format has two entry points onto the same read: one producing `document-schema.js`'s tree-form `DocumentPackage`, one producing the flat, content-level shape that tree decomposes.
 
-const doc = readDocx(decodePackage(bytes));
-// doc.sections[0].blocks holds paragraphs/tables/page-breaks in document order (including
-// inside tables); each run already carries its cascade-resolved bold/italic/colour/font.
-```
+| Format | `DocumentPackage` (primary) | Flat, content-level |
+| --- | --- | --- |
+| docx | `readDocx` / `buildDocxPackage` | `readDocxContent` / `buildDocxPackageFromContent` |
+| pptx | `readPptx` (read-only) | `readPptxContent` (read-only) |
+| xlsx | `readXlsx` / `buildXlsxPackage` | `readXlsxContent` / `buildXlsxPackageFromContent` |
+
+`readXlsxWorkbook` sits outside the table: a separate lossy, cell-values-only reading view (sheet names, references, resolved values, formulas, merged ranges, defined names) with no write side.
 
-`readDocx` also reads the block-scoped fidelity constructs — structured document tags, fields, bookmarks, and tracked changes — as `document-schema.js` construct-boundary markers bracketing the blocks each one spans, and `buildDocxPackage` writes those sections back out as a fresh docx package:
+#### The `DocumentPackage` API
+
+`readDocx`/`readPptx`/`readXlsx` decompose what they read into the tree `document-schema.js` defines — one group per top-level container, headings and lists nested inside the section they belong to, block-scoped constructs promoted to the region they span, repeated formatting factored into a package-level styles table. `buildDocxPackage`/`buildXlsxPackage` take one back the other way:
 
 ```ts
 import { buildDocxPackage, decodePackage, encodePackage, readDocx } from 'ooxml.js';
 
-const doc = readDocx(decodePackage(bytes));
-// doc.sections[0].blocks might read: a constructStart marker carrying a field descriptor, the TOC's
-// own paragraphs, then a constructEnd — one matched pair per construct, nesting as brackets do.
-const out = encodePackage(buildDocxPackage(doc)); // sections -> a complete docx, built from scratch
+const document = readDocx(decodePackage(bytes)); // DocumentPackage, kind: 'wordprocessing'
+// document.children is one section group per section, the section's page geometry on the group's own
+// node. Inside it, a heading paragraph opens a group holding the blocks beneath it, a list paragraph
+// opens its own, and a table stays a leaf — decomposition groups a container's block flow, it never
+// descends into a table's cells.
+const out = encodePackage(buildDocxPackage(document)); // a complete docx, built from scratch
 ```
 
-A construct whose extent is a sub-sequence of one paragraph's runs — a field inside a sentence, a bookmark over three words, a few inserted words in an otherwise untouched paragraph — has no marker encoding: the marker pair brackets whole blocks, so those occurrences keep their existing treatment (the text still comes through; the construct itself does not). See the gotchas below.
+Readers mint the styles table (`assemblePackage`, i.e. `decompose` plus the frequency pass) because a reader is where a package first comes into existence. Writers materialise every ref back into direct properties (`flattenPackage`) before handing the content to the format writer, so a minted package, a hand-built one with no table at all, and a re-minted one all write out identically. Both transforms — and `decompose`/`factorStyles` for a caller composing its own boundary — are re-exported from this package, so consuming what these readers return takes no second dependency.
 
-`readXlsx` is the lossy, cell-values-only view. `readXlsxContent`/`buildXlsxPackage` are a separate `ContentDocument`-shaped pair — a richer reader (column widths, row heights, hidden rows/columns, merged ranges, every cell value kind, cell comments, print settings) matched with this package's first writer, round-tripping a spreadsheet through the same `ContentDocument` shape `documents.js`/`odf.js` use:
+Minting has a real consequence for a caller walking the tree by hand, and it is the single biggest behavioural difference between these primary names and the `Content` ones below: a run or paragraph that shares its formatting with others in the same subtree no longer carries that formatting itself. Three bold, red paragraphs in one section come back as three plain `{"text": "..."}` runs plus one `style: "s1"` ref on the enclosing group, with `styles: {"s1": {"run": {"bold": true, "color": {...}}}}` on the package root — not as three runs each carrying `bold`/`color` directly. Reading a run's real effective formatting off a tree therefore means resolving its ancestor groups' `style` refs first: `resolveStyleChain` collects the chain from the root down to a node, `overlayStyleEntries` merges it outermost-first (the nearest entry wins), and `applyParagraphStyleProperties`/`applyRunStyleProperties` gap-fill a resolved entry onto whatever direct properties the node already carries. All four are re-exported from this package's barrel alongside `StylesTable`/`StyleEntry`/`StyleParagraphProperties`/`StyleRunProperties`, so resolving a run's formatting back out of a tree takes no second dependency either. A `Content`-suffixed reader never needs any of this: it returns a fully materialised `ContentDocument` with no refs and no table to consult.
+
+#### The flat, content-level API
+
+The `Content`-suffixed functions are what the tree-form ones wrap, exported in their own right for a caller driving a pipeline stage by stage (`documents.js`'s conversion engine does exactly this) or needing what the tree has no spelling for. Routing through the tree costs no fidelity of its own: `buildDocxPackage(readDocx(pkg))` builds the identical `Package` `buildDocxPackageFromContent(readDocxContent(pkg))` does, and flattening a tree reproduces exactly the content its content-level reader returns — both pinned in `src/typed/document-package.test.ts`.
 
 ```ts
-import { buildXlsxPackage, decodePackage, readXlsxContent } from 'ooxml.js';
+import { buildXlsxPackageFromContent, decodePackage, readXlsxContent } from 'ooxml.js';
 
 const content = readXlsxContent(decodePackage(bytes)); // ContentDocument, kind: 'spreadsheet'
-const pkg = buildXlsxPackage(content); // a fresh Package built from scratch, not a write-back into `pkg`
+const pkg = buildXlsxPackageFromContent(content); // a fresh Package built from scratch, not a write-back into `pkg`
 ```
 
+`readDocxContent` is the only reader in this package that returns a docx's comments, footnotes, header/footer text, and `word/numbering.xml` definitions: those sit on `DocxDocument` outside its `sections`, which is exactly the part of it `ContentDocument` — and therefore the tree — has no place for. They do not survive `buildDocxPackageFromContent` either (it writes none of those parts), so this is about which reader returns them, not about which pair round-trips them.
+
+#### Fidelity constructs
+
+Both docx readers read the block-scoped fidelity constructs — structured document tags, fields, bookmarks, and tracked changes. In the flat form they are `document-schema.js` construct-boundary markers bracketing the blocks each one spans, one matched `constructStart`/`constructEnd` pair per construct, nesting as brackets do; in the tree they are promoted to a group over exactly that region, carrying the same descriptor. Both docx writers write them back.
+
+A construct whose extent is a sub-sequence of one paragraph's runs — a field inside a sentence, a bookmark over three words, a few inserted words in an otherwise untouched paragraph — has no marker encoding: the marker pair brackets whole blocks, so those occurrences keep their existing treatment (the text still comes through; the construct itself does not). See the gotchas below.
+
+### Migrating from 3.x
+
+The `DocumentPackage` readers and writers took the primary names, and the functions that held them were renamed rather than removed. Every one of them still behaves exactly as it did:
+
+| Was | Is now |
+| --- | --- |
+| `readDocx` | `readDocxContent` |
+| `readPptx` | `readPptxContent` |
+| `readXlsx` | `readXlsxWorkbook` |
+| `buildDocxPackage` | `buildDocxPackageFromContent` |
+| `buildXlsxPackage` | `buildXlsxPackageFromContent` |
+
+`readXlsxContent` is unchanged, and is the one name that already followed this convention.
+
+Three of the renames are silent under a plain call — `readDocx`, `readPptx`, and `readXlsx` still take a `Package`, they just return a `DocumentPackage` now — so a TypeScript caller sees the break where it uses the result (`doc.sections` becomes `document.children`), and a JavaScript caller sees it at runtime. Either add the `Content` suffix to keep the previous behaviour, or move to the tree.
+
+### Deep imports
+
 Every module under `src/` is importable directly, by the same path it has relative to `src/`, without going through the barrel:
 
 ```ts
 import { bytesToBase64, base64ToBytes } from 'ooxml.js/util/base64';
 import { readXlsxContent } from 'ooxml.js/typed/xlsx/content';
+import { readDocx, buildDocxPackage } from 'ooxml.js/typed/document-package';
 ```
 
 ## The ooxml.js format
@@ -241,23 +278,25 @@ The package layers a lossless core outward to lossy convenience views:
 - **`src/package-io/`** — `read.ts`/`write.ts` unzip, classify each entry as XML or binary (`looksLikeXml` byte sniff), and parse/serialize.
 - **`src/codec.ts`** — public round-trip surface: `packageCodec`/`xmlCodec` (`z.codec()` pairs) plus `decodePackage`/`encodePackage` wrappers.
 - **`src/compact.ts`** — the ooxml.js format: `compactCodec`/`compactPackageCodec` plus `toCompact`/`fromCompact`/`decodeCompactPackage`/`encodeCompactPackage` wrappers.
-- **`src/typed/`** — lossy projections. `readDocx` resolves the full style cascade (`docDefaults` → `basedOn` → paragraph-mark → character styles → direct formatting) into ordered `sections` plus comments/footnotes/headers/footers/numbering; `readPptx` resolves placeholder → layout → master → theme inheritance into `slides` (presentation order via `p:sldIdLst`); `readXlsx` covers cell values/formulas, merged ranges, defined names. `typed/shared/` holds shared OOXML primitives (`drawingml.ts` geometry/theme/colour, `color.ts` `ColorTransform` cascade, `units.ts`, `metadata.ts`, `source-path.ts`). Types come from `document-schema.js`. Only the docx and xlsx `ContentDocument`-shaped pairs encode back to a `Package`; everything else is one-way, and faithful round-tripping goes through `decodePackage`/`encodePackage`.
-- **`src/typed/docx/`** — `read.ts` and `write.ts` are a read/write pair over `ContentSection[]`. `constructs.ts` owns the fidelity construct vocabulary both halves share: the descriptor shapes (`contentControl` from `w:sdt`, `field` from `w:fldChar`/`w:fldSimple`, `anchor` from `w:bookmarkStart`/`End`, `provenance` from `w:ins`/`w:del`/`w:moveFrom`/`w:moveTo`) and the rule deciding which occurrences are block-scoped enough to bracket. `buildDocxPackage` builds a complete docx `Package` from scratch; it writes no `styles.xml`, `numbering.xml`, comments, footnotes, or headers/footers, so the `DocxDocument` fields outside `sections` do not survive the pair.
-- **`src/typed/xlsx/`** — a `ContentDocument`-shaped read/write pair alongside the lossy `readXlsx` (both exported; different callers). `readXlsxContent` reads column widths, row heights, hidden rows/columns, merged ranges, every cell value kind, print settings, and cell comments (`comments.ts`: legacy `xl/comments{N}.xml` notes plus `[MS-XLSX]` threaded comments, both resolved through the worksheet part's own relationships, never by part name); `buildXlsxPackage` builds a complete xlsx `Package` from scratch (never editing the decoded package). `number-format.ts`/`styles.ts`/`serial.ts` run both ways: reading classifies style index → format code → kind (`percentage`/`currency`/`date`/`time`/`dateTime`); writing emits interned `numFmt` codes, fed back through the classifier in tests. The classifier is not a formatter (`displayText` is the typed-value spelling). Scope limits: `currency` with no ISO code writes as plain `number`; non-canonical temporal values degrade to text; cell comments read but do not write (`buildXlsxPackage` emits no comment part, so they do not survive this pair).
+- **`src/typed/`** — lossy projections. `readDocxContent` resolves the full style cascade (`docDefaults` → `basedOn` → paragraph-mark → character styles → direct formatting) into ordered `sections` plus comments/footnotes/headers/footers/numbering; `readPptxContent` resolves placeholder → layout → master → theme inheritance into `slides` (presentation order via `p:sldIdLst`); `readXlsxWorkbook` covers cell values/formulas, merged ranges, defined names. `typed/shared/` holds shared OOXML primitives (`drawingml.ts` geometry/theme/colour, `color.ts` `ColorTransform` cascade, `units.ts`, `metadata.ts`, `source-path.ts`). Types come from `document-schema.js`. Only the docx and xlsx `ContentDocument`-shaped pairs encode back to a `Package`; everything else is one-way, and faithful round-tripping goes through `decodePackage`/`encodePackage`.
+- **`src/typed/document-package.ts`** — the `DocumentPackage`-native surface, and nothing else: `readDocx`/`readPptx`/`readXlsx` are their content-level reader composed with `document-schema.js`'s `assemblePackage`, `buildDocxPackage`/`buildXlsxPackage` are `flattenPackage` composed with their content-level writer. One module rather than one per format, because the adapters are format-uniform and the reasoning behind them (why a reader mints styles rather than calling bare `decompose`, why a writer's kind guard lives at this boundary, what a docx's non-content parts do instead of riding the tree) is one argument stated once.
+- **`src/typed/docx/`** — `read.ts` and `write.ts` are a read/write pair over `ContentSection[]`. `constructs.ts` owns the fidelity construct vocabulary both halves share: the descriptor shapes (`contentControl` from `w:sdt`, `field` from `w:fldChar`/`w:fldSimple`, `anchor` from `w:bookmarkStart`/`End`, `provenance` from `w:ins`/`w:del`/`w:moveFrom`/`w:moveTo`) and the rule deciding which occurrences are block-scoped enough to bracket. `buildDocxPackageFromContent` builds a complete docx `Package` from scratch; it writes no `styles.xml`, `numbering.xml`, comments, footnotes, or headers/footers, so the `DocxDocument` fields outside `sections` do not survive the pair.
+- **`src/typed/xlsx/`** — a `ContentDocument`-shaped read/write pair alongside the lossy `readXlsxWorkbook` (both exported; different callers). `readXlsxContent` reads column widths, row heights, hidden rows/columns, merged ranges, every cell value kind, print settings, and cell comments (`comments.ts`: legacy `xl/comments{N}.xml` notes plus `[MS-XLSX]` threaded comments, both resolved through the worksheet part's own relationships, never by part name); `buildXlsxPackageFromContent` builds a complete xlsx `Package` from scratch (never editing the decoded package). `number-format.ts`/`styles.ts`/`serial.ts` run both ways: reading classifies style index → format code → kind (`percentage`/`currency`/`date`/`time`/`dateTime`); writing emits interned `numFmt` codes, fed back through the classifier in tests. The classifier is not a formatter (`displayText` is the typed-value spelling). Scope limits: `currency` with no ISO code writes as plain `number`; non-canonical temporal values degrade to text; cell comments read but do not write (`buildXlsxPackageFromContent` emits no comment part, so they do not survive this pair); column widths re-approximate through xlsx's own character-width unit on every write, so a width drifts slightly on each round trip rather than reaching a fixed point.
 
 ## Conventions
 
 - **Zod-first schema/type/guard.** Every model type is inferred from its Zod schema (`z.infer<typeof XSchema>`), not hand-written.
 - **`XmlNode` uses a recursive structural guard, not `z.lazy`.** `z.lazy` collapses to `unknown` for element-children in the pinned Zod version, so `XmlElementSchema` validates `children` via `z.custom<XmlNode>(isXmlNode)`. Any change to `XmlNode`'s shape must update `isXmlNode` in step. `CompactXmlNode` and `document-schema.js`'s `ContentBlock` reuse this pattern.
-- **Lossless core vs. lossy views is a hard boundary.** `decodePackage`/`encodePackage` stay byte/part faithful. A `src/typed/*` reader is a lossy projection; faithful round-tripping goes through the generic `Package`. `readXlsxContent`/`buildXlsxPackage` and `readDocx`/`buildDocxPackage` are the deliberate exceptions — read/write pairs around the shared content model, where each writer builds a fresh package rather than touching the decoded one.
+- **Lossless core vs. lossy views is a hard boundary.** `decodePackage`/`encodePackage` stay byte/part faithful. A `src/typed/*` reader is a lossy projection; faithful round-tripping goes through the generic `Package`. `readXlsxContent`/`buildXlsxPackageFromContent` and `readDocxContent`/`buildDocxPackageFromContent` are the deliberate exceptions — read/write pairs around the shared content model, where each writer builds a fresh package rather than touching the decoded one. The `DocumentPackage`-native pairs above them are those same pairs with a structural transform on each end, so they inherit exactly the same boundary.
 - **XML entities stay raw in the lossless layer.** `parseXml` runs with `processEntities: false`; typed readers decode the five standard entities (`decodeEntities` in `typed/util.ts`) only in their own lossy projection.
 - **No type assertions.** `eslint.config.ts` bans `as` and angle-bracket casts (`assertionStyle: "never"`, `noInlineConfig: true` — no `eslint-disable` escape hatch). Narrow with a guard or parse with Zod.
 
 ## Gotchas and quirks
 
+- **A `Content` suffix means the flat form, not a lesser one.** `readDocx` and `readDocxContent` are the same read; the suffix says which shape comes back (`DocumentPackage` versus the flat `DocxDocument`/`ContentDocument`), never which is more faithful. The pair that genuinely differs in what it reads is `readXlsxWorkbook`, whose name says so by naming its own return type rather than taking a suffix.
 - **A construct marker brackets whole blocks, never a sub-sequence of runs.** `document-schema.js`'s flat form has no run-level extent, so an inline field, a mid-paragraph bookmark, a run-level content control, or a few inserted words inside an otherwise untouched paragraph are read exactly as before — the text survives, the construct does not. So does an extent that crosses another, or that straddles a section break: neither is expressible as balanced brackets, and both are dropped rather than emitted at a position that would decode to a different nesting.
-- **`readDocx`/`buildDocxPackage` round-trip `sections`, not a whole `DocxDocument`.** Numbering definitions, cell border styling/shading, and `w:themeColor` (without `themeShade`/`themeTint`) are read; images read into `ContentImageBlock` (floating `wp:anchor` position not recorded); `PAGE`/`NUMPAGES` fields resolve to Word's cached text. The writer emits no `styles.xml`, `numbering.xml`, comments, footnotes, or headers/footers, so the `DocxDocument` fields outside `sections` do not come back — a paragraph's `styleId` is still written as a `w:pStyle` reference, resolving to nothing, since every property the style would have contributed is already spelled as direct formatting by then.
-- **`readPptx` is one-way.** Connector shapes (`p:cxnSp`) are skipped; shape rotation composes through groups; a chart graphic frame reads its chart part's cached series/category model into a table block (header row = series names, one row per category index); a SmartArt graphic frame reads its diagram data model's node text as paragraphs in diagram order (depth-first over `parOf` connections, siblings by `srcOrd`); an OLE graphic frame reads the fallback picture its `mc:Fallback` carries (or, with none reachable, a paragraph naming the `p:oleObj`'s `progId`) — the embedded payload itself is an external application's data and is not decoded.
+- **The docx pair round-trips `sections`, not a whole `DocxDocument`.** Numbering definitions, cell border styling/shading, and `w:themeColor` (without `themeShade`/`themeTint`) are read; images read into `ContentImageBlock` (floating `wp:anchor` position not recorded); `PAGE`/`NUMPAGES` fields resolve to Word's cached text. The writer emits no `styles.xml`, `numbering.xml`, comments, footnotes, or headers/footers, so the `DocxDocument` fields outside `sections` do not come back — a paragraph's `styleId` is still written as a `w:pStyle` reference, resolving to nothing, since every property the style would have contributed is already spelled as direct formatting by then.
+- **pptx is read-only.** Connector shapes (`p:cxnSp`) are skipped; shape rotation composes through groups; a chart graphic frame reads its chart part's cached series/category model into a table block (header row = series names, one row per category index); a SmartArt graphic frame reads its diagram data model's node text as paragraphs in diagram order (depth-first over `parOf` connections, siblings by `srcOrd`); an OLE graphic frame reads the fallback picture its `mc:Fallback` carries (or, with none reachable, a paragraph naming the `p:oleObj`'s `progId`) — the embedded payload itself is an external application's data and is not decoded.
 - **xlsx has no native percentage/currency/date/time cell type.** Both directions are closed via the number-format engine: reading classifies style → format code → kind; writing emits interned `numFmt` codes, fed back through the classifier in tests. `displayText` is the typed-value spelling, not the producer's rendered string.
 - **`test:smoke` depends on a fresh build.** It runs `tsdown && vitest run --project smoke`, always rebuilding `dist/` first. A bare `vitest` runs both projects; `smoke` fails loudly (`Cannot find module '../dist/index.js'`) if `dist/` is unbuilt.
 - **Binary-vs-XML part classification is a byte sniff, not an extension check.** `looksLikeXml` looks for a leading `<` after skipping a UTF-8 BOM and whitespace; any future binary format starting with `<` would misclassify.
@@ -281,7 +320,7 @@ Commits follow Conventional Commits (`feat:`, `fix:`, `test:`, `chore:`, …), e
 
 ## References
 
-- [document-schema.js](https://github.com/ExaDev/document-schema.js) — canonical `ContentBlock`/`ContentSection`/geometry/colour schemas and `ContentDocument`/`LayoutMetadata` types shared with `odf.js` and `documents.js`.
+- [document-schema.js](https://github.com/ExaDev/document-schema.js) — canonical `ContentBlock`/`ContentSection`/geometry/colour schemas and `ContentDocument`/`LayoutMetadata` types shared with `odf.js` and `documents.js`, plus the `DocumentPackage` tree and the `decompose`/`flattenPackage`/`assemblePackage`/`factorStyles` transform this package's primary readers and writers are built on.
 - [odf.js](https://github.com/ExaDev/odf.js) — sibling OpenDocument Format package, also on `document-schema.js`.
 - [documents.js](https://github.com/ExaDev/documents.js) — adds PDF conversion and a read-and-write docx/pptx editor on top of this package.
 

package/dist/{build-CBL9scQK.d.cts → build-D-ldsmtA.d.cts}

@@ -1,6 +1,6 @@
 import { r as Package } from "./package-L24lkba-.cjs";
 import { ContentDocument } from "document-schema.js";
 //#region src/typed/xlsx/build.d.ts
-declare function buildXlsxPackage(document: ContentDocument): Package;
+declare function buildXlsxPackageFromContent(document: ContentDocument): Package;
 //#endregion
-export { buildXlsxPackage as t };
+export { buildXlsxPackageFromContent as t };

package/dist/{build-C0gS5QeG.d.ts → build-q0qMH_ML.d.ts}

@@ -1,6 +1,6 @@
 import { r as Package } from "./package-BUojjTXf.js";
 import { ContentDocument } from "document-schema.js";
 //#region src/typed/xlsx/build.d.ts
-declare function buildXlsxPackage(document: ContentDocument): Package;
+declare function buildXlsxPackageFromContent(document: ContentDocument): Package;
 //#endregion
-export { buildXlsxPackage as t };
+export { buildXlsxPackageFromContent as t };

package/dist/codec-BOGj_yQL.d.ts

@@ -0,0 +1,90 @@
+import { d as XmlNode } from "./node-CkBWRjNR.js";
+import { r as Package } from "./package-BUojjTXf.js";
+import "./read-CMDEXqGw.js";
+import "./write-CT-EgVT7.js";
+import "./parse-A8_8sdpX.js";
+import "./build-Z1KRkSEB.js";
+import "./fragment-B1ZV7T5Z.js";
+import "./util-DFe4UbvU.js";
+import "./compact-f0TfhicN.js";
+import "./color-fFIKAs-Y.js";
+import "./metadata-o_WH9V_I.js";
+import "./document-package-kartHoyl.js";
+import "./read-gB0H2bff.js";
+import "./write-97yEqc6w.js";
+import "./numbering-D0YfuiOO.js";
+import "./read-DcJZITV9.js";
+import "./xlsx-DacFqZeF.js";
+import "./content-t6ZfmfQM.js";
+import "./build-q0qMH_ML.js";
+import { z } from "zod";
+import { Alignment as Alignment$1, AlignmentSchema, AnchorDescriptor as AnchorDescriptor$1, AnchorDescriptorSchema, AnchorType, AnchorTypeSchema, Box as Box$1, BoxSchema, COLOR_BLACK as COLOR_BLACK$1, Color as Color$1, ColorSchema, ConstructDescriptor as ConstructDescriptor$1, ConstructDescriptorSchema, ConstructMarkerImbalance, ConstructMarkerImbalanceError, ContentBlock as ContentBlock$1, ContentBlockSchema, ContentBorder, ContentBorderSchema, ContentCellBorders as ContentCellBorders$1, ContentCellBordersSchema, ContentCellValue, ContentCellValueSchema, ContentConstructEnd, ContentConstructEndSchema, ContentConstructStart, ContentConstructStartSchema, ContentControlDescriptor as ContentControlDescriptor$1, ContentControlDescriptorSchema, ContentControlLock, ContentControlLockSchema, ContentControlType, ContentControlTypeSchema, ContentDocument as ContentDocument$1, ContentDocumentSchema, ContentImageBlock, ContentImageBlockSchema, ContentListMembership, ContentListMembershipSchema, ContentPageBreak, ContentPageBreakSchema, ContentParagraph as ContentParagraph$1, ContentParagraphSchema, ContentRun, ContentRunSchema, ContentSection as ContentSection$1, ContentSectionSchema as ContentSectionSchema$1, ContentShape, ContentShapeSchema, ContentSheet, ContentSheetCell, ContentSheetCellSchema, ContentSheetColumn, ContentSheetColumnSchema, ContentSheetImage, ContentSheetImageSchema, ContentSheetPrintRange as ContentSheetPrintRange$1, ContentSheetPrintRangeSchema, ContentSheetPrintSettings as ContentSheetPrintSettings$1, ContentSheetPrintSettingsSchema, ContentSheetRepeatRange as ContentSheetRepeatRange$1, ContentSheetRepeatRangeSchema, ContentSheetRow, ContentSheetRowSchema, ContentSheetSchema, ContentSlide, ContentSlideSchema as ContentSlideSchema$1, ContentStrokeStyle, ContentStrokeStyleSchema, ContentTable as ContentTable$1, ContentTableCell, ContentTableCellSchema, ContentTableRow, ContentTableRowSchema, ContentTableSchema, DivisionDescriptor, DivisionDescriptorSchema, DocumentPackage as DocumentPackage$1, DocumentPackageSchema, DrawPageChild, DrawPageDescriptor, DrawPageGroupNode, DrawPageGroupSchema, FieldDescriptor, FieldDescriptorSchema, HeadingGroupNode, HeadingGroupSchema, HeadingParagraph, LinkDescriptor, LinkDescriptorSchema, LinkTarget, LinkTargetSchema, ListChild, ListGroupNode, ListGroupSchema, ListParagraph, Margins, MarginsSchema, PAGE_SIZE_A4 as PAGE_SIZE_A4$1, PAGE_SIZE_LETTER as PAGE_SIZE_LETTER$1, PackageBlockLeaf, PackageBlockLeafSchema, PackageChildren, PackageGroup, PackageGroupSchema, PackageLeaf, PackageLeafSchema, PackageNode, PackageNodeSchema, PageSize as PageSize$1, PageSizeSchema, ProvenanceChange as ProvenanceChange$1, ProvenanceChangeSchema, ProvenanceDescriptor as ProvenanceDescriptor$1, ProvenanceDescriptorSchema, SLIDE_SIZE_STANDARD, SLIDE_SIZE_WIDESCREEN as SLIDE_SIZE_WIDESCREEN$1, SectionChild, SectionConstructGroupNode, SectionConstructGroupSchema, SectionDescriptor, SectionGroupNode, SectionGroupSchema, ShapeChild, ShapeConstructGroupNode, ShapeConstructGroupSchema, ShapeDescriptor, ShapeGroupNode, ShapeGroupSchema, SheetChild, SheetDescriptor, SheetGroupNode, SheetGroupSchema, SlideDescriptor, SlideGroupNode, SlideGroupSchema, StyleEntry, StyleEntrySchema, StyleParagraphProperties, StyleParagraphPropertiesSchema, StyleRunProperties, StyleRunPropertiesSchema, StylesTable, StylesTableSchema, applyParagraphStyleProperties, applyRunStyleProperties, assemblePackage as assemblePackage$1, colorToRgbHex as colorToRgbHex$1, decompose, factorStyles, findConstructMarkerImbalance as findConstructMarkerImbalance$1, flattenPackage as flattenPackage$1, isContentBlock, isContentConstructEnd, isContentConstructStart, isDrawPageGroupNode, isHeadingGroupNode, isListGroupNode, isPackageBlockLeaf, isPackageGroup, isPackageLeaf, isPackageNode, isSectionConstructGroupNode, isSectionGroupNode, isShapeConstructGroupNode, isShapeGroupNode, isSheetGroupNode, isSlideGroupNode, overlayStyleEntries, resolveStyleChain, rgbHexToColor as rgbHexToColor$1 } from "document-schema.js";
+//#region src/codec.d.ts
+declare const xmlCodec: z.ZodCodec<z.ZodString, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"text">;
+  value: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"cdata">;
+  value: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"comment">;
+  value: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"declaration">;
+  attributes: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"pi">;
+  target: z.ZodString;
+  content: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"element">;
+  tag: z.ZodString;
+  attributes: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodString;
+  }, z.core.$strip>>;
+  children: z.ZodArray<z.ZodCustom<XmlNode, XmlNode>>;
+}, z.core.$strip>], "type">>>;
+declare const packageCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodObject<{
+  parts: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"xml">;
+    nodes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      type: z.ZodLiteral<"text">;
+      value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"cdata">;
+      value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"comment">;
+      value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"declaration">;
+      attributes: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+      }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"pi">;
+      target: z.ZodString;
+      content: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"element">;
+      tag: z.ZodString;
+      attributes: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+      }, z.core.$strip>>;
+      children: z.ZodArray<z.ZodCustom<XmlNode, XmlNode>>;
+    }, z.core.$strip>], "type">>;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"binary">;
+    base64: z.ZodString;
+  }, z.core.$strip>], "kind">>;
+}, z.core.$strip>>;
+declare function decodePackage(bytes: Uint8Array<ArrayBuffer>): Package;
+declare function encodePackage(pkg: Package): Uint8Array<ArrayBuffer>;
+//#endregion
+export { ContentShapeSchema as $, isHeadingGroupNode as $n, PackageChildren as $t, ContentConstructStart as A, SlideDescriptor as An, DrawPageChild as At, ContentImageBlock as B, StylesTableSchema as Bn, LinkDescriptorSchema as Bt, ContentBorderSchema as C, ShapeDescriptor as Cn, ContentTableRow as Ct, ContentCellValueSchema as D, SheetDescriptor as Dn, DivisionDescriptorSchema as Dt, ContentCellValue as E, SheetChild as En, DivisionDescriptor as Et, ContentControlLockSchema as F, StyleParagraphProperties as Fn, FieldDescriptorSchema as Ft, ContentPageBreakSchema as G, decompose as Gn, ListGroupSchema as Gt, ContentListMembership as H, applyRunStyleProperties as Hn, LinkTargetSchema as Ht, ContentControlType as I, StyleParagraphPropertiesSchema as In, HeadingGroupNode as It, ContentRun as J, flattenPackage$1 as Jn, MarginsSchema as Jt, ContentParagraph$1 as K, factorStyles as Kn, ListParagraph as Kt, ContentControlTypeSchema as L, StyleRunProperties as Ln, HeadingGroupSchema as Lt, ContentControlDescriptor$1 as M, SlideGroupSchema as Mn, DrawPageGroupNode as Mt, ContentControlDescriptorSchema as N, StyleEntry as Nn, DrawPageGroupSchema as Nt, ContentConstructEnd as O, SheetGroupNode as On, DocumentPackage$1 as Ot, ContentControlLock as P, StyleEntrySchema as Pn, FieldDescriptor as Pt, ContentShape as Q, isDrawPageGroupNode as Qn, PackageBlockLeafSchema as Qt, ContentDocument$1 as R, StyleRunPropertiesSchema as Rn, HeadingParagraph as Rt, ContentBorder as S, ShapeConstructGroupSchema as Sn, ContentTableCellSchema as St, ContentCellBordersSchema as T, ShapeGroupSchema as Tn, ContentTableSchema as Tt, ContentListMembershipSchema as U, assemblePackage$1 as Un, ListChild as Ut, ContentImageBlockSchema as V, applyParagraphStyleProperties as Vn, LinkTarget as Vt, ContentPageBreak as W, colorToRgbHex$1 as Wn, ListGroupNode as Wt, ContentSection$1 as X, isContentConstructEnd as Xn, PAGE_SIZE_LETTER$1 as Xt, ContentRunSchema as Y, isContentBlock as Yn, PAGE_SIZE_A4$1 as Yt, ContentSectionSchema$1 as Z, isContentConstructStart as Zn, PackageBlockLeaf as Zt, ConstructDescriptorSchema as _, SectionDescriptor as _n, ContentSlideSchema$1 as _t, Alignment$1 as a, PackageNodeSchema as an, isSectionConstructGroupNode as ar, ContentSheetImage as at, ContentBlock$1 as b, ShapeChild as bn, ContentTable$1 as bt, AnchorDescriptorSchema as c, ProvenanceChange$1 as cn, isShapeGroupNode as cr, ContentSheetPrintRangeSchema as ct, Box$1 as d, ProvenanceDescriptorSchema as dn, overlayStyleEntries as dr, ContentSheetRepeatRange$1 as dt, PackageGroup as en, isListGroupNode as er, ContentSheet as et, BoxSchema as f, SLIDE_SIZE_STANDARD as fn, resolveStyleChain as fr, ContentSheetRepeatRangeSchema as ft, ConstructDescriptor$1 as g, SectionConstructGroupSchema as gn, ContentSlide as gt, ColorSchema as h, SectionConstructGroupNode as hn, ContentSheetSchema as ht, xmlCodec as i, PackageNode as in, isPackageNode as ir, ContentSheetColumnSchema as it, ContentConstructStartSchema as j, SlideGroupNode as jn, DrawPageDescriptor as jt, ContentConstructEndSchema as k, SheetGroupSchema as kn, DocumentPackageSchema as kt, AnchorType as l, ProvenanceChangeSchema as ln, isSheetGroupNode as lr, ContentSheetPrintSettings$1 as lt, Color$1 as m, SectionChild as mn, ContentSheetRowSchema as mt, encodePackage as n, PackageLeaf as nn, isPackageGroup as nr, ContentSheetCellSchema as nt, AlignmentSchema as o, PageSize$1 as on, isSectionGroupNode as or, ContentSheetImageSchema as ot, COLOR_BLACK$1 as p, SLIDE_SIZE_WIDESCREEN$1 as pn, rgbHexToColor$1 as pr, ContentSheetRow as pt, ContentParagraphSchema as q, findConstructMarkerImbalance$1 as qn, Margins as qt, packageCodec as r, PackageLeafSchema as rn, isPackageLeaf as rr, ContentSheetColumn as rt, AnchorDescriptor$1 as s, PageSizeSchema as sn, isShapeConstructGroupNode as sr, ContentSheetPrintRange$1 as st, decodePackage as t, PackageGroupSchema as tn, isPackageBlockLeaf as tr, ContentSheetCell as tt, AnchorTypeSchema as u, ProvenanceDescriptor$1 as un, isSlideGroupNode as ur, ContentSheetPrintSettingsSchema as ut, ConstructMarkerImbalance as v, SectionGroupNode as vn, ContentStrokeStyle as vt, ContentCellBorders$1 as w, ShapeGroupNode as wn, ContentTableRowSchema as wt, ContentBlockSchema as x, ShapeConstructGroupNode as xn, ContentTableCell as xt, ConstructMarkerImbalanceError as y, SectionGroupSchema as yn, ContentStrokeStyleSchema as yt, ContentDocumentSchema as z, StylesTable as zn, LinkDescriptor as zt };

package/dist/codec-CZkWeDXF.d.cts

@@ -0,0 +1,90 @@
+import { d as XmlNode } from "./node-CkBWRjNR.cjs";
+import { r as Package } from "./package-L24lkba-.cjs";
+import "./read-DzmMJPHd.cjs";
+import "./write-6JmxvaK5.cjs";
+import "./parse-CP5FLZqv.cjs";
+import "./build-XSm3I8LT.cjs";
+import "./fragment-B1og_8uA.cjs";
+import "./util-M3JJlDhF.cjs";
+import "./compact-B1qg9oex.cjs";
+import "./color-fFIKAs-Y.cjs";
+import "./metadata-D6o-kLpg.cjs";
+import "./document-package-BDr3nkqJ.cjs";
+import "./read-ClIHv1ef.cjs";
+import "./write-BFEF46Ir.cjs";
+import "./numbering-C53LT-Jx.cjs";
+import "./read-DY3Sm5T3.cjs";
+import "./xlsx-CpX5nzGV.cjs";
+import "./content-UlQ-Nhgi.cjs";
+import "./build-D-ldsmtA.cjs";
+import { z } from "zod";
+import { Alignment as Alignment$1, AlignmentSchema, AnchorDescriptor as AnchorDescriptor$1, AnchorDescriptorSchema, AnchorType, AnchorTypeSchema, Box as Box$1, BoxSchema, COLOR_BLACK, Color as Color$1, ColorSchema, ConstructDescriptor as ConstructDescriptor$1, ConstructDescriptorSchema, ConstructMarkerImbalance, ConstructMarkerImbalanceError, ContentBlock as ContentBlock$1, ContentBlockSchema, ContentBorder, ContentBorderSchema, ContentCellBorders as ContentCellBorders$1, ContentCellBordersSchema, ContentCellValue, ContentCellValueSchema, ContentConstructEnd, ContentConstructEndSchema, ContentConstructStart, ContentConstructStartSchema, ContentControlDescriptor as ContentControlDescriptor$1, ContentControlDescriptorSchema, ContentControlLock, ContentControlLockSchema, ContentControlType, ContentControlTypeSchema, ContentDocument as ContentDocument$1, ContentDocumentSchema, ContentImageBlock, ContentImageBlockSchema, ContentListMembership, ContentListMembershipSchema, ContentPageBreak, ContentPageBreakSchema, ContentParagraph as ContentParagraph$1, ContentParagraphSchema, ContentRun, ContentRunSchema, ContentSection as ContentSection$1, ContentSectionSchema, ContentShape, ContentShapeSchema, ContentSheet, ContentSheetCell, ContentSheetCellSchema, ContentSheetColumn, ContentSheetColumnSchema, ContentSheetImage, ContentSheetImageSchema, ContentSheetPrintRange as ContentSheetPrintRange$1, ContentSheetPrintRangeSchema, ContentSheetPrintSettings as ContentSheetPrintSettings$1, ContentSheetPrintSettingsSchema, ContentSheetRepeatRange as ContentSheetRepeatRange$1, ContentSheetRepeatRangeSchema, ContentSheetRow, ContentSheetRowSchema, ContentSheetSchema, ContentSlide, ContentSlideSchema, ContentStrokeStyle, ContentStrokeStyleSchema, ContentTable as ContentTable$1, ContentTableCell, ContentTableCellSchema, ContentTableRow, ContentTableRowSchema, ContentTableSchema, DivisionDescriptor, DivisionDescriptorSchema, DocumentPackage as DocumentPackage$1, DocumentPackageSchema, DrawPageChild, DrawPageDescriptor, DrawPageGroupNode, DrawPageGroupSchema, FieldDescriptor, FieldDescriptorSchema, HeadingGroupNode, HeadingGroupSchema, HeadingParagraph, LinkDescriptor, LinkDescriptorSchema, LinkTarget, LinkTargetSchema, ListChild, ListGroupNode, ListGroupSchema, ListParagraph, Margins, MarginsSchema, PAGE_SIZE_A4, PAGE_SIZE_LETTER, PackageBlockLeaf, PackageBlockLeafSchema, PackageChildren, PackageGroup, PackageGroupSchema, PackageLeaf, PackageLeafSchema, PackageNode, PackageNodeSchema, PageSize as PageSize$1, PageSizeSchema, ProvenanceChange as ProvenanceChange$1, ProvenanceChangeSchema, ProvenanceDescriptor as ProvenanceDescriptor$1, ProvenanceDescriptorSchema, SLIDE_SIZE_STANDARD, SLIDE_SIZE_WIDESCREEN, SectionChild, SectionConstructGroupNode, SectionConstructGroupSchema, SectionDescriptor, SectionGroupNode, SectionGroupSchema, ShapeChild, ShapeConstructGroupNode, ShapeConstructGroupSchema, ShapeDescriptor, ShapeGroupNode, ShapeGroupSchema, SheetChild, SheetDescriptor, SheetGroupNode, SheetGroupSchema, SlideDescriptor, SlideGroupNode, SlideGroupSchema, StyleEntry, StyleEntrySchema, StyleParagraphProperties, StyleParagraphPropertiesSchema, StyleRunProperties, StyleRunPropertiesSchema, StylesTable, StylesTableSchema, applyParagraphStyleProperties, applyRunStyleProperties, assemblePackage, colorToRgbHex, decompose, factorStyles, findConstructMarkerImbalance, flattenPackage, isContentBlock, isContentConstructEnd, isContentConstructStart, isDrawPageGroupNode, isHeadingGroupNode, isListGroupNode, isPackageBlockLeaf, isPackageGroup, isPackageLeaf, isPackageNode, isSectionConstructGroupNode, isSectionGroupNode, isShapeConstructGroupNode, isShapeGroupNode, isSheetGroupNode, isSlideGroupNode, overlayStyleEntries, resolveStyleChain, rgbHexToColor } from "document-schema.js";
+//#region src/codec.d.ts
+declare const xmlCodec: z.ZodCodec<z.ZodString, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"text">;
+  value: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"cdata">;
+  value: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"comment">;
+  value: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"declaration">;
+  attributes: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"pi">;
+  target: z.ZodString;
+  content: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"element">;
+  tag: z.ZodString;
+  attributes: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodString;
+  }, z.core.$strip>>;
+  children: z.ZodArray<z.ZodCustom<XmlNode, XmlNode>>;
+}, z.core.$strip>], "type">>>;
+declare const packageCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodObject<{
+  parts: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"xml">;
+    nodes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      type: z.ZodLiteral<"text">;
+      value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"cdata">;
+      value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"comment">;
+      value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"declaration">;
+      attributes: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+      }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"pi">;
+      target: z.ZodString;
+      content: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"element">;
+      tag: z.ZodString;
+      attributes: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+      }, z.core.$strip>>;
+      children: z.ZodArray<z.ZodCustom<XmlNode, XmlNode>>;
+    }, z.core.$strip>], "type">>;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"binary">;
+    base64: z.ZodString;
+  }, z.core.$strip>], "kind">>;
+}, z.core.$strip>>;
+declare function decodePackage(bytes: Uint8Array<ArrayBuffer>): Package;
+declare function encodePackage(pkg: Package): Uint8Array<ArrayBuffer>;
+//#endregion
+export { ContentShapeSchema as $, isHeadingGroupNode as $n, PackageChildren as $t, ContentConstructStart as A, SlideDescriptor as An, DrawPageChild as At, ContentImageBlock as B, StylesTableSchema as Bn, LinkDescriptorSchema as Bt, ContentBorderSchema as C, ShapeDescriptor as Cn, ContentTableRow as Ct, ContentCellValueSchema as D, SheetDescriptor as Dn, DivisionDescriptorSchema as Dt, ContentCellValue as E, SheetChild as En, DivisionDescriptor as Et, ContentControlLockSchema as F, StyleParagraphProperties as Fn, FieldDescriptorSchema as Ft, ContentPageBreakSchema as G, decompose as Gn, ListGroupSchema as Gt, ContentListMembership as H, applyRunStyleProperties as Hn, LinkTargetSchema as Ht, ContentControlType as I, StyleParagraphPropertiesSchema as In, HeadingGroupNode as It, ContentRun as J, flattenPackage as Jn, MarginsSchema as Jt, ContentParagraph$1 as K, factorStyles as Kn, ListParagraph as Kt, ContentControlTypeSchema as L, StyleRunProperties as Ln, HeadingGroupSchema as Lt, ContentControlDescriptor$1 as M, SlideGroupSchema as Mn, DrawPageGroupNode as Mt, ContentControlDescriptorSchema as N, StyleEntry as Nn, DrawPageGroupSchema as Nt, ContentConstructEnd as O, SheetGroupNode as On, DocumentPackage$1 as Ot, ContentControlLock as P, StyleEntrySchema as Pn, FieldDescriptor as Pt, ContentShape as Q, isDrawPageGroupNode as Qn, PackageBlockLeafSchema as Qt, ContentDocument$1 as R, StyleRunPropertiesSchema as Rn, HeadingParagraph as Rt, ContentBorder as S, ShapeConstructGroupSchema as Sn, ContentTableCellSchema as St, ContentCellBordersSchema as T, ShapeGroupSchema as Tn, ContentTableSchema as Tt, ContentListMembershipSchema as U, assemblePackage as Un, ListChild as Ut, ContentImageBlockSchema as V, applyParagraphStyleProperties as Vn, LinkTarget as Vt, ContentPageBreak as W, colorToRgbHex as Wn, ListGroupNode as Wt, ContentSection$1 as X, isContentConstructEnd as Xn, PAGE_SIZE_LETTER as Xt, ContentRunSchema as Y, isContentBlock as Yn, PAGE_SIZE_A4 as Yt, ContentSectionSchema as Z, isContentConstructStart as Zn, PackageBlockLeaf as Zt, ConstructDescriptorSchema as _, SectionDescriptor as _n, ContentSlideSchema as _t, Alignment$1 as a, PackageNodeSchema as an, isSectionConstructGroupNode as ar, ContentSheetImage as at, ContentBlock$1 as b, ShapeChild as bn, ContentTable$1 as bt, AnchorDescriptorSchema as c, ProvenanceChange$1 as cn, isShapeGroupNode as cr, ContentSheetPrintRangeSchema as ct, Box$1 as d, ProvenanceDescriptorSchema as dn, overlayStyleEntries as dr, ContentSheetRepeatRange$1 as dt, PackageGroup as en, isListGroupNode as er, ContentSheet as et, BoxSchema as f, SLIDE_SIZE_STANDARD as fn, resolveStyleChain as fr, ContentSheetRepeatRangeSchema as ft, ConstructDescriptor$1 as g, SectionConstructGroupSchema as gn, ContentSlide as gt, ColorSchema as h, SectionConstructGroupNode as hn, ContentSheetSchema as ht, xmlCodec as i, PackageNode as in, isPackageNode as ir, ContentSheetColumnSchema as it, ContentConstructStartSchema as j, SlideGroupNode as jn, DrawPageDescriptor as jt, ContentConstructEndSchema as k, SheetGroupSchema as kn, DocumentPackageSchema as kt, AnchorType as l, ProvenanceChangeSchema as ln, isSheetGroupNode as lr, ContentSheetPrintSettings$1 as lt, Color$1 as m, SectionChild as mn, ContentSheetRowSchema as mt, encodePackage as n, PackageLeaf as nn, isPackageGroup as nr, ContentSheetCellSchema as nt, AlignmentSchema as o, PageSize$1 as on, isSectionGroupNode as or, ContentSheetImageSchema as ot, COLOR_BLACK as p, SLIDE_SIZE_WIDESCREEN as pn, rgbHexToColor as pr, ContentSheetRow as pt, ContentParagraphSchema as q, findConstructMarkerImbalance as qn, Margins as qt, packageCodec as r, PackageLeafSchema as rn, isPackageLeaf as rr, ContentSheetColumn as rt, AnchorDescriptor$1 as s, PageSizeSchema as sn, isShapeConstructGroupNode as sr, ContentSheetPrintRange$1 as st, decodePackage as t, PackageGroupSchema as tn, isPackageBlockLeaf as tr, ContentSheetCell as tt, AnchorTypeSchema as u, ProvenanceDescriptor$1 as un, isSlideGroupNode as ur, ContentSheetPrintSettingsSchema as ut, ConstructMarkerImbalance as v, SectionGroupNode as vn, ContentStrokeStyle as vt, ContentCellBorders$1 as w, ShapeGroupNode as wn, ContentTableRowSchema as wt, ContentBlockSchema as x, ShapeConstructGroupNode as xn, ContentTableCell as xt, ConstructMarkerImbalanceError as y, SectionGroupSchema as yn, ContentStrokeStyleSchema as yt, ContentDocumentSchema as z, StylesTable as zn, LinkDescriptor as zt };

package/dist/codec.d.cts

@@ -1,2 +1,2 @@
-import { i as xmlCodec, n as encodePackage, r as packageCodec, t as decodePackage } from "./codec-CuzuI9Dy.cjs";
+import { i as xmlCodec, n as encodePackage, r as packageCodec, t as decodePackage } from "./codec-CZkWeDXF.cjs";
 export { decodePackage, encodePackage, packageCodec, xmlCodec };

package/dist/codec.d.ts

@@ -1,2 +1,2 @@
-import { i as xmlCodec, n as encodePackage, r as packageCodec, t as decodePackage } from "./codec-B3qT1CGZ.js";
+import { i as xmlCodec, n as encodePackage, r as packageCodec, t as decodePackage } from "./codec-BOGj_yQL.js";
 export { decodePackage, encodePackage, packageCodec, xmlCodec };

package/dist/document-package-BDr3nkqJ.d.cts

@@ -0,0 +1,10 @@
+import { r as Package } from "./package-L24lkba-.cjs";
+import { DocumentPackage } from "document-schema.js";
+//#region src/typed/document-package.d.ts
+declare function readDocx(pkg: Package): DocumentPackage;
+declare function buildDocxPackage(document: DocumentPackage): Package;
+declare function readPptx(pkg: Package): DocumentPackage;
+declare function readXlsx(pkg: Package): DocumentPackage;
+declare function buildXlsxPackage(document: DocumentPackage): Package;
+//#endregion
+export { readXlsx as a, readPptx as i, buildXlsxPackage as n, readDocx as r, buildDocxPackage as t };

package/dist/document-package-kartHoyl.d.ts

@@ -0,0 +1,10 @@
+import { r as Package } from "./package-BUojjTXf.js";
+import { DocumentPackage } from "document-schema.js";
+//#region src/typed/document-package.d.ts
+declare function readDocx(pkg: Package): DocumentPackage;
+declare function buildDocxPackage(document: DocumentPackage): Package;
+declare function readPptx(pkg: Package): DocumentPackage;
+declare function readXlsx(pkg: Package): DocumentPackage;
+declare function buildXlsxPackage(document: DocumentPackage): Package;
+//#endregion
+export { readXlsx as a, readPptx as i, buildXlsxPackage as n, readDocx as r, buildDocxPackage as t };