wpd-codec 3.4.6 → 3.5.1

package/dist/stream/wpg.js

@@ -0,0 +1,619 @@
+import { byteAt, int16At, uint16At, uint32At } from "../bytes/view.js";
+//#region src/stream/wpg.ts
+const RECORD_START_WPG = 1;
+const RECORD_END_WPG = 2;
+const RECORD_TEXT_DATA = 15;
+const RECORD_POLYLINE = 21;
+const RECORD_RECTANGLE = 24;
+const RECORD_ARC = 25;
+const RECORD_TEXT_BLOCK = 29;
+const RECORD_GROUP = 32;
+const RECORD_PEN_FORE_COLOR = 37;
+const RECORD_DP_PEN_FORE_COLOR = 38;
+const RECORD_PEN_SIZE = 43;
+const RECORD_DP_PEN_SIZE = 44;
+const RECORD_BRUSH_FORE_COLOR = 49;
+const RECORD_DP_BRUSH_FORE_COLOR = 50;
+const RECORD_NAMES = /* @__PURE__ */ new Map([
+	[1, "Start WPG"],
+	[3, "Form Settings"],
+	[4, "Ruler Settings"],
+	[5, "Grid Settings"],
+	[6, "Layer"],
+	[7, "ObjectLink"],
+	[8, "Pen Style Definition"],
+	[9, "Pattern Definition"],
+	[10, "Comment"],
+	[11, "Color Transfer"],
+	[12, "Color Palette"],
+	[13, "DP Color Palette"],
+	[14, "Bitmap Data"],
+	[15, "Text Data"],
+	[16, "Chart Style"],
+	[17, "Chart Data"],
+	[18, "Object Image"],
+	[21, "Polyline"],
+	[22, "Polyspline"],
+	[23, "Polycurve"],
+	[24, "Rectangle"],
+	[25, "Arc"],
+	[26, "Compound Polygon"],
+	[27, "Bitmap"],
+	[28, "Text Line"],
+	[29, "Text Block"],
+	[30, "Text Path"],
+	[31, "Chart"],
+	[33, "Object Capsule"],
+	[34, "Font Settings"],
+	[39, "Pen Back Color"],
+	[40, "DP Pen Back Color"],
+	[41, "Pen Style"],
+	[42, "Pen Pattern"],
+	[45, "Line Cap"],
+	[46, "Line Join"],
+	[47, "Brush Gradient"],
+	[48, "DP Brush Gradient"],
+	[51, "Brush Back Color"],
+	[52, "DP Brush Back Color"],
+	[53, "Brush Pattern"],
+	[54, "Horizontal Line"],
+	[55, "Vertical Line"],
+	[56, "Poster Settings"],
+	[57, "Image State"],
+	[58, "Envelope Definition"],
+	[59, "Envelope"],
+	[60, "Texture Definition"],
+	[61, "Brush Texture"],
+	[62, "Texture Alignment"],
+	[63, "Pen Texture"]
+]);
+const FLAG_OBJECT_ID = 32;
+const FLAG_EDIT_LOCK = 128;
+const FLAG_PATH_WINDING = 4096;
+const FLAG_FILL = 8192;
+const FLAG_CLOSE = 16384;
+const FLAG_FRAME = 32768;
+const QUARTER_ELLIPSE_KAPPA = 4 / 3 * (Math.SQRT2 - 1);
+const WPG_PRODUCT_TYPE = 1;
+const WPG_FILE_TYPE = 22;
+const WPG_MAJOR_2 = 2;
+const WPG_MAJOR_1 = 1;
+const WPG_PREFIX_HEAD_SIZE = 26;
+const POINTS_PER_INCH = 72;
+const WPG_DEFAULT_BLACK = {
+	r: 0,
+	g: 0,
+	b: 0,
+	a: 0
+};
+function readCountField(bytes, cursor) {
+	const first = bytes[cursor];
+	if (first === void 0) return;
+	if (first <= 254) return {
+		value: first,
+		next: cursor + 1
+	};
+	if (cursor + 3 > bytes.length) return;
+	const shortValue = uint16At(bytes, cursor + 1);
+	if ((shortValue & 32768) === 0) return {
+		value: shortValue,
+		next: cursor + 3
+	};
+	if (cursor + 5 > bytes.length) return;
+	const lowHalf = uint16At(bytes, cursor + 3);
+	return {
+		value: ((shortValue & 32767) << 16) + lowHalf,
+		next: cursor + 5
+	};
+}
+function coordinateAt(bytes, offset, doublePrecision) {
+	if (!doublePrecision) return int16At(bytes, offset);
+	return uint32At(bytes, offset) / 65536;
+}
+function readCharacterization(bytes, cursor, recordEnd) {
+	if (cursor + 2 > recordEnd) return;
+	const flags = uint16At(bytes, cursor);
+	if ((flags & 31) !== 0) return {
+		flags,
+		geometryAt: -1
+	};
+	let geometryAt = cursor + 2;
+	if ((flags & FLAG_EDIT_LOCK) !== 0) geometryAt += 4;
+	if ((flags & FLAG_OBJECT_ID) !== 0) {
+		if (geometryAt + 2 > recordEnd) return;
+		geometryAt += (uint16At(bytes, geometryAt) & 32768) !== 0 ? 4 : 2;
+	}
+	if (geometryAt > recordEnd) return;
+	return {
+		flags,
+		geometryAt
+	};
+}
+function xToPt(geometry, x) {
+	return x / geometry.xPpi * POINTS_PER_INCH;
+}
+function yToPt(geometry, y) {
+	return geometry.heightPt - y / geometry.yPpi * POINTS_PER_INCH;
+}
+function strokeOf(geometry, state) {
+	if (state.penWidthUnits <= 0) return;
+	const opacity = 1 - state.penColor.a;
+	return {
+		color: {
+			r: state.penColor.r,
+			g: state.penColor.g,
+			b: state.penColor.b
+		},
+		widthPt: state.penWidthUnits / geometry.xPpi * POINTS_PER_INCH,
+		...opacity < 1 ? { opacity } : {}
+	};
+}
+function fillOf(state) {
+	return {
+		fill: {
+			r: state.brushColor.r,
+			g: state.brushColor.g,
+			b: state.brushColor.b
+		},
+		fillOpacity: 1 - state.brushColor.a
+	};
+}
+function readSingleColor(data) {
+	if (data.length < 4) return;
+	return {
+		r: byteAt(data, 0) / 255,
+		g: byteAt(data, 1) / 255,
+		b: byteAt(data, 2) / 255,
+		a: byteAt(data, 3) / 255
+	};
+}
+function readDoubleColor(data) {
+	if (data.length < 8) return;
+	return {
+		r: uint16At(data, 0) / 65535,
+		g: uint16At(data, 2) / 65535,
+		b: uint16At(data, 4) / 65535,
+		a: uint16At(data, 6) / 65535
+	};
+}
+function decodeWpgGraphic(bytes, options) {
+	let start = -1;
+	for (let index = 0; index + WPG_PREFIX_HEAD_SIZE <= bytes.length; index += 1) {
+		if (byteAt(bytes, index) !== 255 || byteAt(bytes, index + 1) !== 87 || byteAt(bytes, index + 2) !== 80 || byteAt(bytes, index + 3) !== 67) continue;
+		if (byteAt(bytes, index + 8) !== WPG_PRODUCT_TYPE || byteAt(bytes, index + 9) !== WPG_FILE_TYPE) continue;
+		start = index;
+		break;
+	}
+	if (start < 0) return;
+	const majorVersion = byteAt(bytes, start + 10);
+	if (majorVersion === WPG_MAJOR_1) return {
+		status: "refused",
+		reason: "wpg1"
+	};
+	if (majorVersion !== WPG_MAJOR_2) return {
+		status: "refused",
+		reason: "malformed"
+	};
+	if (uint16At(bytes, start + 12) !== 0) return {
+		status: "refused",
+		reason: "encrypted"
+	};
+	const recordStart = uint32At(bytes, start + 4);
+	if (recordStart < start + WPG_PREFIX_HEAD_SIZE || recordStart >= bytes.length) return {
+		status: "refused",
+		reason: "malformed"
+	};
+	const state = {
+		penColor: { ...WPG_DEFAULT_BLACK },
+		penWidthUnits: 0,
+		brushColor: { ...WPG_DEFAULT_BLACK }
+	};
+	const vectors = [];
+	const shapes = [];
+	const skipped = /* @__PURE__ */ new Set();
+	const groups = [];
+	let geometry;
+	let paintOrder = 0;
+	let pendingTextBlockFrame;
+	let cursor = start + recordStart;
+	const recordName = (type) => RECORD_NAMES.get(type) ?? `record type 0x${type.toString(16)}`;
+	while (cursor < bytes.length) {
+		if (cursor + 2 > bytes.length) break;
+		const type = byteAt(bytes, cursor + 1);
+		let after = cursor + 2;
+		const extension = readCountField(bytes, after);
+		if (extension === void 0) break;
+		after = extension.next;
+		const length = readCountField(bytes, after);
+		if (length === void 0) break;
+		after = length.next;
+		const recordEnd = after + length.value;
+		if (recordEnd > bytes.length) break;
+		const data = bytes.subarray(after, recordEnd);
+		const innermostBefore = groups[groups.length - 1];
+		if (innermostBefore !== void 0) innermostBefore.remaining -= 1;
+		const swallowed = swallowedByOpenGroup(groups);
+		if (type === RECORD_END_WPG && !swallowed) break;
+		if (!swallowed) {
+			switch (type) {
+				case RECORD_START_WPG: {
+					if (data.length < 13) {
+						skipped.add(recordName(type));
+						break;
+					}
+					const xPpi = uint16At(data, 0);
+					const yPpi = uint16At(data, 2);
+					const precision = byteAt(data, 4);
+					if (xPpi === 0 || yPpi === 0 || precision !== 0 && precision !== 1) return {
+						status: "refused",
+						reason: "malformed"
+					};
+					const doublePrecision = precision === 1;
+					const coordinateSize = doublePrecision ? 4 : 2;
+					const extentAt = 5 + coordinateSize * 4;
+					if (extentAt + coordinateSize * 4 > data.length) return {
+						status: "refused",
+						reason: "malformed"
+					};
+					const left = coordinateAt(data, extentAt, doublePrecision);
+					const bottom = coordinateAt(data, extentAt + coordinateSize, doublePrecision);
+					const right = coordinateAt(data, extentAt + coordinateSize * 2, doublePrecision);
+					const top = coordinateAt(data, extentAt + coordinateSize * 3, doublePrecision);
+					geometry = {
+						widthPt: Math.abs(right - left) / xPpi * POINTS_PER_INCH,
+						heightPt: Math.abs(top - bottom) / yPpi * POINTS_PER_INCH,
+						xPpi,
+						yPpi,
+						doublePrecision,
+						coordinateSize
+					};
+					break;
+				}
+				case RECORD_PEN_FORE_COLOR:
+				case RECORD_DP_PEN_FORE_COLOR: {
+					const color = type === RECORD_PEN_FORE_COLOR ? readSingleColor(data) : readDoubleColor(data);
+					if (color !== void 0) state.penColor = color;
+					break;
+				}
+				case RECORD_BRUSH_FORE_COLOR:
+				case RECORD_DP_BRUSH_FORE_COLOR: {
+					const color = type === RECORD_BRUSH_FORE_COLOR ? readSingleColor(data) : readDoubleColor(data);
+					if (color !== void 0) state.brushColor = color;
+					break;
+				}
+				case RECORD_PEN_SIZE:
+					if (data.length >= 4) state.penWidthUnits = uint16At(data, 0);
+					break;
+				case RECORD_DP_PEN_SIZE:
+					if (data.length >= 8) state.penWidthUnits = uint32At(data, 0) / 65536;
+					break;
+				case RECORD_TEXT_BLOCK:
+					pendingTextBlockFrame = readTextBlockFrame(data, geometry);
+					if (pendingTextBlockFrame === void 0) skipped.add(recordName(type));
+					break;
+				case RECORD_TEXT_DATA: {
+					const frame = pendingTextBlockFrame;
+					pendingTextBlockFrame = void 0;
+					if (frame === void 0) {
+						skipped.add(recordName(type));
+						break;
+					}
+					const blocks = options.foldTextData(data);
+					shapes.push({
+						frame,
+						insetLeftPt: 0,
+						insetTopPt: 0,
+						insetRightPt: 0,
+						insetBottomPt: 0,
+						blocks: [...blocks],
+						paintOrder
+					});
+					paintOrder += 1;
+					break;
+				}
+				case RECORD_GROUP: break;
+				default: {
+					const vector = geometry === void 0 ? void 0 : readPrimitiveVector(type, data, geometry, state);
+					if (vector === void 0) skipped.add(recordName(type));
+					else {
+						vectors.push({
+							...vector,
+							paintOrder
+						});
+						paintOrder += 1;
+					}
+					break;
+				}
+			}
+			if (type !== RECORD_TEXT_BLOCK) pendingTextBlockFrame = void 0;
+		}
+		while (groups.length > 0 && groups[groups.length - 1]?.remaining === 0) groups.pop();
+		if (extension.value > 0) groups.push({
+			remaining: extension.value,
+			membersWalk: !swallowed && (type === RECORD_GROUP || type === RECORD_TEXT_BLOCK && pendingTextBlockFrame !== void 0)
+		});
+		cursor = recordEnd;
+	}
+	if (geometry === void 0) return {
+		status: "refused",
+		reason: "malformed"
+	};
+	return {
+		status: "decoded",
+		sizePt: {
+			widthPt: geometry.widthPt,
+			heightPt: geometry.heightPt
+		},
+		vectors,
+		shapes,
+		skippedRecords: [...skipped]
+	};
+}
+function swallowedByOpenGroup(groups) {
+	const innermost = groups[groups.length - 1];
+	return innermost !== void 0 && !innermost.membersWalk;
+}
+function readTextBlockFrame(data, geometry) {
+	if (geometry === void 0) return;
+	const characterization = readCharacterization(data, 0, data.length);
+	if (characterization === void 0 || characterization.geometryAt < 0 || characterization.geometryAt + geometry.coordinateSize * 4 > data.length) return;
+	const at = characterization.geometryAt;
+	return frameFromCorners(geometry, coordinateAt(data, at, geometry.doublePrecision), coordinateAt(data, at + geometry.coordinateSize, geometry.doublePrecision), coordinateAt(data, at + geometry.coordinateSize * 2, geometry.doublePrecision), coordinateAt(data, at + geometry.coordinateSize * 3, geometry.doublePrecision));
+}
+function frameFromCorners(geometry, x1, y1, x2, y2) {
+	const left = Math.min(xToPt(geometry, x1), xToPt(geometry, x2));
+	const right = Math.max(xToPt(geometry, x1), xToPt(geometry, x2));
+	const top = Math.min(yToPt(geometry, y1), yToPt(geometry, y2));
+	const bottom = Math.max(yToPt(geometry, y1), yToPt(geometry, y2));
+	return {
+		xPt: left,
+		yPt: top,
+		widthPt: right - left,
+		heightPt: bottom - top
+	};
+}
+function readPrimitiveVector(type, data, geometry, state) {
+	const characterization = readCharacterization(data, 0, data.length);
+	if (characterization === void 0 || characterization.geometryAt < 0) return;
+	const { flags, geometryAt } = characterization;
+	const stroke = (flags & FLAG_FRAME) !== 0 ? strokeOf(geometry, state) : void 0;
+	switch (type) {
+		case RECORD_POLYLINE: return readPolyline(data, geometry, flags, geometryAt, stroke, state);
+		case RECORD_RECTANGLE: return readWpgRectangle(data, geometry, flags, geometryAt, stroke, state);
+		case RECORD_ARC: return readWpgFullEllipse(data, geometry, flags, geometryAt, stroke, state);
+		default: return;
+	}
+}
+function readPolyline(data, geometry, flags, geometryAt, stroke, state) {
+	if (geometryAt + 2 > data.length) return;
+	const count = uint16At(data, geometryAt);
+	let at = geometryAt + 2;
+	const points = [];
+	for (let index = 0; index < count; index += 1) {
+		if (at + geometry.coordinateSize * 2 > data.length) return;
+		points.push({
+			xPt: xToPt(geometry, coordinateAt(data, at, geometry.doublePrecision)),
+			yPt: yToPt(geometry, coordinateAt(data, at + geometry.coordinateSize, geometry.doublePrecision))
+		});
+		at += geometry.coordinateSize * 2;
+	}
+	const firstPoint = points[0];
+	if (firstPoint === void 0) return;
+	const secondPoint = points[1];
+	const closed = (flags & FLAG_CLOSE) !== 0;
+	const filled = (flags & FLAG_FILL) !== 0;
+	if (points.length === 2 && secondPoint !== void 0 && !closed && stroke !== void 0) return {
+		kind: "line",
+		from: firstPoint,
+		to: secondPoint,
+		stroke
+	};
+	const frame = boundingFrame(points);
+	const local = points.map((point) => ({
+		xPt: point.xPt - frame.xPt,
+		yPt: point.yPt - frame.yPt
+	}));
+	const subpath = {
+		start: {
+			xPt: firstPoint.xPt - frame.xPt,
+			yPt: firstPoint.yPt - frame.yPt
+		},
+		segments: local.slice(1).map((point) => ({
+			kind: "line",
+			to: point
+		})),
+		closed
+	};
+	const fill = filled ? fillOf(state) : void 0;
+	return {
+		kind: "path",
+		frame,
+		subpaths: [subpath],
+		...fill !== void 0 ? {
+			fill: fill.fill,
+			...fill.fillOpacity < 1 ? { fillOpacity: fill.fillOpacity } : {},
+			...(flags & FLAG_PATH_WINDING) !== 0 ? { fillRule: "nonzero" } : {}
+		} : {},
+		...stroke !== void 0 ? { stroke } : {}
+	};
+}
+function boundingFrame(points) {
+	let minX = Number.POSITIVE_INFINITY;
+	let minY = Number.POSITIVE_INFINITY;
+	let maxX = Number.NEGATIVE_INFINITY;
+	let maxY = Number.NEGATIVE_INFINITY;
+	for (const point of points) {
+		minX = Math.min(minX, point.xPt);
+		minY = Math.min(minY, point.yPt);
+		maxX = Math.max(maxX, point.xPt);
+		maxY = Math.max(maxY, point.yPt);
+	}
+	return {
+		xPt: minX,
+		yPt: minY,
+		widthPt: maxX - minX,
+		heightPt: maxY - minY
+	};
+}
+function readWpgRectangle(data, geometry, flags, geometryAt, stroke, state) {
+	const coordinateSize = geometry.coordinateSize;
+	if (geometryAt + coordinateSize * 6 > data.length) return;
+	const xll = coordinateAt(data, geometryAt, geometry.doublePrecision);
+	const yll = coordinateAt(data, geometryAt + coordinateSize, geometry.doublePrecision);
+	const xur = coordinateAt(data, geometryAt + coordinateSize * 2, geometry.doublePrecision);
+	const yur = coordinateAt(data, geometryAt + coordinateSize * 3, geometry.doublePrecision);
+	const rx = coordinateAt(data, geometryAt + coordinateSize * 4, geometry.doublePrecision);
+	const ry = coordinateAt(data, geometryAt + coordinateSize * 5, geometry.doublePrecision);
+	const frame = frameFromCorners(geometry, xll, yll, xur, yur);
+	const fill = (flags & FLAG_FILL) !== 0 ? fillOf(state) : void 0;
+	const fillFields = fill !== void 0 ? {
+		fill: fill.fill,
+		...fill.fillOpacity < 1 ? { fillOpacity: fill.fillOpacity } : {}
+	} : {};
+	if (rx <= 0 || ry <= 0) return {
+		kind: "rect",
+		frame,
+		...fillFields,
+		...stroke !== void 0 ? { stroke } : {}
+	};
+	const cornerRxPt = Math.min(rx / geometry.xPpi * POINTS_PER_INCH, frame.widthPt / 2);
+	const cornerRyPt = Math.min(ry / geometry.yPpi * POINTS_PER_INCH, frame.heightPt / 2);
+	const kx = cornerRxPt * QUARTER_ELLIPSE_KAPPA;
+	const ky = cornerRyPt * QUARTER_ELLIPSE_KAPPA;
+	const width = frame.widthPt;
+	const height = frame.heightPt;
+	const left = {
+		xPt: 0,
+		yPt: height / 2
+	};
+	return {
+		kind: "path",
+		frame,
+		subpaths: [{
+			start: left,
+			closed: true,
+			segments: [
+				{
+					kind: "line",
+					to: {
+						xPt: cornerRxPt,
+						yPt: 0
+					}
+				},
+				{
+					kind: "cubic",
+					control1: {
+						xPt: cornerRxPt - kx,
+						yPt: 0
+					},
+					control2: {
+						xPt: width,
+						yPt: cornerRyPt - ky
+					},
+					to: {
+						xPt: width,
+						yPt: cornerRyPt
+					}
+				},
+				{
+					kind: "line",
+					to: {
+						xPt: width,
+						yPt: height - cornerRyPt
+					}
+				},
+				{
+					kind: "cubic",
+					control1: {
+						xPt: width,
+						yPt: height - cornerRyPt + ky
+					},
+					control2: {
+						xPt: width - cornerRxPt + kx,
+						yPt: height
+					},
+					to: {
+						xPt: width - cornerRxPt,
+						yPt: height
+					}
+				},
+				{
+					kind: "line",
+					to: {
+						xPt: cornerRxPt,
+						yPt: height
+					}
+				},
+				{
+					kind: "cubic",
+					control1: {
+						xPt: cornerRxPt - kx,
+						yPt: height
+					},
+					control2: {
+						xPt: 0,
+						yPt: height - cornerRyPt + ky
+					},
+					to: {
+						xPt: 0,
+						yPt: height - cornerRyPt
+					}
+				},
+				{
+					kind: "line",
+					to: {
+						xPt: 0,
+						yPt: cornerRyPt
+					}
+				},
+				{
+					kind: "cubic",
+					control1: {
+						xPt: 0,
+						yPt: cornerRyPt - ky
+					},
+					control2: {
+						xPt: cornerRxPt - kx,
+						yPt: 0
+					},
+					to: {
+						xPt: cornerRxPt,
+						yPt: 0
+					}
+				},
+				{
+					kind: "line",
+					to: left
+				}
+			]
+		}],
+		...fillFields,
+		...stroke !== void 0 ? { stroke } : {}
+	};
+}
+function readWpgFullEllipse(data, geometry, flags, geometryAt, stroke, state) {
+	const coordinateSize = geometry.coordinateSize;
+	if (geometryAt + coordinateSize * 8 + 1 > data.length) return;
+	const cx = coordinateAt(data, geometryAt, geometry.doublePrecision);
+	const cy = coordinateAt(data, geometryAt + coordinateSize, geometry.doublePrecision);
+	const rx = coordinateAt(data, geometryAt + coordinateSize * 2, geometry.doublePrecision);
+	const ry = coordinateAt(data, geometryAt + coordinateSize * 3, geometry.doublePrecision);
+	const ix = coordinateAt(data, geometryAt + coordinateSize * 4, geometry.doublePrecision);
+	const iy = coordinateAt(data, geometryAt + coordinateSize * 5, geometry.doublePrecision);
+	const ex = coordinateAt(data, geometryAt + coordinateSize * 6, geometry.doublePrecision);
+	const ey = coordinateAt(data, geometryAt + coordinateSize * 7, geometry.doublePrecision);
+	if (ix !== ex || iy !== ey) return;
+	const frame = frameFromCorners(geometry, cx - rx, cy - ry, cx + rx, cy + ry);
+	const fill = (flags & FLAG_FILL) !== 0 ? fillOf(state) : void 0;
+	return {
+		kind: "ellipse",
+		frame,
+		...fill !== void 0 ? {
+			fill: fill.fill,
+			...fill.fillOpacity < 1 ? { fillOpacity: fill.fillOpacity } : {}
+		} : {},
+		...stroke !== void 0 ? { stroke } : {}
+	};
+}
+//#endregion
+export { decodeWpgGraphic };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wpd-codec",
-  "version": "3.4.6",
+  "version": "3.5.1",
   "description": "Hand-written read-only WordPerfect 6.x-X6 (.wpd) reader over document-schema.js's ContentDocument",
   "type": "module",
   "repository": {
@@ -63,7 +63,7 @@
     "test:coverage": "turbo run _test:coverage",
     "_test:coverage": "vitest run --project unit --coverage",
     "test:mutation": "turbo run _test:mutation",
-    "_test:mutation": "stryker run stryker.config.mjs",
+    "_test:mutation": "stryker run stryker.config.ts",
     "test:smoke": "turbo run _test:smoke",
     "_test:smoke": "vitest run --project smoke",
     "prepare": "husky",
@@ -80,8 +80,8 @@
   "license": "MIT",
   "packageManager": "pnpm@11.6.0",
   "dependencies": {
-    "archive-codec": "1.10.8",
-    "document-schema.js": "7.10.0",
+    "archive-codec": "1.11.1",
+    "document-schema.js": "7.11.1",
     "zod": "4.4.3"
   },
   "devDependencies": {