@stll/folio-core 0.45.0 → 0.46.0

package/dist/markdown/renderRuns.js

@@ -76,6 +76,9 @@ function renderRunContent(ctx, pkg, content, paraId) {
 		case "noBreakHyphen":
 			out += "‑";
 			break;
+		case "preservedXml":
+			out += escapeInline(item.text);
+			break;
 		case "footnoteRef":
 		case "endnoteRef": {
 			if (ctx.opts.footnotes === "strip") break;
@@ -147,10 +150,23 @@ function renderHyperlink(ctx, pkg, link, paraId) {
 }
 function renderTrackedWrapper(ctx, pkg, wrapper, paraId) {
 	const renderChild = (child) => {
-		if (child.type === "run") return renderRun(ctx, pkg, child, paraId);
-		if (child.type === "hyperlink") return renderHyperlink(ctx, pkg, child, paraId);
-		if (child.type === "mathEquation") return child.plainText ? escapeInline(child.plainText) : "";
-		return "";
+		switch (child.type) {
+			case "run": return renderRun(ctx, pkg, child, paraId);
+			case "hyperlink": return renderHyperlink(ctx, pkg, child, paraId);
+			case "mathEquation": return child.plainText ? escapeInline(child.plainText) : "";
+			case "inlineWrapper":
+			case "inlineSdt": return renderParagraphInline(ctx, pkg, child.content, paraId);
+			case "insertion":
+			case "deletion":
+			case "moveFrom":
+			case "moveTo": return renderTrackedWrapper(ctx, pkg, child, paraId);
+			case "simpleField":
+			case "complexField": return renderParagraphInline(ctx, pkg, [child], paraId);
+			case "bookmarkStart":
+			case "bookmarkEnd":
+			case "preservedInline": return "";
+			default: return child;
+		}
 	};
 	if (ctx.opts.trackedChanges === "clean") {
 		if (wrapper.type === "insertion" || wrapper.type === "moveTo") return wrapper.content.map(renderChild).join("");
@@ -196,10 +212,17 @@ function renderParagraphInline(ctx, pkg, content, paraId) {
 		case "simpleField":
 		case "complexField": {
 			const runs = item.type === "simpleField" ? item.content : item.fieldResult;
-			for (const child of runs) out += child.type === "run" ? renderRun(ctx, pkg, child, paraId) : renderHyperlink(ctx, pkg, child, paraId);
+			for (const child of runs) {
+				if (child.type === "run") {
+					out += renderRun(ctx, pkg, child, paraId);
+					continue;
+				}
+				out += child.type === "hyperlink" ? renderHyperlink(ctx, pkg, child, paraId) : child.text;
+			}
 			break;
 		}
 		case "inlineSdt":
+		case "inlineWrapper":
 			out += renderParagraphInline(ctx, pkg, item.content, paraId);
 			break;
 		case "mathEquation":

package/dist/markdown/renderTable.js

@@ -113,7 +113,7 @@ function renderHtmlCell(ctx, pkg, cell) {
 	for (const item of cell.content) if (item.type === "paragraph") {
 		const inner = renderHtmlInline(ctx, pkg, item.content, item.paraId);
 		if (inner) parts.push(inner);
-	} else {
+	} else if (item.type === "table") {
 		const nested = renderHtmlTable(ctx, pkg, item.rows, true);
 		if (nested) parts.push(nested);
 	}
@@ -148,6 +148,7 @@ function renderHtmlInline(ctx, pkg, content, paraId) {
 			break;
 		}
 		case "inlineSdt":
+		case "inlineWrapper":
 			out += renderHtmlInline(ctx, pkg, item.content, paraId);
 			break;
 		case "mathEquation":
@@ -159,10 +160,23 @@ function renderHtmlInline(ctx, pkg, content, paraId) {
 }
 function renderHtmlChildren(ctx, pkg, children, paraId) {
 	return children.map((child) => {
-		if (child.type === "run") return renderHtmlRun(ctx, pkg, child, paraId);
-		if (child.type === "hyperlink") return renderHtmlHyperlink(ctx, pkg, child, paraId);
-		if (child.type === "mathEquation") return child.plainText ? escapeHtml(child.plainText) : "";
-		return "";
+		switch (child.type) {
+			case "run": return renderHtmlRun(ctx, pkg, child, paraId);
+			case "hyperlink": return renderHtmlHyperlink(ctx, pkg, child, paraId);
+			case "mathEquation": return child.plainText ? escapeHtml(child.plainText) : "";
+			case "inlineWrapper":
+			case "inlineSdt":
+			case "simpleField":
+			case "complexField":
+			case "insertion":
+			case "deletion":
+			case "moveFrom":
+			case "moveTo": return renderHtmlInline(ctx, pkg, [child], paraId);
+			case "bookmarkStart":
+			case "bookmarkEnd":
+			case "preservedInline": return "";
+			default: return child;
+		}
 	}).join("");
 }
 function renderHtmlRun(ctx, pkg, run, paraId) {
@@ -184,6 +198,9 @@ function renderHtmlRun(ctx, pkg, run, paraId) {
 		case "noBreakHyphen":
 			text += "‑";
 			break;
+		case "preservedXml":
+			text += escapeHtml(item.text);
+			break;
 		case "softHyphen": break;
 		case "drawing": {
 			const ref = resolveRelationshipIdOfType(pkg?.relationships, item.image.rId, RELATIONSHIP_TYPES.image);

package/dist/markdown/trailers.js

@@ -65,12 +65,15 @@ function inlineText(content) {
 		case "moveFrom":
 		case "moveTo":
 		case "inlineSdt":
-		case "bidiWrapper":
+		case "inlineWrapper":
 			out += inlineText(item.content);
 			break;
 		case "mathEquation":
 			out += item.plainText ?? "";
 			break;
+		case "preservedInline":
+			out += item.text;
+			break;
 		case "bookmarkStart":
 		case "bookmarkEnd":
 		case "commentRangeStart":

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",
@@ -146,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();
@@ -172,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) => {
@@ -257,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");
@@ -304,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 = [];
@@ -346,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");
@@ -394,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);
@@ -517,6 +549,9 @@ const readShapeAttrs = (node) => {
 	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);
@@ -554,6 +589,9 @@ const readTextBoxAttrs = (node) => {
 	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);
@@ -574,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");
@@ -752,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 = [];
@@ -1306,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;
@@ -2024,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 };