@stll/folio-core 0.44.0 → 0.45.0

package/dist/docx/xmlResourceLimits.d.ts

@@ -1,27 +1,107 @@
 //#region src/docx/xmlResourceLimits.d.ts
-/** Shared bounds for XML parts parsed by Folio. */
+/**
+ * Shared bounds for XML parts parsed by Folio.
+ *
+ * `maxBytes` and the package expansion ceiling bound the *markup*; they do not
+ * bound what parsing that markup allocates. A parsed element retains far more
+ * than the bytes it was written as, so a part that satisfies a byte bound can
+ * still cost multiples of it in tree. Measured on this repository's corpus
+ * generators (Bun 1.4, arm64, heap retained after a forced GC):
+ *
+ *   shape                       bytes/element   tree heap / part bytes
+ *   `<w:r/>`                          49.5 B            8.3x
+ *   `<w:r a=".." x4/>`               105-124 B          2.8-3.3x
+ *   `<w:r><w:t>x</w:t></w:r>`        162-171 B         14.1-14.8x
+ *
+ * An element is therefore the unit a memory bound has to count, because the
+ * adversarial shape is the cheap one: `<w:r/>` is 7 bytes of markup and 49.5
+ * bytes of tree, so 128 MiB of markup buys ~19M elements and ~950 MB of tree
+ * inside a byte budget that never trips.
+ *
+ * Corpus distribution (5,314 readable packages, every XML and .rels part):
+ *
+ *   metric                     p50      p90      p99    p99.9        max
+ *   elements / part             16      227    1,590   24,719    596,668
+ *   elements / package         917    3,230   29,106   71,975    602,212
+ *   attributes / part           27      577    1,993   21,037    630,374
+ *   attributes / package     1,783    4,711   25,896   91,946    639,110
+ *   depth / part                 3        9       15       22     15,005
+ *   elements per byte        0.012    0.027    0.036    0.043      0.111
+ *
+ * The defaults below reject no corpus package that today's bounds accept. The
+ * package budget is the one that matters: it caps a whole package at ~2.5M
+ * elements and ~3M attributes, which is at most ~425 MB of tree at the densest
+ * measured shape and ~124 MB at the cheapest. Before it existed, only
+ * `word/document.xml`, `word/styles.xml` and `word/numbering.xml` were counted
+ * at all, so a package of many merely-large parts could reach the expansion
+ * ceiling of 250 MiB, ~37M elements and well past 1.8 GB of tree while passing
+ * every bound. Lower these to trade format reach for a smaller ceiling.
+ */
 declare const FOLIO_XML_RESOURCE_LIMITS: {
   readonly maxBytes: number;
   readonly maxDepth: 100;
-  readonly maxNodes: 1000000;
+  /** 1.68x the corpus maximum (596,668). Unchanged; a shipped bound is not loosened. */
+  readonly maxElementsPerPart: 1000000;
+  /** 3.97x the corpus maximum (630,374). */
+  readonly maxAttributesPerPart: 2500000;
+  /** 4.15x the corpus maximum (602,212). */
+  readonly maxElementsPerPackage: 2500000;
+  /** 4.69x the corpus maximum (639,110). */
+  readonly maxAttributesPerPackage: 3000000;
 };
 type XmlResourceLimits = {
   maxBytes: number;
   maxDepth: number;
-  maxNodes: number;
+  maxElementsPerPart: number;
+  maxAttributesPerPart: number;
+  maxElementsPerPackage: number;
+  maxAttributesPerPackage: number;
 };
