@office-kit/pptx-editor 0.0.0-stage → 0.1.0

package/dist/deck-merge-XZc2oNxd.js

@@ -0,0 +1,1304 @@
+import { strFromU8, strToU8, unzipSync, zipSync } from "fflate";
+//#region ../../src/internal/opc/zip.ts
+const STORE_BY_EXTENSION = new Set([
+	"png",
+	"jpg",
+	"jpeg",
+	"gif",
+	"bmp",
+	"tif",
+	"tiff",
+	"webp",
+	"mp3",
+	"mp4",
+	"m4a",
+	"m4v",
+	"wav",
+	"wmv",
+	"mov",
+	"avi",
+	"webm",
+	"ogg",
+	"wma",
+	"pdf",
+	"zip",
+	"gz",
+	"7z",
+	"rar"
+]);
+const extensionOf = (name) => {
+	const dot = name.lastIndexOf(".");
+	return dot < 0 ? "" : name.slice(dot + 1).toLowerCase();
+};
+/**
+* Returns true if the entry should be stored uncompressed. PPTX writers
+* conventionally STORE already-compressed payloads to avoid wasting CPU on
+* negligible savings.
+*/
+const shouldStore = (name) => STORE_BY_EXTENSION.has(extensionOf(name));
+/**
+* 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.
+*/
+const readZip = (input) => {
+	const obj = unzipSync(input);
+	const entries = [];
+	for (const name of Object.keys(obj)) {
+		const data = obj[name];
+		if (data === void 0) continue;
+		entries.push({
+			name,
+			data
+		});
+	}
+	return { entries };
+};
+const writeZip = (entries, options = {}) => {
+	const defaultLevel = options.level ?? 6;
+	const obj = {};
+	for (const e of entries) {
+		const level = shouldStore(e.name) ? 0 : defaultLevel;
+		obj[e.name] = [e.data, { level }];
+	}
+	return zipSync(obj);
+};
+//#endregion
+//#region ../../src/internal/opc/part-name.ts
+/**
+* Asserts the given string is a syntactically valid OPC part name and returns
+* it as a branded `PartName`. Throws otherwise.
+*
+* Rules enforced (subset; see ECMA-376 Part 2 §9.1.1.1-9.1.1.6):
+*
+*   - Must start with `/`.
+*   - Must not end with `/`.
+*   - Must not contain `//` (empty segments).
+*   - Each segment must be non-empty and must not be `.` or `..`.
+*/
+const partName = (raw) => {
+	if (raw === "") throw new Error("part name is empty");
+	if (!raw.startsWith("/")) throw new Error(`part name must start with "/": ${raw}`);
+	if (raw.length > 1 && raw.endsWith("/")) throw new Error(`part name must not end with "/": ${raw}`);
+	const segments = raw.slice(1).split("/");
+	for (const s of segments) {
+		if (s === "") throw new Error(`part name contains empty segment: ${raw}`);
+		if (s === "." || s === "..") throw new Error(`part name contains "." or ".." segment: ${raw}`);
+	}
+	return raw;
+};
+/** Convert a part name to the corresponding ZIP entry path (no leading slash). */
+const toZipPath = (name) => name.slice(1);
+/** Convert a ZIP entry path to a part name (adds leading slash). */
+const fromZipPath = (zipPath) => partName(`/${zipPath}`);
+/**
+* Returns the directory portion of a part name (everything before the final
+* `/`). The result keeps the leading slash but has no trailing slash, except
+* for the root which returns `/`.
+*/
+const dirname = (name) => {
+	const idx = name.lastIndexOf("/");
+	if (idx <= 0) return "/";
+	return name.slice(0, idx);
+};
+/**
+* Resolves a relationship Target (which may be relative) against a base part
+* name. 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.
+*/
+const resolveTarget = (basePart, target) => {
+	if (target === "") throw new Error("relationship target is empty");
+	if (target.startsWith("/")) return partName(target);
+	const baseDir = dirname(basePart);
+	const stack = baseDir === "/" ? [] : baseDir.slice(1).split("/");
+	for (const segment of target.split("/")) {
+		if (segment === "" || segment === ".") continue;
+		if (segment === "..") {
+			if (stack.length === 0) throw new Error(`relationship target "${target}" escapes the package root`);
+			stack.pop();
+			continue;
+		}
+		stack.push(segment);
+	}
+	return partName(`/${stack.join("/")}`);
+};
+//#endregion
+//#region ../../src/internal/xml/ast.ts
+const qname = (prefix, localName, namespaceURI) => ({
+	prefix,
+	localName,
+	namespaceURI
+});
+const attr = (name, value) => ({
+	name,
+	value
+});
+const elem = (name, init = {}) => ({
+	kind: "element",
+	name,
+	attrs: init.attrs ?? [],
+	prefixDecls: init.prefixDecls ?? /* @__PURE__ */ new Map(),
+	children: init.children ?? []
+});
+const text = (data) => ({
+	kind: "text",
+	data
+});
+const cdata = (data) => ({
+	kind: "cdata",
+	data
+});
+const comment = (data) => ({
+	kind: "comment",
+	data
+});
+const pi = (target, data) => ({
+	kind: "pi",
+	target,
+	data
+});
+//#endregion
+//#region ../../src/internal/xml/namespaces.ts
+const NS = {
+	contentTypes: "http://schemas.openxmlformats.org/package/2006/content-types",
+	relationships: "http://schemas.openxmlformats.org/package/2006/relationships",
+	officeDocRels: "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+	pml: "http://schemas.openxmlformats.org/presentationml/2006/main",
+	dml: "http://schemas.openxmlformats.org/drawingml/2006/main",
+	diagram: "http://schemas.openxmlformats.org/drawingml/2006/diagram",
+	chart: "http://schemas.openxmlformats.org/drawingml/2006/chart",
+	chartDrawing: "http://schemas.openxmlformats.org/drawingml/2006/chartDrawing",
+	sml: "http://schemas.openxmlformats.org/spreadsheetml/2006/main",
+	wml: "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
+	mc: "http://schemas.openxmlformats.org/markup-compatibility/2006",
+	a14: "http://schemas.microsoft.com/office/drawing/2010/main",
+	a15: "http://schemas.microsoft.com/office/drawing/2012/main",
+	a16: "http://schemas.microsoft.com/office/drawing/2014/main",
+	p14: "http://schemas.microsoft.com/office/powerpoint/2010/main",
+	p15: "http://schemas.microsoft.com/office/powerpoint/2012/main",
+	p16: "http://schemas.microsoft.com/office/powerpoint/2015/main",
+	p159: "http://schemas.microsoft.com/office/powerpoint/2015/09/main",
+	xml: "http://www.w3.org/XML/1998/namespace",
+	xmlns: "http://www.w3.org/2000/xmlns/"
+};
+NS.contentTypes, NS.relationships, NS.officeDocRels, NS.pml, NS.dml, NS.diagram, NS.chart, NS.chartDrawing, NS.sml, NS.wml, NS.mc, NS.a14, NS.a15, NS.a16, NS.p14, NS.p15, NS.p16, NS.p159, NS.xml;
+//#endregion
+//#region ../../src/internal/xml/parse.ts
+var XmlParseError = class extends Error {
+	offset;
+	line;
+	column;
+	constructor(message, offset, line, column) {
+		super(`${message} at line ${line}:${column} (offset ${offset})`);
+		this.offset = offset;
+		this.line = line;
+		this.column = column;
+		this.name = "XmlParseError";
+	}
+};
+const isNameStartChar = (c) => {
+	const code = c.charCodeAt(0);
+	return code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 95 || code === 58;
+};
+const isNameChar = (c) => {
+	if (isNameStartChar(c)) return true;
+	const code = c.charCodeAt(0);
+	return code >= 48 && code <= 57 || code === 45 || code === 46;
+};
+const isWhitespace = (c) => c === " " || c === "	" || c === "\n" || c === "\r";
+const lineColOf = (src, pos) => {
+	let line = 1;
+	let column = 1;
+	for (let i = 0; i < pos && i < src.length; i++) if (src.charCodeAt(i) === 10) {
+		line++;
+		column = 1;
+	} else column++;
+	return {
+		line,
+		column
+	};
+};
+const fail = (cur, message) => {
+	const { line, column } = lineColOf(cur.src, cur.pos);
+	throw new XmlParseError(message, cur.pos, line, column);
+};
+const expect = (cur, literal) => {
+	if (cur.src.slice(cur.pos, cur.pos + literal.length) !== literal) fail(cur, `expected "${literal}"`);
+	cur.pos += literal.length;
+};
+const accept = (cur, literal) => {
+	if (cur.src.slice(cur.pos, cur.pos + literal.length) !== literal) return false;
+	cur.pos += literal.length;
+	return true;
+};
+const skipWhitespace = (cur) => {
+	while (cur.pos < cur.src.length && isWhitespace(cur.src[cur.pos] ?? "")) cur.pos++;
+};
+const readName = (cur) => {
+	const start = cur.pos;
+	if (cur.pos >= cur.src.length || !isNameStartChar(cur.src[cur.pos] ?? "")) fail(cur, "expected XML name");
+	cur.pos++;
+	while (cur.pos < cur.src.length && isNameChar(cur.src[cur.pos] ?? "")) cur.pos++;
+	return cur.src.slice(start, cur.pos);
+};
+const splitQName = (raw) => {
+	const idx = raw.indexOf(":");
+	if (idx < 0) return {
+		prefix: "",
+		localName: raw
+	};
+	return {
+		prefix: raw.slice(0, idx),
+		localName: raw.slice(idx + 1)
+	};
+};
+const decodeRefs = (cur, raw) => {
+	let out = "";
+	let i = 0;
+	while (i < raw.length) {
+		if (raw.charCodeAt(i) !== 38) {
+			out += raw[i];
+			i++;
+			continue;
+		}
+		const end = raw.indexOf(";", i + 1);
+		if (end < 0) {
+			cur.pos -= raw.length - i;
+			fail(cur, "unterminated entity reference");
+		}
+		const ref = raw.slice(i + 1, end);
+		if (ref === "amp") out += "&";
+		else if (ref === "lt") out += "<";
+		else if (ref === "gt") out += ">";
+		else if (ref === "quot") out += "\"";
+		else if (ref === "apos") out += "'";
+		else if (ref.startsWith("#x") || ref.startsWith("#X")) {
+			const code = Number.parseInt(ref.slice(2), 16);
+			if (!Number.isFinite(code)) fail(cur, `invalid hex numeric reference: &${ref};`);
+			out += String.fromCodePoint(code);
+		} else if (ref.startsWith("#")) {
+			const code = Number.parseInt(ref.slice(1), 10);
+			if (!Number.isFinite(code)) fail(cur, `invalid decimal numeric reference: &${ref};`);
+			out += String.fromCodePoint(code);
+		} else fail(cur, `unknown entity reference: &${ref};`);
+		i = end + 1;
+	}
+	return out;
+};
+const readAttrValue = (cur) => {
+	const quote = cur.src[cur.pos];
+	if (quote !== "\"" && quote !== "'") fail(cur, "expected attribute value");
+	cur.pos++;
+	const start = cur.pos;
+	while (cur.pos < cur.src.length && cur.src[cur.pos] !== quote) {
+		if (cur.src.charCodeAt(cur.pos) === 60) fail(cur, "\"<\" is not allowed inside an attribute value");
+		cur.pos++;
+	}
+	if (cur.pos >= cur.src.length) fail(cur, "unterminated attribute value");
+	const raw = cur.src.slice(start, cur.pos);
+	cur.pos++;
+	return decodeRefs(cur, raw);
+};
+const xmlScope = {
+	parent: null,
+	bindings: new Map([["xml", NS.xml]])
+};
+const resolvePrefix = (scope, prefix) => {
+	let cursor = scope;
+	while (cursor) {
+		const found = cursor.bindings.get(prefix);
+		if (found !== void 0) return found;
+		cursor = cursor.parent;
+	}
+	return null;
+};
+const resolveQName = (cur, scope, raw, isAttribute) => {
+	const { prefix, localName } = splitQName(raw);
+	let namespaceURI = "";
+	if (prefix !== "") {
+		const found = resolvePrefix(scope, prefix);
+		if (found === null) return fail(cur, `unbound namespace prefix "${prefix}"`);
+		namespaceURI = found;
+	} else if (!isAttribute) namespaceURI = resolvePrefix(scope, "") ?? "";
+	return qname(prefix, localName, namespaceURI);
+};
+const parseDeclaration = (cur) => {
+	if (!accept(cur, "<?xml")) return null;
+	const end = cur.src.indexOf("?>", cur.pos);
+	if (end < 0) fail(cur, "unterminated XML declaration");
+	const body = cur.src.slice(cur.pos, end);
+	cur.pos = end + 2;
+	const get = (key) => {
+		return body.match(new RegExp(`\\b${key}\\s*=\\s*(['"])(.*?)\\1`))?.[2];
+	};
+	const version = get("version");
+	if (version === void 0) return fail(cur, "XML declaration missing \"version\"");
+	const encoding = get("encoding");
+	const standaloneRaw = get("standalone");
+	let standalone;
+	if (standaloneRaw === "yes" || standaloneRaw === "no") standalone = standaloneRaw;
+	else if (standaloneRaw !== void 0) return fail(cur, `invalid standalone value "${standaloneRaw}"`);
+	return {
+		version,
+		...encoding !== void 0 ? { encoding } : {},
+		...standalone !== void 0 ? { standalone } : {}
+	};
+};
+const parseComment = (cur) => {
+	expect(cur, "<!--");
+	const end = cur.src.indexOf("-->", cur.pos);
+	if (end < 0) fail(cur, "unterminated comment");
+	const data = cur.src.slice(cur.pos, end);
+	if (data.includes("--")) fail(cur, "\"--\" is not allowed inside an XML comment");
+	cur.pos = end + 3;
+	return comment(data);
+};
+const parsePI = (cur) => {
+	expect(cur, "<?");
+	const targetStart = cur.pos;
+	while (cur.pos < cur.src.length && !isWhitespace(cur.src[cur.pos] ?? "") && cur.src.slice(cur.pos, cur.pos + 2) !== "?>") cur.pos++;
+	const target = cur.src.slice(targetStart, cur.pos);
+	if (target.toLowerCase() === "xml") fail(cur, "PI target may not be \"xml\"");
+	skipWhitespace(cur);
+	const end = cur.src.indexOf("?>", cur.pos);
+	if (end < 0) fail(cur, "unterminated processing instruction");
+	const data = cur.src.slice(cur.pos, end);
+	cur.pos = end + 2;
+	return pi(target, data);
+};
+const parseCData = (cur) => {
+	expect(cur, "<![CDATA[");
+	const end = cur.src.indexOf("]]>", cur.pos);
+	if (end < 0) fail(cur, "unterminated CDATA section");
+	const data = cur.src.slice(cur.pos, end);
+	cur.pos = end + 3;
+	return cdata(data);
+};
+const skipDoctype = (cur) => {
+	expect(cur, "<!DOCTYPE");
+	while (cur.pos < cur.src.length) {
+		const c = cur.src[cur.pos];
+		if (c === "[") fail(cur, "DOCTYPE internal subset is not supported");
+		if (c === ">") {
+			cur.pos++;
+			return;
+		}
+		cur.pos++;
+	}
+	fail(cur, "unterminated DOCTYPE");
+};
+const parseStartOrEmptyTag = (cur, parentScope) => {
+	expect(cur, "<");
+	const rawName = readName(cur);
+	const ownAttrs = [];
+	const prefixDecls = /* @__PURE__ */ new Map();
+	let empty = false;
+	while (true) {
+		const wsStart = cur.pos;
+		skipWhitespace(cur);
+		if (cur.pos === wsStart && cur.src[cur.pos] !== "/" && cur.src[cur.pos] !== ">") fail(cur, "expected whitespace before next attribute");
+		if (accept(cur, "/>")) {
+			empty = true;
+			break;
+		}
+		if (accept(cur, ">")) break;
+		const attrRawName = readName(cur);
+		skipWhitespace(cur);
+		expect(cur, "=");
+		skipWhitespace(cur);
+		const value = readAttrValue(cur);
+		if (attrRawName === "xmlns") prefixDecls.set("", value);
+		else if (attrRawName.startsWith("xmlns:")) {
+			const p = attrRawName.slice(6);
+			if (p === "") fail(cur, "empty namespace prefix in xmlns:");
+			if (p === "xmlns") fail(cur, "prefix \"xmlns\" cannot be redeclared");
+			prefixDecls.set(p, value);
+		} else ownAttrs.push({
+			raw: attrRawName,
+			rawValue: value
+		});
+	}
+	const scope = {
+		parent: parentScope,
+		bindings: new Map(prefixDecls)
+	};
+	return {
+		element: elem(resolveQName(cur, scope, rawName, false), {
+			attrs: ownAttrs.map(({ raw, rawValue }) => attr(resolveQName(cur, scope, raw, true), rawValue)),
+			prefixDecls,
+			children: []
+		}),
+		scope,
+		empty
+	};
+};
+const parseEndTag = (cur) => {
+	expect(cur, "</");
+	const name = readName(cur);
+	skipWhitespace(cur);
+	expect(cur, ">");
+	return name;
+};
+const parseTextContent = (cur) => {
+	const start = cur.pos;
+	while (cur.pos < cur.src.length && cur.src.charCodeAt(cur.pos) !== 60) cur.pos++;
+	return decodeRefs(cur, cur.src.slice(start, cur.pos));
+};
+const parseElement = (cur, parentScope) => {
+	const { element, scope, empty } = parseStartOrEmptyTag(cur, parentScope);
+	if (empty) return element;
+	while (cur.pos < cur.src.length) if (cur.src.charCodeAt(cur.pos) === 60) {
+		if (cur.src.startsWith("</", cur.pos)) {
+			const closingRaw = parseEndTag(cur);
+			const expectedRaw = element.name.prefix === "" ? element.name.localName : `${element.name.prefix}:${element.name.localName}`;
+			if (closingRaw !== expectedRaw) fail(cur, `mismatched closing tag: expected </${expectedRaw}>, got </${closingRaw}>`);
+			return element;
+		}
+		if (cur.src.startsWith("<![CDATA[", cur.pos)) element.children.push(parseCData(cur));
+		else if (cur.src.startsWith("<!--", cur.pos)) element.children.push(parseComment(cur));
+		else if (cur.src.startsWith("<?", cur.pos)) element.children.push(parsePI(cur));
+		else element.children.push(parseElement(cur, scope));
+	} else {
+		const t = parseTextContent(cur);
+		if (t.length > 0) element.children.push(text(t));
+	}
+	return fail(cur, `unterminated element <${element.name.localName}>`);
+};
+const parseXml = (src) => {
+	const cur = {
+		src: (src.charCodeAt(0) === 65279 ? src.slice(1) : src).replace(/\r\n?/g, "\n"),
+		pos: 0
+	};
+	const decl = parseDeclaration(cur);
+	skipWhitespace(cur);
+	const prolog = [];
+	while (cur.pos < cur.src.length) {
+		skipWhitespace(cur);
+		if (cur.src.startsWith("<!--", cur.pos)) prolog.push(parseComment(cur));
+		else if (cur.src.startsWith("<!DOCTYPE", cur.pos)) skipDoctype(cur);
+		else if (cur.src.startsWith("<?", cur.pos)) prolog.push(parsePI(cur));
+		else break;
+	}
+	skipWhitespace(cur);
+	if (cur.pos >= cur.src.length || cur.src[cur.pos] !== "<") fail(cur, "expected root element");
+	const root = parseElement(cur, xmlScope);
+	const epilog = [];
+	while (cur.pos < cur.src.length) {
+		skipWhitespace(cur);
+		if (cur.pos >= cur.src.length) break;
+		if (cur.src.startsWith("<!--", cur.pos)) epilog.push(parseComment(cur));
+		else if (cur.src.startsWith("<?", cur.pos)) epilog.push(parsePI(cur));
+		else fail(cur, "unexpected content after root element");
+	}
+	return {
+		kind: "document",
+		decl,
+		prolog,
+		root,
+		epilog
+	};
+};
+//#endregion
+//#region ../../src/internal/xml/query.ts
+const isElement = (n) => n.kind === "element";
+/**
+* Walks the element tree depth-first, yielding every element including the
+* root. The visitor returns `false` to skip descending into the current
+* element's children. Returning nothing (or `true`) descends as usual.
+*/
+const walkElements = (root, visit) => {
+	const stack = [root];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		if (!node) continue;
+		if (visit(node) === false) continue;
+		for (let i = node.children.length - 1; i >= 0; i--) {
+			const c = node.children[i];
+			if (c && isElement(c)) stack.push(c);
+		}
+	}
+};
+//#endregion
+//#region ../../src/internal/xml/serialize.ts
+const rejectForbiddenChar = (c) => {
+	const control = c < 32 && c !== 9 && c !== 10 && c !== 13;
+	if (control || c >= 55296 && c <= 57343 || c === 65534 || c === 65535) {
+		const hex = c.toString(16).toUpperCase().padStart(4, "0");
+		throw new Error(`XML-illegal ${control ? "control character" : "character"} U+${hex} in text; strip ${control ? "control" : "illegal"} characters before authoring`);
+	}
+};
+const escapeAttr = (s) => {
+	let out = "";
+	for (const char of s) {
+		const c = char.codePointAt(0);
+		rejectForbiddenChar(c);
+		if (c === 38) out += "&amp;";
+		else if (c === 60) out += "&lt;";
+		else if (c === 62) out += "&gt;";
+		else if (c === 34) out += "&quot;";
+		else if (c === 9) out += "&#9;";
+		else if (c === 10) out += "&#10;";
+		else if (c === 13) out += "&#13;";
+		else out += char;
+	}
+	return out;
+};
+const escapeText = (s) => {
+	let out = "";
+	for (const char of s) {
+		const c = char.codePointAt(0);
+		rejectForbiddenChar(c);
+		if (c === 38) out += "&amp;";
+		else if (c === 60) out += "&lt;";
+		else if (c === 62) out += "&gt;";
+		else if (c === 13) out += "&#13;";
+		else out += char;
+	}
+	return out;
+};
+const rawName = (prefix, localName) => prefix === "" ? localName : `${prefix}:${localName}`;
+const writeAttr = (a) => {
+	return ` ${rawName(a.name.prefix, a.name.localName)}="${escapeAttr(a.value)}"`;
+};
+const writeElement = (e, parts) => {
+	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)}"`);
+	}
+	for (const a of e.attrs) parts.push(writeAttr(a));
+	if (e.children.length === 0) {
+		parts.push("/>");
+		return;
+	}
+	parts.push(">");
+	for (const child of e.children) writeNode(child, parts);
+	parts.push("</");
+	parts.push(name);
+	parts.push(">");
+};
+const writeNode = (n, parts) => {
+	switch (n.kind) {
+		case "element":
+			writeElement(n, parts);
+			return;
+		case "text":
+			parts.push(escapeText(n.data));
+			return;
+		case "cdata":
+			parts.push("<![CDATA[");
+			parts.push(n.data.split("]]>").join("]]]]><![CDATA[>"));
+			parts.push("]]>");
+			return;
+		case "comment":
+			parts.push("<!--");
+			parts.push(n.data);
+			parts.push("-->");
+			return;
+		case "pi":
+			parts.push("<?");
+			parts.push(n.target);
+			if (n.data.length > 0) {
+				parts.push(" ");
+				parts.push(n.data);
+			}
+			parts.push("?>");
+			return;
+	}
+};
+const writeDeclaration = (doc, parts) => {
+	if (!doc.decl) return;
+	parts.push("<?xml version=\"");
+	parts.push(escapeAttr(doc.decl.version));
+	parts.push("\"");
+	if (doc.decl.encoding !== void 0) {
+		parts.push(" encoding=\"");
+		parts.push(escapeAttr(doc.decl.encoding));
+		parts.push("\"");
+	}
+	if (doc.decl.standalone !== void 0) {
+		parts.push(" standalone=\"");
+		parts.push(doc.decl.standalone);
+		parts.push("\"");
+	}
+	parts.push("?>");
+};
+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);
+	return parts.join("");
+};
+const serializeFragment = (element) => {
+	const parts = [];
+	writeElement(element, parts);
+	return parts.join("");
+};
+//#endregion
+//#region ../../src/internal/opc/content-types.ts
+const CT_NS = NS.contentTypes;
+const NAME_TYPES = qname("", "Types", CT_NS);
+const NAME_DEFAULT = qname("", "Default", CT_NS);
+const NAME_OVERRIDE = qname("", "Override", CT_NS);
+const ATTR_EXTENSION = qname("", "Extension", "");
+const ATTR_CONTENT_TYPE = qname("", "ContentType", "");
+const ATTR_PART_NAME = qname("", "PartName", "");
+const getAttrValueRaw = (e, local) => {
+	for (const a of e.attrs) if (a.name.localName === local) return a.value;
+	return null;
+};
+const parseContentTypes = (xml) => {
+	const doc = parseXml(xml);
+	if (doc.root.name.namespaceURI !== CT_NS || doc.root.name.localName !== "Types") throw new Error(`expected root <Types xmlns="${CT_NS}">, got <${doc.root.name.localName}>`);
+	const defaults = [];
+	const overrides = [];
+	for (const child of doc.root.children) {
+		if (child.kind !== "element") continue;
+		if (child.name.namespaceURI !== CT_NS) continue;
+		if (child.name.localName === "Default") {
+			const ext = getAttrValueRaw(child, "Extension");
+			const ct = getAttrValueRaw(child, "ContentType");
+			if (ext === null || ct === null) throw new Error("Content_Types Default missing Extension or ContentType");
+			defaults.push({
+				extension: ext.toLowerCase(),
+				contentType: ct
+			});
+		} else if (child.name.localName === "Override") {
+			const pn = getAttrValueRaw(child, "PartName");
+			const ct = getAttrValueRaw(child, "ContentType");
+			if (pn === null || ct === null) throw new Error("Content_Types Override missing PartName or ContentType");
+			overrides.push({
+				partName: partName(pn),
+				contentType: ct
+			});
+		}
+	}
+	return {
+		defaults,
+		overrides
+	};
+};
+const serializeContentTypes = (ct) => {
+	const children = [...ct.defaults.map((d) => elem(NAME_DEFAULT, { attrs: [{
+		name: ATTR_EXTENSION,
+		value: d.extension
+	}, {
+		name: ATTR_CONTENT_TYPE,
+		value: d.contentType
+	}] })), ...ct.overrides.map((o) => elem(NAME_OVERRIDE, { attrs: [{
+		name: ATTR_PART_NAME,
+		value: o.partName
+	}, {
+		name: ATTR_CONTENT_TYPE,
+		value: o.contentType
+	}] }))];
+	return serializeXml({
+		kind: "document",
+		decl: {
+			version: "1.0",
+			encoding: "UTF-8",
+			standalone: "yes"
+		},
+		prolog: [],
+		root: elem(NAME_TYPES, {
+			prefixDecls: new Map([["", CT_NS]]),
+			children
+		}),
+		epilog: []
+	});
+};
+//#endregion
+//#region ../../src/internal/opc/rels.ts
+const REL_NS = NS.relationships;
+const NAME_RELATIONSHIPS = qname("", "Relationships", REL_NS);
+const NAME_RELATIONSHIP = qname("", "Relationship", REL_NS);
+const ATTR_ID = qname("", "Id", "");
+const ATTR_TYPE = qname("", "Type", "");
+const ATTR_TARGET = qname("", "Target", "");
+const ATTR_TARGET_MODE = qname("", "TargetMode", "");
+const findAttr = (e, local) => {
+	for (const a of e.attrs) if (a.name.localName === local) return a.value;
+	return null;
+};
+const parseRels = (xml) => {
+	const doc = parseXml(xml);
+	if (doc.root.name.namespaceURI !== REL_NS || doc.root.name.localName !== "Relationships") throw new Error(`expected root <Relationships xmlns="${REL_NS}">, got <${doc.root.name.localName}>`);
+	const items = [];
+	for (const child of doc.root.children) {
+		if (child.kind !== "element") continue;
+		if (child.name.namespaceURI !== REL_NS || child.name.localName !== "Relationship") continue;
+		const id = findAttr(child, "Id");
+		const type = findAttr(child, "Type");
+		const target = findAttr(child, "Target");
+		if (id === null || type === null || target === null) throw new Error("Relationship missing Id, Type, or Target");
+		const modeRaw = findAttr(child, "TargetMode");
+		let targetMode = "Internal";
+		if (modeRaw !== null) {
+			if (modeRaw !== "Internal" && modeRaw !== "External") throw new Error(`invalid TargetMode "${modeRaw}"`);
+			targetMode = modeRaw;
+		}
+		items.push({
+			id,
+			type,
+			target,
+			targetMode
+		});
+	}
+	return { items };
+};
+const serializeRels = (rels) => {
+	const children = rels.items.map((r) => {
+		const attrs = [
+			{
+				name: ATTR_ID,
+				value: r.id
+			},
+			{
+				name: ATTR_TYPE,
+				value: r.type
+			},
+			{
+				name: ATTR_TARGET,
+				value: r.target
+			}
+		];
+		if (r.targetMode === "External") attrs.push({
+			name: ATTR_TARGET_MODE,
+			value: "External"
+		});
+		return elem(NAME_RELATIONSHIP, { attrs });
+	});
+	return serializeXml({
+		kind: "document",
+		decl: {
+			version: "1.0",
+			encoding: "UTF-8",
+			standalone: "yes"
+		},
+		prolog: [],
+		root: elem(NAME_RELATIONSHIPS, {
+			prefixDecls: new Map([["", REL_NS]]),
+			children
+		}),
+		epilog: []
+	});
+};
+/**
+* Convenience: an empty Relationships value with no items.
+*/
+const emptyRels = () => ({ items: [] });
+//#endregion
+//#region src/merge/deck-merge.ts
+const CORE_PROPERTIES = "docProps/core.xml";
+const CORE_TIMESTAMPS = /<(dcterms:(?:created|modified))\b[^>]*>[\s\S]*?<\/\1>/g;
+/**
+* The part as the merge compares it. Every build stamps fresh creation and
+* modification times into the core properties, so those are left out.
+*/
+function comparablePart(name, bytes) {
+	if (name !== CORE_PROPERTIES) return bytes;
+	return strToU8(strFromU8(bytes).replace(CORE_TIMESTAMPS, ""));
+}
+const CONTENT_TYPES = "[Content_Types].xml";
+const PRESENTATION = "ppt/presentation.xml";
+const SHAPE_TREE_PART = /^ppt\/(?:slides|slideLayouts|slideMasters|notesSlides|notesMasters|handoutMasters)\/[^/]+\.xml$/;
+const RELATIONSHIPS_PART = /(?:^|\/)_rels\/[^/]*\.rels$/;
+const SLIDE_RELATIONSHIP = `${NS.officeDocRels}/slide`;
+const NOTES_RELATIONSHIP = `${NS.officeDocRels}/notesSlide`;
+const SHAPE_TREE_PROPERTIES = new Set([
+	"nvGrpSpPr",
+	"grpSpPr",
+	"extLst"
+]);
+function sameBytes(a, b) {
+	if (a.length !== b.length) return false;
+	for (let index = 0; index < a.length; index++) if (a[index] !== b[index]) return false;
+	return true;
+}
+/**
+* Three-way merge of keyed items. An item changed on one side only takes that
+* side; an item changed differently on both sides is a conflict.
+*/
+function mergeEntries(base, ours, theirs, options) {
+	const byKey = (entries) => new Map(entries.map((entry) => [entry.key, entry]));
+	const [b, o, t] = [
+		byKey(base),
+		byKey(ours),
+		byKey(theirs)
+	];
+	const keys = new Set([
+		...t.keys(),
+		...o.keys(),
+		...b.keys()
+	]);
+	const chosen = /* @__PURE__ */ new Map();
+	const conflicts = [];
+	const same = (x, y) => x?.value === y?.value;
+	for (const key of keys) {
+		const [be, oe, te] = [
+			b.get(key),
+			o.get(key),
+			t.get(key)
+		];
+		let pick;
+		if (same(oe, be)) pick = te;
+		else if (same(te, be) || same(oe, te)) pick = oe;
+		else {
+			const refined = be && oe && te ? options.refine?.(key, be.item, oe.item, te.item) : null;
+			if (refined?.ok) chosen.set(key, refined.value);
+			else if (refined) conflicts.push(...refined.conflicts);
+			else {
+				const reason = !be ? "both-added" : !oe || !te ? "deleted-and-changed" : "both-changed";
+				conflicts.push(options.conflict(key, reason, (oe ?? te ?? be).item));
+			}
+			continue;
+		}
+		if (pick) chosen.set(key, pick.item);
+	}
+	if (conflicts.length) return {
+		ok: false,
+		conflicts
+	};
+	const order = mergeOrder(base.map((entry) => entry.key), ours.map((entry) => entry.key), theirs.map((entry) => entry.key), new Set(chosen.keys()), options.ordering);
+	if (!order) return {
+		ok: false,
+		conflicts: [options.conflict("", "both-changed")]
+	};
+	return {
+		ok: true,
+		value: order.map((key) => chosen.get(key))
+	};
+}
+/** True when the keys both lists share appear in the same order in each. */
+function sameRelativeOrder(a, b) {
+	const [inA, inB] = [new Set(a), new Set(b)];
+	const sharedA = a.filter((key) => inB.has(key));
+	const sharedB = b.filter((key) => inA.has(key));
+	return sharedA.every((key, index) => key === sharedB[index]);
+}
+/**
+* Orders the kept keys. The side that reordered (or the source when neither
+* did) gives the order; the other side's additions follow their nearest
+* preceding sibling. `null` means the order cannot be decided.
+*/
+function mergeOrder(base, ours, theirs, keep, ordering) {
+	const oursMoved = ordering !== "none" && !sameRelativeOrder(base, ours);
+	const theirsMoved = ordering !== "none" && !sameRelativeOrder(base, theirs);
+	if (oursMoved && theirsMoved && !sameRelativeOrder(ours, theirs)) return null;
+	const [primary, secondary] = oursMoved ? [ours, theirs] : [theirs, ours];
+	const kept = primary.filter((key) => keep.has(key));
+	const placed = new Set(kept);
+	const inSecondary = new Set(secondary);
+	const next = new Map(kept.map((key, index) => [index === 0 ? null : kept[index - 1], key]));
+	if (kept.length) next.set(kept.at(-1), void 0);
+	const after = /* @__PURE__ */ new Map();
+	let anchor = null;
+	let chained = false;
+	for (const key of secondary) {
+		if (!keep.has(key)) continue;
+		if (placed.has(key)) {
+			anchor = key;
+			chained = false;
+			continue;
+		}
+		if (!chained) {
+			const following = next.get(anchor);
+			if (ordering === "schema" && following !== void 0 && !inSecondary.has(following)) return null;
+		}
+		after.set(anchor, key);
+		anchor = key;
+		chained = true;
+	}
+	const result = [];
+	const emit = (key) => {
+		for (let at = key; at !== void 0; at = after.get(at)) if (at !== null) result.push(at);
+	};
+	emit(null);
+	for (const key of kept) emit(key);
+	return result;
+}
+const partConflict = (context, reason, shape = null) => ({
+	part: context.part,
+	slide: null,
+	shape,
+	reason
+});
+function shapeIdentity(element) {
+	let found;
+	walkElements(element, (child) => {
+		if (found) return false;
+		if (child.name.localName === "cNvPr") found = child;
+	});
+	if (!found) return null;
+	const value = (name) => found.attrs.find((item) => item.name.localName === name)?.value;
+	const id = value("id");
+	return id === void 0 ? null : {
+		id,
+		name: value("name") ?? ""
+	};
+}
+const elementKey = (element) => `${element.name.namespaceURI} ${element.name.localName}`;
+/** Keys an element's children, or `null` when they cannot be told apart. */
+function childEntries(element, kind) {
+	const entries = [];
+	const keys = /* @__PURE__ */ new Set();
+	const occurrences = /* @__PURE__ */ new Map();
+	for (const child of element.children) {
+		if (child.kind !== "element") {
+			if (child.kind === "text" && !child.data.trim()) continue;
+			return null;
+		}
+		let key;
+		if (kind === "spTree" && !(child.name.namespaceURI === NS.pml && SHAPE_TREE_PROPERTIES.has(child.name.localName))) {
+			const identity = shapeIdentity(child);
+			if (!identity) return null;
+			key = `shape ${identity.id}`;
+		} else {
+			const name = elementKey(child);
+			const occurrence = occurrences.get(name) ?? 0;
+			occurrences.set(name, occurrence + 1);
+			key = `${name} ${occurrence}`;
+		}
+		if (keys.has(key)) return null;
+		keys.add(key);
+		entries.push({
+			key,
+			value: serializeFragment(child),
+			item: child
+		});
+	}
+	return entries;
+}
+const attributesValue = (attrs) => JSON.stringify(attrs.map((item) => [
+	item.name.namespaceURI,
+	item.name.localName,
+	item.value
+]));
+const NESTED = {
+	root: {
+		localName: "cSld",
+		kind: "cSld"
+	},
+	cSld: {
+		localName: "spTree",
+		kind: "spTree"
+	}
+};
+/** Merges a slide-like element: its attributes as one unit, its children by key. */
+function mergeContainer(context, base, ours, theirs, kind) {
+	const conflicts = [];
+	const [ba, oa, ta] = [
+		base.attrs,
+		ours.attrs,
+		theirs.attrs
+	].map(attributesValue);
+	let attrs = theirs.attrs;
+	if (oa !== ba && (ta === ba || oa === ta)) attrs = ours.attrs;
+	else if (oa !== ba) conflicts.push(partConflict(context, "both-changed"));
+	const prefixDecls = new Map(theirs.prefixDecls);
+	for (const [prefix, uri] of ours.prefixDecls) {
+		const existing = prefixDecls.get(prefix);
+		if (existing === void 0) prefixDecls.set(prefix, uri);
+		else if (existing !== uri) conflicts.push(partConflict(context, "both-changed"));
+	}
+	const entries = [
+		base,
+		ours,
+		theirs
+	].map((element) => childEntries(element, kind));
+	if (entries.some((list) => !list)) conflicts.push(partConflict(context, "both-changed"));
+	if (conflicts.length) return {
+		ok: false,
+		conflicts
+	};
+	const nested = NESTED[kind];
+	const children = mergeEntries(entries[0], entries[1], entries[2], {
+		ordering: kind === "spTree" ? "free" : "schema",
+		refine: (_key, b, o, t) => nested && t.name.namespaceURI === NS.pml && t.name.localName === nested.localName ? mergeContainer(context, b, o, t, nested.kind) : null,
+		conflict: (key, reason, sample) => partConflict(context, reason, sample && key.startsWith("shape ") ? shapeIdentity(sample) : null)
+	});
+	if (!children.ok) return children;
+	return {
+		ok: true,
+		value: elem(theirs.name, {
+			attrs,
+			prefixDecls,
+			children: children.value
+		})
+	};
+}
+function mergeShapeTreePart(context, base, ours, theirs) {
+	const [b, o, t] = [
+		base,
+		ours,
+		theirs
+	].map((bytes) => parseXml(strFromU8(bytes)));
+	const root = mergeContainer(context, b.root, o.root, t.root, "root");
+	if (!root.ok) return root;
+	return {
+		ok: true,
+		value: strToU8(serializeXml({
+			...t,
+			root: root.value
+		}))
+	};
+}
+function relationshipEntries(bytes) {
+	return (bytes ? parseRels(strFromU8(bytes)) : emptyRels()).items.map((item) => ({
+		key: item.id,
+		value: JSON.stringify([
+			item.type,
+			item.target,
+			item.targetMode
+		]),
+		item
+	}));
+}
+function mergeRelationshipsPart(context, base, ours, theirs) {
+	const items = mergeEntries(relationshipEntries(base), relationshipEntries(ours), relationshipEntries(theirs), {
+		ordering: "none",
+		conflict: (_key, reason) => partConflict(context, reason)
+	});
+	if (!items.ok) return items;
+	return {
+		ok: true,
+		value: strToU8(serializeRels({ items: items.value }))
+	};
+}
+/**
+* Content types are declarations about parts, so both sides' entries are kept
+* and only overrides for parts the merged package no longer has are dropped.
+*/
+function mergeContentTypes(ours, theirs, parts) {
+	const [o, t] = [ours, theirs].map((bytes) => parseContentTypes(strFromU8(bytes)));
+	const merged = {
+		defaults: [],
+		overrides: []
+	};
+	const defaults = /* @__PURE__ */ new Map();
+	const overrides = /* @__PURE__ */ new Map();
+	const conflicts = [];
+	const context = { part: CONTENT_TYPES };
+	for (const types of [t, o]) {
+		for (const item of types.defaults) {
+			const existing = defaults.get(item.extension);
+			if (existing === void 0) {
+				defaults.set(item.extension, item.contentType);
+				merged.defaults.push(item);
+			} else if (existing !== item.contentType) conflicts.push(partConflict(context, "both-changed"));
+		}
+		for (const item of types.overrides) {
+			const key = item.partName.toLowerCase();
+			if (!parts.has(key)) continue;
+			const existing = overrides.get(key);
+			if (existing === void 0) {
+				overrides.set(key, item.contentType);
+				merged.overrides.push(item);
+			} else if (existing !== item.contentType) conflicts.push(partConflict(context, "both-changed"));
+		}
+	}
+	if (conflicts.length) return {
+		ok: false,
+		conflicts
+	};
+	return {
+		ok: true,
+		value: strToU8(serializeContentTypes(merged))
+	};
+}
+/** Maps each slide's parts (the slide, its notes and their relationships) to its number. */
+function slideNumbers(parts) {
+	const numbers = /* @__PURE__ */ new Map();
+	const presentation = parts.get(PRESENTATION);
+	const presentationRels = parts.get("ppt/_rels/presentation.xml.rels");
+	if (!presentation || !presentationRels) return numbers;
+	const targets = new Map(parseRels(strFromU8(presentationRels)).items.filter((item) => item.type === SLIDE_RELATIONSHIP).map((item) => [item.id, toZipPath(resolveTarget(fromZipPath(PRESENTATION), item.target))]));
+	let number = 0;
+	walkElements(parseXml(strFromU8(presentation)).root, (element) => {
+		if (element.name.localName !== "sldId") return void 0;
+		number++;
+		const id = element.attrs.find((item) => item.name.namespaceURI === NS.officeDocRels && item.name.localName === "id")?.value;
+		const slide = id === void 0 ? void 0 : targets.get(id);
+		if (!slide) return false;
+		const relsPart = relsName(slide);
+		numbers.set(slide, number).set(relsPart, number);
+		const rels = parts.get(relsPart);
+		if (!rels) return false;
+		for (const item of parseRels(strFromU8(rels)).items) {
+			if (item.type !== NOTES_RELATIONSHIP) continue;
+			const notes = toZipPath(resolveTarget(fromZipPath(slide), item.target));
+			numbers.set(notes, number).set(relsName(notes), number);
+		}
+		return false;
+	});
+	return numbers;
+}
+const relsName = (part) => {
+	const slash = part.lastIndexOf("/");
+	return `${part.slice(0, slash + 1)}_rels/${part.slice(slash + 1)}.rels`;
+};
+/**
+* Both sides allocate the next free relationship ID, so a relationship the
+* editor added and a different one the source added often share an ID. IDs
+* are private to a part and its relationships, so the editor's is renamed
+* (in its relationships and in the part referring to it) instead of
+* reporting a conflict.
+*/
+function renumberAddedRelationships(base, ours, theirs) {
+	for (const [name, bytes] of ours) {
+		const owner = relationshipsOwner(name);
+		const theirsBytes = theirs.get(name);
+		const ownerBytes = owner && ours.get(owner);
+		if (!ownerBytes || !theirsBytes) continue;
+		const parse = (value) => value ? parseRels(strFromU8(value)) : emptyRels();
+		const [b, o, t] = [
+			parse(base.get(name)),
+			parse(bytes),
+			parse(theirsBytes)
+		];
+		const inBase = new Set(b.items.map((item) => item.id));
+		const theirsById = new Map(t.items.map((item) => [item.id, item]));
+		const used = new Set([
+			...inBase,
+			...theirsById.keys(),
+			...o.items.map((item) => item.id)
+		]);
+		const renamed = /* @__PURE__ */ new Map();
+		let next = 1;
+		for (const item of o.items) {
+			const other = theirsById.get(item.id);
+			if (inBase.has(item.id) || !other || sameRelationship(item, other)) continue;
+			while (used.has(`rId${next}`)) next++;
+			renamed.set(item.id, `rId${next}`);
+			used.add(`rId${next}`);
+			item.id = `rId${next}`;
+		}
+		if (!renamed.size) continue;
+		ours.set(name, strToU8(serializeRels(o)));
+		const document = parseXml(strFromU8(ownerBytes));
+		walkElements(document.root, (element) => {
+			element.attrs = element.attrs.map((item) => item.name.namespaceURI === NS.officeDocRels && renamed.has(item.value) ? {
+				name: item.name,
+				value: renamed.get(item.value)
+			} : item);
+		});
+		ours.set(owner, strToU8(serializeXml(document)));
+	}
+}
+const sameRelationship = (a, b) => a.type === b.type && a.target === b.target && a.targetMode === b.targetMode;
+/** The part whose relationships `name` holds; `null` for the package's own. */
+function relationshipsOwner(name) {
+	const match = /^(.*?)_rels\/([^/]+)\.rels$/.exec(name);
+	return match ? `${match[1]}${match[2]}` : null;
+}
+function unzip(bytes) {
+	return new Map(readZip(bytes).entries.map((entry) => [entry.name, entry.data]));
+}
+/** True when both packages have the same parts with the same content, as the merge compares them. */
+function sameDeck(a, b) {
+	const [x, y] = [unzip(a), unzip(b)];
+	if (x.size !== y.size) return false;
+	for (const [name, bytes] of x) {
+		const other = y.get(name);
+		if (!other || !sameBytes(comparablePart(name, bytes), comparablePart(name, other))) return false;
+	}
+	return true;
+}
+/**
+* Three-way merge of presentation packages: `base` is the version the other two
+* were both made from, `ours` the editor's copy and `theirs` the other copy (a
+* new source build, an agent's version). Changes on different parts, shapes or
+* relationships combine; the same item changed differently on both sides is
+* reported as a conflict.
+*/
+function mergeDecks(base, ours, theirs) {
+	const [b, o, t] = [
+		unzip(base),
+		unzip(ours),
+		unzip(theirs)
+	];
+	renumberAddedRelationships(b, o, t);
+	const names = new Set([
+		...t.keys(),
+		...o.keys(),
+		...b.keys()
+	]);
+	const result = /* @__PURE__ */ new Map();
+	const conflicts = [];
+	const same = (name, x, y) => x === void 0 || y === void 0 ? x === y : sameBytes(comparablePart(name, x), comparablePart(name, y));
+	for (const name of names) {
+		if (name === CONTENT_TYPES) continue;
+		const [bp, op, tp] = [
+			b.get(name),
+			o.get(name),
+			t.get(name)
+		];
+		let pick;
+		if (same(name, op, bp)) pick = tp;
+		else if (same(name, tp, bp) || same(name, op, tp)) pick = op;
+		else {
+			const context = { part: name };
+			let merged = null;
+			if (op && tp && RELATIONSHIPS_PART.test(name)) merged = mergeRelationshipsPart(context, bp, op, tp);
+			else if (bp && op && tp && SHAPE_TREE_PART.test(name)) merged = mergeShapeTreePart(context, bp, op, tp);
+			if (merged?.ok) result.set(name, merged.value);
+			else if (merged) conflicts.push(...merged.conflicts);
+			else conflicts.push(partConflict(context, !bp ? "both-added" : !op || !tp ? "deleted-and-changed" : "both-changed"));
+			continue;
+		}
+		if (pick) result.set(name, pick);
+	}
+	const [bt, ot, tt] = [
+		b,
+		o,
+		t
+	].map((parts) => parts.get(CONTENT_TYPES));
+	let contentTypes;
+	if (same(CONTENT_TYPES, ot, bt)) contentTypes = tt;
+	else if (same(CONTENT_TYPES, tt, bt) || same(CONTENT_TYPES, ot, tt)) contentTypes = ot;
+	else {
+		const merged = mergeContentTypes(ot, tt, new Set([...result.keys()].map((name) => `/${name}`.toLowerCase())));
+		if (merged.ok) contentTypes = merged.value;
+		else conflicts.push(...merged.conflicts);
+	}
+	if (conflicts.length) {
+		const numbers = [
+			b,
+			t,
+			o
+		].reduce((all, parts) => new Map([...all, ...slideNumbers(parts)]), /* @__PURE__ */ new Map());
+		return {
+			ok: false,
+			conflicts: conflicts.map((conflict) => ({
+				...conflict,
+				slide: numbers.get(conflict.part) ?? null
+			}))
+		};
+	}
+	return {
+		ok: true,
+		bytes: writeZip([{
+			name: CONTENT_TYPES,
+			data: contentTypes
+		}, ...[...result].map(([name, data]) => ({
+			name,
+			data
+		}))])
+	};
+}
+/** One line per conflict, for the CLI and server messages. */
+function describeConflict(conflict) {
+	const where = conflict.slide === null ? conflict.part : `Slide ${conflict.slide}`;
+	const what = conflict.shape ? `${where}: ${conflict.shape.name || `shape ${conflict.shape.id}`}` : where;
+	return conflict.reason === "deleted-and-changed" ? `${what} was deleted on one side and changed on the other.` : `${what} was changed both in the editor and in the source.`;
+}
+//#endregion
+export { sameDeck as i, describeConflict as n, mergeDecks as r, comparablePart as t };
+
+//# sourceMappingURL=deck-merge-XZc2oNxd.js.map