@stll/folio-core 0.3.1 → 0.5.0

package/dist/document-operations.js

@@ -0,0 +1,575 @@
+import { applyFolioAIEditOperations, previewFolioAIEditOperations } from "./ai-edits/apply.js";
+import { TaggedError } from "better-result";
+//#region src/document-operations.ts
+const FOLIO_DOCUMENT_OPERATION_CONTRACT_VERSION = 1;
+const FOLIO_DOCUMENT_OPERATION_TYPES = Object.freeze([
+	"replaceInBlock",
+	"replaceRange",
+	"commentOnRange",
+	"formatRange",
+	"insertAfterBlock",
+	"insertBeforeBlock",
+	"replaceBlock",
+	"deleteBlock",
+	"commentOnBlock",
+	"insertSignatureTable"
+]);
+const FOLIO_DOCUMENT_OPERATION_MODES = Object.freeze(["direct", "tracked-changes"]);
+const FOLIO_DOCUMENT_OPERATION_STORIES = Object.freeze(["main"]);
+const FOLIO_DOCUMENT_OPERATION_PRECONDITIONS = Object.freeze(["blockTextHash"]);
+const FOLIO_DOCUMENT_OPERATION_BATCH_MODES = Object.freeze(["best-effort", "atomic"]);
+const DIRECT_AND_TRACKED_MODES = FOLIO_DOCUMENT_OPERATION_MODES;
+const DIRECT_ONLY_MODES = Object.freeze(["direct"]);
+const FOLIO_DOCUMENT_OPERATION_MODES_BY_TYPE = Object.freeze({
+	replaceInBlock: DIRECT_AND_TRACKED_MODES,
+	replaceRange: DIRECT_AND_TRACKED_MODES,
+	commentOnRange: DIRECT_AND_TRACKED_MODES,
+	formatRange: DIRECT_ONLY_MODES,
+	insertAfterBlock: DIRECT_AND_TRACKED_MODES,
+	insertBeforeBlock: DIRECT_AND_TRACKED_MODES,
+	replaceBlock: DIRECT_AND_TRACKED_MODES,
+	deleteBlock: DIRECT_AND_TRACKED_MODES,
+	commentOnBlock: DIRECT_AND_TRACKED_MODES,
+	insertSignatureTable: DIRECT_ONLY_MODES
+});
+const DOCUMENT_OPERATION_CAPABILITIES = Object.freeze({
+	version: 1,
+	operationTypes: FOLIO_DOCUMENT_OPERATION_TYPES,
+	modes: FOLIO_DOCUMENT_OPERATION_MODES,
+	modesByOperationType: FOLIO_DOCUMENT_OPERATION_MODES_BY_TYPE,
+	batchModes: FOLIO_DOCUMENT_OPERATION_BATCH_MODES,
+	dryRun: true,
+	preconditions: FOLIO_DOCUMENT_OPERATION_PRECONDITIONS,
+	stories: FOLIO_DOCUMENT_OPERATION_STORIES
+});
+const getFolioDocumentOperationCapabilities = () => DOCUMENT_OPERATION_CAPABILITIES;
+const includesDocumentOperationMode = (supportedModes, mode) => supportedModes.includes(mode);
+const isFolioDocumentOperationModeSupported = (operationType, mode) => {
+	const supportedModes = FOLIO_DOCUMENT_OPERATION_MODES_BY_TYPE[operationType];
+	if (supportedModes === void 0) return false;
+	return includesDocumentOperationMode(supportedModes, mode);
+};
+const isSupportedFolioDocumentOperationVersion = (value) => value === 1;
+var UnsupportedFolioDocumentOperationVersionError = class extends TaggedError("UnsupportedFolioDocumentOperationVersionError")() {};
+var InvalidFolioDocumentOperationBatchError = class extends TaggedError("InvalidFolioDocumentOperationBatchError")() {};
+const assertSupportedFolioDocumentOperationVersion = (value) => {
+	if (isSupportedFolioDocumentOperationVersion(value)) return value;
+	throw new UnsupportedFolioDocumentOperationVersionError({
+		message: "Unsupported document operation contract version.",
+		receivedVersion: value
+	});
+};
+const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const invalidBatch = (path, reason) => {
+	throw new InvalidFolioDocumentOperationBatchError({
+		message: `Invalid document operation batch at ${path}: ${reason}.`,
+		path,
+		reason
+	});
+};
+const assertAllowedKeys = (value, path, allowedKeys) => {
+	const unexpected = Object.keys(value).find((key) => !allowedKeys.includes(key));
+	if (unexpected !== void 0) invalidBatch(`${path}.${unexpected}`, "unexpected property");
+};
+const readString = (value, key, path) => {
+	const candidate = value[key];
+	if (typeof candidate === "string") return candidate;
+	return invalidBatch(`${path}.${key}`, "expected a string");
+};
+const readOptionalString = (value, key, path) => {
+	const candidate = value[key];
+	if (candidate === void 0) return;
+	if (typeof candidate === "string") return candidate;
+	return invalidBatch(`${path}.${key}`, "expected a string when provided");
+};
+const readOptionalBoolean = (value, key, path) => {
+	const candidate = value[key];
+	if (candidate === void 0) return;
+	if (typeof candidate === "boolean") return candidate;
+	return invalidBatch(`${path}.${key}`, "expected a boolean when provided");
+};
+const readNonNegativeInteger = (value, key, path) => {
+	const candidate = value[key];
+	if (typeof candidate === "number" && Number.isInteger(candidate) && candidate >= 0) return candidate;
+	return invalidBatch(`${path}.${key}`, "expected a non-negative integer");
+};
+const readTextRange = (value, path) => {
+	const candidate = value["range"];
+	const rangePath = `${path}.range`;
+	if (!isPlainObject(candidate)) return invalidBatch(rangePath, "expected an object");
+	assertAllowedKeys(candidate, rangePath, [
+		"type",
+		"story",
+		"blockId",
+		"startOffset",
+		"endOffset",
+		"selectedTextHash"
+	]);
+	if (candidate["type"] !== "textRange") return invalidBatch(`${rangePath}.type`, "expected \"textRange\"");
+	if (candidate["story"] !== "main") return invalidBatch(`${rangePath}.story`, "expected \"main\"");
+	const blockId = readString(candidate, "blockId", rangePath);
+	if (blockId.length === 0) return invalidBatch(`${rangePath}.blockId`, "expected a non-empty string");
+	const startOffset = readNonNegativeInteger(candidate, "startOffset", rangePath);
+	const endOffset = readNonNegativeInteger(candidate, "endOffset", rangePath);
+	if (endOffset <= startOffset) return invalidBatch(`${rangePath}.endOffset`, "expected a value greater than startOffset");
+	const selectedTextHash = readString(candidate, "selectedTextHash", rangePath);
+	if (!/^h[0-9a-z]+$/.test(selectedTextHash)) return invalidBatch(`${rangePath}.selectedTextHash`, "expected a normalized text hash");
+	return {
+		type: "textRange",
+		story: "main",
+		blockId,
+		startOffset,
+		endOffset,
+		selectedTextHash
+	};
+};
+const readInlineFormatting = (value, path) => {
+	const candidate = value["formatting"];
+	const formattingPath = `${path}.formatting`;
+	if (!isPlainObject(candidate)) return invalidBatch(formattingPath, "expected an object");
+	assertAllowedKeys(candidate, formattingPath, [
+		"bold",
+		"italic",
+		"underline"
+	]);
+	const bold = readOptionalBoolean(candidate, "bold", formattingPath);
+	const italic = readOptionalBoolean(candidate, "italic", formattingPath);
+	const underline = readOptionalBoolean(candidate, "underline", formattingPath);
+	if (bold === void 0 && italic === void 0 && underline === void 0) return invalidBatch(formattingPath, "expected at least one formatting property");
+	return {
+		...bold !== void 0 && { bold },
+		...italic !== void 0 && { italic },
+		...underline !== void 0 && { underline }
+	};
+};
+const readOptionalComment = (value, path) => {
+	const candidate = value["comment"];
+	if (candidate === void 0) return;
+	if (isPlainObject(candidate)) {
+		assertAllowedKeys(candidate, `${path}.comment`, ["text"]);
+		return { text: readString(candidate, "text", `${path}.comment`) };
+	}
+	return invalidBatch(`${path}.comment`, "expected an object when provided");
+};
+const readOptionalPrecondition = (value, path) => {
+	const candidate = value["precondition"];
+	if (candidate === void 0) return;
+	if (!isPlainObject(candidate)) return invalidBatch(`${path}.precondition`, "expected an object when provided");
+	const preconditionPath = `${path}.precondition`;
+	assertAllowedKeys(candidate, preconditionPath, ["blockTextHash"]);
+	const blockTextHash = readString(candidate, "blockTextHash", preconditionPath);
+	if (!/^h[0-9a-z]+$/.test(blockTextHash)) return invalidBatch(`${preconditionPath}.blockTextHash`, "expected a normalized block text hash");
+	return { blockTextHash };
+};
+const isReviewSeverity = (value) => value === "low" || value === "medium" || value === "high";
+const readReviewMeta = (value, path) => {
+	const severity = value["severity"];
+	if (severity !== void 0 && !isReviewSeverity(severity)) return invalidBatch(`${path}.severity`, "expected \"low\", \"medium\", or \"high\" when provided");
+	const area = readOptionalString(value, "area", path);
+	return {
+		...severity !== void 0 && { severity },
+		...area !== void 0 && { area }
+	};
+};
+const COMMON_OPERATION_KEYS = [
+	"id",
+	"type",
+	"blockId",
+	"severity",
+	"area",
+	"precondition"
+];
+const parseSignatureParties = (value, path) => {
+	const parties = value["parties"];
+	if (!Array.isArray(parties)) return invalidBatch(`${path}.parties`, "expected an array");
+	return parties.map((party, index) => {
+		const partyPath = `${path}.parties[${index}]`;
+		if (!isPlainObject(party)) return invalidBatch(partyPath, "expected an object");
+		assertAllowedKeys(party, partyPath, [
+			"name",
+			"signatory",
+			"title"
+		]);
+		const signatory = readOptionalString(party, "signatory", partyPath);
+		const title = readOptionalString(party, "title", partyPath);
+		const parsedParty = { name: readString(party, "name", partyPath) };
+		if (signatory !== void 0) parsedParty.signatory = signatory;
+		if (title !== void 0) parsedParty.title = title;
+		return parsedParty;
+	});
+};
+const parseDocumentOperation = (value, index) => {
+	const path = `$.operations[${index}]`;
+	if (!isPlainObject(value)) return invalidBatch(path, "expected an object");
+	const id = readString(value, "id", path);
+	const type = readString(value, "type", path);
+	const reviewMeta = readReviewMeta(value, path);
+	const precondition = readOptionalPrecondition(value, path);
+	const comment = readOptionalComment(value, path);
+	const operationMeta = {
+		...reviewMeta,
+		...precondition !== void 0 && { precondition }
+	};
+	if (type === "replaceRange") {
+		assertAllowedKeys(value, path, [
+			"id",
+			"type",
+			"range",
+			"replace",
+			"comment",
+			"severity",
+			"area",
+			"precondition"
+		]);
+		return {
+			...operationMeta,
+			id,
+			type,
+			range: readTextRange(value, path),
+			replace: readString(value, "replace", path),
+			...comment !== void 0 && { comment }
+		};
+	}
+	if (type === "commentOnRange") {
+		assertAllowedKeys(value, path, [
+			"id",
+			"type",
+			"range",
+			"comment",
+			"severity",
+			"area",
+			"precondition"
+		]);
+		if (comment === void 0) return invalidBatch(`${path}.comment`, "expected an object");
+		return {
+			...operationMeta,
+			id,
+			type,
+			range: readTextRange(value, path),
+			comment
+		};
+	}
+	if (type === "formatRange") {
+		assertAllowedKeys(value, path, [
+			"id",
+			"type",
+			"range",
+			"formatting",
+			"severity",
+			"area",
+			"precondition"
+		]);
+		return {
+			...operationMeta,
+			id,
+			type,
+			range: readTextRange(value, path),
+			formatting: readInlineFormatting(value, path)
+		};
+	}
+	const blockId = readString(value, "blockId", path);
+	if (type === "replaceInBlock") {
+		assertAllowedKeys(value, path, [
+			...COMMON_OPERATION_KEYS,
+			"find",
+			"replace",
+			"comment"
+		]);
+		return {
+			...operationMeta,
+			id,
+			type,
+			blockId,
+			find: readString(value, "find", path),
+			replace: readString(value, "replace", path),
+			...comment !== void 0 && { comment }
+		};
+	}
+	if (type === "insertAfterBlock" || type === "insertBeforeBlock") {
+		assertAllowedKeys(value, path, [
+			...COMMON_OPERATION_KEYS,
+			"text",
+			"inheritFormatting",
+			"pageBreakBefore",
+			"styleId",
+			"comment"
+		]);
+		const inheritFormatting = readOptionalBoolean(value, "inheritFormatting", path);
+		const pageBreakBefore = readOptionalBoolean(value, "pageBreakBefore", path);
+		const styleId = readOptionalString(value, "styleId", path);
+		return {
+			...operationMeta,
+			id,
+			type,
+			blockId,
+			text: readString(value, "text", path),
+			...inheritFormatting !== void 0 && { inheritFormatting },
+			...pageBreakBefore !== void 0 && { pageBreakBefore },
+			...styleId !== void 0 && { styleId },
+			...comment !== void 0 && { comment }
+		};
+	}
+	if (type === "replaceBlock") {
+		assertAllowedKeys(value, path, [
+			...COMMON_OPERATION_KEYS,
+			"text",
+			"preserveFormatting",
+			"styleId",
+			"comment"
+		]);
+		const preserveFormatting = readOptionalBoolean(value, "preserveFormatting", path);
+		const styleId = readOptionalString(value, "styleId", path);
+		return {
+			...operationMeta,
+			id,
+			type,
+			blockId,
+			text: readString(value, "text", path),
+			...preserveFormatting !== void 0 && { preserveFormatting },
+			...styleId !== void 0 && { styleId },
+			...comment !== void 0 && { comment }
+		};
+	}
+	if (type === "deleteBlock") {
+		assertAllowedKeys(value, path, [...COMMON_OPERATION_KEYS, "comment"]);
+		return {
+			...operationMeta,
+			id,
+			type,
+			blockId,
+			...comment !== void 0 && { comment }
+		};
+	}
+	if (type === "commentOnBlock") {
+		assertAllowedKeys(value, path, [
+			...COMMON_OPERATION_KEYS,
+			"quote",
+			"comment"
+		]);
+		if (comment === void 0) return invalidBatch(`${path}.comment`, "expected an object");
+		const quote = readOptionalString(value, "quote", path);
+		return {
+			...operationMeta,
+			id,
+			type,
+			blockId,
+			...quote !== void 0 && { quote },
+			comment
+		};
+	}
+	if (type === "insertSignatureTable") {
+		assertAllowedKeys(value, path, [
+			...COMMON_OPERATION_KEYS,
+			"position",
+			"parties",
+			"comment"
+		]);
+		const position = value["position"];
+		if (position !== void 0 && position !== "after" && position !== "before") return invalidBatch(`${path}.position`, "expected \"after\" or \"before\" when provided");
+		return {
+			...operationMeta,
+			id,
+			type,
+			blockId,
+			...position !== void 0 && { position },
+			parties: parseSignatureParties(value, path),
+			...comment !== void 0 && { comment }
+		};
+	}
+	return invalidBatch(`${path}.type`, `unsupported operation type "${type}"`);
+};
+const parseFolioDocumentOperationBatch = (value) => {
+	if (!isPlainObject(value)) return invalidBatch("$", "expected an object");
+	assertAllowedKeys(value, "$", [
+		"version",
+		"operations",
+		"mode",
+		"atomic",
+		"dryRun"
+	]);
+	const version = assertSupportedFolioDocumentOperationVersion(value["version"]);
+	const operations = value["operations"];
+	if (!Array.isArray(operations)) return invalidBatch("$.operations", "expected an array");
+	const mode = value["mode"];
+	if (mode !== void 0 && mode !== "direct" && mode !== "tracked-changes") return invalidBatch("$.mode", "expected \"direct\" or \"tracked-changes\" when provided");
+	const atomic = readOptionalBoolean(value, "atomic", "$");
+	const dryRun = readOptionalBoolean(value, "dryRun", "$");
+	const parsedOperations = operations.map(parseDocumentOperation);
+	const operationIds = /* @__PURE__ */ new Set();
+	for (const [index, operation] of parsedOperations.entries()) {
+		if (operationIds.has(operation.id)) return invalidBatch(`$.operations[${index}].id`, "expected a unique operation id");
+		operationIds.add(operation.id);
+	}
+	return {
+		version,
+		operations: parsedOperations,
+		...mode !== void 0 && { mode },
+		...atomic !== void 0 && { atomic },
+		...dryRun !== void 0 && { dryRun }
+	};
+};
+const recoveryByReason = {
+	missingBlock: "refreshDocument",
+	changedBlock: "refreshDocument",
+	ambiguousFind: "narrowMatch",
+	missingFind: "refreshDocument",
+	unsupportedBlock: "changeTarget",
+	unsupportedMode: "changeMode",
+	atomicBatchRejected: "inspectBatch",
+	preconditionFailed: "refreshDocument",
+	staleRange: "refreshDocument",
+	emptyOperation: "removeOperation",
+	noopOperation: "removeOperation"
+};
+const getFolioDocumentOperationIssues = (operations, skipped) => {
+	const indexById = /* @__PURE__ */ new Map();
+	operations.forEach(({ id }, index) => {
+		indexById.set(id, index);
+	});
+	return skipped.map(({ id, reason }) => {
+		const operationIndex = indexById.get(id) ?? -1;
+		return {
+			operationId: id,
+			operationIndex,
+			path: `$.operations[${operationIndex}]`,
+			code: reason,
+			retryable: reason !== "emptyOperation" && reason !== "noopOperation",
+			recovery: recoveryByReason[reason]
+		};
+	});
+};
+const getPrimaryAffectedTarget = (operation) => {
+	switch (operation.type) {
+		case "replaceInBlock":
+		case "replaceBlock": return {
+			type: "block",
+			story: "main",
+			blockId: operation.blockId,
+			effect: "updated"
+		};
+		case "replaceRange": return {
+			type: "block",
+			story: "main",
+			blockId: operation.range.blockId,
+			effect: "updated"
+		};
+		case "commentOnRange": return {
+			type: "textRange",
+			range: operation.range,
+			effect: "commented"
+		};
+		case "formatRange": return {
+			type: "textRange",
+			range: operation.range,
+			effect: "formatted"
+		};
+		case "insertAfterBlock":
+		case "insertBeforeBlock": return {
+			type: "insertion",
+			story: "main",
+			anchorBlockId: operation.blockId,
+			position: operation.type === "insertBeforeBlock" ? "before" : "after",
+			content: "block"
+		};
+		case "deleteBlock": return {
+			type: "block",
+			story: "main",
+			blockId: operation.blockId,
+			effect: "deleted"
+		};
+		case "commentOnBlock": return {
+			type: "block",
+			story: "main",
+			blockId: operation.blockId,
+			effect: "commented"
+		};
+		case "insertSignatureTable": return {
+			type: "insertion",
+			story: "main",
+			anchorBlockId: operation.blockId,
+			position: operation.position ?? "after",
+			content: "signatureTable"
+		};
+	}
+};
+/** Build deterministic affected-target receipts from operations and their applied entries. */
+const getFolioDocumentOperationReceipts = (operations, applied) => {
+	const appliedById = /* @__PURE__ */ new Map();
+	applied.forEach((operation) => {
+		appliedById.set(operation.id, operation);
+	});
+	const receipts = [];
+	operations.forEach((operation, operationIndex) => {
+		const appliedOperation = appliedById.get(operation.id);
+		if (!appliedOperation) return;
+		const affected = [getPrimaryAffectedTarget(operation)];
+		if (appliedOperation.commentId !== void 0) affected.push({
+			type: "comment",
+			commentId: appliedOperation.commentId
+		});
+		receipts.push({
+			operationId: operation.id,
+			operationIndex,
+			affected
+		});
+	});
+	return receipts;
+};
+const applyFolioDocumentOperations = ({ view, snapshot, batch, author, createCommentId }) => {
+	const parsedBatch = parseFolioDocumentOperationBatch(batch);
+	const apply = ({ targetView, targetCreateCommentId = createCommentId, preview = false }) => {
+		return (preview ? previewFolioAIEditOperations : applyFolioAIEditOperations)({
+			view: targetView,
+			snapshot,
+			operations: parsedBatch.operations,
+			mode: parsedBatch.mode ?? "tracked-changes",
+			...author !== void 0 && { author },
+			...targetCreateCommentId !== void 0 && { createCommentId: targetCreateCommentId }
+		});
+	};
+	const preview = () => apply({
+		targetView: view,
+		preview: true
+	});
+	const atomicResult = (previewResult, status) => {
+		const skippedById = new Map(previewResult.skipped.map((operation) => [operation.id, operation]));
+		const skipped = parsedBatch.operations.map(({ id }) => skippedById.get(id) ?? {
+			id,
+			reason: "atomicBatchRejected"
+		});
+		return {
+			version: 1,
+			status,
+			applied: [],
+			skipped,
+			issues: getFolioDocumentOperationIssues(parsedBatch.operations, skipped),
+			receipts: []
+		};
+	};
+	if (parsedBatch.dryRun === true) {
+		const previewResult = preview();
+		if (parsedBatch.atomic === true && previewResult.skipped.length > 0) return atomicResult(previewResult, "previewed");
+		return {
+			version: 1,
+			status: "previewed",
+			applied: previewResult.applied.map(({ id }) => ({ id })),
+			skipped: previewResult.skipped,
+			issues: getFolioDocumentOperationIssues(parsedBatch.operations, previewResult.skipped),
+			receipts: getFolioDocumentOperationReceipts(parsedBatch.operations, previewResult.applied)
+		};
+	}
+	if (parsedBatch.atomic === true) {
+		const previewResult = preview();
+		if (previewResult.skipped.length > 0) return atomicResult(previewResult, "rejected");
+	}
+	const result = apply({ targetView: view });
+	return {
+		version: 1,
+		status: "committed",
+		...result,
+		issues: getFolioDocumentOperationIssues(parsedBatch.operations, result.skipped),
+		receipts: getFolioDocumentOperationReceipts(parsedBatch.operations, result.applied)
+	};
+};
+//#endregion
+export { FOLIO_DOCUMENT_OPERATION_BATCH_MODES, FOLIO_DOCUMENT_OPERATION_CONTRACT_VERSION, FOLIO_DOCUMENT_OPERATION_MODES, FOLIO_DOCUMENT_OPERATION_MODES_BY_TYPE, FOLIO_DOCUMENT_OPERATION_PRECONDITIONS, FOLIO_DOCUMENT_OPERATION_STORIES, FOLIO_DOCUMENT_OPERATION_TYPES, InvalidFolioDocumentOperationBatchError, UnsupportedFolioDocumentOperationVersionError, applyFolioDocumentOperations, assertSupportedFolioDocumentOperationVersion, getFolioDocumentOperationCapabilities, getFolioDocumentOperationIssues, getFolioDocumentOperationReceipts, isFolioDocumentOperationModeSupported, isSupportedFolioDocumentOperationVersion, parseFolioDocumentOperationBatch };

