@office-kit/pptx-editor 0.1.0 → 0.2.0

package/dist/agent-tools-bDB2Jq41.d.ts

@@ -0,0 +1,28 @@
+import { PresentationData, SlideShapeData } from "@office-kit/pptx";
+
+//#region src/core/agent-tools.d.ts
+/** A JSON value: what a tool takes as input and gives back. */
+type JsonValue = null | boolean | number | string | readonly JsonValue[] | {
+  readonly [key: string]: JsonValue;
+};
+/** A JSON Schema (draft 2020-12) object. */
+type JsonSchema = {
+  readonly [key: string]: JsonValue;
+};
+/**
+* A tool definition in the shape model APIs take: Anthropic's `tools` entries
+* as they are; for OpenAI, `{ type: 'function', function: { name, description,
+* parameters: input_schema } }`.
+*/
+interface EditorTool {
+  /** The `@office-kit/pptx` export it calls, or a read tool's name. */
+  readonly name: string;
+  readonly description: string;
+  /** The input, as a self-contained JSON Schema (draft 2020-12) object. */
+  readonly input_schema: JsonSchema & {
+    readonly type: "object";
+  };
+}
+//#endregion
+export { JsonSchema as n, JsonValue as r, EditorTool as t };
+//# sourceMappingURL=agent-tools-bDB2Jq41.d.ts.map

package/dist/{deck-merge-XZc2oNxd.js → deck-merge-Dj_XHQQM.js}