-type XmlResourceLimitKind = "bytes" | "depth" | "nodes" | "syntax";
+type XmlResourceLimitKind = "bytes" | "depth" | "elements" | "attributes" | "package-elements" | "package-attributes" | "syntax";
 declare const XmlResourceLimitError_base: import("better-result").TaggedErrorClass<"XmlResourceLimitError">;
 /** XML input exceeded a parser resource bound or could not be scanned safely. */
 declare class XmlResourceLimitError extends XmlResourceLimitError_base<{
   message: string;
   limit: XmlResourceLimitKind;
+  /** The package part being scanned, when the caller named one. */
+  partPath?: string;
+  /** The count reached at the point of refusal, not the count of the whole input. */
+  observed: number;
+  allowed: number;
 }> {}
 /**
- * Bound XML bytes, element count, and nesting before building an object tree.
- * The lexical scan is iterative, so deeply nested input cannot consume the JS
- * call stack before the depth limit is enforced.
+ * What a package has spent so far, shared by every part in one package.
+ *
+ * Per-part bounds alone do not bound a package: a package may hold hundreds of
+ * parts, each individually modest. The budget is the accumulator the readers
+ * carry across parts so the ceiling is the package's, not each part's.
+ */
+type XmlPackageBudget = {
+  elements: number;
+  attributes: number;
+};
+declare const createXmlPackageBudget: () => XmlPackageBudget;
+type XmlResourceScanOptions = {
+  xml: string;
+  limits?: XmlResourceLimits;
+  /** The package path scanned, carried on any refusal so a host can name it. */
+  partPath?: string;
+  /** Charged as the scan proceeds; omit for a part with no package context. */
+  budget?: XmlPackageBudget;
+};
+/** What the preflight counted, for callers that reconcile it against the tree. */
+type XmlResourceScanResult = {
+  elements: number;
+  attributes: number;
+  maxDepth: number;
+};
+/**
+ * Bound XML bytes, element count, attribute count and nesting before building
+ * an object tree. The lexical scan is iterative, so deeply nested input cannot
+ * consume the JS call stack before the depth limit is enforced, and every
+ * bound is checked at the point it is crossed, so the work done before a
+ * refusal is proportional to the limit rather than to the input.
  */
-declare const assertXmlResourceLimits: (xml: string, limits?: XmlResourceLimits) => void;
+declare const assertXmlResourceLimits: ({ xml, limits, partPath, budget }: XmlResourceScanOptions) => XmlResourceScanResult;
 //#endregion
-export { FOLIO_XML_RESOURCE_LIMITS, XmlResourceLimitError, assertXmlResourceLimits };
+export { FOLIO_XML_RESOURCE_LIMITS, XmlPackageBudget, XmlResourceLimitError, XmlResourceLimits, XmlResourceScanOptions, XmlResourceScanResult, assertXmlResourceLimits, createXmlPackageBudget };

package/dist/docx/xmlResourceLimits.js

@@ -1,12 +1,60 @@
 import { TaggedError } from "better-result";
