odf.js 1.12.0 → 1.13.0

package/dist/manifest.cjs

@@ -0,0 +1,252 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_util_base64 = require("./util/base64.cjs");
+const require_package_io_write = require("./package-io/write.cjs");
+const require_ns = require("./ns.cjs");
+const require_media_type = require("./media-type.cjs");
+const require_image_sniff = require("./image/sniff.cjs");
+const require_mimetype = require("./mimetype.cjs");
+const require_xml_fragment = require("./xml/fragment.cjs");
+const require_xml_entities = require("./xml/entities.cjs");
+let zod = require("zod");
+//#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[require_package_io_write.MANIFEST_PART];
+	if (part?.kind !== "xml") throw new Error(`package has no ${require_package_io_write.MANIFEST_PART} XML part to read`);
+	const root = findChildElement(part.nodes, "manifest:manifest");
+	if (root === void 0) throw new Error(`${require_package_io_write.MANIFEST_PART} has no manifest:manifest root element`);
+	const version = attrValue(root, "manifest:version");
+	if (version === void 0) throw new Error(`${require_package_io_write.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(`${require_package_io_write.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 : require_media_type.mediaTypeForExtension(extension);
+	if (byExtension !== void 0) return byExtension;
+	if (bytes !== void 0) {
+		const sniffed = require_image_sniff.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 ?? require_mimetype.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" ? require_util_base64.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": require_xml_entities.encodeXmlText(entry.fullPath) };
+		if (entry.version !== void 0) attrs["manifest:version"] = require_xml_entities.encodeXmlText(entry.version);
+		attrs["manifest:media-type"] = require_xml_entities.encodeXmlText(entry.mediaType);
+		return require_xml_fragment.el("manifest:file-entry", attrs);
+	});
+	return [{
+		type: "declaration",
+		attributes: [{
+			name: "version",
+			value: "1.0"
+		}, {
+			name: "encoding",
+			value: "UTF-8"
+		}]
+	}, require_xml_fragment.el("manifest:manifest", {
+		...require_ns.xmlnsAttributes(["manifest"]),
+		"manifest:version": require_xml_entities.encodeXmlText(manifest.version)
+	}, fileEntries)];
+}
+function writeManifest(pkg, manifest) {
+	pkg.parts[require_package_io_write.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[require_package_io_write.MANIFEST_PART];
+	if (manifestPart === void 0) {
+		problems.push({
+			severity: "error",
+			message: `package has no ${require_package_io_write.MANIFEST_PART} part`
+		});
+		return problems;
+	}
+	if (manifestPart.kind !== "xml") {
+		problems.push({
+			severity: "error",
+			message: `${require_package_io_write.MANIFEST_PART} part is not XML`
+		});
+		return problems;
+	}
+	const root = findChildElement(manifestPart.nodes, "manifest:manifest");
+	if (root === void 0) {
+		problems.push({
+			severity: "error",
+			message: `${require_package_io_write.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 ${require_package_io_write.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 = require_mimetype.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) {
+	require_mimetype.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.MANIFEST_PART = require_package_io_write.MANIFEST_PART;
+exports.ManifestEntrySchema = ManifestEntrySchema;
+exports.ManifestProblemSchema = ManifestProblemSchema;
+exports.ManifestSchema = ManifestSchema;
+exports.buildManifest = buildManifest;
+exports.readManifest = readManifest;
+exports.setDocumentMediaType = setDocumentMediaType;
+exports.syncManifest = syncManifest;
+exports.validateManifest = validateManifest;
+exports.writeManifest = writeManifest;

package/dist/manifest.d.cts

@@ -0,0 +1,41 @@
+import { Package } from "./model/package.cjs";
+import { MANIFEST_PART } from "./package-io/write.cjs";
+import { z } from "zod";
+//#region src/manifest.d.ts
+declare const ManifestEntrySchema: z.ZodObject<{
+  fullPath: z.ZodString;
+  mediaType: z.ZodString;
+  version: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ManifestEntry = z.infer<typeof ManifestEntrySchema>;
+declare const ManifestSchema: z.ZodObject<{
+  version: z.ZodString;
+  entries: z.ZodArray<z.ZodObject<{
+    fullPath: z.ZodString;
+    mediaType: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type Manifest = z.infer<typeof ManifestSchema>;
+declare const ManifestProblemSchema: z.ZodObject<{
+  severity: z.ZodEnum<{
+    error: "error";
+    warning: "warning";
+  }>;
+  message: z.ZodString;
+  path: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ManifestProblem = z.infer<typeof ManifestProblemSchema>;
+declare function readManifest(pkg: Package): Manifest;
+interface BuildManifestOptions {
+  documentMediaType?: string;
+  version?: string;
+  mediaTypeOverrides?: Readonly<Record<string, string>>;
+}
+declare function buildManifest(pkg: Package, options?: BuildManifestOptions): Manifest;
+declare function writeManifest(pkg: Package, manifest: Manifest): void;
+declare function syncManifest(pkg: Package, options?: BuildManifestOptions): void;
+declare function validateManifest(pkg: Package): ManifestProblem[];
+declare function setDocumentMediaType(pkg: Package, mediaType: string, version?: string): void;
+//#endregion
+export { BuildManifestOptions, MANIFEST_PART, Manifest, ManifestEntry, ManifestEntrySchema, ManifestProblem, ManifestProblemSchema, ManifestSchema, buildManifest, readManifest, setDocumentMediaType, syncManifest, validateManifest, writeManifest };

package/dist/manifest.d.ts

@@ -0,0 +1,41 @@
+import { Package } from "./model/package.js";
+import { MANIFEST_PART } from "./package-io/write.js";
+import { z } from "zod";
+//#region src/manifest.d.ts
+declare const ManifestEntrySchema: z.ZodObject<{
+  fullPath: z.ZodString;
+  mediaType: z.ZodString;
+  version: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ManifestEntry = z.infer<typeof ManifestEntrySchema>;
+declare const ManifestSchema: z.ZodObject<{
+  version: z.ZodString;
+  entries: z.ZodArray<z.ZodObject<{
+    fullPath: z.ZodString;
+    mediaType: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type Manifest = z.infer<typeof ManifestSchema>;
+declare const ManifestProblemSchema: z.ZodObject<{
+  severity: z.ZodEnum<{
+    error: "error";
+    warning: "warning";
+  }>;
+  message: z.ZodString;
+  path: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ManifestProblem = z.infer<typeof ManifestProblemSchema>;
+declare function readManifest(pkg: Package): Manifest;
+interface BuildManifestOptions {
+  documentMediaType?: string;
+  version?: string;
+  mediaTypeOverrides?: Readonly<Record<string, string>>;
+}
+declare function buildManifest(pkg: Package, options?: BuildManifestOptions): Manifest;
+declare function writeManifest(pkg: Package, manifest: Manifest): void;
+declare function syncManifest(pkg: Package, options?: BuildManifestOptions): void;
+declare function validateManifest(pkg: Package): ManifestProblem[];
+declare function setDocumentMediaType(pkg: Package, mediaType: string, version?: string): void;
+//#endregion
+export { BuildManifestOptions, MANIFEST_PART, Manifest, ManifestEntry, ManifestEntrySchema, ManifestProblem, ManifestProblemSchema, ManifestSchema, buildManifest, readManifest, setDocumentMediaType, syncManifest, validateManifest, writeManifest };

package/dist/manifest.js

@@ -0,0 +1,242 @@
+import { base64ToBytes } from "./util/base64.js";
+import { MANIFEST_PART } from "./package-io/write.js";
+import { xmlnsAttributes } from "./ns.js";
+import { mediaTypeForExtension } from "./media-type.js";
+import { sniffImageFormat } from "./image/sniff.js";
+import { readMimetype, writeMimetype } from "./mimetype.js";
+import { el } from "./xml/fragment.js";
+import { encodeXmlText } from "./xml/entities.js";
+import { z } from "zod";
+//#region src/manifest.ts
+const ManifestEntrySchema = z.object({
+	fullPath: z.string(),
+	mediaType: z.string(),
+	version: z.string().optional()
+});
+const ManifestSchema = z.object({
+	version: z.string(),
+	entries: z.array(ManifestEntrySchema)
+});
+const ManifestProblemSchema = z.object({
+	severity: z.enum(["error", "warning"]),
+	message: z.string(),
+	path: 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
+export { MANIFEST_PART, ManifestEntrySchema, ManifestProblemSchema, ManifestSchema, buildManifest, readManifest, setDocumentMediaType, syncManifest, validateManifest, writeManifest };

package/dist/media-type.cjs

@@ -0,0 +1,27 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#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
+exports.ODF_MEDIA_TYPES = ODF_MEDIA_TYPES;
+exports.mediaTypeForExtension = mediaTypeForExtension;

package/dist/media-type.d.cts

@@ -0,0 +1,20 @@
+//#region src/media-type.d.ts
+declare const ODF_MEDIA_TYPES: Readonly<{
+  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";
+}>;
+type OdfExtension = keyof typeof ODF_MEDIA_TYPES;
+declare function mediaTypeForExtension(extension: string): string | undefined;
+//#endregion
+export { ODF_MEDIA_TYPES, OdfExtension, mediaTypeForExtension };

package/dist/media-type.d.ts

@@ -0,0 +1,20 @@
+//#region src/media-type.d.ts
+declare const ODF_MEDIA_TYPES: Readonly<{
+  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";
+}>;
+type OdfExtension = keyof typeof ODF_MEDIA_TYPES;
+declare function mediaTypeForExtension(extension: string): string | undefined;
+//#endregion
+export { ODF_MEDIA_TYPES, OdfExtension, mediaTypeForExtension };

package/dist/media-type.js

@@ -0,0 +1,25 @@
+//#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
+export { ODF_MEDIA_TYPES, mediaTypeForExtension };