@@ -1,4 +1,4 @@
-import { strFromU8, strToU8, unzipSync, zipSync } from "fflate";
+import { Inflate, inflateSync, strFromU8, strToU8, zipSync } from "fflate";
 //#region ../../src/internal/opc/zip.ts
 const STORE_BY_EXTENSION = new Set([
 	"png",
@@ -36,20 +36,173 @@ const extensionOf = (name) => {
 * negligible savings.
 */
 const shouldStore = (name) => STORE_BY_EXTENSION.has(extensionOf(name));
+const SIG_LOCAL_HEADER = 67324752;
+const SIG_CENTRAL_HEADER = 33639248;
+const SIG_EOCD = 101010256;
+const SIG_ZIP64_EOCD = 101075792;
+const SIG_ZIP64_LOCATOR = 117853008;
+const EOCD_SIZE = 22;
+const MAX_COMMENT_LENGTH = 65535;
+const ZIP64_LOCATOR_SIZE = 20;
+const ZIP64_EOCD_MIN_SIZE = 56;
+const CENTRAL_HEADER_SIZE = 46;
+const LOCAL_HEADER_SIZE = 30;
+const ZIP64_EXTRA_ID = 1;
+const ZIP64_SENTINEL_32 = 4294967295;
+const FLAG_UTF8 = 2048;
+const METHOD_STORE = 0;
+const METHOD_DEFLATE = 8;
+const INFLATE_CHUNK_SIZE = 16 * 1024;
+const MAX_DEFLATE_RATIO = 1032;
+const DEFLATE_RATIO_SLACK = 1024;
+const invalid = (reason) => /* @__PURE__ */ new Error(`invalid ZIP: ${reason}`);
+const u16 = (d, at) => d[at] | d[at + 1] << 8;
+const u32 = (d, at) => (d[at] | d[at + 1] << 8 | d[at + 2] << 16 | d[at + 3] << 24) >>> 0;
+const u64 = (d, at) => {
+	const value = u32(d, at) + u32(d, at + 4) * 2 ** 32;
+	if (!Number.isSafeInteger(value)) throw invalid("ZIP64 value out of range");
+	return value;
+};
+const requireRange = (d, at, length, what) => {
+	if (at < 0 || length < 0 || at + length > d.length) throw invalid(`${what} is out of bounds`);
+};
+const findEocd = (d) => {
+	const lowest = Math.max(0, d.length - EOCD_SIZE - MAX_COMMENT_LENGTH);
+	for (let at = d.length - EOCD_SIZE; at >= lowest; at--) if (u32(d, at) === SIG_EOCD) return at;
+	throw invalid("end of central directory not found");
+};
+const readCentralDirectoryLocation = (d) => {
+	const eocd = findEocd(d);
+	const locator = eocd - ZIP64_LOCATOR_SIZE;
+	if (locator >= 0 && u32(d, locator) === SIG_ZIP64_LOCATOR) {
+		const zip64Eocd = u32(d, locator + 8) + u32(d, locator + 12) * 2 ** 32;
+		if (zip64Eocd + ZIP64_EOCD_MIN_SIZE <= d.length && u32(d, zip64Eocd) === SIG_ZIP64_EOCD) return {
+			count: u64(d, zip64Eocd + 32),
+			offset: u64(d, zip64Eocd + 48)
+		};
+	}
+	return {
+		count: u16(d, eocd + 10),
+		offset: u32(d, eocd + 16)
+	};
+};
+const resolveZip64Sizes = (d, extraStart, extraEnd, sizes) => {
+	const needUncompressed = sizes.uncompressedSize === ZIP64_SENTINEL_32;
+	const needCompressed = sizes.compressedSize === ZIP64_SENTINEL_32;
+	const needOffset = sizes.localHeaderOffset === ZIP64_SENTINEL_32;
+	if (!needUncompressed && !needCompressed && !needOffset) return sizes;
+	for (let at = extraStart; at + 4 <= extraEnd; at += 4 + u16(d, at + 2)) {
+		if (u16(d, at) !== ZIP64_EXTRA_ID) continue;
+		const fieldEnd = at + 4 + u16(d, at + 2);
+		if (fieldEnd > extraEnd) break;
+		let cursor = at + 4;
+		const next = () => {
+			if (cursor + 8 > fieldEnd) throw invalid("ZIP64 extra field is truncated");
+			const value = u64(d, cursor);
+			cursor += 8;
+			return value;
+		};
+		return {
+			uncompressedSize: needUncompressed ? next() : sizes.uncompressedSize,
+			compressedSize: needCompressed ? next() : sizes.compressedSize,
+			localHeaderOffset: needOffset ? next() : sizes.localHeaderOffset
+		};
+	}
+	throw invalid("ZIP64 sizes without a ZIP64 extra field");
+};
+const overflowError = (name, declaredSize) => invalid(`entry "${name}" inflates beyond its declared size of ${declaredSize} bytes`);
+const corruptError = (name, error) => {
+	return invalid(`entry "${name}" is not valid DEFLATE data: ${error instanceof Error ? error.message : String(error)}`);
+};
+const inflateSmallEntry = (compressed, declaredSize, name) => {
+	if (compressed.length === 0) return new Uint8Array(0);
+	let out;
+	try {
+		out = inflateSync(compressed, { out: new Uint8Array(declaredSize + 1) });
+	} catch (error) {
+		if (error instanceof RangeError) throw overflowError(name, declaredSize);
+		throw corruptError(name, error);
+	}
+	if (out.length > declaredSize) throw overflowError(name, declaredSize);
+	return out;
+};
+const inflateLargeEntry = (compressed, declaredSize, name) => {
+	const out = new Uint8Array(declaredSize);
+	let overflowed = false;
+	let produced = 0;
+	const inflater = new Inflate((chunk) => {
+		if (produced + chunk.length > declaredSize) {
+			overflowed = true;
+			throw overflowError(name, declaredSize);
+		}
+		out.set(chunk, produced);
+		produced += chunk.length;
+	});
+	for (let at = 0; at < compressed.length; at += INFLATE_CHUNK_SIZE) {
+		const end = Math.min(at + INFLATE_CHUNK_SIZE, compressed.length);
+		try {
+			inflater.push(compressed.subarray(at, end), end === compressed.length);
+		} catch (error) {
+			if (overflowed) throw error;
+			throw corruptError(name, error);
+		}
+	}
+	return out.subarray(0, produced);
+};
+const inflateEntry = (compressed, declaredSize, name) => {
+	if (declaredSize > compressed.length * MAX_DEFLATE_RATIO + DEFLATE_RATIO_SLACK) throw invalid(`entry "${name}" declares ${declaredSize} bytes, more than ${compressed.length} compressed bytes can hold`);
+	const out = compressed.length <= INFLATE_CHUNK_SIZE ? inflateSmallEntry(compressed, declaredSize, name) : inflateLargeEntry(compressed, declaredSize, name);
+	if (out.length !== declaredSize) throw invalid(`entry "${name}" inflates to ${out.length} bytes, not its declared ${declaredSize}`);
+	return out;
+};
 /**
 * Reads a ZIP archive (a `.pptx` file is a ZIP) and returns entries in
-* central-directory order. Throws if `input` is not a valid ZIP.
+* central-directory order. Throws if `input` is not a valid ZIP, if two
+* entries share a name, or if an entry's data does not match the size its
+* central-directory record declares.
 */
 const readZip = (input) => {
-	const obj = unzipSync(input);
+	const { offset, count } = readCentralDirectoryLocation(input);
 	const entries = [];
-	for (const name of Object.keys(obj)) {
-		const data = obj[name];
-		if (data === void 0) continue;
-		entries.push({
+	const seen = /* @__PURE__ */ new Set();
+	let cursor = offset;
+	for (let i = 0; i < count; i++) {
+		requireRange(input, cursor, CENTRAL_HEADER_SIZE, "central directory");
+		if (u32(input, cursor) !== SIG_CENTRAL_HEADER) throw invalid("bad central directory signature");
+		const flags = u16(input, cursor + 8);
+		const method = u16(input, cursor + 10);
+		const nameLength = u16(input, cursor + 28);
+		const extraLength = u16(input, cursor + 30);
+		const commentLength = u16(input, cursor + 32);
+		const nameStart = cursor + CENTRAL_HEADER_SIZE;
+		const extraStart = nameStart + nameLength;
+		const recordEnd = extraStart + extraLength + commentLength;
+		requireRange(input, cursor, recordEnd - cursor, "central directory");
+		const name = strFromU8(input.subarray(nameStart, extraStart), (flags & FLAG_UTF8) === 0);
+		const { compressedSize, uncompressedSize, localHeaderOffset } = resolveZip64Sizes(input, extraStart, extraStart + extraLength, {
+			compressedSize: u32(input, cursor + 20),
+			uncompressedSize: u32(input, cursor + 24),
+			localHeaderOffset: u32(input, cursor + 42)
+		});
+		cursor = recordEnd;
+		if (seen.has(name)) throw invalid(`duplicate entry "${name}"`);
+		seen.add(name);
+		requireRange(input, localHeaderOffset, LOCAL_HEADER_SIZE, `local header of "${name}"`);
+		if (u32(input, localHeaderOffset) !== SIG_LOCAL_HEADER) throw invalid(`bad local header signature for "${name}"`);
+		const dataStart = localHeaderOffset + LOCAL_HEADER_SIZE + u16(input, localHeaderOffset + 26) + u16(input, localHeaderOffset + 28);
+		requireRange(input, dataStart, compressedSize, `data of "${name}"`);
+		const compressed = input.subarray(dataStart, dataStart + compressedSize);
+		if (method === METHOD_STORE) {
+			if (compressedSize !== uncompressedSize) throw invalid(`stored entry "${name}" has mismatched sizes`);
+			entries.push({
+				name,
+				data: compressed.slice()
+			});
+		} else if (method === METHOD_DEFLATE) entries.push({
 			name,
-			data
+			data: inflateEntry(compressed, uncompressedSize, name)
 		});
+		else throw invalid(`entry "${name}" uses unsupported compression method ${method}`);
 	}
 	return { entries };
 };
@@ -102,7 +255,7 @@ const dirname = (name) => {
 };
 /**
 * Resolves a relationship Target (which may be relative) against a base part
-* name. Returns the absolute part name (always starts with `/`).
+* name, or against `PACKAGE_ROOT` for a package-root relationship. Returns the absolute part name (always starts with `/`).
 *
 * `target` is from a Relationship element's `Target` attribute when
 * `TargetMode="Internal"`. External targets must not be passed through here.
@@ -110,7 +263,7 @@ const dirname = (name) => {
 const resolveTarget = (basePart, target) => {
 	if (target === "") throw new Error("relationship target is empty");
 	if (target.startsWith("/")) return partName(target);
-	const baseDir = dirname(basePart);
+	const baseDir = basePart === "/" ? "/" : dirname(basePart);
 	const stack = baseDir === "/" ? [] : baseDir.slice(1).split("/");
 	for (const segment of target.split("/")) {
 		if (segment === "" || segment === ".") continue;
@@ -561,13 +714,46 @@ const rawName = (prefix, localName) => prefix === "" ? localName : `${prefix}:${
 const writeAttr = (a) => {
 	return ` ${rawName(a.name.prefix, a.name.localName)}="${escapeAttr(a.value)}"`;
 };
-const writeElement = (e, parts) => {
+const DOCUMENT_SCOPE = new Map([["xml", NS.xml]]);
+const missingDecls = (e, scope) => {
+	let added = null;
+	for (let i = -1; i < e.attrs.length; i++) {
+		const name = i < 0 ? e.name : e.attrs[i].name;
+		if (i >= 0 && name.prefix === "") continue;
+		const own = e.prefixDecls.get(name.prefix) ?? added?.get(name.prefix);
+		if (own === void 0) {
+			if ((scope.get(name.prefix) ?? "") === name.namespaceURI) continue;
+			added ??= /* @__PURE__ */ new Map();
+			added.set(name.prefix, name.namespaceURI);
+		} else if (own !== name.namespaceURI) throw new Error(`prefix "${name.prefix}" on <${rawName(e.name.prefix, e.name.localName)}> is bound to both ${own} and ${name.namespaceURI}`);
+	}
+	return added;
+};
+const writeDecls = (decls, parts) => {
+	for (const [prefix, uri] of decls) {
+		const decl = prefix === "" ? "xmlns" : `xmlns:${prefix}`;
+		parts.push(` ${decl}="${escapeAttr(uri)}"`);
+	}
+};
+const withDecls = (scope, decls) => {
+	if (decls.size === 0) return scope;
+	const next = new Map(scope);
+	for (const [prefix, uri] of decls) next.set(prefix, uri);
+	return next;
+};
+const writeElement = (e, parts, scope) => {
 	const name = rawName(e.name.prefix, e.name.localName);
 	parts.push("<");
 	parts.push(name);
-	for (const [prefix, uri] of e.prefixDecls) {
-		const decl = prefix === "" ? "xmlns" : `xmlns:${prefix}`;
-		parts.push(` ${decl}="${escapeAttr(uri)}"`);
+	writeDecls(e.prefixDecls, parts);
+	let childScope = scope;
+	if (scope) {
+		const added = missingDecls(e, scope);
+		childScope = withDecls(scope, e.prefixDecls);
+		if (added) {
+			writeDecls(added, parts);
+			childScope = withDecls(childScope, added);
+		}
 	}
 	for (const a of e.attrs) parts.push(writeAttr(a));
 	if (e.children.length === 0) {
@@ -575,15 +761,15 @@ const writeElement = (e, parts) => {
 		return;
 	}
 	parts.push(">");
-	for (const child of e.children) writeNode(child, parts);
+	for (const child of e.children) writeNode(child, parts, childScope);
 	parts.push("</");
 	parts.push(name);
 	parts.push(">");
 };
-const writeNode = (n, parts) => {
+const writeNode = (n, parts, scope) => {
 	switch (n.kind) {
 		case "element":
-			writeElement(n, parts);
+			writeElement(n, parts, scope);
 			return;
 		case "text":
 			parts.push(escapeText(n.data));
@@ -609,6 +795,7 @@ const writeNode = (n, parts) => {
 			return;
 	}
 };
+const XML_DECLARATION = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
 const writeDeclaration = (doc, parts) => {
 	if (!doc.decl) return;
 	parts.push("<?xml version=\"");
@@ -629,15 +816,15 @@ const writeDeclaration = (doc, parts) => {
 const serializeXml = (doc, options = {}) => {
 	const parts = [];
 	if (doc.decl) writeDeclaration(doc, parts);
-	else if (options.standaloneDeclaration ?? true) parts.push("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>");
-	for (const p of doc.prolog) writeNode(p, parts);
-	writeElement(doc.root, parts);
-	for (const e of doc.epilog) writeNode(e, parts);
+	else if (options.standaloneDeclaration ?? true) parts.push(XML_DECLARATION);
+	for (const p of doc.prolog) writeNode(p, parts, null);
+	writeElement(doc.root, parts, DOCUMENT_SCOPE);
+	for (const e of doc.epilog) writeNode(e, parts, null);
 	return parts.join("");
 };
 const serializeFragment = (element) => {
 	const parts = [];
-	writeElement(element, parts);
+	writeElement(element, parts, null);
 	return parts.join("");
 };
 //#endregion
@@ -1301,4 +1488,4 @@ function describeConflict(conflict) {
 //#endregion
 export { sameDeck as i, describeConflict as n, mergeDecks as r, comparablePart as t };
 
-//# sourceMappingURL=deck-merge-XZc2oNxd.js.map
+//# sourceMappingURL=deck-merge-Dj_XHQQM.js.map