-/** Shared bounds for XML parts parsed by Folio. */
+/**
+* Shared bounds for XML parts parsed by Folio.
+*
+* `maxBytes` and the package expansion ceiling bound the *markup*; they do not
+* bound what parsing that markup allocates. A parsed element retains far more
+* than the bytes it was written as, so a part that satisfies a byte bound can
+* still cost multiples of it in tree. Measured on this repository's corpus
+* generators (Bun 1.4, arm64, heap retained after a forced GC):
+*
+*   shape                       bytes/element   tree heap / part bytes
+*   `<w:r/>`                          49.5 B            8.3x
+*   `<w:r a=".." x4/>`               105-124 B          2.8-3.3x
+*   `<w:r><w:t>x</w:t></w:r>`        162-171 B         14.1-14.8x
+*
+* An element is therefore the unit a memory bound has to count, because the
+* adversarial shape is the cheap one: `<w:r/>` is 7 bytes of markup and 49.5
+* bytes of tree, so 128 MiB of markup buys ~19M elements and ~950 MB of tree
+* inside a byte budget that never trips.
+*
+* Corpus distribution (5,314 readable packages, every XML and .rels part):
+*
+*   metric                     p50      p90      p99    p99.9        max
+*   elements / part             16      227    1,590   24,719    596,668
+*   elements / package         917    3,230   29,106   71,975    602,212
+*   attributes / part           27      577    1,993   21,037    630,374
+*   attributes / package     1,783    4,711   25,896   91,946    639,110
+*   depth / part                 3        9       15       22     15,005
+*   elements per byte        0.012    0.027    0.036    0.043      0.111
+*
+* The defaults below reject no corpus package that today's bounds accept. The
+* package budget is the one that matters: it caps a whole package at ~2.5M
+* elements and ~3M attributes, which is at most ~425 MB of tree at the densest
+* measured shape and ~124 MB at the cheapest. Before it existed, only
+* `word/document.xml`, `word/styles.xml` and `word/numbering.xml` were counted
+* at all, so a package of many merely-large parts could reach the expansion
+* ceiling of 250 MiB, ~37M elements and well past 1.8 GB of tree while passing
+* every bound. Lower these to trade format reach for a smaller ceiling.
+*/
 const FOLIO_XML_RESOURCE_LIMITS = {
 	maxBytes: 128 * (1024 * 1024),
 	maxDepth: 100,
-	maxNodes: 1e6
+	/** 1.68x the corpus maximum (596,668). Unchanged; a shipped bound is not loosened. */
+	maxElementsPerPart: 1e6,
+	/** 3.97x the corpus maximum (630,374). */
+	maxAttributesPerPart: 25e5,
+	/** 4.15x the corpus maximum (602,212). */
+	maxElementsPerPackage: 25e5,
+	/** 4.69x the corpus maximum (639,110). */
+	maxAttributesPerPackage: 3e6
 };
 /** XML input exceeded a parser resource bound or could not be scanned safely. */
 var XmlResourceLimitError = class extends TaggedError("XmlResourceLimitError") {};