package/dist/docx/blockContentParser.js

@@ -57,19 +57,30 @@ const computeListMarker = (paragraph, numbering, listCounters, abstractCounters)
 	if (!listRendering || !numbering) return;
 	const { numId, level } = listRendering;
 	if (numId === 0) return;
-	if (!listCounters.has(numId)) listCounters.set(numId, Array.from({ length: 9 }).fill(0));
+	if (!listCounters.has(numId)) listCounters.set(numId, Array.from({ length: 9 }).fill(NaN));
 	const counters = listCounters.get(numId);
 	if (!counters) return;
 	const abstractNumId = numbering.getAbstractNumId(numId);
+	const styleNumbering = paragraph.formatting?.numPrFromStyle;
+	if (abstractNumId !== null && styleNumbering) {
+		const latestAbstractCounters = abstractCounters.get(abstractNumId);
+		if (latestAbstractCounters) for (let i = 0; i < counters.length; i += 1) counters[i] = latestAbstractCounters[i] ?? NaN;
+	}
 	if (abstractNumId !== null && level > 0) {
 		const latestAbstractCounters = abstractCounters.get(abstractNumId);
-		const missingParentCounters = counters.slice(0, level).every((value) => value === 0);
-		if (latestAbstractCounters && missingParentCounters) for (let i = 0; i < level; i += 1) counters[i] = latestAbstractCounters[i] ?? 0;
+		if (counters.slice(0, level).every(Number.isNaN)) for (let i = 0; i < level; i += 1) {
+			const latestCounter = latestAbstractCounters?.[i];
+			counters[i] = latestCounter !== void 0 && !Number.isNaN(latestCounter) ? latestCounter : numbering.getLevel(numId, i)?.start ?? 1;
+		}
 	}
