document-schema 7.11.5 → 7.13.0

package/dist/{package-node-DK-b0h6V.d.cts → package-node-D7WUiIDz.d.cts}

@@ -1,4 +1,4 @@
-import { D as ContentEmbeddedObject, Gt as ContentSheetImage, Sn as ContentVector, W as ContentFormula, _ as ContentConstructEnd, a as ContentBlock, y as ContentConstructStart } from "./content-DWSflkUJ.cjs";
+import { D as ContentEmbeddedObject, Gt as ContentSheetImage, Sn as ContentVector, W as ContentFormula, _ as ContentConstructEnd, a as ContentBlock, y as ContentConstructStart } from "./content-CvvaHPSp.cjs";
 import { a as ConstructDescriptor } from "./construct-GVdTKrE7.cjs";
 import { z } from "zod";
 //#region src/package-node.d.ts
@@ -85,6 +85,7 @@ declare const SectionDescriptorSchema: z.ZodObject<{
 }, z.core.$strict>;
 type SectionDescriptor = z.infer<typeof SectionDescriptorSchema>;
 declare const SlideDescriptorSchema: z.ZodObject<{
+  notes: z.ZodString;
   source: z.ZodOptional<z.ZodObject<{
     format: z.ZodEnum<{
       docx: "docx";
@@ -105,7 +106,6 @@ declare const SlideDescriptorSchema: z.ZodObject<{
     }>;
     xml: z.ZodString;
   }, z.core.$strict>>;
-  notes: z.ZodString;
   origin: z.ZodOptional<z.ZodEnum<{
     chart: "chart";
     diagram: "diagram";
@@ -161,7 +161,6 @@ declare const SheetDescriptorSchema: z.ZodObject<{
     }>;
     xml: z.ZodString;
   }, z.core.$strict>>;
-  name: z.ZodString;
   origin: z.ZodOptional<z.ZodEnum<{
     chart: "chart";
     diagram: "diagram";
@@ -189,6 +188,7 @@ declare const SheetDescriptorSchema: z.ZodObject<{
       at: z.ZodString;
     }, z.core.$strip>>;
   }, z.core.$strip>>;
+  name: z.ZodString;
   printSettings: z.ZodObject<{
     pageSize: z.ZodObject<{
       widthPt: z.ZodNumber;
@@ -552,8 +552,8 @@ declare const SheetDescriptorSchema: z.ZodObject<{
     }, z.core.$strip>>;
     alignment: z.ZodOptional<z.ZodEnum<{
       left: "left";
-      center: "center";
       right: "right";
+      center: "center";
       justify: "justify";
     }>>;
     verticalAlignment: z.ZodOptional<z.ZodEnum<{
@@ -617,10 +617,10 @@ declare const SheetDescriptorSchema: z.ZodObject<{
       endColumn: z.ZodNumber;
     }, z.core.$strip>>;
     type: z.ZodEnum<{
-      decimal: "decimal";
-      list: "list";
       date: "date";
       custom: "custom";
+      decimal: "decimal";
+      list: "list";
       time: "time";
       whole: "whole";
       textLength: "textLength";
@@ -1298,6 +1298,7 @@ declare const DrawPageDescriptorSchema: z.ZodObject<{
 }, z.core.$strict>;
 type DrawPageDescriptor = z.infer<typeof DrawPageDescriptorSchema>;
 declare const ShapeDescriptorSchema: z.ZodObject<{
+  sourcePath: z.ZodOptional<z.ZodString>;
   source: z.ZodOptional<z.ZodObject<{
     format: z.ZodEnum<{
       docx: "docx";
@@ -1318,8 +1319,6 @@ declare const ShapeDescriptorSchema: z.ZodObject<{
     }>;
     xml: z.ZodString;
   }, z.core.$strict>>;
-  name: z.ZodOptional<z.ZodString>;
-  sourcePath: z.ZodOptional<z.ZodString>;
   frames: z.ZodOptional<z.ZodArray<z.ZodObject<{
     pageIndex: z.ZodNumber;
     xPt: z.ZodNumber;
@@ -1354,6 +1353,7 @@ declare const ShapeDescriptorSchema: z.ZodObject<{
       at: z.ZodString;
     }, z.core.$strip>>;
   }, z.core.$strip>>;
+  name: z.ZodOptional<z.ZodString>;
   frame: z.ZodObject<{
     xPt: z.ZodNumber;
     yPt: z.ZodNumber;
@@ -1677,8 +1677,8 @@ declare const HeadingParagraphSchema: z.ZodObject<{
   preformatted: z.ZodOptional<z.ZodBoolean>;
   alignment: z.ZodOptional<z.ZodEnum<{
     left: "left";
-    center: "center";
     right: "right";
+    center: "center";
     justify: "justify";
   }>>;
   list: z.ZodOptional<z.ZodObject<{
@@ -2103,8 +2103,8 @@ declare const ListParagraphSchema: z.ZodObject<{
   headingLevel: z.ZodOptional<z.ZodNumber>;
   alignment: z.ZodOptional<z.ZodEnum<{
     left: "left";
-    center: "center";
     right: "right";
+    center: "center";
     justify: "justify";
   }>>;
   spacingBeforePt: z.ZodOptional<z.ZodNumber>;

package/dist/package-node.d.cts

@@ -1,2 +1,2 @@
-import { $ as isSheetGroupNode, A as SheetDescriptor, B as TreeGroup, C as ShapeConstructGroupNode, D as ShapeGroupNode, E as ShapeDescriptorSchema, F as SlideDescriptorSchema, G as TreeNodeSchema, H as TreeLeaf, I as SlideGroupNode, J as isListGroupNode, K as isDrawPageGroupNode, L as SlideGroupSchema, M as SheetGroupNode, N as SheetGroupSchema, O as ShapeGroupSchema, P as SlideDescriptor, Q as isShapeGroupNode, R as TreeBlockLeaf, S as ShapeChild, T as ShapeDescriptor, U as TreeLeafSchema, V as TreeGroupSchema, W as TreeNode, X as isSectionGroupNode, Y as isSectionConstructGroupNode, Z as isShapeConstructGroupNode, _ as SectionConstructGroupSchema, a as DrawPageGroupSchema, b as SectionGroupNode, c as HeadingParagraph, d as ListGroupNode, et as isSlideGroupNode, f as ListGroupSchema, g as SectionConstructGroupNode, h as SectionChild, i as DrawPageGroupNode, it as isTreeNode, j as SheetDescriptorSchema, k as SheetChild, l as HeadingParagraphSchema, m as ListParagraphSchema, n as DrawPageDescriptor, nt as isTreeGroup, o as HeadingGroupNode, p as ListParagraph, q as isHeadingGroupNode, r as DrawPageDescriptorSchema, rt as isTreeLeaf, s as HeadingGroupSchema, t as DrawPageChild, tt as isTreeBlockLeaf, u as ListChild, v as SectionDescriptor, w as ShapeConstructGroupSchema, x as SectionGroupSchema, y as SectionDescriptorSchema, z as TreeBlockLeafSchema } from "./package-node-DK-b0h6V.cjs";
+import { $ as isSheetGroupNode, A as SheetDescriptor, B as TreeGroup, C as ShapeConstructGroupNode, D as ShapeGroupNode, E as ShapeDescriptorSchema, F as SlideDescriptorSchema, G as TreeNodeSchema, H as TreeLeaf, I as SlideGroupNode, J as isListGroupNode, K as isDrawPageGroupNode, L as SlideGroupSchema, M as SheetGroupNode, N as SheetGroupSchema, O as ShapeGroupSchema, P as SlideDescriptor, Q as isShapeGroupNode, R as TreeBlockLeaf, S as ShapeChild, T as ShapeDescriptor, U as TreeLeafSchema, V as TreeGroupSchema, W as TreeNode, X as isSectionGroupNode, Y as isSectionConstructGroupNode, Z as isShapeConstructGroupNode, _ as SectionConstructGroupSchema, a as DrawPageGroupSchema, b as SectionGroupNode, c as HeadingParagraph, d as ListGroupNode, et as isSlideGroupNode, f as ListGroupSchema, g as SectionConstructGroupNode, h as SectionChild, i as DrawPageGroupNode, it as isTreeNode, j as SheetDescriptorSchema, k as SheetChild, l as HeadingParagraphSchema, m as ListParagraphSchema, n as DrawPageDescriptor, nt as isTreeGroup, o as HeadingGroupNode, p as ListParagraph, q as isHeadingGroupNode, r as DrawPageDescriptorSchema, rt as isTreeLeaf, s as HeadingGroupSchema, t as DrawPageChild, tt as isTreeBlockLeaf, u as ListChild, v as SectionDescriptor, w as ShapeConstructGroupSchema, x as SectionGroupSchema, y as SectionDescriptorSchema, z as TreeBlockLeafSchema } from "./package-node-D7WUiIDz.cjs";
 export { DrawPageChild, DrawPageDescriptor, DrawPageDescriptorSchema, DrawPageGroupNode, DrawPageGroupSchema, HeadingGroupNode, HeadingGroupSchema, HeadingParagraph, HeadingParagraphSchema, ListChild, ListGroupNode, ListGroupSchema, ListParagraph, ListParagraphSchema, SectionChild, SectionConstructGroupNode, SectionConstructGroupSchema, SectionDescriptor, SectionDescriptorSchema, SectionGroupNode, SectionGroupSchema, ShapeChild, ShapeConstructGroupNode, ShapeConstructGroupSchema, ShapeDescriptor, ShapeDescriptorSchema, ShapeGroupNode, ShapeGroupSchema, SheetChild, SheetDescriptor, SheetDescriptorSchema, SheetGroupNode, SheetGroupSchema, SlideDescriptor, SlideDescriptorSchema, SlideGroupNode, SlideGroupSchema, TreeBlockLeaf, TreeBlockLeafSchema, TreeGroup, TreeGroupSchema, TreeLeaf, TreeLeafSchema, TreeNode, TreeNodeSchema, isDrawPageGroupNode, isHeadingGroupNode, isListGroupNode, isSectionConstructGroupNode, isSectionGroupNode, isShapeConstructGroupNode, isShapeGroupNode, isSheetGroupNode, isSlideGroupNode, isTreeBlockLeaf, isTreeGroup, isTreeLeaf, isTreeNode };

package/dist/package-node.d.ts

@@ -1,2 +1,2 @@
-import { $ as isSheetGroupNode, A as SheetDescriptor, B as TreeGroup, C as ShapeConstructGroupNode, D as ShapeGroupNode, E as ShapeDescriptorSchema, F as SlideDescriptorSchema, G as TreeNodeSchema, H as TreeLeaf, I as SlideGroupNode, J as isListGroupNode, K as isDrawPageGroupNode, L as SlideGroupSchema, M as SheetGroupNode, N as SheetGroupSchema, O as ShapeGroupSchema, P as SlideDescriptor, Q as isShapeGroupNode, R as TreeBlockLeaf, S as ShapeChild, T as ShapeDescriptor, U as TreeLeafSchema, V as TreeGroupSchema, W as TreeNode, X as isSectionGroupNode, Y as isSectionConstructGroupNode, Z as isShapeConstructGroupNode, _ as SectionConstructGroupSchema, a as DrawPageGroupSchema, b as SectionGroupNode, c as HeadingParagraph, d as ListGroupNode, et as isSlideGroupNode, f as ListGroupSchema, g as SectionConstructGroupNode, h as SectionChild, i as DrawPageGroupNode, it as isTreeNode, j as SheetDescriptorSchema, k as SheetChild, l as HeadingParagraphSchema, m as ListParagraphSchema, n as DrawPageDescriptor, nt as isTreeGroup, o as HeadingGroupNode, p as ListParagraph, q as isHeadingGroupNode, r as DrawPageDescriptorSchema, rt as isTreeLeaf, s as HeadingGroupSchema, t as DrawPageChild, tt as isTreeBlockLeaf, u as ListChild, v as SectionDescriptor, w as ShapeConstructGroupSchema, x as SectionGroupSchema, y as SectionDescriptorSchema, z as TreeBlockLeafSchema } from "./package-node-5OqgGCtu.js";
+import { $ as isSheetGroupNode, A as SheetDescriptor, B as TreeGroup, C as ShapeConstructGroupNode, D as ShapeGroupNode, E as ShapeDescriptorSchema, F as SlideDescriptorSchema, G as TreeNodeSchema, H as TreeLeaf, I as SlideGroupNode, J as isListGroupNode, K as isDrawPageGroupNode, L as SlideGroupSchema, M as SheetGroupNode, N as SheetGroupSchema, O as ShapeGroupSchema, P as SlideDescriptor, Q as isShapeGroupNode, R as TreeBlockLeaf, S as ShapeChild, T as ShapeDescriptor, U as TreeLeafSchema, V as TreeGroupSchema, W as TreeNode, X as isSectionGroupNode, Y as isSectionConstructGroupNode, Z as isShapeConstructGroupNode, _ as SectionConstructGroupSchema, a as DrawPageGroupSchema, b as SectionGroupNode, c as HeadingParagraph, d as ListGroupNode, et as isSlideGroupNode, f as ListGroupSchema, g as SectionConstructGroupNode, h as SectionChild, i as DrawPageGroupNode, it as isTreeNode, j as SheetDescriptorSchema, k as SheetChild, l as HeadingParagraphSchema, m as ListParagraphSchema, n as DrawPageDescriptor, nt as isTreeGroup, o as HeadingGroupNode, p as ListParagraph, q as isHeadingGroupNode, r as DrawPageDescriptorSchema, rt as isTreeLeaf, s as HeadingGroupSchema, t as DrawPageChild, tt as isTreeBlockLeaf, u as ListChild, v as SectionDescriptor, w as ShapeConstructGroupSchema, x as SectionGroupSchema, y as SectionDescriptorSchema, z as TreeBlockLeafSchema } from "./package-node--fbVCVcl.js";
 export { DrawPageChild, DrawPageDescriptor, DrawPageDescriptorSchema, DrawPageGroupNode, DrawPageGroupSchema, HeadingGroupNode, HeadingGroupSchema, HeadingParagraph, HeadingParagraphSchema, ListChild, ListGroupNode, ListGroupSchema, ListParagraph, ListParagraphSchema, SectionChild, SectionConstructGroupNode, SectionConstructGroupSchema, SectionDescriptor, SectionDescriptorSchema, SectionGroupNode, SectionGroupSchema, ShapeChild, ShapeConstructGroupNode, ShapeConstructGroupSchema, ShapeDescriptor, ShapeDescriptorSchema, ShapeGroupNode, ShapeGroupSchema, SheetChild, SheetDescriptor, SheetDescriptorSchema, SheetGroupNode, SheetGroupSchema, SlideDescriptor, SlideDescriptorSchema, SlideGroupNode, SlideGroupSchema, TreeBlockLeaf, TreeBlockLeafSchema, TreeGroup, TreeGroupSchema, TreeLeaf, TreeLeafSchema, TreeNode, TreeNodeSchema, isDrawPageGroupNode, isHeadingGroupNode, isListGroupNode, isSectionConstructGroupNode, isSectionGroupNode, isShapeConstructGroupNode, isShapeGroupNode, isSheetGroupNode, isSlideGroupNode, isTreeBlockLeaf, isTreeGroup, isTreeLeaf, isTreeNode };

package/dist/package.d.cts

@@ -1,6 +1,6 @@
 import { d as MathMlNode } from "./mathml-Czqc1mdZ.cjs";
 import { p as MathExpression } from "./math-BScHxedi.cjs";
-import { I as SlideGroupNode, M as SheetGroupNode, b as SectionGroupNode, i as DrawPageGroupNode } from "./package-node-DK-b0h6V.cjs";
+import { I as SlideGroupNode, M as SheetGroupNode, b as SectionGroupNode, i as DrawPageGroupNode } from "./package-node-D7WUiIDz.cjs";
 import { z } from "zod";
 //#region src/package.d.ts
 declare const TreeEmbeddedFontSchema: z.ZodObject<{
@@ -26,8 +26,8 @@ declare const DocumentTreeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     paragraph: z.ZodOptional<z.ZodObject<{
       alignment: z.ZodOptional<z.ZodEnum<{
         left: "left";
-        center: "center";
         right: "right";
+        center: "center";
         justify: "justify";
       }>>;
       list: z.ZodOptional<z.ZodObject<{
@@ -181,8 +181,8 @@ declare const DocumentTreeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     paragraph: z.ZodOptional<z.ZodObject<{
       alignment: z.ZodOptional<z.ZodEnum<{
         left: "left";
-        center: "center";
         right: "right";
+        center: "center";
         justify: "justify";
       }>>;
       list: z.ZodOptional<z.ZodObject<{
@@ -341,8 +341,8 @@ declare const DocumentTreeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     paragraph: z.ZodOptional<z.ZodObject<{
       alignment: z.ZodOptional<z.ZodEnum<{
         left: "left";
-        center: "center";
         right: "right";
+        center: "center";
         justify: "justify";
       }>>;
       list: z.ZodOptional<z.ZodObject<{
@@ -496,8 +496,8 @@ declare const DocumentTreeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     paragraph: z.ZodOptional<z.ZodObject<{
       alignment: z.ZodOptional<z.ZodEnum<{
         left: "left";
-        center: "center";
         right: "right";
+        center: "center";
         justify: "justify";
       }>>;
       list: z.ZodOptional<z.ZodObject<{
@@ -710,8 +710,8 @@ declare const DocumentTreeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     paragraph: z.ZodOptional<z.ZodObject<{
       alignment: z.ZodOptional<z.ZodEnum<{
         left: "left";
-        center: "center";
         right: "right";
+        center: "center";
         justify: "justify";
       }>>;
       list: z.ZodOptional<z.ZodObject<{

package/dist/package.d.ts

@@ -1,6 +1,6 @@
 import { d as MathMlNode } from "./mathml-Czqc1mdZ.js";
 import { p as MathExpression } from "./math-BScHxedi.js";
-import { I as SlideGroupNode, M as SheetGroupNode, b as SectionGroupNode, i as DrawPageGroupNode } from "./package-node-5OqgGCtu.js";
+import { I as SlideGroupNode, M as SheetGroupNode, b as SectionGroupNode, i as DrawPageGroupNode } from "./package-node--fbVCVcl.js";
 import { z } from "zod";
 //#region src/package.d.ts
 declare const TreeEmbeddedFontSchema: z.ZodObject<{
@@ -26,8 +26,8 @@ declare const DocumentTreeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     paragraph: z.ZodOptional<z.ZodObject<{
       alignment: z.ZodOptional<z.ZodEnum<{
         left: "left";
-        center: "center";
         right: "right";
+        center: "center";
         justify: "justify";
       }>>;
       list: z.ZodOptional<z.ZodObject<{
@@ -181,8 +181,8 @@ declare const DocumentTreeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     paragraph: z.ZodOptional<z.ZodObject<{
       alignment: z.ZodOptional<z.ZodEnum<{
         left: "left";
-        center: "center";
         right: "right";
+        center: "center";
         justify: "justify";
       }>>;
       list: z.ZodOptional<z.ZodObject<{
@@ -341,8 +341,8 @@ declare const DocumentTreeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     paragraph: z.ZodOptional<z.ZodObject<{
       alignment: z.ZodOptional<z.ZodEnum<{
         left: "left";
-        center: "center";
         right: "right";
+        center: "center";
         justify: "justify";
       }>>;
       list: z.ZodOptional<z.ZodObject<{
@@ -496,8 +496,8 @@ declare const DocumentTreeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     paragraph: z.ZodOptional<z.ZodObject<{
       alignment: z.ZodOptional<z.ZodEnum<{
         left: "left";
-        center: "center";
         right: "right";
+        center: "center";
         justify: "justify";
       }>>;
       list: z.ZodOptional<z.ZodObject<{
@@ -710,8 +710,8 @@ declare const DocumentTreeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     paragraph: z.ZodOptional<z.ZodObject<{
       alignment: z.ZodOptional<z.ZodEnum<{
         left: "left";
-        center: "center";
         right: "right";
+        center: "center";
         justify: "justify";
       }>>;
       list: z.ZodOptional<z.ZodObject<{

package/dist/schema-io.cjs

@@ -7,7 +7,7 @@ const SCHEMA_FILE_NAMES = {
 	ContentDocument: "content-document.schema.json"
 };
 function schemaUriFor(kind) {
-	return `https://cdn.jsdelivr.net/npm/document-schema.js@7.11.5/schemas/${SCHEMA_FILE_NAMES[kind]}`;
+	return `https://cdn.jsdelivr.net/npm/document-schema.js@7.13.0/schemas/${SCHEMA_FILE_NAMES[kind]}`;
 }
 const SCHEMA_URI_PATTERN = /^https:\/\/cdn\.jsdelivr\.net\/npm\/document-schema\.js@([^/]+)\/schemas\/(document-tree|document-package|content-document|layout-document)\.schema\.json$/;
 function parseSchemaUri(uri) {
@@ -102,7 +102,7 @@ function documentFromJson(value) {
 	if (parts.stem === "document-package") throw new DocumentPackageRenamedError(value.$schema);
 	const kind = kindForFileStem(parts.stem);
 	if (kind === void 0) throw new UnrecognizedDocumentSchemaError(value.$schema);
-	if (majorVersionOf(parts.version) !== majorVersionOf("7.11.5")) throw new SchemaVersionMismatchError(value.$schema, parts.version, "7.11.5");
+	if (majorVersionOf(parts.version) !== majorVersionOf("7.13.0")) throw new SchemaVersionMismatchError(value.$schema, parts.version, "7.13.0");
 	switch (kind) {
 		case "DocumentTree": return {
 			kind,

package/dist/schema-io.d.cts

@@ -1,4 +1,4 @@
-import { C as ContentDocument } from "./content-DWSflkUJ.cjs";
+import { C as ContentDocument } from "./content-CvvaHPSp.cjs";
 import { DocumentTree } from "./package.cjs";
 //#region src/schema-io.d.ts
 type DocumentSchemaKind = "DocumentTree" | "ContentDocument";

package/dist/schema-io.d.ts

@@ -1,4 +1,4 @@
-import { C as ContentDocument } from "./content-C5CsxSt1.js";
+import { C as ContentDocument } from "./content-DbjeTN2j.js";
 import { DocumentTree } from "./package.js";
 //#region src/schema-io.d.ts
 type DocumentSchemaKind = "DocumentTree" | "ContentDocument";

package/dist/schema-io.js

@@ -6,7 +6,7 @@ const SCHEMA_FILE_NAMES = {
 	ContentDocument: "content-document.schema.json"
 };
 function schemaUriFor(kind) {
-	return `https://cdn.jsdelivr.net/npm/document-schema.js@7.11.5/schemas/${SCHEMA_FILE_NAMES[kind]}`;
+	return `https://cdn.jsdelivr.net/npm/document-schema.js@7.13.0/schemas/${SCHEMA_FILE_NAMES[kind]}`;
 }
 const SCHEMA_URI_PATTERN = /^https:\/\/cdn\.jsdelivr\.net\/npm\/document-schema\.js@([^/]+)\/schemas\/(document-tree|document-package|content-document|layout-document)\.schema\.json$/;
 function parseSchemaUri(uri) {
@@ -101,7 +101,7 @@ function documentFromJson(value) {
 	if (parts.stem === "document-package") throw new DocumentPackageRenamedError(value.$schema);
 	const kind = kindForFileStem(parts.stem);
 	if (kind === void 0) throw new UnrecognizedDocumentSchemaError(value.$schema);
-	if (majorVersionOf(parts.version) !== majorVersionOf("7.11.5")) throw new SchemaVersionMismatchError(value.$schema, parts.version, "7.11.5");
+	if (majorVersionOf(parts.version) !== majorVersionOf("7.13.0")) throw new SchemaVersionMismatchError(value.$schema, parts.version, "7.13.0");
 	switch (kind) {
 		case "DocumentTree": return {
 			kind,

package/dist/{style-D06NwxAJ.d.cts → style-BGMcYrD2.d.cts}

@@ -2,8 +2,8 @@ import { z } from "zod";
 //#region src/style.d.ts
 declare const AlignmentSchema: z.ZodEnum<{
   left: "left";
-  center: "center";
   right: "right";
+  center: "center";
   justify: "justify";
 }>;
 type Alignment = z.infer<typeof AlignmentSchema>;

package/dist/{style-D06NwxAJ.d.ts → style-BGMcYrD2.d.ts}

@@ -2,8 +2,8 @@ import { z } from "zod";
 //#region src/style.d.ts
 declare const AlignmentSchema: z.ZodEnum<{
   left: "left";
-  center: "center";
   right: "right";
+  center: "center";
   justify: "justify";
 }>;
 type Alignment = z.infer<typeof AlignmentSchema>;

package/dist/style.d.cts

@@ -1,2 +1,2 @@
-import { a as LayoutFontSchema, i as LayoutFont, n as AlignmentSchema, o as TextDirection, r as DEFAULT_LAYOUT_FONT, s as TextDirectionSchema, t as Alignment } from "./style-D06NwxAJ.cjs";
+import { a as LayoutFontSchema, i as LayoutFont, n as AlignmentSchema, o as TextDirection, r as DEFAULT_LAYOUT_FONT, s as TextDirectionSchema, t as Alignment } from "./style-BGMcYrD2.cjs";
 export { Alignment, AlignmentSchema, DEFAULT_LAYOUT_FONT, LayoutFont, LayoutFontSchema, TextDirection, TextDirectionSchema };

package/dist/style.d.ts

@@ -1,2 +1,2 @@
-import { a as LayoutFontSchema, i as LayoutFont, n as AlignmentSchema, o as TextDirection, r as DEFAULT_LAYOUT_FONT, s as TextDirectionSchema, t as Alignment } from "./style-D06NwxAJ.js";
+import { a as LayoutFontSchema, i as LayoutFont, n as AlignmentSchema, o as TextDirection, r as DEFAULT_LAYOUT_FONT, s as TextDirectionSchema, t as Alignment } from "./style-BGMcYrD2.js";
 export { Alignment, AlignmentSchema, DEFAULT_LAYOUT_FONT, LayoutFont, LayoutFontSchema, TextDirection, TextDirectionSchema };

package/dist/table-grid.cjs

@@ -0,0 +1,204 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/table-grid.ts
+/** The number of grid columns a cell occupies; an absent `colSpan` means the cell occupies its own column only. */
+function tableCellColumnSpan(cell) {
+	return cell.colSpan ?? 1;
+}
+/** The number of grid rows a cell occupies; an absent `rowSpan` means the cell occupies its own row only. */
+function tableCellRowSpan(cell) {
+	return cell.rowSpan ?? 1;
+}
+/**
+* The table's grid width. For a table obeying the dense rule this is `columnWidthsPt.length` and every row's `cells.length` alike; taking the largest of them is what lets a reader mid-construction, or a table whose source declared a grid narrower than a row actually uses, still be walked without the walk inventing a narrower grid than the rows occupy.
+*/
+function tableGridColumnCount(table) {
+	let count = table.columnWidthsPt.length;
+	for (const row of table.rows) count = Math.max(count, row.cells.length);
+	return count;
+}
+function coveringAnchor(anchors, rowIndex, columnIndex) {
+	for (const anchor of anchors) if (rowIndex < anchor.rowEnd && anchor.column <= columnIndex && columnIndex < anchor.columnEnd) return anchor;
+}
+/**
+* Classify every entry of every row as an anchor or as covered, in row-major order, one inner array per table row.
+*
+* This is the walk a consumer runs instead of accumulating spans itself. A writer targeting a format that stores only anchors (HTML's `<td colspan>`, a docx `w:tc` with `w:gridSpan`) keeps the anchors and drops the covered positions; a writer targeting a format that stores covered positions explicitly (ODF, pptx) writes both; a reader checks its own output against it.
+*/
+function walkTableGrid(table) {
+	const anchors = [];
+	return table.rows.map((row, rowIndex) => row.cells.map((cell, columnIndex) => {
+		const anchor = coveringAnchor(anchors, rowIndex, columnIndex);
+		if (anchor !== void 0) return {
+			rowIndex,
+			columnIndex,
+			cell,
+			anchorRowIndex: anchor.row,
+			anchorColumnIndex: anchor.column
+		};
+		anchors.push({
+			row: rowIndex,
+			column: columnIndex,
+			rowEnd: rowIndex + tableCellRowSpan(cell),
+			columnEnd: columnIndex + tableCellColumnSpan(cell)
+		});
+		return {
+			rowIndex,
+			columnIndex,
+			cell
+		};
+	}));
+}
+/** The span of a cell that occupies its own grid position only, which is what an absent `colSpan` or `rowSpan` means. */
+const UNMERGED_SPAN = 1;
+function widestRowLength(table) {
+	let width = 0;
+	for (const row of table.rows) width = Math.max(width, row.cells.length);
+	return width;
+}
+function coveredFault(position) {
+	const { rowIndex, columnIndex, anchorRowIndex, anchorColumnIndex, cell } = position;
+	if (cell.blocks.length > 0) return {
+		kind: "coveredContent",
+		rowIndex,
+		columnIndex,
+		anchorRowIndex,
+		anchorColumnIndex
+	};
+	if (tableCellColumnSpan(cell) > UNMERGED_SPAN || tableCellRowSpan(cell) > UNMERGED_SPAN) return {
+		kind: "coveredSpan",
+		rowIndex,
+		columnIndex,
+		anchorRowIndex,
+		anchorColumnIndex
+	};
+}
+function overlappedRegion(anchor, row) {
+	const footprintEnd = anchor.columnIndex + tableCellColumnSpan(anchor.cell);
+	for (const position of row.slice(anchor.columnIndex + 1, footprintEnd)) if (position.anchorRowIndex !== void 0 && position.anchorRowIndex < anchor.rowIndex) return position;
+}
+function anchorFault(anchor, row, rowCount) {
+	const { rowIndex, columnIndex, cell } = anchor;
+	if (columnIndex + tableCellColumnSpan(cell) > row.length) return {
+		kind: "anchorOverrunsColumns",
+		rowIndex,
+		columnIndex
+	};
+	if (rowIndex + tableCellRowSpan(cell) > rowCount) return {
+		kind: "anchorOverrunsRows",
+		rowIndex,
+		columnIndex
+	};
+	const overlapped = overlappedRegion(anchor, row);
+	if (overlapped !== void 0) return {
+		kind: "overlappingAnchors",
+		rowIndex,
+		columnIndex,
+		earlierAnchorRowIndex: overlapped.anchorRowIndex,
+		earlierAnchorColumnIndex: overlapped.anchorColumnIndex
+	};
+}
+/**
+* The first place `table` contradicts the grid rule, or `undefined` when it obeys it. It never throws: a caller decides what a fault means for it, the way findConstructMarkerImbalance leaves that decision to each consumer of a block list.
+*
+* Rows are compared with each other before any position is classified, since an anchor's footprint can only be measured against a grid every row shares; the positions are then checked in row-major order, so the fault returned is the earliest one in reading order.
+*
+* The check states the whole of the rule and nothing beyond it: a table with no rows, or whose rows are all empty, has no fault, and neither `columnWidthsPt` nor a cell's own properties other than its blocks and spans are consulted.
+*/
+function findTableGridFault(table) {
+	const gridColumnCount = widestRowLength(table);
+	for (const [rowIndex, row] of table.rows.entries()) if (row.cells.length !== gridColumnCount) return {
+		kind: "raggedRow",
+		rowIndex,
+		cellCount: row.cells.length,
+		gridColumnCount
+	};
+	const grid = walkTableGrid(table);
+	for (const row of grid) for (const position of row) {
+		const fault = position.anchorRowIndex === void 0 ? anchorFault(position, row, grid.length) : coveredFault(position);
+		if (fault !== void 0) return fault;
+	}
+}
+/**
+* One sentence stating a fault in words, for a writer that refuses or reports a table the grid rule does not admit: it names the fault by its position and, where the fault involves a second region, by that region's anchor. Indices are 0-based, matching every index in the descriptor. The sentence carries no entry point or format of its own, so each caller prefixes whatever names its own operation.
+*/
+function describeTableGridFault(fault) {
+	switch (fault.kind) {
+		case "raggedRow": return `row ${String(fault.rowIndex)} holds ${String(fault.cellCount)} cells where the widest row holds ${String(fault.gridColumnCount)}, but every row of a table covers the same grid`;
+		case "coveredContent": return `the cell at row ${String(fault.rowIndex)}, column ${String(fault.columnIndex)} lies inside the merged region anchored at row ${String(fault.anchorRowIndex)}, column ${String(fault.anchorColumnIndex)} but carries content of its own, and a merged region's content belongs to its anchor`;
+		case "coveredSpan": return `the cell at row ${String(fault.rowIndex)}, column ${String(fault.columnIndex)} lies inside the merged region anchored at row ${String(fault.anchorRowIndex)}, column ${String(fault.anchorColumnIndex)} but states a span of its own, and only a region's anchor carries a span`;
+		case "anchorOverrunsColumns": return `the merged region anchored at row ${String(fault.rowIndex)}, column ${String(fault.columnIndex)} spans past the last column of the grid`;
+		case "anchorOverrunsRows": return `the merged region anchored at row ${String(fault.rowIndex)}, column ${String(fault.columnIndex)} spans past the last row of the table`;
+		case "overlappingAnchors": return `the merged region anchored at row ${String(fault.rowIndex)}, column ${String(fault.columnIndex)} overlaps the region anchored at row ${String(fault.earlierAnchorRowIndex)}, column ${String(fault.earlierAnchorColumnIndex)}, but a grid position belongs to one region only`;
+	}
+}
+function placedGridWidth(rows, columnCount) {
+	let width = columnCount;
+	for (const row of rows) for (const { columnIndex, cell } of row.cells) width = Math.max(width, columnIndex + tableCellColumnSpan(cell));
+	return width;
+}
+/**
+* Build dense rows from cells a reader has already positioned, filling every position no cell was placed at with an empty covered cell.
+*
+* `columnCount` is the grid width the source declared (a docx `w:tblGrid`, an ODF `table:table-column` run). The result is that wide, or wider if some row places a cell past it, so that every returned row has the same length whatever the source's own grid declaration said.
+*/
+function denseTableRows(rows, columnCount) {
+	const width = placedGridWidth(rows, columnCount);
+	return rows.map((row) => {
+		const cells = Array.from({ length: width }, () => ({ blocks: [] }));
+		for (const { columnIndex, cell } of row.cells) cells[columnIndex] = cell;
+		return {
+			...row,
+			cells
+		};
+	});
+}
+function occupiedColumns(occupied, rowIndex) {
+	const existing = occupied.get(rowIndex);
+	if (existing !== void 0) return existing;
+	const created = /* @__PURE__ */ new Set();
+	occupied.set(rowIndex, created);
+	return created;
+}
+function positionAnchorRows(rows) {
+	const occupied = /* @__PURE__ */ new Map();
+	return rows.map((row, rowIndex) => {
+		const taken = occupiedColumns(occupied, rowIndex);
+		let column = 0;
+		const cells = row.cells.map((cell) => {
+			while (taken.has(column)) column++;
+			const lastRow = rowIndex + tableCellRowSpan(cell);
+			const lastColumn = column + tableCellColumnSpan(cell);
+			for (let r = rowIndex; r < lastRow; r++) {
+				const rowTaken = occupiedColumns(occupied, r);
+				for (let c = column; c < lastColumn; c++) rowTaken.add(c);
+			}
+			const positioned = {
+				columnIndex: column,
+				cell
+			};
+			column = lastColumn;
+			return positioned;
+		});
+		return {
+			...row,
+			cells
+		};
+	});
+}
+/**
+* Build dense rows from anchor cells alone, placing each at the first grid column no earlier cell already reaches -- the placement HTML's own table model needs, where a `rowspan` in one row silently consumes a column in the rows below it and nothing marks the consumed position.
+*
+* `columnCount` is the grid width the source declared, where it declares one at all; pass 0 when it does not and the width follows from the placement.
+*/
+function placeAnchorTableRows(rows, columnCount) {
+	return denseTableRows(positionAnchorRows(rows), columnCount);
+}
+//#endregion
+exports.denseTableRows = denseTableRows;
+exports.describeTableGridFault = describeTableGridFault;
+exports.findTableGridFault = findTableGridFault;
+exports.placeAnchorTableRows = placeAnchorTableRows;
+exports.tableCellColumnSpan = tableCellColumnSpan;
+exports.tableCellRowSpan = tableCellRowSpan;
+exports.tableGridColumnCount = tableGridColumnCount;
+exports.walkTableGrid = walkTableGrid;

package/dist/table-grid.d.cts

@@ -0,0 +1,112 @@
+import { o as TextDirection } from "./style-BGMcYrD2.cjs";
+import { _n as ContentTableRow, hn as ContentTableCell, mn as ContentTable } from "./content-CvvaHPSp.cjs";
+//#region src/table-grid.d.ts
+/** The number of grid columns a cell occupies; an absent `colSpan` means the cell occupies its own column only. */
+declare function tableCellColumnSpan(cell: ContentTableCell): number;
+/** The number of grid rows a cell occupies; an absent `rowSpan` means the cell occupies its own row only. */
+declare function tableCellRowSpan(cell: ContentTableCell): number;
+/**
+ * The table's grid width. For a table obeying the dense rule this is `columnWidthsPt.length` and every row's `cells.length` alike; taking the largest of them is what lets a reader mid-construction, or a table whose source declared a grid narrower than a row actually uses, still be walked without the walk inventing a narrower grid than the rows occupy.
+ */
+declare function tableGridColumnCount(table: ContentTable): number;
+/** A grid position holding a merged region's anchor, or an unmerged cell (which is its own one-position region's anchor). */
+interface TableGridAnchor {
+  readonly rowIndex: number;
+  readonly columnIndex: number;
+  readonly cell: ContentTableCell;
+  readonly anchorRowIndex?: never;
+  readonly anchorColumnIndex?: never;
+}
+/** A grid position covered by a merged region anchored elsewhere. `anchorRowIndex < rowIndex` means the region reaches this position vertically; `anchorRowIndex === rowIndex` means it reaches it horizontally along this same row. */
+interface TableGridCovered {
+  readonly rowIndex: number;
+  readonly columnIndex: number;
+  readonly cell: ContentTableCell;
+  readonly anchorRowIndex: number;
+  readonly anchorColumnIndex: number;
+}
+/** Discriminated by the presence of the anchor coordinates rather than by a tag field, since the two shapes' required fields are already mutually exclusive: `"anchorRowIndex" in position` narrows to the covered branch. */
+type TableGridPosition = TableGridAnchor | TableGridCovered;
+/**
+ * Classify every entry of every row as an anchor or as covered, in row-major order, one inner array per table row.
+ *
+ * This is the walk a consumer runs instead of accumulating spans itself. A writer targeting a format that stores only anchors (HTML's `<td colspan>`, a docx `w:tc` with `w:gridSpan`) keeps the anchors and drops the covered positions; a writer targeting a format that stores covered positions explicitly (ODF, pptx) writes both; a reader checks its own output against it.
+ */
+declare function walkTableGrid(table: ContentTable): TableGridPosition[][];
+/**
+ * Where a table stops obeying the grid rule (ContentTableCell in src/content.ts states the rule; walkTableGrid derives the classification every check here is made against). Every variant names a position in the table's own row and column indices.
+ *
+ * - `raggedRow`: the row holds `cellCount` entries where the table's widest row holds `gridColumnCount`, so the rows do not all cover the same grid.
+ * - `coveredContent`: the position is covered by the region anchored at `anchorRowIndex`, `anchorColumnIndex` yet carries blocks of its own; the region's content belongs to its anchor, so a second copy has nowhere to go.
+ * - `coveredSpan`: the position is covered by the region anchored at `anchorRowIndex`, `anchorColumnIndex` yet carries a `colSpan` or `rowSpan` of its own. Spans are set on the anchor only and walkTableGrid never consults a covered entry's, so this is how a second anchor starting inside another's footprint shows up: the walk assigns each position to the first anchor covering it, which leaves the second entry classified as covered and its span ignored.
+ * - `anchorOverrunsColumns`: the anchor at this position has a `colSpan` reaching past the last grid column.
+ * - `anchorOverrunsRows`: the anchor at this position has a `rowSpan` reaching past the last row of the table.
+ * - `overlappingAnchors`: the anchor at this position starts outside every other region but its footprint reaches a position already covered by the region anchored at `earlierAnchorRowIndex`, `earlierAnchorColumnIndex`, so two regions claim one position.
+ *
+ * A `kind` tag discriminates rather than property presence, because the variants' required fields are not mutually exclusive: several variants' fields include another's.
+ */
+type TableGridFault = {
+  readonly kind: "raggedRow";
+  readonly rowIndex: number;
+  readonly cellCount: number;
+  readonly gridColumnCount: number;
+} | {
+  readonly kind: "coveredContent" | "coveredSpan";
+  readonly rowIndex: number;
+  readonly columnIndex: number;
+  readonly anchorRowIndex: number;
+  readonly anchorColumnIndex: number;
+} | {
+  readonly kind: "anchorOverrunsColumns" | "anchorOverrunsRows";
+  readonly rowIndex: number;
+  readonly columnIndex: number;
+} | {
+  readonly kind: "overlappingAnchors";
+  readonly rowIndex: number;
+  readonly columnIndex: number;
+  readonly earlierAnchorRowIndex: number;
+  readonly earlierAnchorColumnIndex: number;
+};
+/**
+ * The first place `table` contradicts the grid rule, or `undefined` when it obeys it. It never throws: a caller decides what a fault means for it, the way findConstructMarkerImbalance leaves that decision to each consumer of a block list.
+ *
+ * Rows are compared with each other before any position is classified, since an anchor's footprint can only be measured against a grid every row shares; the positions are then checked in row-major order, so the fault returned is the earliest one in reading order.
+ *
+ * The check states the whole of the rule and nothing beyond it: a table with no rows, or whose rows are all empty, has no fault, and neither `columnWidthsPt` nor a cell's own properties other than its blocks and spans are consulted.
+ */
+declare function findTableGridFault(table: ContentTable): TableGridFault | undefined;
+/**
+ * One sentence stating a fault in words, for a writer that refuses or reports a table the grid rule does not admit: it names the fault by its position and, where the fault involves a second region, by that region's anchor. Indices are 0-based, matching every index in the descriptor. The sentence carries no entry point or format of its own, so each caller prefixes whatever names its own operation.
+ */
+declare function describeTableGridFault(fault: TableGridFault): string;
+/** A cell together with the grid column it starts at, for a reader whose source format states that column directly. */
+interface PositionedTableCell {
+  readonly columnIndex: number;
+  readonly cell: ContentTableCell;
+}
+/** One row's worth of positioned cells, carrying the row-level properties denseTableRows copies through unchanged. */
+interface PositionedTableRow {
+  readonly cells: readonly PositionedTableCell[];
+  readonly heightPt?: number;
+  readonly direction?: TextDirection;
+}
+/**
+ * Build dense rows from cells a reader has already positioned, filling every position no cell was placed at with an empty covered cell.
+ *
+ * `columnCount` is the grid width the source declared (a docx `w:tblGrid`, an ODF `table:table-column` run). The result is that wide, or wider if some row places a cell past it, so that every returned row has the same length whatever the source's own grid declaration said.
+ */
+declare function denseTableRows(rows: readonly PositionedTableRow[], columnCount: number): ContentTableRow[];
+/** One row's worth of anchor cells only, for a reader whose source format omits covered positions entirely and leaves their grid columns to be worked out from the spans around them. */
+interface AnchorTableRow {
+  readonly cells: readonly ContentTableCell[];
+  readonly heightPt?: number;
+  readonly direction?: TextDirection;
+}
+/**
+ * Build dense rows from anchor cells alone, placing each at the first grid column no earlier cell already reaches -- the placement HTML's own table model needs, where a `rowspan` in one row silently consumes a column in the rows below it and nothing marks the consumed position.
+ *
+ * `columnCount` is the grid width the source declared, where it declares one at all; pass 0 when it does not and the width follows from the placement.
+ */
+declare function placeAnchorTableRows(rows: readonly AnchorTableRow[], columnCount: number): ContentTableRow[];
+//#endregion
+export { AnchorTableRow, PositionedTableCell, PositionedTableRow, TableGridAnchor, TableGridCovered, TableGridFault, TableGridPosition, denseTableRows, describeTableGridFault, findTableGridFault, placeAnchorTableRows, tableCellColumnSpan, tableCellRowSpan, tableGridColumnCount, walkTableGrid };