odf.js 0.0.0 → 1.1.0

package/dist/index.cjs

@@ -0,0 +1,729 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let zod = require("zod");
+let fast_xml_parser = require("fast-xml-parser");
+let fflate = require("fflate");
+//#region src/model/node.ts
+const AttributeSchema = zod.z.object({
+	name: zod.z.string(),
+	value: zod.z.string()
+});
+const XmlTextSchema = zod.z.object({
+	type: zod.z.literal("text"),
+	value: zod.z.string()
+});
+const XmlCdataSchema = zod.z.object({
+	type: zod.z.literal("cdata"),
+	value: zod.z.string()
+});
+const XmlCommentSchema = zod.z.object({
+	type: zod.z.literal("comment"),
+	value: zod.z.string()
+});
+const XmlDeclarationSchema = zod.z.object({
+	type: zod.z.literal("declaration"),
+	attributes: zod.z.array(AttributeSchema)
+});
+const XmlPiSchema = zod.z.object({
+	type: zod.z.literal("pi"),
+	target: zod.z.string(),
+	content: zod.z.string()
+});
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isAttribute(value) {
+	return isRecord$1(value) && typeof value.name === "string" && typeof value.value === "string";
+}
+function isXmlNode(value) {
+	if (!isRecord$1(value)) return false;
+	const t = value.type;
+	if (t === "text" || t === "cdata" || t === "comment") return typeof value.value === "string";
+	if (t === "declaration") return Array.isArray(value.attributes) && value.attributes.every(isAttribute);
+	if (t === "pi") return typeof value.target === "string" && typeof value.content === "string";
+	if (t === "element") return typeof value.tag === "string" && Array.isArray(value.attributes) && value.attributes.every(isAttribute) && Array.isArray(value.children) && value.children.every(isXmlNode);
+	return false;
+}
+const XmlElementSchema = zod.z.object({
+	type: zod.z.literal("element"),
+	tag: zod.z.string(),
+	attributes: zod.z.array(AttributeSchema),
+	children: zod.z.array(zod.z.custom(isXmlNode))
+});
+const XmlNodeSchema = zod.z.discriminatedUnion("type", [
+	XmlTextSchema,
+	XmlCdataSchema,
+	XmlCommentSchema,
+	XmlDeclarationSchema,
+	XmlPiSchema,
+	XmlElementSchema
+]);
+//#endregion
+//#region src/model/package.ts
+const XmlPartSchema = zod.z.object({
+	kind: zod.z.literal("xml"),
+	nodes: zod.z.array(XmlNodeSchema)
+});
+const BinaryPartSchema = zod.z.object({
+	kind: zod.z.literal("binary"),
+	base64: zod.z.string()
+});
+const PartSchema = zod.z.discriminatedUnion("kind", [XmlPartSchema, BinaryPartSchema]);
+const PackageSchema = zod.z.object({ parts: zod.z.record(zod.z.string(), PartSchema) });
+//#endregion
+//#region src/util/base64.ts
+const TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const DECODE = (() => {
+	const map = (/* @__PURE__ */ new Uint8Array(256)).fill(255);
+	for (let i = 0; i < 64; i = i + 1) map[TABLE.charCodeAt(i)] = i;
+	return map;
+})();
+function bytesToBase64(bytes) {
+	let out = "";
+	const len = bytes.length;
+	for (let i = 0; i < len; i = i + 3) {
+		const b0 = bytes[i];
+		const b1 = i + 1 < len ? bytes[i + 1] : 0;
+		const b2 = i + 2 < len ? bytes[i + 2] : 0;
+		out += TABLE[b0 >> 2];
+		out += TABLE[(b0 & 3) << 4 | b1 >> 4];
+		out += i + 1 < len ? TABLE[(b1 & 15) << 2 | b2 >> 6] : "=";
+		out += i + 2 < len ? TABLE[b2 & 63] : "=";
+	}
+	return out;
+}
+function base64ToBytes(b64) {
+	const clean = b64.replace(/[^A-Za-z0-9+/=]/g, "");
+	const len = clean.length;
+	const out = new Uint8Array(len * 3 / 4 | 0);
+	let p = 0;
+	for (let i = 0; i < len; i = i + 4) {
+		const c0 = DECODE[clean.charCodeAt(i)];
+		const c1 = DECODE[clean.charCodeAt(i + 1)];
+		const c2 = clean.charCodeAt(i + 2);
+		const c3 = clean.charCodeAt(i + 3);
+		if (c0 === 255 || c1 === 255) throw new Error("invalid base64 input");
+		out[p++] = c0 << 2 | c1 >> 4;
+		if (c2 !== 61) {
+			const d2 = DECODE[c2];
+			out[p++] = (c1 & 15) << 4 | d2 >> 2;
+			if (c3 !== 61) {
+				const d3 = DECODE[c3];
+				out[p++] = (d2 & 3) << 6 | d3;
+			}
+		}
+	}
+	return out.subarray(0, p);
+}
+//#endregion
+//#region src/xml/parse.ts
+const PARSER = new fast_xml_parser.XMLParser({
+	preserveOrder: true,
+	attributeNamePrefix: "@_",
+	ignoreAttributes: false,
+	textNodeName: "#text",
+	cdataPropName: "__cdata",
+	commentPropName: "__comment",
+	processEntities: false,
+	parseTagValue: false,
+	trimValues: false
+});
+function parseXml(xml) {
+	return parseNodes(PARSER.parse(xml));
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isUnknownArray(value) {
+	return Array.isArray(value);
+}
+function asString(value) {
+	if (typeof value !== "string") throw new Error(`expected string while parsing XML, got ${typeof value}`);
+	return value;
+}
+function parseNodes(raw) {
+	if (!isUnknownArray(raw)) throw new Error("fast-xml-parser output was not an ordered array");
+	return raw.map(parseNode);
+}
+function parseNode(raw) {
+	if (!isRecord(raw)) throw new Error("fast-xml-parser node was not an object");
+	let tagKey;
+	for (const key of Object.keys(raw)) if (key !== ":@") {
+		if (tagKey !== void 0) throw new Error("XML node had multiple tag keys");
+		tagKey = key;
+	}
+	if (tagKey === void 0) throw new Error("XML node had no tag key");
+	const attributes = parseAttributes(raw[":@"]);
+	if (tagKey === "#text") return {
+		type: "text",
+		value: asString(raw["#text"])
+	};
+	if (tagKey === "__comment") return {
+		type: "comment",
+		value: scalarText(raw.__comment)
+	};
+	if (tagKey === "__cdata") return {
+		type: "cdata",
+		value: scalarText(raw.__cdata)
+	};
+	if (tagKey === "?xml") return {
+		type: "declaration",
+		attributes
+	};
+	if (tagKey.startsWith("?")) return {
+		type: "pi",
+		target: tagKey.slice(1),
+		content: scalarText(raw[tagKey])
+	};
+	return {
+		type: "element",
+		tag: tagKey,
+		attributes,
+		children: parseNodes(raw[tagKey])
+	};
+}
+function parseAttributes(raw) {
+	if (raw === void 0) return [];
+	if (!isRecord(raw)) throw new Error("XML attributes were not an object");
+	const attrs = [];
+	for (const key of Object.keys(raw)) {
+		if (!key.startsWith("@_")) throw new Error(`unexpected attribute key without @_ prefix: ${key}`);
+		attrs.push({
+			name: key.slice(2),
+			value: asString(raw[key])
+		});
+	}
+	return attrs;
+}
+function scalarText(raw) {
+	if (!isUnknownArray(raw) || raw.length === 0) throw new Error("expected a scalar-text wrapper array");
+	const first = raw[0];
+	if (!isRecord(first)) throw new Error("scalar-text wrapper was not an object");
+	return asString(first["#text"]);
+}
+//#endregion
+//#region src/zip.ts
+function unzipPackage(bytes) {
+	return (0, fflate.unzipSync)(bytes);
+}
+function zipPackage(entries) {
+	const data = {};
+	for (const [path, entry] of entries) if (entry.stored === true) data[path] = [entry.bytes, { level: 0 }];
+	else data[path] = entry.bytes;
+	return (0, fflate.zipSync)(data);
+}
+//#endregion
+//#region src/package-io/read.ts
+function parsePackage(bytes) {
+	const entries = unzipPackage(bytes);
+	const parts = {};
+	for (const [path, partBytes] of Object.entries(entries)) if (looksLikeXml(partBytes)) parts[path] = {
+		kind: "xml",
+		nodes: parseXml(new TextDecoder("utf-8").decode(partBytes))
+	};
+	else parts[path] = {
+		kind: "binary",
+		base64: bytesToBase64(partBytes)
+	};
+	return { parts };
+}
+function looksLikeXml(bytes) {
+	let i = 0;
+	if (bytes.length >= 3 && bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191) i = 3;
+	while (i < bytes.length) {
+		const b = bytes[i];
+		if (b === 32 || b === 9 || b === 10 || b === 13) {
+			i = i + 1;
+			continue;
+		}
+		return b === 60;
+	}
+	return false;
+}
+//#endregion
+//#region src/xml/build.ts
+const BUILDER = new fast_xml_parser.XMLBuilder({
+	preserveOrder: true,
+	attributeNamePrefix: "@_",
+	ignoreAttributes: false,
+	textNodeName: "#text",
+	cdataPropName: "__cdata",
+	commentPropName: "__comment",
+	processEntities: false,
+	format: false,
+	suppressEmptyNode: false
+});
+function buildXml(nodes) {
+	const out = BUILDER.build(toOrdered(nodes));
+	if (typeof out !== "string") throw new Error("XMLBuilder did not return a string");
+	return out;
+}
+function toOrdered(nodes) {
+	return nodes.map(toOrderedNode);
+}
+function attrsObject(attributes) {
+	const obj = {};
+	for (const a of attributes) obj[`@_${a.name}`] = a.value;
+	return obj;
+}
+function toOrderedNode(node) {
+	switch (node.type) {
+		case "text": return { "#text": node.value };
+		case "comment": return { __comment: [{ "#text": node.value }] };
+		case "cdata": return { __cdata: [{ "#text": node.value }] };
+		case "pi": return { [`?${node.target}`]: [{ "#text": node.content }] };
+		case "declaration": return {
+			"?xml": [{ "#text": "" }],
+			":@": attrsObject(node.attributes)
+		};
+		case "element": {
+			const obj = { [node.tag]: toOrdered(node.children) };
+			const attrs = attrsObject(node.attributes);
+			if (Object.keys(attrs).length > 0) obj[":@"] = attrs;
+			return obj;
+		}
+	}
+}
+//#endregion
+//#region src/package-io/write.ts
+const MIMETYPE_PART = "mimetype";
+const MANIFEST_PART = "META-INF/manifest.xml";
+function serializePackage(pkg) {
+	const remaining = new Map(Object.entries(pkg.parts));
+	const entries = [];
+	const mimetype = remaining.get(MIMETYPE_PART);
+	if (mimetype !== void 0) {
+		entries.push([MIMETYPE_PART, {
+			bytes: partToBytes(mimetype),
+			stored: true
+		}]);
+		remaining.delete(MIMETYPE_PART);
+	}
+	const manifest = remaining.get(MANIFEST_PART);
+	if (manifest !== void 0) {
+		entries.push([MANIFEST_PART, { bytes: partToBytes(manifest) }]);
+		remaining.delete(MANIFEST_PART);
+	}
+	for (const [path, part] of remaining) entries.push([path, { bytes: partToBytes(part) }]);
+	return zipPackage(entries);
+}
+function partToBytes(part) {
+	switch (part.kind) {
+		case "xml": return new TextEncoder().encode(buildXml(part.nodes));
+		case "binary": return base64ToBytes(part.base64);
+	}
+}
+//#endregion
+//#region src/codec.ts
+const xmlCodec = zod.z.codec(zod.z.string(), zod.z.array(XmlNodeSchema), {
+	decode: (xml) => parseXml(xml),
+	encode: (nodes) => buildXml(nodes)
+});
+const packageCodec = zod.z.codec(zod.z.instanceof(Uint8Array), PackageSchema, {
+	decode: (bytes) => parsePackage(bytes),
+	encode: (pkg) => serializePackage(pkg)
+});
+function decodePackage(bytes) {
+	return zod.z.decode(packageCodec, bytes);
+}
+function encodePackage(pkg) {
+	return zod.z.encode(packageCodec, pkg);
+}
+//#endregion
+//#region src/ns.ts
+const ODF_NAMESPACES = Object.freeze({
+	office: "urn:oasis:names:tc:opendocument:xmlns:office:1.0",
+	style: "urn:oasis:names:tc:opendocument:xmlns:style:1.0",
+	text: "urn:oasis:names:tc:opendocument:xmlns:text:1.0",
+	table: "urn:oasis:names:tc:opendocument:xmlns:table:1.0",
+	draw: "urn:oasis:names:tc:opendocument:xmlns:drawing:1.0",
+	fo: "urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0",
+	svg: "urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0",
+	xlink: "http://www.w3.org/1999/xlink",
+	dc: "http://purl.org/dc/elements/1.1/",
+	meta: "urn:oasis:names:tc:opendocument:xmlns:meta:1.0",
+	number: "urn:oasis:names:tc:opendocument:xmlns:datastyle:1.0",
+	chart: "urn:oasis:names:tc:opendocument:xmlns:chart:1.0",
+	dr3d: "urn:oasis:names:tc:opendocument:xmlns:dr3d:1.0",
+	math: "http://www.w3.org/1998/Math/MathML",
+	form: "urn:oasis:names:tc:opendocument:xmlns:form:1.0",
+	script: "urn:oasis:names:tc:opendocument:xmlns:script:1.0",
+	config: "urn:oasis:names:tc:opendocument:xmlns:config:1.0",
+	presentation: "urn:oasis:names:tc:opendocument:xmlns:presentation:1.0",
+	smil: "urn:oasis:names:tc:opendocument:xmlns:smil-compatible:1.0",
+	anim: "urn:oasis:names:tc:opendocument:xmlns:animation:1.0",
+	xforms: "http://www.w3.org/2002/xforms",
+	xsd: "http://www.w3.org/2001/XMLSchema",
+	xsi: "http://www.w3.org/2001/XMLSchema-instance",
+	manifest: "urn:oasis:names:tc:opendocument:xmlns:manifest:1.0"
+});
+function xmlnsAttributes(prefixes) {
+	const attrs = {};
+	for (const prefix of prefixes) attrs[`xmlns:${prefix}`] = ODF_NAMESPACES[prefix];
+	return attrs;
+}
+//#endregion
+//#region src/media-type.ts
+const ODF_MEDIA_TYPES = Object.freeze({
+	odt: "application/vnd.oasis.opendocument.text",
+	ott: "application/vnd.oasis.opendocument.text-template",
+	ods: "application/vnd.oasis.opendocument.spreadsheet",
+	ots: "application/vnd.oasis.opendocument.spreadsheet-template",
+	odp: "application/vnd.oasis.opendocument.presentation",
+	otp: "application/vnd.oasis.opendocument.presentation-template",
+	odg: "application/vnd.oasis.opendocument.graphics",
+	otg: "application/vnd.oasis.opendocument.graphics-template",
+	odf: "application/vnd.oasis.opendocument.formula",
+	otf: "application/vnd.oasis.opendocument.formula-template",
+	odm: "application/vnd.oasis.opendocument.text-master",
+	otm: "application/vnd.oasis.opendocument.text-master-template",
+	odb: "application/vnd.oasis.opendocument.base"
+});
+function isOdfExtension(extension) {
+	return Object.hasOwn(ODF_MEDIA_TYPES, extension);
+}
+function mediaTypeForExtension(extension) {
+	const lower = extension.toLowerCase();
+	return isOdfExtension(lower) ? ODF_MEDIA_TYPES[lower] : void 0;
+}
+//#endregion
+//#region src/image/sniff.ts
+const PNG_SIGNATURE = [
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10
+];
+const JPEG_SIGNATURE = [
+	255,
+	216,
+	255
+];
+function startsWith(bytes, signature) {
+	if (bytes.length < signature.length) return false;
+	for (let i = 0; i < signature.length; i++) if (bytes[i] !== signature[i]) return false;
+	return true;
+}
+function sniffImageFormat(bytes) {
+	if (startsWith(bytes, PNG_SIGNATURE)) return "png";
+	if (startsWith(bytes, JPEG_SIGNATURE)) return "jpeg";
+}
+//#endregion
+//#region src/mimetype.ts
+function readMimetype(pkg) {
+	const part = pkg.parts[MIMETYPE_PART];
+	if (part?.kind !== "binary") return;
+	return new TextDecoder("utf-8").decode(base64ToBytes(part.base64));
+}
+function writeMimetype(pkg, mediaType) {
+	pkg.parts[MIMETYPE_PART] = {
+		kind: "binary",
+		base64: bytesToBase64(new TextEncoder().encode(mediaType))
+	};
+}
+//#endregion
+//#region src/xml/fragment.ts
+function el(tag, attrs = {}, children = []) {
+	return {
+		type: "element",
+		tag,
+		attributes: Object.entries(attrs).map(([name, value]) => ({
+			name,
+			value
+		})),
+		children
+	};
+}
+function txt(value) {
+	return {
+		type: "text",
+		value
+	};
+}
+//#endregion
+//#region src/xml/entities.ts
+function encodeXmlText(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+//#endregion
+//#region src/manifest.ts
+const ManifestEntrySchema = zod.z.object({
+	fullPath: zod.z.string(),
+	mediaType: zod.z.string(),
+	version: zod.z.string().optional()
+});
+const ManifestSchema = zod.z.object({
+	version: zod.z.string(),
+	entries: zod.z.array(ManifestEntrySchema)
+});
+const ManifestProblemSchema = zod.z.object({
+	severity: zod.z.enum(["error", "warning"]),
+	message: zod.z.string(),
+	path: zod.z.string().optional()
+});
+const DEFAULT_MANIFEST_VERSION = "1.3";
+const STANDARD_XML_PART_NAMES = /* @__PURE__ */ new Set([
+	"content.xml",
+	"styles.xml",
+	"meta.xml",
+	"settings.xml"
+]);
+function findChildElement(nodes, tag) {
+	for (const node of nodes) if (node.type === "element" && node.tag === tag) return node;
+}
+function attrValue(element, name) {
+	return element.attributes.find((attribute) => attribute.name === name)?.value;
+}
+function readManifest(pkg) {
+	const part = pkg.parts[MANIFEST_PART];
+	if (part?.kind !== "xml") throw new Error(`package has no ${MANIFEST_PART} XML part to read`);
+	const root = findChildElement(part.nodes, "manifest:manifest");
+	if (root === void 0) throw new Error(`${MANIFEST_PART} has no manifest:manifest root element`);
+	const version = attrValue(root, "manifest:version");
+	if (version === void 0) throw new Error(`${MANIFEST_PART}'s manifest:manifest root is missing the required manifest:version attribute`);
+	const entries = [];
+	for (const child of root.children) {
+		if (child.type !== "element" || child.tag !== "manifest:file-entry") continue;
+		const fullPath = attrValue(child, "manifest:full-path");
+		const mediaType = attrValue(child, "manifest:media-type");
+		if (fullPath === void 0 || mediaType === void 0) throw new Error(`${MANIFEST_PART} has a manifest:file-entry missing manifest:full-path or manifest:media-type`);
+		const entryVersion = attrValue(child, "manifest:version");
+		entries.push(entryVersion === void 0 ? {
+			fullPath,
+			mediaType
+		} : {
+			fullPath,
+			mediaType,
+			version: entryVersion
+		});
+	}
+	return {
+		version,
+		entries
+	};
+}
+function subdocumentDirectories(partPaths) {
+	const dirs = [];
+	for (const path of partPaths) if (path.endsWith("/content.xml")) dirs.push(path.slice(0, path.length - 11));
+	return dirs;
+}
+function resolvePartMediaType(path, bytes, overrides) {
+	const override = overrides?.[path];
+	if (override !== void 0) return override;
+	const baseName = path.slice(path.lastIndexOf("/") + 1);
+	if (STANDARD_XML_PART_NAMES.has(baseName)) return "text/xml";
+	const dotIndex = baseName.lastIndexOf(".");
+	const extension = dotIndex === -1 ? "" : baseName.slice(dotIndex + 1);
+	const byExtension = extension === "" ? void 0 : mediaTypeForExtension(extension);
+	if (byExtension !== void 0) return byExtension;
+	if (bytes !== void 0) {
+		const sniffed = sniffImageFormat(bytes);
+		if (sniffed === "png") return "image/png";
+		if (sniffed === "jpeg") return "image/jpeg";
+	}
+	return "";
+}
+function buildManifest(pkg, options = {}) {
+	const version = options.version ?? DEFAULT_MANIFEST_VERSION;
+	const documentMediaType = options.documentMediaType ?? readMimetype(pkg);
+	if (documentMediaType === void 0) throw new Error("buildManifest: package has no \"mimetype\" part and no documentMediaType override was supplied -- the manifest root entry requires a known document media type");
+	const entries = [{
+		fullPath: "/",
+		mediaType: documentMediaType,
+		version
+	}];
+	const partPaths = Object.keys(pkg.parts);
+	for (const dir of new Set(subdocumentDirectories(partPaths))) entries.push({
+		fullPath: dir,
+		mediaType: resolvePartMediaType(dir, void 0, options.mediaTypeOverrides)
+	});
+	for (const [path, part] of Object.entries(pkg.parts)) {
+		if (path === "mimetype" || path === "META-INF/manifest.xml") continue;
+		const bytes = part.kind === "binary" ? base64ToBytes(part.base64) : void 0;
+		entries.push({
+			fullPath: path,
+			mediaType: resolvePartMediaType(path, bytes, options.mediaTypeOverrides)
+		});
+	}
+	return {
+		version,
+		entries
+	};
+}
+function buildManifestNodes(manifest) {
+	const fileEntries = manifest.entries.map((entry) => {
+		const attrs = { "manifest:full-path": encodeXmlText(entry.fullPath) };
+		if (entry.version !== void 0) attrs["manifest:version"] = encodeXmlText(entry.version);
+		attrs["manifest:media-type"] = encodeXmlText(entry.mediaType);
+		return el("manifest:file-entry", attrs);
+	});
+	return [{
+		type: "declaration",
+		attributes: [{
+			name: "version",
+			value: "1.0"
+		}, {
+			name: "encoding",
+			value: "UTF-8"
+		}]
+	}, el("manifest:manifest", {
+		...xmlnsAttributes(["manifest"]),
+		"manifest:version": encodeXmlText(manifest.version)
+	}, fileEntries)];
+}
+function writeManifest(pkg, manifest) {
+	pkg.parts[MANIFEST_PART] = {
+		kind: "xml",
+		nodes: buildManifestNodes(manifest)
+	};
+}
+function syncManifest(pkg, options) {
+	writeManifest(pkg, buildManifest(pkg, options));
+}
+function validateManifest(pkg) {
+	const problems = [];
+	const manifestPart = pkg.parts[MANIFEST_PART];
+	if (manifestPart === void 0) {
+		problems.push({
+			severity: "error",
+			message: `package has no ${MANIFEST_PART} part`
+		});
+		return problems;
+	}
+	if (manifestPart.kind !== "xml") {
+		problems.push({
+			severity: "error",
+			message: `${MANIFEST_PART} part is not XML`
+		});
+		return problems;
+	}
+	const root = findChildElement(manifestPart.nodes, "manifest:manifest");
+	if (root === void 0) {
+		problems.push({
+			severity: "error",
+			message: `${MANIFEST_PART} has no manifest:manifest root element`
+		});
+		return problems;
+	}
+	let manifest;
+	try {
+		manifest = readManifest(pkg);
+	} catch (error) {
+		problems.push({
+			severity: "error",
+			message: `failed to parse ${MANIFEST_PART}: ${error instanceof Error ? error.message : String(error)}`
+		});
+		return problems;
+	}
+	const rootEntry = manifest.entries.find((entry) => entry.fullPath === "/");
+	if (rootEntry === void 0) problems.push({
+		severity: "error",
+		message: "manifest has no root (\"/\") entry"
+	});
+	else {
+		const documentMediaType = readMimetype(pkg);
+		if (documentMediaType !== void 0 && documentMediaType !== rootEntry.mediaType) problems.push({
+			severity: "error",
+			message: `manifest root entry media type "${rootEntry.mediaType}" does not match the mimetype part's media type "${documentMediaType}"`,
+			path: "/"
+		});
+	}
+	const partPaths = new Set(Object.keys(pkg.parts).filter((path) => path !== "mimetype" && path !== "META-INF/manifest.xml"));
+	const manifestPaths = new Set(manifest.entries.map((entry) => entry.fullPath));
+	for (const entry of manifest.entries) {
+		if (entry.fullPath === "/" || entry.fullPath.endsWith("/")) continue;
+		if (!partPaths.has(entry.fullPath)) problems.push({
+			severity: "warning",
+			message: `manifest lists "${entry.fullPath}" but the package has no such part`,
+			path: entry.fullPath
+		});
+	}
+	for (const path of partPaths) if (!manifestPaths.has(path)) problems.push({
+		severity: "warning",
+		message: `package has part "${path}" not listed in the manifest`,
+		path
+	});
+	for (const child of root.children) {
+		if (child.type !== "element" || child.tag !== "manifest:file-entry") continue;
+		if (!child.children.some((grandchild) => grandchild.type === "element" && grandchild.tag === "manifest:encryption-data")) continue;
+		const fullPath = attrValue(child, "manifest:full-path");
+		if (fullPath === void 0) continue;
+		problems.push({
+			severity: "warning",
+			message: `entry "${fullPath}" carries manifest:encryption-data -- odf.js does not implement ODF encryption/decryption`,
+			path: fullPath
+		});
+	}
+	return problems;
+}
+function setDocumentMediaType(pkg, mediaType, version = DEFAULT_MANIFEST_VERSION) {
+	writeMimetype(pkg, mediaType);
+	const rootEntry = {
+		fullPath: "/",
+		mediaType,
+		version
+	};
+	if (pkg.parts["META-INF/manifest.xml"] === void 0) {
+		writeManifest(pkg, {
+			version,
+			entries: [rootEntry]
+		});
+		return;
+	}
+	const existing = readManifest(pkg);
+	const rootIndex = existing.entries.findIndex((entry) => entry.fullPath === "/");
+	writeManifest(pkg, {
+		version,
+		entries: rootIndex === -1 ? [rootEntry, ...existing.entries] : existing.entries.map((entry, index) => index === rootIndex ? rootEntry : entry)
+	});
+}
+//#endregion
+exports.AttributeSchema = AttributeSchema;
+exports.BinaryPartSchema = BinaryPartSchema;
+exports.MANIFEST_PART = MANIFEST_PART;
+exports.MIMETYPE_PART = MIMETYPE_PART;
+exports.ManifestEntrySchema = ManifestEntrySchema;
+exports.ManifestProblemSchema = ManifestProblemSchema;
+exports.ManifestSchema = ManifestSchema;
+exports.ODF_MEDIA_TYPES = ODF_MEDIA_TYPES;
+exports.ODF_NAMESPACES = ODF_NAMESPACES;
+exports.PackageSchema = PackageSchema;
+exports.PartSchema = PartSchema;
+exports.XmlCdataSchema = XmlCdataSchema;
+exports.XmlCommentSchema = XmlCommentSchema;
+exports.XmlDeclarationSchema = XmlDeclarationSchema;
+exports.XmlElementSchema = XmlElementSchema;
+exports.XmlNodeSchema = XmlNodeSchema;
+exports.XmlPartSchema = XmlPartSchema;
+exports.XmlPiSchema = XmlPiSchema;
+exports.XmlTextSchema = XmlTextSchema;
+exports.base64ToBytes = base64ToBytes;
+exports.buildManifest = buildManifest;
+exports.buildXml = buildXml;
+exports.bytesToBase64 = bytesToBase64;
+exports.decodePackage = decodePackage;
+exports.el = el;
+exports.encodePackage = encodePackage;
+exports.encodeXmlText = encodeXmlText;
+exports.isXmlNode = isXmlNode;
+exports.mediaTypeForExtension = mediaTypeForExtension;
+exports.packageCodec = packageCodec;
+exports.parsePackage = parsePackage;
+exports.parseXml = parseXml;
+exports.readManifest = readManifest;
+exports.readMimetype = readMimetype;
+exports.serializePackage = serializePackage;
+exports.setDocumentMediaType = setDocumentMediaType;
+exports.sniffImageFormat = sniffImageFormat;
+exports.syncManifest = syncManifest;
+exports.txt = txt;
+exports.unzipPackage = unzipPackage;
+exports.validateManifest = validateManifest;
+exports.writeManifest = writeManifest;
+exports.writeMimetype = writeMimetype;
+exports.xmlCodec = xmlCodec;
+exports.xmlnsAttributes = xmlnsAttributes;
+exports.zipPackage = zipPackage;