@stll/folio-core 0.44.0 → 0.46.0

package/dist/pdf/images.js

@@ -12,9 +12,10 @@ import { inflateSync } from "node:zlib";
 * so a 4-bit palette image stays 4-bit and an alpha channel becomes an
 * `/SMask` rather than being composited against a guess at the backdrop.
 *
-* A form this module cannot represent exactly (16-bit samples, interlacing)
-* is an error, never an approximation: painting the wrong pixels silently is
-* worse than refusing the page.
+* A form this module cannot represent exactly (16-bit samples) is an error,
+* never an approximation: painting the wrong pixels silently is worse than
+* refusing the page. Adam7 interlacing is not such a form — it is seven
+* ordinary rasters of the same samples — so it is decoded rather than refused.
 */
 var PdfImageError = class extends TaggedError("PdfImageError") {};
 const PNG_SIGNATURE = [
@@ -43,6 +44,8 @@ const CHANNELS_PER_COLOR_TYPE = {
 };
 const FULLY_OPAQUE = 255;
 const EIGHT_BIT = 8;
+/** IHDR interlace method 1: the only one PNG defines besides "none". */
+const ADAM7_INTERLACE = 1;
 const toHex = (bytes) => {
 	let out = "";
 	for (const byte of bytes) out += byte.toString(16).padStart(2, "0").toUpperCase();
@@ -138,6 +141,131 @@ const unfilterPng = ({ filtered, bytesPerRow, bytesPerPixel, height }) => {
 	}
 	return Result.ok(out);
 };
+/**
+* The seven Adam7 passes, in the order the IDAT stream carries them: the
+* offset of the pass's first pixel and the stride between its pixels.
+*/
+const ADAM7_PASSES = [
+	{
+		xOffset: 0,
+		yOffset: 0,
+		xStep: 8,
+		yStep: 8
+	},
+	{
+		xOffset: 4,
+		yOffset: 0,
+		xStep: 8,
+		yStep: 8
+	},
+	{
+		xOffset: 0,
+		yOffset: 4,
+		xStep: 4,
+		yStep: 8
+	},
+	{
+		xOffset: 2,
+		yOffset: 0,
+		xStep: 4,
+		yStep: 4
+	},
+	{
+		xOffset: 0,
+		yOffset: 2,
+		xStep: 2,
+		yStep: 4
+	},
+	{
+		xOffset: 1,
+		yOffset: 0,
+		xStep: 2,
+		yStep: 2
+	},
+	{
+		xOffset: 0,
+		yOffset: 1,
+		xStep: 1,
+		yStep: 2
+	}
+];
+/**
+* The passes that carry data, with their own geometry.
+*
+* A narrow or short image leaves later passes empty — a 1x1 image has only
+* pass 1 — and an empty pass contributes no bytes at all, not even a filter
+* byte, so it must be dropped rather than read as a zero-row raster.
+*/
+const adam7Passes = (width, height, bitsPerPixel) => {
+	const passes = [];
+	for (const { xOffset, yOffset, xStep, yStep } of ADAM7_PASSES) {
+		const passWidth = Math.ceil(Math.max(0, width - xOffset) / xStep);
+		const passHeight = Math.ceil(Math.max(0, height - yOffset) / yStep);
+		if (passWidth === 0 || passHeight === 0) continue;
+		passes.push({
+			xOffset,
+			yOffset,
+			xStep,
+			yStep,
+			width: passWidth,
+			height: passHeight,
+			bytesPerRow: Math.ceil(bitsPerPixel * passWidth / EIGHT_BIT)
+		});
+	}
+	return passes;
+};
+/** One filter byte per row of every pass: the whole inflated size Adam7 needs. */
+const adam7FilteredBytes = (passes) => passes.reduce((sum, pass) => sum + pass.height * (pass.bytesPerRow + 1), 0);
+/** Write one unfiltered pass into the pixels of the full raster it owns. */
+const scatterPass = ({ pass, rows, out, bytesPerRow, bitDepth, bytesPerPixel }) => {
+	if (bitDepth >= EIGHT_BIT) {
+		for (let row = 0; row < pass.height; row += 1) {
+			const targetRow = pass.yOffset + row * pass.yStep;
+			for (let column = 0; column < pass.width; column += 1) {
+				const source = row * pass.bytesPerRow + column * bytesPerPixel;
+				const target = targetRow * bytesPerRow + (pass.xOffset + column * pass.xStep) * bytesPerPixel;
+				for (let byte = 0; byte < bytesPerPixel; byte += 1) out[target + byte] = rows[source + byte] ?? 0;
+			}
+		}
+		return;
+	}
+	const perByte = EIGHT_BIT / bitDepth;
+	const mask = (1 << bitDepth) - 1;
+	for (let row = 0; row < pass.height; row += 1) {
+		const targetRow = pass.yOffset + row * pass.yStep;
+		for (let column = 0; column < pass.width; column += 1) {
+			const value = (rows[row * pass.bytesPerRow + Math.floor(column / perByte)] ?? 0) >> EIGHT_BIT - bitDepth * (column % perByte + 1) & mask;
+			const targetColumn = pass.xOffset + column * pass.xStep;
+			const targetIndex = targetRow * bytesPerRow + Math.floor(targetColumn / perByte);
+			const targetShift = EIGHT_BIT - bitDepth * (targetColumn % perByte + 1);
+			out[targetIndex] = (out[targetIndex] ?? 0) & ~(mask << targetShift) | value << targetShift;
+		}
+	}
+};
+/** Unfilter each Adam7 pass and scatter it into the raster it describes. */
+const deinterlacePng = ({ filtered, passes, height, bytesPerRow, bytesPerPixel, bitDepth }) => {
+	const out = new Uint8Array(height * bytesPerRow);
+	let cursor = 0;
+	for (const pass of passes) {
+		const unfiltered = unfilterPng({
+			filtered: filtered.subarray(cursor),
+			bytesPerRow: pass.bytesPerRow,
+			bytesPerPixel,
+			height: pass.height
+		});
+		if (unfiltered.isErr()) return Result.err(unfiltered.error);
+		scatterPass({
+			pass,
+			rows: unfiltered.value,
+			out,
+			bytesPerRow,
+			bitDepth,
+			bytesPerPixel
+		});
+		cursor += pass.height * (pass.bytesPerRow + 1);
+	}
+	return Result.ok(out);
+};
 /** One byte per pixel index, for sub-byte palette and greyscale depths. */
 const expandIndices = ({ rows, bytesPerRow, width, height, bitDepth }) => {
 	if (bitDepth === EIGHT_BIT) return rows;
@@ -162,7 +290,7 @@ const decodePng = (bytes) => {
 	const colorType = header[9] ?? 0;
 	const interlace = header[12] ?? 0;
 	if (width === 0 || height === 0) return Result.err(new PdfImageError({ message: "PNG has a zero dimension" }));
-	if (interlace !== 0) return Result.err(new PdfImageError({ message: "interlaced PNG is not supported" }));
+	if (interlace !== 0 && interlace !== ADAM7_INTERLACE) return Result.err(new PdfImageError({ message: `unknown PNG interlace method ${String(interlace)}` }));
 	const channels = CHANNELS_PER_COLOR_TYPE[colorType];
 	if (channels === void 0) return Result.err(new PdfImageError({ message: `unknown PNG colour type ${String(colorType)}` }));
 	if (!(colorType === PNG_COLOR_TYPE.greyscale || colorType === PNG_COLOR_TYPE.palette ? [
@@ -174,18 +302,26 @@ const decodePng = (bytes) => {
 	const bitsPerPixel = bitDepth * channels;
 	const bytesPerRow = Math.ceil(bitsPerPixel * width / EIGHT_BIT);
 	const bytesPerPixel = Math.max(1, Math.ceil(bitsPerPixel / EIGHT_BIT));
-	const inflatedBytesExpected = height * (bytesPerRow + 1);
+	const passes = interlace === ADAM7_INTERLACE ? adam7Passes(width, height, bitsPerPixel) : null;
+	const inflatedBytesExpected = passes === null ? height * (bytesPerRow + 1) : adam7FilteredBytes(passes);
 	const inflated = Result.try({
 		try: () => inflateSync(pixels, { maxOutputLength: inflatedBytesExpected }),
 		catch: (cause) => new PdfImageError({ message: `PNG IDAT does not inflate to the ${String(inflatedBytesExpected)} bytes its IHDR declares: ${cause instanceof Error ? cause.message : String(cause)}` })
 	});
 	if (inflated.isErr()) return Result.err(inflated.error);
 	const filtered = new Uint8Array(inflated.value.buffer, inflated.value.byteOffset, inflated.value.byteLength);
-	const unfiltered = unfilterPng({
+	const unfiltered = passes === null ? unfilterPng({
 		filtered,
 		bytesPerRow,
 		bytesPerPixel,
 		height
+	}) : deinterlacePng({
+		filtered,
+		passes,
+		height,
+		bytesPerRow,
+		bytesPerPixel,
+		bitDepth
 	});
 	if (unfiltered.isErr()) return Result.err(unfiltered.error);
 	const rows = unfiltered.value;

package/dist/prosemirror/attrs/index.d.ts

@@ -1,5 +1,5 @@
-import { CharacterSpacingAttrs, CharacterStyleAttrs, CommentAttrs, EmphasisMarkAttrs, FontFamilyAttrs, FontSizeAttrs, FootnoteRefAttrs, HighlightAttrs, HyperlinkAttrs, LanguageAttrs, PageBreakRunOwnerMarkAttrs, RunFormattingOverrideAttrs, RunPropertyChangeMarkAttrs, RunShadingAttrs, StrikeAttrs, TextColorAttrs, TextEffectAttrs, TrackedChangeMarkAttrs, UnderlineAttrs } from "../schema/marks.js";
-import { BlockSdtAttrs, FieldAttrs, HardBreakAttrs, ImageAttrs, MathAttrs, PageBreakRunAttrs, ParagraphAttrs, SdtAttrs, ShapeAttrs, SymbolAttrs, TabAttrs, TableAttrs, TableCellAttrs, TableRowAttrs, TextBoxAttrs } from "../schema/nodes.js";
+import { CharacterSpacingAttrs, CharacterStyleAttrs, CommentAttrs, EmphasisMarkAttrs, FontFamilyAttrs, FontSizeAttrs, FootnoteRefAttrs, HighlightAttrs, HyperlinkAttrs, InlineWrapperAttrs, InlineWrapperLayer, LanguageAttrs, PageBreakRunOwnerMarkAttrs, RunFormattingOverrideAttrs, RunPropertyChangeMarkAttrs, RunShadingAttrs, StrikeAttrs, TextColorAttrs, TextEffectAttrs, TrackedChangeMarkAttrs, UnderlineAttrs } from "../schema/marks.js";
+import { BlockSdtAttrs, FieldAttrs, HardBreakAttrs, ImageAttrs, MathAttrs, PageBreakRunAttrs, ParagraphAttrs, PreservedBlockAttrs, PreservedXmlAttrs, SdtAttrs, ShapeAttrs, SymbolAttrs, TabAttrs, TableAttrs, TableCellAttrs, TableRowAttrs, TextBoxAttrs } from "../schema/nodes.js";
 import "../schema/index.js";
 import { Mark, Node } from "prosemirror-model";
 //#region src/prosemirror/attrs/index.d.ts
@@ -24,6 +24,10 @@ declare const readTabAttrs: (node: Node) => ReadProseMirrorAttrsResult<TabAttrs>
 declare const expectTabAttrs: (node: Node) => TabAttrs;
 declare const readSymbolAttrs: (node: Node) => ReadProseMirrorAttrsResult<SymbolAttrs>;
 declare const expectSymbolAttrs: (node: Node) => SymbolAttrs;
+declare const readPreservedXmlAttrs: (node: Node) => ReadProseMirrorAttrsResult<PreservedXmlAttrs>;
+declare const expectPreservedXmlAttrs: (node: Node) => PreservedXmlAttrs;
+declare const readPreservedBlockAttrs: (node: Node) => ReadProseMirrorAttrsResult<PreservedBlockAttrs>;
+declare const expectPreservedBlockAttrs: (node: Node) => PreservedBlockAttrs;
 declare const readTableAttrs: (node: Node) => ReadProseMirrorAttrsResult<TableAttrs>;
 declare const expectTableAttrs: (node: Node) => TableAttrs;
 declare const readTableRowAttrs: (node: Node) => ReadProseMirrorAttrsResult<TableRowAttrs>;
@@ -78,6 +82,13 @@ declare const readRunPropertyChangeMarkAttrs: (mark: Mark) => ReadProseMirrorAtt
 declare const expectRunPropertyChangeMarkAttrs: (mark: Mark) => RunPropertyChangeMarkAttrs;
 declare const readPageBreakRunOwnerMarkAttrs: (mark: Mark) => ReadProseMirrorAttrsResult<PageBreakRunOwnerMarkAttrs>;
 declare const expectPageBreakRunOwnerMarkAttrs: (mark: Mark) => PageBreakRunOwnerMarkAttrs;
+/**
+ * A wrapper stack read from outside the editor — the DOM on paste, a stored
+ * snapshot — validated layer by layer.
+ */
+declare const readInlineWrapperStack: (value: unknown, path?: string) => ReadProseMirrorAttrsResult<readonly InlineWrapperLayer[]>;
+declare const readInlineWrapperMarkAttrs: (mark: Mark) => ReadProseMirrorAttrsResult<InlineWrapperAttrs>;
+declare const expectInlineWrapperMarkAttrs: (mark: Mark) => InlineWrapperAttrs;
 declare const readRunFormattingOverrideMarkAttrs: (mark: Mark) => ReadProseMirrorAttrsResult<RunFormattingOverrideAttrs>;
 declare const expectRunFormattingOverrideMarkAttrs: (mark: Mark) => RunFormattingOverrideAttrs;
 declare const readHyperlinkMarkAttrs: (mark: Mark) => ReadProseMirrorAttrsResult<HyperlinkAttrs>;
@@ -89,4 +100,4 @@ declare const mergeTableAttrs: (node: Node, patch: NodeAttrPatch<TableAttrs>) =>
 declare const mergeTableRowAttrs: (node: Node, patch: NodeAttrPatch<TableRowAttrs>) => TableRowAttrs;
 declare const mergeTableCellAttrs: (node: Node, patch: NodeAttrPatch<TableCellAttrs>) => TableCellAttrs;
 //#endregion
-export { ProseMirrorAttrIssue, ReadProseMirrorAttrsResult, expectBlockSdtAttrs, expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFieldAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHardBreakAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectLanguageMarkAttrs, expectMathAttrs, expectPageBreakRunAttrs, expectPageBreakRunOwnerMarkAttrs, expectParagraphAttrs, expectRunFormattingOverrideMarkAttrs, expectRunPropertyChangeMarkAttrs, expectRunShadingMarkAttrs, expectSdtAttrs, expectShapeAttrs, expectStrikeMarkAttrs, expectSymbolAttrs, expectTabAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs, mergeImageAttrs, mergeParagraphAttrs, mergeTableAttrs, mergeTableCellAttrs, mergeTableRowAttrs, readBlockSdtAttrs, readCharacterSpacingMarkAttrs, readCharacterStyleMarkAttrs, readCommentMarkAttrs, readEmphasisMarkAttrs, readFieldAttrs, readFontFamilyMarkAttrs, readFontSizeMarkAttrs, readFootnoteRefMarkAttrs, readHardBreakAttrs, readHighlightMarkAttrs, readHyperlinkMarkAttrs, readImageAttrs, readLanguageMarkAttrs, readMathAttrs, readPageBreakRunAttrs, readPageBreakRunOwnerMarkAttrs, readParagraphAttrs, readRunFormattingOverrideMarkAttrs, readRunPropertyChangeMarkAttrs, readRunShadingMarkAttrs, readSdtAttrs, readShapeAttrs, readStrikeMarkAttrs, readSymbolAttrs, readTabAttrs, readTableAttrs, readTableCellAttrs, readTableRowAttrs, readTextBoxAttrs, readTextColorMarkAttrs, readTextEffectMarkAttrs, readTrackedChangeMarkAttrs, readUnderlineMarkAttrs };
+export { ProseMirrorAttrIssue, ReadProseMirrorAttrsResult, expectBlockSdtAttrs, expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFieldAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHardBreakAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectInlineWrapperMarkAttrs, expectLanguageMarkAttrs, expectMathAttrs, expectPageBreakRunAttrs, expectPageBreakRunOwnerMarkAttrs, expectParagraphAttrs, expectPreservedBlockAttrs, expectPreservedXmlAttrs, expectRunFormattingOverrideMarkAttrs, expectRunPropertyChangeMarkAttrs, expectRunShadingMarkAttrs, expectSdtAttrs, expectShapeAttrs, expectStrikeMarkAttrs, expectSymbolAttrs, expectTabAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs, mergeImageAttrs, mergeParagraphAttrs, mergeTableAttrs, mergeTableCellAttrs, mergeTableRowAttrs, readBlockSdtAttrs, readCharacterSpacingMarkAttrs, readCharacterStyleMarkAttrs, readCommentMarkAttrs, readEmphasisMarkAttrs, readFieldAttrs, readFontFamilyMarkAttrs, readFontSizeMarkAttrs, readFootnoteRefMarkAttrs, readHardBreakAttrs, readHighlightMarkAttrs, readHyperlinkMarkAttrs, readImageAttrs, readInlineWrapperMarkAttrs, readInlineWrapperStack, readLanguageMarkAttrs, readMathAttrs, readPageBreakRunAttrs, readPageBreakRunOwnerMarkAttrs, readParagraphAttrs, readPreservedBlockAttrs, readPreservedXmlAttrs, readRunFormattingOverrideMarkAttrs, readRunPropertyChangeMarkAttrs, readRunShadingMarkAttrs, readSdtAttrs, readShapeAttrs, readStrikeMarkAttrs, readSymbolAttrs, readTabAttrs, readTableAttrs, readTableCellAttrs, readTableRowAttrs, readTextBoxAttrs, readTextColorMarkAttrs, readTextEffectMarkAttrs, readTrackedChangeMarkAttrs, readUnderlineMarkAttrs };

package/dist/prosemirror/attrs/index.js

@@ -5,10 +5,11 @@ import { canonicalJson } from "../../utils/canonicalJson.js";
 import { normalizeHorizontalScalePercent } from "../../utils/horizontalScale.js";
 import { isParagraphDirection } from "../paragraphDirection.js";
 import { COMPLEX_SCRIPT_RUN_PROPERTY_KEYS, RUN_FORMATTING_BOOLEAN_PROPERTIES, RUN_FORMATTING_VALUE_PROPERTIES, TRACKED_CHANGE_PROVENANCE_VALUES } from "../schema/marks.js";
-import { TEXT_BOX_TEXT_BODY_CONTENT_STATE_TYPES } from "../schema/nodes.js";
+import { PRESERVED_XML_LEVELS, TEXT_BOX_TEXT_BODY_CONTENT_STATE_TYPES } from "../schema/nodes.js";
 import { panic } from "better-result";
 import { DRAWING_RAW_XML_MODES, isOoxmlSymbolCharacter } from "@stll/docx-core/model";
 //#region src/prosemirror/attrs/index.ts
+const PRESERVED_XML_LEVEL_VALUES = new Set(Object.values(PRESERVED_XML_LEVELS));
 const SECTION_BREAK_TYPES = [
 	"nextPage",
 	"continuous",
@@ -53,6 +54,11 @@ const SHAPE_OUTLINE_CAPS = [
 	"round",
 	"square"
 ];
+const SHAPE_OUTLINE_JOINS = [
+	"bevel",
+	"miter",
+	"round"
+];
 const SHAPE_LINE_END_TYPES = [
 	"none",
 	"triangle",
@@ -141,6 +147,8 @@ const hardBreakAttrsCache = /* @__PURE__ */ new WeakMap();
 const pageBreakRunAttrsCache = /* @__PURE__ */ new WeakMap();
 const tabAttrsCache = /* @__PURE__ */ new WeakMap();
 const symbolAttrsCache = /* @__PURE__ */ new WeakMap();
+const preservedXmlAttrsCache = /* @__PURE__ */ new WeakMap();
+const preservedBlockAttrsCache = /* @__PURE__ */ new WeakMap();
 const tableAttrsCache = /* @__PURE__ */ new WeakMap();
 const tableRowAttrsCache = /* @__PURE__ */ new WeakMap();
 const tableCellAttrsCache = /* @__PURE__ */ new WeakMap();
@@ -167,6 +175,7 @@ const commentAttrsCache = /* @__PURE__ */ new WeakMap();
 const trackedChangeAttrsCache = /* @__PURE__ */ new WeakMap();
 const runPropertyChangeAttrsCache = /* @__PURE__ */ new WeakMap();
 const pageBreakRunOwnerAttrsCache = /* @__PURE__ */ new WeakMap();
+const inlineWrapperAttrsCache = /* @__PURE__ */ new WeakMap();
 const runFormattingOverrideAttrsCache = /* @__PURE__ */ new WeakMap();
 const hyperlinkAttrsCache = /* @__PURE__ */ new WeakMap();
 const readParagraphAttrs = (node) => {
@@ -252,6 +261,7 @@ const readParagraphAttrs = (node) => {
 	optionalAutospacingBase(attrs, "paragraph.attrs._autospacingBase", issues);
 	optionalSectionProperties(attrs, "_sectionProperties", "paragraph.attrs._sectionProperties", issues);
 	optionalPropertyChanges(attrs, "_propertyChanges", "paragraph.attrs._propertyChanges", issues, ["paragraphPropertyChange"]);
+	optionalPreservedAttributes(attrs, "paragraph.attrs._preservedAttributes", issues);
 	return attrsResult(attrs, issues);
 };
 const expectParagraphAttrs = (node) => expectCachedNodeAttrs(node, paragraphAttrsCache, readParagraphAttrs, "paragraph attrs");
@@ -299,6 +309,27 @@ const readSymbolAttrs = (node) => {
 	return attrsResult(attrs, issues);
 };
 const expectSymbolAttrs = (node) => expectCachedNodeAttrs(node, symbolAttrsCache, readSymbolAttrs, "symbol attrs");
+const readPreservedXmlAttrs = (node) => {
+	const attrs = attrsRecord(node.attrs);
+	const issues = [];
+	expectNodeType(node, "preservedXml", issues);
+	requiredString(attrs, "xml", "preservedXml.attrs.xml", issues);
+	requiredString(attrs, "text", "preservedXml.attrs.text", issues);
+	if (!PRESERVED_XML_LEVEL_VALUES.has(attrs["level"])) issues.push({
+		path: "preservedXml.attrs.level",
+		message: `Expected one of ${[...PRESERVED_XML_LEVEL_VALUES].join(", ")}.`
+	});
+	return attrsResult(attrs, issues);
+};
+const expectPreservedXmlAttrs = (node) => expectCachedNodeAttrs(node, preservedXmlAttrsCache, readPreservedXmlAttrs, "preservedXml attrs");
+const readPreservedBlockAttrs = (node) => {
+	const attrs = attrsRecord(node.attrs);
+	const issues = [];
+	expectNodeType(node, "preservedBlock", issues);
+	requiredString(attrs, "xml", "preservedBlock.attrs.xml", issues);
+	return attrsResult(attrs, issues);
+};
+const expectPreservedBlockAttrs = (node) => expectCachedNodeAttrs(node, preservedBlockAttrsCache, readPreservedBlockAttrs, "preservedBlock attrs");
 const readTableAttrs = (node) => {
 	const attrs = attrsRecord(node.attrs);
 	const issues = [];
@@ -341,6 +372,7 @@ const readTableRowAttrs = (node) => {
 		path: "tableRow.attrs",
 		message: "Expected at most one structural revision marker."
 	});
+	optionalPreservedAttributes(attrs, "tableRow.attrs._preservedAttributes", issues);
 	return attrsResult(attrs, issues);
 };
 const expectTableRowAttrs = (node) => expectCachedNodeAttrs(node, tableRowAttrsCache, readTableRowAttrs, "table row attrs");
@@ -389,11 +421,16 @@ const readImageAttrs = (node) => {
 	optionalOneOf(attrs, "displayMode", "image.attrs.displayMode", issues, IMAGE_DISPLAY_MODES);
 	optionalOneOf(attrs, "cssFloat", "image.attrs.cssFloat", issues, IMAGE_CSS_FLOATS);
 	optionalString(attrs, "transform", "image.attrs.transform", issues);
+	optionalNumber(attrs, "docxRotation", "image.attrs.docxRotation", issues);
+	optionalBoolean(attrs, "docxFlipH", "image.attrs.docxFlipH", issues);
+	optionalBoolean(attrs, "docxFlipV", "image.attrs.docxFlipV", issues);
 	optionalNumber(attrs, "distTop", "image.attrs.distTop", issues);
 	optionalNumber(attrs, "distBottom", "image.attrs.distBottom", issues);
 	optionalNumber(attrs, "distLeft", "image.attrs.distLeft", issues);
 	optionalNumber(attrs, "distRight", "image.attrs.distRight", issues);
 	optionalNumber(attrs, "opacity", "image.attrs.opacity", issues);
+	optionalNumber(attrs, "brightness", "image.attrs.brightness", issues);
+	optionalNumber(attrs, "contrast", "image.attrs.contrast", issues);
 	optionalNumber(attrs, "cropTop", "image.attrs.cropTop", issues);
 	optionalNumber(attrs, "cropRight", "image.attrs.cropRight", issues);
 	optionalNumber(attrs, "cropBottom", "image.attrs.cropBottom", issues);
@@ -404,7 +441,11 @@ const readImageAttrs = (node) => {
 	optionalNumber(attrs, "paddingLeft", "image.attrs.paddingLeft", issues);
 	optionalImagePosition(attrs, "position", "image.attrs.position", issues);
 	optionalBoolean(attrs, "layoutInCell", "image.attrs.layoutInCell", issues);
+	optionalBoolean(attrs, "decorative", "image.attrs.decorative", issues);
+	optionalBoolean(attrs, "hidden", "image.attrs.hidden", issues);
+	optionalStringArray(attrs, "docPrExtensions", "image.attrs.docPrExtensions", issues);
 	optionalImageFrameLocks(attrs, "frameLocks", "image.attrs.frameLocks", issues);
+	optionalAuthoredEmu(attrs, "_docxAuthoredEmu", "image.attrs._docxAuthoredEmu", issues, IMAGE_AUTHORED_EMU_ATTRS);
 	optionalNumber(attrs, "borderWidth", "image.attrs.borderWidth", issues);
 	optionalString(attrs, "borderColor", "image.attrs.borderColor", issues);
 	optionalString(attrs, "borderStyle", "image.attrs.borderStyle", issues);
@@ -487,8 +528,12 @@ const readShapeAttrs = (node) => {
 	optionalString(attrs, "shapeType", "shape.attrs.shapeType", issues);
 	optionalString(attrs, "geometryAdjustments", "shape.attrs.geometryAdjustments", issues);
 	optionalString(attrs, "shapeId", "shape.attrs.shapeId", issues);
+	optionalString(attrs, "shapeName", "shape.attrs.shapeName", issues);
+	optionalString(attrs, "alt", "shape.attrs.alt", issues);
+	optionalString(attrs, "title", "shape.attrs.title", issues);
 	optionalNumber(attrs, "width", "shape.attrs.width", issues);
 	optionalNumber(attrs, "height", "shape.attrs.height", issues);
+	optionalAuthoredEmu(attrs, "_docxAuthoredEmu", "shape.attrs._docxAuthoredEmu", issues, SHAPE_AUTHORED_EMU_ATTRS);
 	optionalString(attrs, "fillColor", "shape.attrs.fillColor", issues);
 	optionalColorValue(attrs, "fillColorValue", "shape.attrs.fillColorValue", issues);
 	optionalOneOf(attrs, "fillType", "shape.attrs.fillType", issues, SHAPE_FILL_TYPES);
@@ -500,9 +545,13 @@ const readShapeAttrs = (node) => {
 	optionalColorValue(attrs, "outlineColorValue", "shape.attrs.outlineColorValue", issues);
 	optionalOneOf(attrs, "outlineStyle", "shape.attrs.outlineStyle", issues, OUTLINE_STYLE_ATTR_VALUES);
 	optionalOneOf(attrs, "outlineCap", "shape.attrs.outlineCap", issues, SHAPE_OUTLINE_CAPS);
+	optionalOneOf(attrs, "outlineJoin", "shape.attrs.outlineJoin", issues, SHAPE_OUTLINE_JOINS);
 	optionalShapeLineEnd(attrs, "outlineHeadEnd", "shape.attrs.outlineHeadEnd", issues);
 	optionalShapeLineEnd(attrs, "outlineTailEnd", "shape.attrs.outlineTailEnd", issues);
 	optionalString(attrs, "transform", "shape.attrs.transform", issues);
+	optionalNumber(attrs, "docxRotation", "shape.attrs.docxRotation", issues);
+	optionalBoolean(attrs, "docxFlipH", "shape.attrs.docxFlipH", issues);
+	optionalBoolean(attrs, "docxFlipV", "shape.attrs.docxFlipV", issues);
 	optionalOneOf(attrs, "displayMode", "shape.attrs.displayMode", issues, IMAGE_DISPLAY_MODES);
 	optionalOneOf(attrs, "cssFloat", "shape.attrs.cssFloat", issues, IMAGE_CSS_FLOATS);
 	optionalOneOf(attrs, "wrapType", "shape.attrs.wrapType", issues, IMAGE_WRAP_TYPE_VALUES);
@@ -531,11 +580,18 @@ const readTextBoxAttrs = (node) => {
 	optionalWordArt(attrs, "wordArt", "textBox.attrs.wordArt", issues);
 	optionalOneOf(attrs, "textWrap", "textBox.attrs.textWrap", issues, TEXT_BOX_TEXT_WRAP_VALUES);
 	optionalString(attrs, "textBoxId", "textBox.attrs.textBoxId", issues);
+	optionalString(attrs, "textBoxName", "textBox.attrs.textBoxName", issues);
+	optionalString(attrs, "alt", "textBox.attrs.alt", issues);
+	optionalString(attrs, "title", "textBox.attrs.title", issues);
 	optionalString(attrs, "fillColor", "textBox.attrs.fillColor", issues);
 	optionalNumber(attrs, "outlineWidth", "textBox.attrs.outlineWidth", issues);
+	optionalAuthoredEmu(attrs, "_docxAuthoredEmu", "textBox.attrs._docxAuthoredEmu", issues, TEXT_BOX_AUTHORED_EMU_ATTRS);
 	optionalString(attrs, "outlineColor", "textBox.attrs.outlineColor", issues);
 	optionalOneOf(attrs, "outlineStyle", "textBox.attrs.outlineStyle", issues, OUTLINE_STYLE_ATTR_VALUES);
 	optionalTextBoxTransform(attrs, "transform", "textBox.attrs.transform", issues);
+	optionalNumber(attrs, "docxRotation", "textBox.attrs.docxRotation", issues);
+	optionalBoolean(attrs, "docxFlipH", "textBox.attrs.docxFlipH", issues);
+	optionalBoolean(attrs, "docxFlipV", "textBox.attrs.docxFlipV", issues);
 	optionalNumber(attrs, "marginTop", "textBox.attrs.marginTop", issues);
 	optionalNumber(attrs, "marginBottom", "textBox.attrs.marginBottom", issues);
 	optionalNumber(attrs, "marginLeft", "textBox.attrs.marginLeft", issues);
@@ -556,6 +612,7 @@ const readTextBoxAttrs = (node) => {
 	requiredTextBoxBodyContentState(attrs, issues);
 	optionalTextBoxTrackedChange(attrs, issues);
 	optionalTextBoxInlineSdts(attrs, issues);
+	optionalPreservedAttributes(attrs, "textBox.attrs._preservedAttributes", issues);
 	return attrsResult(attrs, issues);
 };
 const expectTextBoxAttrs = (node) => expectCachedNodeAttrs(node, textBoxAttrsCache, readTextBoxAttrs, "text box attrs");
@@ -734,6 +791,89 @@ const readPageBreakRunOwnerMarkAttrs = (mark) => {
 	return attrsResult(attrs, issues);
 };
 const expectPageBreakRunOwnerMarkAttrs = (mark) => expectCachedMarkAttrs(mark, pageBreakRunOwnerAttrsCache, readPageBreakRunOwnerMarkAttrs, "page break run owner attrs");
+const BIDI_LAYER_CONTROLS = ["embedding", "override"];
+const BIDI_LAYER_DIRECTIONS = ["ltr", "rtl"];
+const BIDI_LAYER_KEYS = /* @__PURE__ */ new Set([
+	"kind",
+	"control",
+	"direction"
+]);
+/**
+* One validator per wrapper kind, total over the kinds the model declares: a
+* kind added without a field-by-field check does not compile, and a layer that
+* states a field its kind does not carry (a smart tag with a bidi `control`)
+* is rejected rather than stored and written back.
+*/
+const INLINE_WRAPPER_LAYER_VALIDATORS = { bidi: (layer, path, issues) => {
+	requiredOneOf(layer, "control", `${path}.control`, issues, BIDI_LAYER_CONTROLS);
+	optionalOneOf(layer, "direction", `${path}.direction`, issues, BIDI_LAYER_DIRECTIONS);
+	for (const key of Object.keys(layer)) if (!BIDI_LAYER_KEYS.has(key)) issues.push({
+		path: `${path}.${key}`,
+		message: "Unexpected bidi wrapper property."
+	});
+} };
+const inlineWrapperLayerValidator = (kind) => {
+	return typeof kind === "string" ? INLINE_WRAPPER_LAYER_VALIDATORS[kind] : void 0;
+};
+const validateInlineWrapperStack = (value, path, issues) => {
+	if (!Array.isArray(value)) {
+		issues.push({
+			path,
+			message: "Expected an array of inline wrapper layers."
+		});
+		return;
+	}
+	if (value.length === 0) {
+		issues.push({
+			path,
+			message: "Expected at least one inline wrapper layer."
+		});
+		return;
+	}
+	for (const [index, layer] of value.entries()) {
+		const layerPath = `${path}[${index}]`;
+		if (!isRecord(layer)) {
+			issues.push({
+				path: layerPath,
+				message: "Expected an inline wrapper layer object."
+			});
+			continue;
+		}
+		const validator = inlineWrapperLayerValidator(layer["kind"]);
+		if (!validator) {
+			issues.push({
+				path: `${layerPath}.kind`,
+				message: `Expected one of ${Object.keys(INLINE_WRAPPER_LAYER_VALIDATORS).join(", ")}.`
+			});
+			continue;
+		}
+		validator(layer, layerPath, issues);
+	}
+};
+/**
+* A wrapper stack read from outside the editor — the DOM on paste, a stored
+* snapshot — validated layer by layer.
+*/
+const readInlineWrapperStack = (value, path = "inlineWrapper.attrs.stack") => {
+	const issues = [];
+	validateInlineWrapperStack(value, path, issues);
+	if (issues.length > 0) return {
+		ok: false,
+		issues
+	};
+	return {
+		ok: true,
+		value
+	};
+};
+const readInlineWrapperMarkAttrs = (mark) => {
+	const attrs = attrsRecord(mark.attrs);
+	const issues = [];
+	expectMarkType(mark, "inlineWrapper", issues);
+	validateInlineWrapperStack(attrs["stack"], "inlineWrapper.attrs.stack", issues);
+	return attrsResult(attrs, issues);
+};
+const expectInlineWrapperMarkAttrs = (mark) => expectCachedMarkAttrs(mark, inlineWrapperAttrsCache, readInlineWrapperMarkAttrs, "inline wrapper attrs");
 const readRunFormattingOverrideMarkAttrs = (mark) => {
 	const attrs = attrsRecord(mark.attrs);
 	const issues = [];
@@ -1288,6 +1428,37 @@ const validateSdtAttrsRecord = (attrs, path, issues) => {
 	optionalString(attrs, "rawPropertiesXml", `${path}.rawPropertiesXml`, issues);
 	optionalString(attrs, "rawEndPropertiesXml", `${path}.rawEndPropertiesXml`, issues);
 };
+/**
+* The attribute remainder an authored element's record carries.
+*
+* Every entry is a resolved name and a string value; nothing here is a
+* spelling, which is why the namespace is a URI and optional rather than a
+* prefix. See `docx/attributeRemainder.ts`.
+*/
+const optionalPreservedAttributes = (attrs, path, issues) => {
+	const value = attrs["_preservedAttributes"];
+	if (value === void 0 || value === null) return;
+	if (!Array.isArray(value)) {
+		issues.push({
+			path,
+			message: "Expected an array."
+		});
+		return;
+	}
+	for (const [index, entry] of value.entries()) {
+		const entryPath = `${path}[${index}]`;
+		if (!isRecord(entry)) {
+			issues.push({
+				path: entryPath,
+				message: "Expected an object."
+			});
+			continue;
+		}
+		requiredString(entry, "name", `${entryPath}.name`, issues);
+		requiredString(entry, "value", `${entryPath}.value`, issues);
+		optionalString(entry, "namespace", `${entryPath}.namespace`, issues);
+	}
+};
 const optionalAutospacingBase = (attrs, path, issues) => {
 	const value = attrs["_autospacingBase"];
 	if (value === void 0 || value === null) return;
@@ -1784,6 +1955,57 @@ const validatePropertyChangeInfo = (value, path, issues) => {
 	optionalOneOf(value, "provenance", `${path}.provenance`, issues, TRACKED_CHANGE_PROVENANCE_VALUES);
 	optionalString(value, "suggestionId", `${path}.suggestionId`, issues);
 };
+/**
+* The authored-EMU carrier: a sparse record of finite numbers keyed by the
+* pixel attribute each one was projected into. The keys are the node's own, so
+* they are checked against the list the caller passes rather than a shared one.
+*/
+const optionalAuthoredEmu = (attrs, key, path, issues, allowed) => {
+	const value = attrs[key];
+	if (value === void 0 || value === null) return;
+	if (!isRecord(value)) {
+		issues.push({
+			path,
+			message: "Expected an object."
+		});
+		return;
+	}
+	for (const name of Object.keys(value)) {
+		if (!allowed.includes(name)) {
+			issues.push({
+				path: `${path}.${name}`,
+				message: "Not a pixel attribute of this node."
+			});
+			continue;
+		}
+		optionalNumber(value, name, `${path}.${name}`, issues);
+	}
+};
+const WRAP_DISTANCE_ATTRS = [
+	"distTop",
+	"distBottom",
+	"distLeft",
+	"distRight"
+];
+const TEXT_BOX_MARGIN_ATTRS = [
+	"marginTop",
+	"marginBottom",
+	"marginLeft",
+	"marginRight"
+];
+const IMAGE_AUTHORED_EMU_ATTRS = [
+	"width",
+	"height",
+	"borderWidth",
+	...WRAP_DISTANCE_ATTRS
+];
+const SHAPE_AUTHORED_EMU_ATTRS = [
+	"width",
+	"height",
+	"outlineWidth",
+	...WRAP_DISTANCE_ATTRS
+];
+const TEXT_BOX_AUTHORED_EMU_ATTRS = [...SHAPE_AUTHORED_EMU_ATTRS, ...TEXT_BOX_MARGIN_ATTRS];
 const optionalImageFrameLocks = (attrs, key, path, issues) => {
 	const value = attrs[key];
 	if (value === void 0 || value === null) return;
@@ -1955,4 +2177,4 @@ const optionalEmptyHyperlinkArray = (value, issues) => {
 	}
 };
 //#endregion
-export { expectBlockSdtAttrs, expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFieldAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHardBreakAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectLanguageMarkAttrs, expectMathAttrs, expectPageBreakRunAttrs, expectPageBreakRunOwnerMarkAttrs, expectParagraphAttrs, expectRunFormattingOverrideMarkAttrs, expectRunPropertyChangeMarkAttrs, expectRunShadingMarkAttrs, expectSdtAttrs, expectShapeAttrs, expectStrikeMarkAttrs, expectSymbolAttrs, expectTabAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs, mergeImageAttrs, mergeParagraphAttrs, mergeTableAttrs, mergeTableCellAttrs, mergeTableRowAttrs, readBlockSdtAttrs, readCharacterSpacingMarkAttrs, readCharacterStyleMarkAttrs, readCommentMarkAttrs, readEmphasisMarkAttrs, readFieldAttrs, readFontFamilyMarkAttrs, readFontSizeMarkAttrs, readFootnoteRefMarkAttrs, readHardBreakAttrs, readHighlightMarkAttrs, readHyperlinkMarkAttrs, readImageAttrs, readLanguageMarkAttrs, readMathAttrs, readPageBreakRunAttrs, readPageBreakRunOwnerMarkAttrs, readParagraphAttrs, readRunFormattingOverrideMarkAttrs, readRunPropertyChangeMarkAttrs, readRunShadingMarkAttrs, readSdtAttrs, readShapeAttrs, readStrikeMarkAttrs, readSymbolAttrs, readTabAttrs, readTableAttrs, readTableCellAttrs, readTableRowAttrs, readTextBoxAttrs, readTextColorMarkAttrs, readTextEffectMarkAttrs, readTrackedChangeMarkAttrs, readUnderlineMarkAttrs };
+export { expectBlockSdtAttrs, expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFieldAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHardBreakAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectInlineWrapperMarkAttrs, expectLanguageMarkAttrs, expectMathAttrs, expectPageBreakRunAttrs, expectPageBreakRunOwnerMarkAttrs, expectParagraphAttrs, expectPreservedBlockAttrs, expectPreservedXmlAttrs, expectRunFormattingOverrideMarkAttrs, expectRunPropertyChangeMarkAttrs, expectRunShadingMarkAttrs, expectSdtAttrs, expectShapeAttrs, expectStrikeMarkAttrs, expectSymbolAttrs, expectTabAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs, mergeImageAttrs, mergeParagraphAttrs, mergeTableAttrs, mergeTableCellAttrs, mergeTableRowAttrs, readBlockSdtAttrs, readCharacterSpacingMarkAttrs, readCharacterStyleMarkAttrs, readCommentMarkAttrs, readEmphasisMarkAttrs, readFieldAttrs, readFontFamilyMarkAttrs, readFontSizeMarkAttrs, readFootnoteRefMarkAttrs, readHardBreakAttrs, readHighlightMarkAttrs, readHyperlinkMarkAttrs, readImageAttrs, readInlineWrapperMarkAttrs, readInlineWrapperStack, readLanguageMarkAttrs, readMathAttrs, readPageBreakRunAttrs, readPageBreakRunOwnerMarkAttrs, readParagraphAttrs, readPreservedBlockAttrs, readPreservedXmlAttrs, readRunFormattingOverrideMarkAttrs, readRunPropertyChangeMarkAttrs, readRunShadingMarkAttrs, readSdtAttrs, readShapeAttrs, readStrikeMarkAttrs, readSymbolAttrs, readTabAttrs, readTableAttrs, readTableCellAttrs, readTableRowAttrs, readTextBoxAttrs, readTextColorMarkAttrs, readTextEffectMarkAttrs, readTrackedChangeMarkAttrs, readUnderlineMarkAttrs };

package/dist/prosemirror/authoredTransformAttrs.d.ts

@@ -0,0 +1,28 @@
+import { document_d_exports } from "../types/document.js";
+//#region src/prosemirror/authoredTransformAttrs.d.ts
+/** The transform attrs a drawing node (`image`, `shape`, `textBox`) carries. */
+type AuthoredTransformAttrs = {
+  docxFlipH: boolean | null;
+  docxFlipV: boolean | null;
+  docxRotation: number | null;
+  /** The rendered CSS, derived from the three above. */
+  transform: string | undefined;
+};
+/** What a drawing node's attrs say, as they arrive from a persisted document. */
+type ReadableTransformAttrs = {
+  docxFlipH?: boolean | null;
+  docxFlipV?: boolean | null;
+  docxRotation?: number | null;
+  transform?: string;
+};
+/** Project a model transform onto a drawing node's attrs. */
+declare const authoredTransformAttrs: (transform: document_d_exports.ImageTransform | undefined) => AuthoredTransformAttrs;
+/**
+ * Read a drawing node's authored transform back.
+ *
+ * The attrs are the record; the CSS string answers only for a node that states
+ * none of them, which is how a node persisted before they existed arrives.
+ */
+declare const readAuthoredTransform: (attrs: ReadableTransformAttrs) => document_d_exports.ImageTransform | undefined;
+//#endregion
+export { authoredTransformAttrs, readAuthoredTransform };