@agimon-ai/doompi-author 0.0.1-alpha.2 → 0.0.1-alpha.21

package/dist/structuredDocuments-CzMYD0Bq.mjs

@@ -0,0 +1,810 @@
+import { parse } from "csv-parse/sync";
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { SaxesParser } from "saxes";
+import yauzl from "yauzl";
+import yazl from "yazl";
+//#region src/models/authorBridgeState.ts
+const AUTHOR_REQUEST_TIMEOUT_MS = 15e3;
+const AUTHOR_OWNER_LEASE_MS = 1e4;
+var AuthorBridgeError = class extends Error {
+	status;
+	constructor(message, status = 409) {
+		super(message);
+		this.status = status;
+	}
+};
+function createAuthorBridgeState(options) {
+	const { now, issueToken, scheduleTimeout } = options;
+	const timeoutMs = options.requestTimeoutMs ?? 15e3;
+	const leaseMs = options.leaseMs ?? 1e4;
+	let owner;
+	let pending;
+	let delivery;
+	let deliveryWaiter;
+	const tombstones = /* @__PURE__ */ new Set();
+	const rememberCancellation = (requestId) => {
+		tombstones.add(requestId);
+		if (tombstones.size > 100) tombstones.delete(tombstones.values().next().value);
+	};
+	const publishDelivery = (value) => {
+		if (deliveryWaiter === void 0) delivery = value;
+		else {
+			const waiter = deliveryWaiter;
+			deliveryWaiter = void 0;
+			waiter.resolve(value);
+		}
+	};
+	const rejectPending = (reason, sendCancel) => {
+		const current = pending;
+		if (current === void 0) return;
+		pending = void 0;
+		current.cancelTimer();
+		current.removeAbort?.();
+		rememberCancellation(current.request.requestId);
+		if (sendCancel) publishDelivery({
+			...current.request,
+			kind: "cancel"
+		});
+		current.reject(new AuthorBridgeError(reason, 503));
+	};
+	const liveOwner = () => {
+		if (owner === void 0) throw new AuthorBridgeError("No Author viewport is registered.", 503);
+		if (owner.expiresAt <= now()) {
+			rejectPending("The Author viewport lease expired.", false);
+			owner = void 0;
+			throw new AuthorBridgeError("The Author viewport lease expired.", 503);
+		}
+		return owner;
+	};
+	const assertOwner = (bindingId, generation, ownerToken) => {
+		const current = liveOwner();
+		if (current.bindingId !== bindingId || current.generation !== generation || current.ownerToken !== ownerToken) throw new AuthorBridgeError("Stale Author viewport binding.");
+		return current;
+	};
+	const assertRequest = (bindingId, generation, ownerToken, catalogToken, requestId) => {
+		if (assertOwner(bindingId, generation, ownerToken).catalogToken !== catalogToken) throw new AuthorBridgeError("Stale Author catalog token.");
+		if (tombstones.has(requestId)) throw new AuthorBridgeError("The Author request was already cancelled.");
+		if (pending?.request.requestId !== requestId) throw new AuthorBridgeError("Stale Author request.");
+		return pending;
+	};
+	return {
+		register(bindingId, generation) {
+			if (bindingId === "" || !Number.isSafeInteger(generation) || generation < 0) throw new AuthorBridgeError("Invalid Author registration.", 400);
+			if (owner !== void 0 && owner.expiresAt > now()) {
+				if (owner.bindingId !== bindingId) throw new AuthorBridgeError("Another Author viewport owns the lease.");
+				if (generation < owner.generation) throw new AuthorBridgeError("Stale Author generation.");
+				if (generation === owner.generation) {
+					owner.expiresAt = now() + leaseMs;
+					return {
+						kind: "accepted",
+						generation,
+						ownerToken: owner.ownerToken,
+						...owner.catalogToken === void 0 ? {} : { catalogToken: owner.catalogToken },
+						leaseMs
+					};
+				}
+			}
+			rejectPending("The Author viewport generation changed.", false);
+			delivery = void 0;
+			const current = {
+				bindingId,
+				generation,
+				ownerToken: issueToken(),
+				expiresAt: now() + leaseMs,
+				tools: []
+			};
+			owner = current;
+			return {
+				kind: "accepted",
+				generation,
+				ownerToken: current.ownerToken,
+				leaseMs
+			};
+		},
+		catalog(bindingId, generation, ownerToken, tools) {
+			const current = assertOwner(bindingId, generation, ownerToken);
+			if (!Array.isArray(tools) || tools.length > 15) throw new AuthorBridgeError("Invalid Author catalog.", 400);
+			const names = /* @__PURE__ */ new Set();
+			for (const tool of tools) {
+				if (typeof tool !== "object" || tool === null || typeof tool.name !== "string" || !/^[a-z][a-z0-9_]{0,29}$/.test(tool.name) || typeof tool.label !== "string" || typeof tool.description !== "string" || typeof tool.inputSchema !== "object" || tool.inputSchema === null || Array.isArray(tool.inputSchema) || names.has(tool.name)) throw new AuthorBridgeError("Invalid Author catalog.", 400);
+				names.add(tool.name);
+			}
+			if (pending !== void 0) throw new AuthorBridgeError("Cannot replace the Author catalog during a request.");
+			current.tools = tools.map((tool) => ({
+				...tool,
+				inputSchema: { ...tool.inputSchema }
+			}));
+			current.catalogToken = issueToken();
+			current.expiresAt = now() + leaseMs;
+			return {
+				kind: "accepted",
+				generation,
+				ownerToken,
+				catalogToken: current.catalogToken,
+				leaseMs
+			};
+		},
+		describe() {
+			const current = liveOwner();
+			if (current.catalogToken === void 0) throw new AuthorBridgeError("The Author viewport has no catalog.", 503);
+			return {
+				catalogToken: current.catalogToken,
+				tools: current.tools
+			};
+		},
+		invoke(input, signal) {
+			let current;
+			try {
+				current = liveOwner();
+				if (current.catalogToken !== input.catalogToken) throw new AuthorBridgeError("The Author capability catalog changed.");
+				if (!current.tools.some((tool) => tool.name === input.name)) throw new AuthorBridgeError(`Unknown Author capability: ${input.name}`, 404);
+				if (pending !== void 0) throw new AuthorBridgeError("Another Author request is already pending.");
+				if (signal?.aborted) throw signal.reason instanceof Error ? signal.reason : /* @__PURE__ */ new Error("Author request cancelled.");
+			} catch (error) {
+				return Promise.reject(error);
+			}
+			const request = {
+				kind: "request",
+				generation: current.generation,
+				ownerToken: current.ownerToken,
+				catalogToken: current.catalogToken,
+				requestId: issueToken(),
+				name: input.name,
+				arguments: input.arguments
+			};
+			return new Promise((resolve, reject) => {
+				const cancel = (reason) => rejectPending(reason, true);
+				const cancelTimer = scheduleTimeout(() => cancel("The Author request timed out."), Math.min(timeoutMs, current.expiresAt - now()));
+				pending = {
+					request,
+					resolve,
+					reject,
+					cancelTimer
+				};
+				if (signal !== void 0) {
+					const onAbort = () => cancel("The Author request was cancelled.");
+					signal.addEventListener("abort", onAbort, { once: true });
+					pending.removeAbort = () => signal.removeEventListener("abort", onAbort);
+				}
+				publishDelivery(request);
+			});
+		},
+		async next(bindingId, generation, ownerToken, signal) {
+			assertOwner(bindingId, generation, ownerToken);
+			if (delivery !== void 0) {
+				const value = delivery;
+				delivery = void 0;
+				return value;
+			}
+			if (deliveryWaiter !== void 0) throw new AuthorBridgeError("An Author delivery poll is already active.");
+			return await new Promise((resolve, reject) => {
+				let waiter;
+				const onAbort = () => {
+					if (deliveryWaiter === waiter) deliveryWaiter = void 0;
+					reject(signal?.reason ?? /* @__PURE__ */ new Error("Author delivery poll cancelled."));
+				};
+				waiter = {
+					resolve(value) {
+						signal?.removeEventListener("abort", onAbort);
+						resolve(value);
+					},
+					reject
+				};
+				deliveryWaiter = waiter;
+				signal?.addEventListener("abort", onAbort, { once: true });
+			});
+		},
+		result(bindingId, generation, ownerToken, catalogToken, requestId, result) {
+			const current = assertRequest(bindingId, generation, ownerToken, catalogToken, requestId);
+			pending = void 0;
+			current.cancelTimer();
+			current.removeAbort?.();
+			current.resolve({
+				catalogToken,
+				name: current.request.name,
+				result
+			});
+		},
+		cancelled(bindingId, generation, ownerToken, catalogToken, requestId) {
+			const current = assertRequest(bindingId, generation, ownerToken, catalogToken, requestId);
+			pending = void 0;
+			current.cancelTimer();
+			current.removeAbort?.();
+			rememberCancellation(requestId);
+			current.reject(new AuthorBridgeError("The Author viewport cancelled the request."));
+		},
+		disconnect(bindingId, generation) {
+			if (owner?.bindingId !== bindingId || owner.generation !== generation) return;
+			rejectPending("The Author viewport disconnected.", false);
+			owner = void 0;
+			delivery = void 0;
+		},
+		close() {
+			rejectPending("The Author bridge closed.", false);
+			owner = void 0;
+			delivery = void 0;
+			deliveryWaiter?.reject(/* @__PURE__ */ new Error("The Author bridge closed."));
+			deliveryWaiter = void 0;
+		}
+	};
+}
+function digestOf(value) {
+	return createHash("sha256").update(value).digest("hex");
+}
+function parsedDocument(format, bytes, fragments, metadata = {}) {
+	return {
+		manifest: {
+			format,
+			sourceDigest: digestOf(bytes),
+			byteLength: bytes.byteLength,
+			fragmentCount: fragments.length,
+			metadata
+		},
+		fragments,
+		renderModel: renderModel(format, fragments)
+	};
+}
+function renderModel(format, fragments) {
+	return {
+		format,
+		blocks: fragments.map(({ id, text, readOnly }) => ({
+			id,
+			text,
+			readOnly: readOnly === true
+		}))
+	};
+}
+function preflight(document, operations, validate, binding) {
+	const fragments = new Map(document.fragments.map((fragment) => [fragment.id, fragment]));
+	const seen = /* @__PURE__ */ new Set();
+	const issues = [];
+	const log = [];
+	let replacementBytes = 0;
+	for (const operation of operations) {
+		const fragment = fragments.get(operation.fragmentId);
+		if (!fragment) {
+			issues.push({
+				code: "unknown-fragment",
+				message: "The operation names an unknown fragment.",
+				fragmentId: operation.fragmentId
+			});
+			continue;
+		}
+		if (seen.has(operation.fragmentId)) {
+			issues.push({
+				code: "duplicate-operation",
+				message: "A fragment may be replaced only once.",
+				fragmentId: operation.fragmentId
+			});
+			continue;
+		}
+		seen.add(operation.fragmentId);
+		const operationBytes = new TextEncoder().encode(operation.replacement).byteLength;
+		replacementBytes += operationBytes;
+		if (operationBytes > 10485760 || replacementBytes > 104857600) {
+			issues.push({
+				code: "replacement-limit",
+				message: "Replacement content exceeds the document mutation limits.",
+				fragmentId: operation.fragmentId
+			});
+			continue;
+		}
+		if (fragment.readOnly === true) {
+			issues.push({
+				code: "read-only",
+				message: "The fragment is read-only.",
+				fragmentId: operation.fragmentId
+			});
+			continue;
+		}
+		const issue = validate?.(operation, fragment);
+		if (issue) issues.push(issue);
+		else log.push({
+			...operation,
+			previous: fragment.text
+		});
+	}
+	const digest = digestOf(JSON.stringify({
+		format: document.manifest.format,
+		binding,
+		sourceDigest: document.manifest.sourceDigest,
+		operations: log,
+		issues
+	}));
+	return {
+		accepted: issues.length === 0,
+		digest,
+		sourceDigest: document.manifest.sourceDigest,
+		operations: log,
+		issues
+	};
+}
+function requireAccepted(report, expectedDigest) {
+	if (!report.accepted || report.digest !== expectedDigest) throw new Error("An accepted, current preflight report digest is required.");
+}
+function decodeUtf8(bytes) {
+	const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+	if (text.includes("\0")) throw new Error("NUL bytes are not supported.");
+	return text;
+}
+//#endregion
+//#region src/services/structuredDocuments/csv.ts
+const FORMULA_TRIGGER = /^\s*[=+\-@]/;
+const MAX_CELLS = 1e6;
+function detectDialect(text) {
+	const recordDelimiter = text.includes("\r\n") ? "\r\n" : "\n";
+	const firstRecord = text.split(/\r?\n/, 1)[0] ?? "";
+	return {
+		delimiter: [
+			",",
+			";",
+			"	",
+			"|"
+		].reduce((best, candidate) => firstRecord.split(candidate).length > firstRecord.split(best).length ? candidate : best),
+		quote: "\"",
+		recordDelimiter
+	};
+}
+function normalizeDialect(text, requestedDialect) {
+	if (requestedDialect !== void 0 && (typeof requestedDialect !== "object" || requestedDialect === null || Array.isArray(requestedDialect))) throw new Error("CSV dialect must be an object.");
+	const dialect = {
+		...detectDialect(text),
+		...requestedDialect
+	};
+	if (![
+		",",
+		";",
+		"	",
+		"|"
+	].includes(dialect.delimiter)) throw new Error("Invalid CSV delimiter.");
+	if (!["\"", "'"].includes(dialect.quote)) throw new Error("Invalid CSV quote.");
+	if (!["\n", "\r\n"].includes(dialect.recordDelimiter)) throw new Error("Invalid CSV record delimiter.");
+	return dialect;
+}
+function parseCsv(source, requestedDialect) {
+	const bytes = typeof source === "string" ? new TextEncoder().encode(source) : source;
+	if (bytes.byteLength > 26214400) throw new Error("CSV input exceeds the size limit.");
+	const text = decodeUtf8(bytes);
+	const dialect = normalizeDialect(text, requestedDialect);
+	const records = parse(text, {
+		bom: true,
+		delimiter: dialect.delimiter,
+		quote: dialect.quote,
+		record_delimiter: [dialect.recordDelimiter],
+		relax_column_count: false,
+		skip_empty_lines: false
+	});
+	if (records.reduce((total, row) => total + row.length, 0) > MAX_CELLS) throw new Error("CSV input has too many cells.");
+	return parsedDocument("csv", bytes, records.flatMap((row, rowIndex) => row.map((text, columnIndex) => {
+		if (FORMULA_TRIGGER.test(text)) throw new Error(`CSV formula trigger rejected at row ${rowIndex + 1}.`);
+		return {
+			id: `cell:${rowIndex + 1}:${columnIndex + 1}`,
+			kind: "cell",
+			text,
+			location: `row ${rowIndex + 1}, column ${columnIndex + 1}`
+		};
+	})), {
+		rows: records.length,
+		columns: records.reduce((maximum, row) => Math.max(maximum, row.length), 0),
+		delimiter: dialect.delimiter,
+		quote: dialect.quote,
+		recordDelimiter: dialect.recordDelimiter
+	});
+}
+function preflightCsv(source, operations, dialect) {
+	const bytes = typeof source === "string" ? new TextEncoder().encode(source) : source;
+	const normalizedDialect = normalizeDialect(decodeUtf8(bytes), dialect);
+	return preflight(parseCsv(bytes, normalizedDialect), operations, (operation) => FORMULA_TRIGGER.test(operation.replacement) ? {
+		code: "formula-trigger",
+		message: "CSV values may not begin with a formula trigger.",
+		fragmentId: operation.fragmentId
+	} : void 0, { dialect: normalizedDialect });
+}
+function encodeCell(value, dialect) {
+	const escaped = value.replaceAll(dialect.quote, dialect.quote + dialect.quote);
+	return value.includes(dialect.delimiter) || value.includes(dialect.quote) || /[\r\n]/.test(value) ? `${dialect.quote}${escaped}${dialect.quote}` : escaped;
+}
+function serializeCsv(source, operations, acceptedReportDigest, requestedDialect) {
+	const dialect = normalizeDialect(typeof source === "string" ? source : decodeUtf8(source), requestedDialect);
+	const document = parseCsv(source, dialect);
+	const report = preflightCsv(source, operations, dialect);
+	requireAccepted(report, acceptedReportDigest);
+	const replacements = new Map(report.operations.map((operation) => [operation.fragmentId, operation.replacement]));
+	const fragments = new Map(document.fragments.map((fragment) => [fragment.id, fragment]));
+	const rows = Number(document.manifest.metadata.rows);
+	const columns = Number(document.manifest.metadata.columns);
+	const outputRows = [];
+	for (let row = 1; row <= rows; row += 1) {
+		const values = [];
+		for (let column = 1; column <= columns; column += 1) {
+			const id = `cell:${row}:${column}`;
+			const fragment = fragments.get(id);
+			if (fragment) values.push(encodeCell(replacements.get(id) ?? fragment.text, dialect));
+		}
+		outputRows.push(values.join(dialect.delimiter));
+	}
+	const bytes = new TextEncoder().encode(outputRows.join(dialect.recordDelimiter));
+	return {
+		bytes,
+		operationLog: report.operations,
+		manifest: parseCsv(bytes, dialect).manifest
+	};
+}
+//#endregion
+//#region src/services/structuredDocuments/markdownSlides.ts
+const SLIDE_SEPARATOR = /^(?:---|\*\*\*)[ \t]*$/m;
+const MAX_SLIDES = 1e3;
+function parseMarkdownSlides(source) {
+	const bytes = typeof source === "string" ? new TextEncoder().encode(source) : source;
+	if (bytes.byteLength > 26214400) throw new Error("Markdown input exceeds the size limit.");
+	const slides = decodeUtf8(bytes).split(SLIDE_SEPARATOR);
+	if (slides.length > MAX_SLIDES) throw new Error("Markdown input has too many slides.");
+	const fragments = slides.map((slide, index) => ({
+		id: `slide:${index + 1}`,
+		kind: "slide",
+		text: slide.replace(/^\r?\n+|\r?\n+$/g, ""),
+		location: `slide ${index + 1}`
+	}));
+	return parsedDocument("markdown-slides", bytes, fragments, { slideCount: fragments.length });
+}
+function preflightMarkdownSlides(source, operations) {
+	return preflight(parseMarkdownSlides(source), operations);
+}
+function serializeMarkdownSlides(source, operations, acceptedReportDigest) {
+	const document = parseMarkdownSlides(source);
+	const report = preflight(document, operations);
+	requireAccepted(report, acceptedReportDigest);
+	const replacements = new Map(report.operations.map((operation) => [operation.fragmentId, operation.replacement]));
+	const output = document.fragments.map((fragment) => replacements.get(fragment.id) ?? fragment.text).join("\n\n---\n\n");
+	const bytes = new TextEncoder().encode(output);
+	return {
+		bytes,
+		operationLog: report.operations,
+		manifest: parseMarkdownSlides(bytes).manifest
+	};
+}
+//#endregion
+//#region src/services/structuredDocuments/ooxmlArchive.ts
+function normalizedEntryName(name) {
+	const slashName = name.replaceAll("\\", "/");
+	if (slashName.startsWith("/") || /^[A-Za-z]:/.test(slashName)) throw new Error("Absolute archive entry path rejected.");
+	const normalized = path.posix.normalize(slashName);
+	if (normalized === ".." || normalized.startsWith("..") || normalized.includes("/../")) throw new Error("Archive path traversal rejected.");
+	return normalized.replace(/^\.\//, "");
+}
+function openArchive(bytes) {
+	return new Promise((resolve, reject) => {
+		yauzl.fromBuffer(bytes, {
+			lazyEntries: true,
+			decodeStrings: true,
+			validateEntrySizes: true
+		}, (error, zipFile) => {
+			if (error || !zipFile) reject(error ?? /* @__PURE__ */ new Error("Malformed ZIP archive."));
+			else resolve(zipFile);
+		});
+	});
+}
+function readEntry(zipFile, entry) {
+	return new Promise((resolve, reject) => {
+		zipFile.openReadStream(entry, (error, stream) => {
+			if (error || !stream) {
+				reject(error ?? /* @__PURE__ */ new Error("Could not read archive entry."));
+				return;
+			}
+			const chunks = [];
+			stream.on("data", (chunk) => chunks.push(chunk));
+			stream.once("error", reject);
+			stream.once("end", () => resolve(Buffer.concat(chunks)));
+		});
+	});
+}
+function validateXml(name, data) {
+	if (data.byteLength > 10485760) throw new Error(`XML entry exceeds its size limit: ${name}`);
+	const xml = new TextDecoder("utf-8", { fatal: true }).decode(data);
+	const withoutDeclaration = xml.replace(/^\uFEFF?\s*<\?xml\s[^?]*\?>/i, "");
+	if (/<!DOCTYPE|<!ENTITY|<\?/i.test(withoutDeclaration)) throw new Error(`Unsafe XML construct rejected: ${name}`);
+	const parser = new SaxesParser({ xmlns: true });
+	let parseError;
+	parser.on("error", (error) => {
+		parseError = error;
+	});
+	parser.write(xml).close();
+	if (parseError) throw new Error(`Malformed XML entry: ${name}`);
+	if (/TargetMode\s*=\s*["']External["']/i.test(xml)) throw new Error("External OOXML relationship rejected.");
+	if (/<(?:\w+:)?(?:workbookProtection|sheetProtection|documentProtection|modifyVerifier)\b/i.test(xml)) throw new Error("Protected OOXML content rejected.");
+}
+async function readOoxmlArchive(source) {
+	if (source.byteLength > 26214400) throw new Error("OOXML archive exceeds the compressed size limit.");
+	const zipFile = await openArchive(Buffer.from(source));
+	return await new Promise((resolve, reject) => {
+		const entries = [];
+		const names = /* @__PURE__ */ new Set();
+		let expanded = 0;
+		const fail = (error) => {
+			zipFile.close();
+			reject(error instanceof Error ? error : new Error(String(error)));
+		};
+		zipFile.once("error", fail);
+		zipFile.on("entry", (entry) => {
+			(async () => {
+				if (entries.length >= 4096) throw new Error("OOXML archive has too many entries.");
+				if ((entry.generalPurposeBitFlag & 1) !== 0) throw new Error("Encrypted OOXML archive rejected.");
+				if ((entry.externalFileAttributes >>> 16 & 61440) === 40960) throw new Error("Archive symlink rejected.");
+				if (entry.compressionMethod !== 0 && entry.compressionMethod !== 8) throw new Error("Unsupported ZIP compression method.");
+				const name = normalizedEntryName(entry.fileName);
+				if (!name || names.has(name)) throw new Error("Duplicate normalized archive entry rejected.");
+				names.add(name);
+				expanded += entry.uncompressedSize;
+				if (expanded > 104857600) throw new Error("OOXML archive exceeds the expanded size limit.");
+				if (entry.uncompressedSize > Math.max(1, entry.compressedSize) * 100) throw new Error("OOXML archive compression ratio exceeds the limit.");
+				const lower = name.toLowerCase();
+				if (lower === "encryptedpackage" || lower === "encryptioninfo" || lower.includes("vbaproject") || lower.includes("_xmlsignatures") || lower.endsWith(".bin")) throw new Error("Encrypted, signed, or macro-enabled OOXML content rejected.");
+				const data = name.endsWith("/") ? Buffer.alloc(0) : await readEntry(zipFile, entry);
+				if (/\.xml$|\.rels$/i.test(name)) validateXml(name, data);
+				entries.push({
+					name,
+					data,
+					compressionMethod: entry.compressionMethod
+				});
+				zipFile.readEntry();
+			})().catch(fail);
+		});
+		zipFile.once("end", () => {
+			if (!names.has("[Content_Types].xml")) {
+				fail(/* @__PURE__ */ new Error("Unsupported OOXML archive: missing content types."));
+				return;
+			}
+			resolve({
+				entries,
+				byName: new Map(entries.map((entry) => [entry.name, entry]))
+			});
+		});
+		zipFile.readEntry();
+	});
+}
+function assertOoxmlKind(archive, kind) {
+	const contentTypes = archive.byName.get("[Content_Types].xml")?.data.toString("utf8") ?? "";
+	const required = kind === "pptx" ? "presentationml.presentation.main+xml" : "spreadsheetml.sheet.main+xml";
+	if (!contentTypes.includes(required)) throw new Error(`Unsupported OOXML archive: not a ${kind.toUpperCase()} document.`);
+	if (/macroEnabled|vnd\.ms-office\.vbaProject/i.test(contentTypes)) throw new Error("Macro-enabled OOXML content rejected.");
+}
+async function writeOoxmlArchive(archive, replacements) {
+	const zipFile = new yazl.ZipFile();
+	const chunks = [];
+	const output = new Promise((resolve, reject) => {
+		zipFile.outputStream.on("data", (chunk) => chunks.push(chunk));
+		zipFile.outputStream.once("error", reject);
+		zipFile.outputStream.once("end", () => resolve(Buffer.concat(chunks)));
+	});
+	for (const entry of archive.entries) if (entry.name.endsWith("/")) zipFile.addEmptyDirectory(entry.name);
+	else zipFile.addBuffer(replacements.get(entry.name) ?? entry.data, entry.name, { compress: entry.compressionMethod === 8 });
+	zipFile.end();
+	return await output;
+}
+//#endregion
+//#region src/services/structuredDocuments/xmlText.ts
+function decodeXmlText(value) {
+	return value.replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&quot;", "\"").replaceAll("&apos;", "'").replaceAll("&amp;", "&");
+}
+function encodeXmlText(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function replaceRange(source, start, end, replacement) {
+	return source.slice(0, start) + replacement + source.slice(end);
+}
+//#endregion
+//#region src/services/structuredDocuments/pptx.ts
+async function stateOf$1(source) {
+	const archive = await readOoxmlArchive(source);
+	assertOoxmlKind(archive, "pptx");
+	const fragments = [];
+	const ranges = /* @__PURE__ */ new Map();
+	const slideEntries = archive.entries.filter((entry) => /^ppt\/slides\/slide\d+\.xml$/i.test(entry.name)).sort((left, right) => left.name.localeCompare(right.name, void 0, { numeric: true }));
+	for (const entry of slideEntries) {
+		const paragraphs = entry.data.toString("utf8").matchAll(/<a:p(?:\s[^>]*)?>([\s\S]*?)<\/a:p>/g);
+		let runIndex = 0;
+		for (const paragraph of paragraphs) {
+			const body = paragraph[1] ?? "";
+			const runCount = (body.match(/<a:r(?:\s[^>]*)?>/g) ?? []).length;
+			const textCount = (body.match(/<a:t(?:\s[^>]*)?>/g) ?? []).length;
+			if (textCount === 0) continue;
+			if (runCount !== 1 || textCount !== 1) throw new Error("Unsupported PPTX paragraph with multiple text styles.");
+			const textMatch = /<a:t(?:\s[^>]*)?>([\s\S]*?)<\/a:t>/.exec(body);
+			if (!textMatch) throw new Error("Malformed PPTX text run.");
+			runIndex += 1;
+			const id = `${entry.name}#text:${runIndex}`;
+			const paragraphStart = paragraph.index ?? 0;
+			const bodyOffset = paragraph[0].indexOf(body);
+			const textOffset = body.indexOf(textMatch[1] ?? "", textMatch.index);
+			const start = paragraphStart + bodyOffset + textOffset;
+			const end = start + (textMatch[1]?.length ?? 0);
+			fragments.push({
+				id,
+				kind: "text-run",
+				text: decodeXmlText(textMatch[1] ?? ""),
+				location: entry.name
+			});
+			ranges.set(id, {
+				entry: entry.name,
+				start,
+				end
+			});
+		}
+	}
+	return {
+		archive,
+		document: parsedDocument("pptx", source, fragments, { slides: slideEntries.length }),
+		ranges
+	};
+}
+async function parsePptx(source) {
+	return (await stateOf$1(source)).document;
+}
+async function preflightPptx(source, operations) {
+	return preflight((await stateOf$1(source)).document, operations);
+}
+async function serializePptx(source, operations, acceptedReportDigest) {
+	const state = await stateOf$1(source);
+	const report = preflight(state.document, operations);
+	requireAccepted(report, acceptedReportDigest);
+	const byEntry = /* @__PURE__ */ new Map();
+	for (const operation of report.operations) {
+		const range = state.ranges.get(operation.fragmentId);
+		if (!range) throw new Error("PPTX text run changed during serialization.");
+		const list = byEntry.get(range.entry) ?? [];
+		list.push({
+			start: range.start,
+			end: range.end,
+			replacement: encodeXmlText(operation.replacement)
+		});
+		byEntry.set(range.entry, list);
+	}
+	const replacements = /* @__PURE__ */ new Map();
+	for (const [entryName, edits] of byEntry) {
+		let xml = state.archive.byName.get(entryName)?.data.toString("utf8") ?? "";
+		for (const edit of edits.sort((left, right) => right.start - left.start)) xml = replaceRange(xml, edit.start, edit.end, edit.replacement);
+		replacements.set(entryName, Buffer.from(xml));
+	}
+	const bytes = await writeOoxmlArchive(state.archive, replacements);
+	return {
+		bytes,
+		operationLog: report.operations,
+		manifest: (await parsePptx(bytes)).manifest
+	};
+}
+//#endregion
+//#region src/services/structuredDocuments/xlsx.ts
+function textNodes(xml) {
+	return [...xml.matchAll(/<(?:\w+:)?t(?:\s[^>]*)?>([\s\S]*?)<\/(?:\w+:)?t>/g)].map((match) => decodeXmlText(match[1] ?? "")).join("");
+}
+function sharedStrings(archive) {
+	const xml = archive.byName.get("xl/sharedStrings.xml")?.data.toString("utf8");
+	if (!xml) return [];
+	return [...xml.matchAll(/<si(?:\s[^>]*)?>([\s\S]*?)<\/si>/g)].map((match) => {
+		const body = match[1] ?? "";
+		return {
+			text: textNodes(body),
+			multiRun: [...body.matchAll(/<(?:\w+:)?r(?:\s[^>]*)?>/g)].length > 1
+		};
+	});
+}
+function attribute(attributes, name) {
+	return new RegExp(`\\s${name}=["']([^"']*)["']`).exec(attributes)?.[1];
+}
+async function stateOf(source) {
+	const archive = await readOoxmlArchive(source);
+	assertOoxmlKind(archive, "xlsx");
+	const shared = sharedStrings(archive);
+	const fragments = [];
+	const ranges = /* @__PURE__ */ new Map();
+	const worksheets = archive.entries.filter((entry) => /^xl\/worksheets\/sheet\d+\.xml$/i.test(entry.name)).sort((left, right) => left.name.localeCompare(right.name, void 0, { numeric: true }));
+	for (const entry of worksheets) {
+		const xml = entry.data.toString("utf8");
+		for (const match of xml.matchAll(/<c(\s[^>]*)>([\s\S]*?)<\/c>/g)) {
+			const attributes = match[1] ?? "";
+			const body = match[2] ?? "";
+			const reference = attribute(attributes, "r");
+			if (!reference) continue;
+			const type = attribute(attributes, "t");
+			const formula = /<f(?:\s[^>]*)?>[\s\S]*?<\/f>|<f\s*\/>/.test(body);
+			const value = /<v(?:\s[^>]*)?>([\s\S]*?)<\/v>/.exec(body)?.[1] ?? "";
+			let text;
+			let multiRun = false;
+			if (type === "s") {
+				const index = Number(value);
+				const sharedString = shared[index];
+				if (!Number.isInteger(index) || sharedString === void 0) throw new Error(`Malformed shared string cell: ${reference}`);
+				text = sharedString.text;
+				multiRun = sharedString.multiRun;
+			} else if (type === "inlineStr") {
+				text = textNodes(body);
+				multiRun = [...body.matchAll(/<(?:\w+:)?r(?:\s[^>]*)?>/g)].length > 1;
+			} else text = decodeXmlText(value);
+			const id = `${entry.name}#cell:${reference}`;
+			fragments.push({
+				id,
+				kind: "cell",
+				text,
+				readOnly: formula || multiRun,
+				location: `${entry.name}!${reference}`
+			});
+			ranges.set(id, {
+				entry: entry.name,
+				start: match.index,
+				end: match.index + match[0].length,
+				attributes
+			});
+		}
+	}
+	return {
+		archive,
+		document: parsedDocument("xlsx", source, fragments, { worksheets: worksheets.length }),
+		ranges
+	};
+}
+async function parseXlsx(source) {
+	return (await stateOf(source)).document;
+}
+async function preflightXlsx(source, operations) {
+	return preflight((await stateOf(source)).document, operations, (operation) => /^\s*=/.test(operation.replacement) ? {
+		code: "formula-input",
+		message: "Formula input is not accepted.",
+		fragmentId: operation.fragmentId
+	} : void 0);
+}
+async function serializeXlsx(source, operations, acceptedReportDigest) {
+	const state = await stateOf(source);
+	const report = await preflightXlsx(source, operations);
+	requireAccepted(report, acceptedReportDigest);
+	const byEntry = /* @__PURE__ */ new Map();
+	for (const operation of report.operations) {
+		const range = state.ranges.get(operation.fragmentId);
+		if (!range) throw new Error("XLSX cell changed during serialization.");
+		const list = byEntry.get(range.entry) ?? [];
+		list.push({
+			...range,
+			replacement: operation.replacement
+		});
+		byEntry.set(range.entry, list);
+	}
+	const replacements = /* @__PURE__ */ new Map();
+	for (const [entryName, edits] of byEntry) {
+		let xml = state.archive.byName.get(entryName)?.data.toString("utf8") ?? "";
+		for (const edit of edits.sort((left, right) => right.start - left.start)) {
+			const cell = `<c${edit.attributes.replace(/\st=["'][^"']*["']/, "") + " t=\"inlineStr\""}><is><t>${encodeXmlText(edit.replacement)}</t></is></c>`;
+			xml = replaceRange(xml, edit.start, edit.end, cell);
+		}
+		replacements.set(entryName, Buffer.from(xml));
+	}
+	const bytes = await writeOoxmlArchive(state.archive, replacements);
+	return {
+		bytes,
+		operationLog: report.operations,
+		manifest: (await parseXlsx(bytes)).manifest
+	};
+}
+//#endregion
+//#region src/services/structuredDocuments/index.ts
+async function parseStructuredDocument(format, bytes, csvDialect) {
+	if (format === "markdown-slides") return parseMarkdownSlides(bytes);
+	if (format === "csv") return parseCsv(bytes, csvDialect);
+	if (format === "pptx") return await parsePptx(bytes);
+	return await parseXlsx(bytes);
+}
+async function preflightStructuredDocument(format, bytes, operations, csvDialect) {
+	if (format === "markdown-slides") return preflightMarkdownSlides(bytes, operations);
+	if (format === "csv") return preflightCsv(bytes, operations, csvDialect);
+	if (format === "pptx") return await preflightPptx(bytes, operations);
+	return await preflightXlsx(bytes, operations);
+}
+async function serializeStructuredDocument(format, bytes, operations, acceptedReportDigest, csvDialect) {
+	if (format === "markdown-slides") return serializeMarkdownSlides(bytes, operations, acceptedReportDigest);
+	if (format === "csv") return serializeCsv(bytes, operations, acceptedReportDigest, csvDialect);
+	if (format === "pptx") return await serializePptx(bytes, operations, acceptedReportDigest);
+	return await serializeXlsx(bytes, operations, acceptedReportDigest);
+}
+//#endregion
+export { AUTHOR_OWNER_LEASE_MS as _, preflightXlsx as a, createAuthorBridgeState as b, preflightPptx as c, parseMarkdownSlides as d, preflightMarkdownSlides as f, serializeCsv as g, preflightCsv as h, parseXlsx as i, serializePptx as l, parseCsv as m, preflightStructuredDocument as n, serializeXlsx as o, serializeMarkdownSlides as p, serializeStructuredDocument as r, parsePptx as s, parseStructuredDocument as t, readOoxmlArchive as u, AUTHOR_REQUEST_TIMEOUT_MS as v, AuthorBridgeError as y };
+
+//# sourceMappingURL=structuredDocuments-CzMYD0Bq.mjs.map