-	counters[level] = (counters[level] || 0) + 1;
-	for (let i = level + 1; i < counters.length; i += 1) counters[i] = 0;
+	if (Number.isNaN(counters[level])) counters[level] = (numbering.getLevel(numId, level)?.start ?? 1) - 1;
+	counters[level] = (counters[level] ?? 0) + 1;
+	for (let i = level + 1; i < counters.length; i += 1) counters[i] = NaN;
 	const childAdvances = listRendering.implicitChildLevelAdvances ?? 0;
-	if (childAdvances > 0 && level + 1 < counters.length) counters[level + 1] = (counters[level + 1] ?? 0) + childAdvances;
+	if (childAdvances > 0 && level + 1 < counters.length) {
+		const childCounter = counters[level + 1];
+		counters[level + 1] = (childCounter === void 0 || Number.isNaN(childCounter) ? 0 : childCounter) + childAdvances;
+	}
 	if (abstractNumId !== null) abstractCounters.set(abstractNumId, [...counters]);
 	const pattern = listRendering.marker;
 	if (listRendering.isBullet) {
@@ -90,7 +101,6 @@ const computeListMarker = (paragraph, numbering, listCounters, abstractCounters)
 	listRendering.marker = computedMarker;
 };
 const enrichParagraphTextBoxes = (paragraph, paraXml, styles, theme, numbering, rels, media) => {
-	if (paragraph.content.length === 0) return;
 	const xmlChildren = getChildElements(paraXml);
 	let parsedIndex = 0;
 	let lastConsumedRun;

package/dist/docx/encryption/agileDecryption.d.ts

@@ -0,0 +1,6 @@
+import { AgileKeyMaterial } from "./encryptionInfo.js";
+
+//#region src/docx/encryption/agileDecryption.d.ts
+declare const decryptAgileEncryptedPackage: (password: string, material: AgileKeyMaterial, encryptedPackage: Uint8Array) => Promise<Uint8Array>;
+//#endregion
+export { decryptAgileEncryptedPackage };