+const createXmlPackageBudget = () => ({
+	elements: 0,
+	attributes: 0
+});
 const exceedsUtf8ByteLimit = (value, maxBytes) => {
 	let bytes = 0;
 	for (let index = 0; index < value.length; index += 1) {
@@ -22,8 +70,9 @@ const exceedsUtf8ByteLimit = (value, maxBytes) => {
 	return false;
 };
 const isXmlWhitespace = (code) => code === 9 || code === 10 || code === 13 || code === 32;
-const findTagClose = (xml, start) => {
+const scanTag = (xml, start) => {
 	let quote = 0;
+	let attributes = 0;
 	for (let cursor = start; cursor < xml.length; cursor += 1) {
 		const code = xml.charCodeAt(cursor);
 		if (quote !== 0) {
@@ -34,29 +83,53 @@ const findTagClose = (xml, start) => {
 			quote = code;
 			continue;
 		}
-		if (code === 62) return cursor;
+		if (code === 61) {
+			attributes += 1;
+			continue;
+		}
+		if (code === 62) return {
+			close: cursor,
+			attributes
+		};
 	}
-	return -1;
+	return {
+		close: -1,
+		attributes
+	};
 };
 const throwSyntaxLimit = () => {
 	throw new XmlResourceLimitError({
 		message: "XML resource preflight could not safely scan malformed markup",
-		limit: "syntax"
+		limit: "syntax",
+		observed: 0,
+		allowed: 0
 	});
 };
 /**
-* Bound XML bytes, element count, and nesting before building an object tree.
-* The lexical scan is iterative, so deeply nested input cannot consume the JS
-* call stack before the depth limit is enforced.
+* Bound XML bytes, element count, attribute count and nesting before building
+* an object tree. The lexical scan is iterative, so deeply nested input cannot
+* consume the JS call stack before the depth limit is enforced, and every
+* bound is checked at the point it is crossed, so the work done before a
+* refusal is proportional to the limit rather than to the input.
 */
-const assertXmlResourceLimits = (xml, limits = FOLIO_XML_RESOURCE_LIMITS) => {
-	if (exceedsUtf8ByteLimit(xml, limits.maxBytes)) throw new XmlResourceLimitError({
-		message: `XML part exceeds ${String(limits.maxBytes)} bytes`,
-		limit: "bytes"
-	});
+const assertXmlResourceLimits = ({ xml, limits = FOLIO_XML_RESOURCE_LIMITS, partPath, budget }) => {
+	const refuse = (limit, message, observed, allowed) => {
+		throw new XmlResourceLimitError({
+			message: partPath === void 0 ? message : `${message} (part ${partPath})`,
+			limit,
+			...partPath === void 0 ? {} : { partPath },
+			observed,
+			allowed
+		});
+	};
+	if (exceedsUtf8ByteLimit(xml, limits.maxBytes)) refuse("bytes", `XML part exceeds ${String(limits.maxBytes)} bytes`, limits.maxBytes + 1, limits.maxBytes);
+	const budgetElements = budget?.elements ?? 0;
+	const budgetAttributes = budget?.attributes ?? 0;
 	let cursor = 0;
 	let depth = 0;
+	let maxDepth = 0;
 	let nodes = 0;
+	let attributes = 0;
 	while (cursor < xml.length) {
 		const open = xml.indexOf("<", cursor);
 		if (open === -1) break;
@@ -79,7 +152,7 @@ const assertXmlResourceLimits = (xml, limits = FOLIO_XML_RESOURCE_LIMITS) => {
 			continue;
 		}
 		if (xml.startsWith("<!", open)) throwSyntaxLimit();
-		const close = findTagClose(xml, open + 1);
+		const { close, attributes: tagAttributes } = scanTag(xml, open + 1);
 		if (close === -1) throwSyntaxLimit();
 		if (xml.charCodeAt(open + 1) === 47) {
 			if (depth === 0) throwSyntaxLimit();
@@ -88,21 +161,29 @@ const assertXmlResourceLimits = (xml, limits = FOLIO_XML_RESOURCE_LIMITS) => {
 			continue;
 		}
 		nodes += 1;
-		if (nodes > limits.maxNodes) throw new XmlResourceLimitError({
-			message: `XML part contains more than ${String(limits.maxNodes)} elements`,
-			limit: "nodes"
-		});
+		if (nodes > limits.maxElementsPerPart) refuse("elements", `XML part contains more than ${String(limits.maxElementsPerPart)} elements`, nodes, limits.maxElementsPerPart);
+		if (budgetElements + nodes > limits.maxElementsPerPackage) refuse("package-elements", `DOCX package contains more than ${String(limits.maxElementsPerPackage)} XML elements`, budgetElements + nodes, limits.maxElementsPerPackage);
+		attributes += tagAttributes;
+		if (attributes > limits.maxAttributesPerPart) refuse("attributes", `XML part contains more than ${String(limits.maxAttributesPerPart)} attributes`, attributes, limits.maxAttributesPerPart);
+		if (budgetAttributes + attributes > limits.maxAttributesPerPackage) refuse("package-attributes", `DOCX package contains more than ${String(limits.maxAttributesPerPackage)} XML attributes`, budgetAttributes + attributes, limits.maxAttributesPerPackage);
 		let lastContent = close - 1;
 		while (lastContent > open && isXmlWhitespace(xml.charCodeAt(lastContent))) lastContent -= 1;
 		const elementDepth = depth + 1;
-		if (elementDepth > limits.maxDepth) throw new XmlResourceLimitError({
-			message: `XML part is nested deeper than ${String(limits.maxDepth)} elements`,
-			limit: "depth"
-		});
+		if (elementDepth > limits.maxDepth) refuse("depth", `XML part is nested deeper than ${String(limits.maxDepth)} elements`, elementDepth, limits.maxDepth);
+		if (elementDepth > maxDepth) maxDepth = elementDepth;
 		if (xml.charCodeAt(lastContent) !== 47) depth = elementDepth;
 		cursor = close + 1;
 	}
 	if (depth !== 0) throwSyntaxLimit();
+	if (budget) {
+		budget.elements += nodes;
+		budget.attributes += attributes;
+	}
+	return {
+		elements: nodes,
+		attributes,
+		maxDepth
+	};
 };
 //#endregion
-export { FOLIO_XML_RESOURCE_LIMITS, XmlResourceLimitError, assertXmlResourceLimits };
+export { FOLIO_XML_RESOURCE_LIMITS, XmlResourceLimitError, assertXmlResourceLimits, createXmlPackageBudget };

package/dist/internal/paragraphFormattingSerialization.js

@@ -1,8 +1,9 @@
 import { serializeBorder } from "../docx/serializer/borderSerializer.js";
 import { serializeShading, serializeTextFormatting } from "../docx/serializer/textFormattingSerializer.js";
-import { escapeXml, intAttr } from "../docx/serializer/xmlUtils.js";
+import { intAttr } from "../docx/serializer/xmlUtils.js";
 import { sanitizeCapturedXmlElement } from "../docx/verbatimCapture.js";
 import { NAMESPACES, OOXML_NAMESPACE_SCOPE } from "../docx/xmlParser.js";
+import { escapeXmlAttribute } from "@stll/docx-core";
 //#region src/internal/paragraphFormattingSerialization.ts
 const modelParagraphNumberingReference = (reference) => {
 	if (!reference) return null;
@@ -140,7 +141,7 @@ const modelParagraphFormattingEmission = (input) => {
 	const { alignment, bidi, kinsoku, overflowPunctuation, spaceBefore, spaceAfter, lineSpacing, lineSpacingRule, snapToGrid, beforeAutospacing, afterAutospacing, spacingExplicit, indentLeft, indentRight, indentFirstLine, hangingIndent, borders, shading, tabs, keepNext, keepLines, widowControl, pageBreakBefore, contextualSpacing, numPr, numPrFromStyle, numberingChangeXml, outlineLevel, styleId, frame, suppressLineNumbers, suppressAutoHyphens, runProperties, runInWithNext } = input;
 	modelSpacingProvenance(spacingExplicit);
 	const propertiesXml = [
-		styleId ? `<w:pStyle w:val="${escapeXml(styleId)}"/>` : "",
+		styleId ? `<w:pStyle w:val="${escapeXmlAttribute(styleId)}"/>` : "",
 		serializeToggle("keepNext", keepNext),
 		serializeToggle("keepLines", keepLines),
 		serializeToggle("pageBreakBefore", pageBreakBefore),

package/dist/layout-painter/renderImage.js

@@ -1,5 +1,5 @@
 import { applySanitizedImageSrc } from "../utils/sanitizeImageSrc.js";
-import { sanitizeExternalUrl } from "../utils/urlSecurity.js";
+import { anchorTargetAttrs, sanitizeExternalUrl } from "../utils/urlSecurity.js";
 //#region src/layout-painter/renderImage.ts
 /**
 * CSS class names for image elements
@@ -145,8 +145,9 @@ function renderImageFragment(fragment, block, _measure, _context, options = {})
 	if (hlinkHref) {
 		const linkEl = doc.createElement("a");
 		linkEl.href = hlinkHref;
-		linkEl.target = "_blank";
-		linkEl.rel = "noopener noreferrer";
+		const { target, rel } = anchorTargetAttrs(void 0);
+		linkEl.target = target;
+		linkEl.rel = rel;
 		linkEl.style.display = "block";
 		linkEl.style.width = "100%";
 		linkEl.style.height = "100%";

package/dist/layout-painter/renderParagraph.js

@@ -16,7 +16,7 @@ import { resolvePhysicalParagraphInlineLayout } from "../utils/paragraphInlineLa
 import { inlineImageBoundingBox, parseRotationDegrees, rotatedBoundingBox } from "../utils/rotationBoundingBox.js";
 import { sanitizeImageSrc } from "../utils/sanitizeImageSrc.js";
 import { SCRIPT_CLASS, hasCjk, hasComplexScript, segmentByScript } from "../utils/scriptSegments.js";
-import { sanitizeExternalUrl } from "../utils/urlSecurity.js";
+import { anchorTargetAttrs, sanitizeExternalUrl } from "../utils/urlSecurity.js";
 import { borderStrokeToCss, resolveParagraphBorderHorizontalOutsets } from "./borderStroke.js";
 import { planCursiveJoiners, withCursiveJoiners } from "./cursiveJoiners.js";
 import { getAutomaticTextColorForBackground, setAuthoredBackgroundColor, setAuthoredTextColor } from "./documentColors.js";
@@ -357,8 +357,9 @@ function renderTextRun(run, doc, options) {
 		anchor.href = hyperlinkHref;
 		if (options?.hyperlinkDirection || DISPLAYED_URL_PATTERN.test(paintedText.trim())) anchor.dir = LEFT_TO_RIGHT_DIRECTION;
 		if (!isBookmarkTarget) {
-			anchor.target = "_blank";
-			anchor.rel = "noopener noreferrer";
+			const { target, rel } = anchorTargetAttrs(void 0);
+			anchor.target = target;
+			anchor.rel = rel;
 		}
 		if (run.hyperlink.tooltip) anchor.title = run.hyperlink.tooltip;
 		appendPaintedText({

package/dist/managers/autoSaveCodec.js

@@ -1,13 +1,7 @@
 import { validateFolioDocumentModel } from "../docx/modelValidation.js";
+import { bytesToBase64 } from "../utils/base64.js";
 //#region src/managers/autoSaveCodec.ts
 const AUTOSAVE_FORMAT_VERSION = 2;
-const BASE64_CHUNK_BYTES = 32768;
-const encodeBase64 = (buffer) => {
-	const bytes = new Uint8Array(buffer);
-	const chunks = [];
-	for (let offset = 0; offset < bytes.length; offset += BASE64_CHUNK_BYTES) chunks.push(String.fromCharCode(...bytes.subarray(offset, offset + BASE64_CHUNK_BYTES)));
-	return btoa(chunks.join(""));
-};
 const decodeBase64 = (value) => {
 	const binary = atob(value);
 	const bytes = new Uint8Array(binary.length);
@@ -23,7 +17,7 @@ const encodeValue = (value) => {
 	};
 	if (value instanceof ArrayBuffer) return {
 		type: "arrayBuffer",
-		value: encodeBase64(value)
+		value: bytesToBase64(new Uint8Array(value))
 	};
 	if (value instanceof Map) return {
 		type: "map",

package/dist/markdown/images.js

@@ -1,3 +1,4 @@
+import { bytesToBase64 } from "../utils/base64.js";
 //#region src/markdown/images.ts
 const MIME_TO_EXT = {
 	"image/png": "png",
@@ -14,10 +15,6 @@ const MIME_TO_EXT = {
 function extFor(mimeType, fallback) {
 	return MIME_TO_EXT[mimeType] ?? fallback;
 }
-function bytesToBase64(bytes) {
-	if (typeof Buffer !== "undefined") return Buffer.from(bytes).toString("base64");
-	return btoa(new TextDecoder("latin1").decode(bytes));
-}
 function toUint8(data) {
 	if (data instanceof Uint8Array) return data;
 	return new Uint8Array(data);

package/dist/prosemirror/attrs/index.js

@@ -53,6 +53,11 @@ const SHAPE_OUTLINE_CAPS = [
 	"round",
 	"square"
 ];
+const SHAPE_OUTLINE_JOINS = [
+	"bevel",
+	"miter",
+	"round"
+];
 const SHAPE_LINE_END_TYPES = [
 	"none",
 	"triangle",
@@ -404,7 +409,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 +496,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,6 +513,7 @@ 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);
@@ -531,8 +545,12 @@ 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);
@@ -1784,6 +1802,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;

package/dist/prosemirror/commands/image.js

@@ -179,6 +179,7 @@ const insertImageFromFile = async (view, file, onInserted) => {
 	if (!imageType) return;
 	const imageNode = imageType.create({
 		src: dataUrl,
+		docPrName: file.name,
 		alt: file.name,
 		width: constrained.width,
 		height: constrained.height,