@segnavia/idml 0.0.0-stage → 0.28.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 modstudio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/import.d.ts

@@ -0,0 +1,13 @@
+import { Book } from "@segnavia/format";
+//#region src/import.d.ts
+export type IdmlImportOptions = Record<never, never>;
+export interface IdmlImportReport {
+  partsRead: string[];
+  unsupportedElements: Record<string, number>;
+}
+export interface IdmlImportResult {
+  book: Book;
+  report: IdmlImportReport;
+}
+export declare function importIdml(bytes: Uint8Array, _options?: IdmlImportOptions): Promise<IdmlImportResult>;
+//#endregion

package/dist/import.js

@@ -0,0 +1,25 @@
+import { refusal } from "./refusal.js";
+import { modelToBook } from "./map-book.js";
+import { idmlModel } from "./model.js";
+import { readZip } from "./zip.js";
+//#region src/import.ts
+const IDML_MIMETYPE = "application/vnd.adobe.indesign-idml-package";
+async function importIdml(bytes, _options = {}) {
+	const entries = await readZip(bytes);
+	const byName = new Map(entries.map((entry) => [entry.name, entry.bytes]));
+	const mimetype = byName.get("mimetype");
+	if (!mimetype) throw refusal("the IDML mimetype entry is missing", "add the required mimetype entry");
+	const value = new TextDecoder().decode(mimetype);
+	if (value !== IDML_MIMETYPE) throw refusal(`the IDML mimetype entry is ${JSON.stringify(value)}, not ${IDML_MIMETYPE}`, "use the IDML package mimetype");
+	if (!byName.has("designmap.xml")) throw refusal("the IDML designmap.xml entry is missing", "add the required designmap.xml entry");
+	const model = idmlModel(entries);
+	return {
+		book: modelToBook(model),
+		report: {
+			partsRead: model.partsRead,
+			unsupportedElements: model.unsupportedElements
+		}
+	};
+}
+//#endregion
+export { importIdml };

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { IdmlImportOptions, IdmlImportReport, IdmlImportResult, importIdml } from "./import.js";
+import { IDML_LIMITS, MAX_IDML_ENTRIES, MAX_IDML_PACKAGE_BYTES, MAX_IDML_PART_BYTES, MAX_IDML_TOTAL_INFLATED_BYTES, MAX_IDML_XML_DEPTH } from "./limits.js";
+import { IdmlDocumentPreferences, IdmlMargin, IdmlMasterSpread, IdmlModel, IdmlPage, IdmlSpread, IdmlStory } from "./model.js";
+export { IDML_LIMITS, type IdmlDocumentPreferences, type IdmlImportOptions, type IdmlImportReport, type IdmlImportResult, type IdmlMargin, type IdmlMasterSpread, type IdmlModel, type IdmlPage, type IdmlSpread, type IdmlStory, MAX_IDML_ENTRIES, MAX_IDML_PACKAGE_BYTES, MAX_IDML_PART_BYTES, MAX_IDML_TOTAL_INFLATED_BYTES, MAX_IDML_XML_DEPTH, importIdml };

package/dist/index.js

@@ -0,0 +1,3 @@
+import { IDML_LIMITS, MAX_IDML_ENTRIES, MAX_IDML_PACKAGE_BYTES, MAX_IDML_PART_BYTES, MAX_IDML_TOTAL_INFLATED_BYTES, MAX_IDML_XML_DEPTH } from "./limits.js";
+import { importIdml } from "./import.js";
+export { IDML_LIMITS, MAX_IDML_ENTRIES, MAX_IDML_PACKAGE_BYTES, MAX_IDML_PART_BYTES, MAX_IDML_TOTAL_INFLATED_BYTES, MAX_IDML_XML_DEPTH, importIdml };

package/dist/limits.d.ts

@@ -0,0 +1,15 @@
+//#region src/limits.d.ts
+export declare const MAX_IDML_PACKAGE_BYTES: number;
+export declare const MAX_IDML_ENTRIES = 4096;
+export declare const MAX_IDML_PART_BYTES: number;
+export declare const MAX_IDML_TOTAL_INFLATED_BYTES: number;
+export declare const MAX_IDML_XML_DEPTH = 256;
+export interface IdmlLimits {
+  packageBytes: number;
+  entries: number;
+  partBytes: number;
+  totalInflatedBytes: number;
+  xmlDepth: number;
+}
+export declare const IDML_LIMITS: Readonly<IdmlLimits>;
+//#endregion

package/dist/limits.js

@@ -0,0 +1,15 @@
+//#region src/limits.ts
+const MAX_IDML_PACKAGE_BYTES = 67108864;
+const MAX_IDML_ENTRIES = 4096;
+const MAX_IDML_PART_BYTES = 33554432;
+const MAX_IDML_TOTAL_INFLATED_BYTES = 268435456;
+const MAX_IDML_XML_DEPTH = 256;
+const IDML_LIMITS = {
+	packageBytes: MAX_IDML_PACKAGE_BYTES,
+	entries: MAX_IDML_ENTRIES,
+	partBytes: MAX_IDML_PART_BYTES,
+	totalInflatedBytes: MAX_IDML_TOTAL_INFLATED_BYTES,
+	xmlDepth: 256
+};
+//#endregion
+export { IDML_LIMITS, MAX_IDML_ENTRIES, MAX_IDML_PACKAGE_BYTES, MAX_IDML_PART_BYTES, MAX_IDML_TOTAL_INFLATED_BYTES, MAX_IDML_XML_DEPTH };

package/dist/map-book.js

@@ -0,0 +1,47 @@
+import { refusal } from "./refusal.js";
+import { Book, MM_PER_PT } from "@segnavia/format";
+import { findActiveContent } from "@segnavia/html";
+import serialize from "dom-serializer";
+import { Element } from "domhandler";
+//#region src/map-book.ts
+const emptyParagraph = () => serialize(new Element("p", {}, []), { xmlMode: false });
+function orderedStories(model) {
+	const order = /* @__PURE__ */ new Map();
+	for (const spread of model.spreads) for (const page of spread.pages) for (const story of page.stories) if (!order.has(story)) order.set(story, order.size);
+	const masterStories = new Set(model.masterStoryIds);
+	return model.stories.filter((story) => !masterStories.has(story.id)).sort((left, right) => (order.get(left.id) ?? Number.MAX_SAFE_INTEGER) - (order.get(right.id) ?? Number.MAX_SAFE_INTEGER));
+}
+function modelToBook(model) {
+	const preferences = model.preferences;
+	const rightBinding = preferences.binding === "right-to-left";
+	const chapters = orderedStories(model).map((story) => ({
+		title: story.id,
+		html: emptyParagraph()
+	}));
+	if (chapters.length === 0) throw refusal("the IDML has no stories", "add at least one Story");
+	const html = chapters.map((chapter) => chapter.html).join("");
+	const active = findActiveContent(html);
+	if (active.length > 0) throw refusal(`the imported Book contains active content (${active.join(", ")})`, "remove that active content");
+	return Book.parse({
+		title: model.id,
+		mode: "paginated",
+		page: {
+			paper: {
+				width: preferences.pageWidth,
+				height: preferences.pageHeight,
+				unit: "pt"
+			},
+			margin: {
+				top: preferences.margin.top * MM_PER_PT,
+				bottom: preferences.margin.bottom * MM_PER_PT,
+				inner: (rightBinding ? preferences.margin.right : preferences.margin.left) * MM_PER_PT,
+				outer: (rightBinding ? preferences.margin.left : preferences.margin.right) * MM_PER_PT
+			}
+		},
+		dir: rightBinding ? "rtl" : "ltr",
+		rectoOpenings: preferences.facingPages,
+		chapters
+	});
+}
+//#endregion
+export { modelToBook };

package/dist/model.d.ts

@@ -0,0 +1,42 @@
+//#region src/model.d.ts
+export interface IdmlMargin {
+  top: number;
+  bottom: number;
+  left: number;
+  right: number;
+}
+export interface IdmlDocumentPreferences {
+  pageWidth: number;
+  pageHeight: number;
+  facingPages: boolean;
+  binding: 'left-to-right' | 'right-to-left';
+  margin: IdmlMargin;
+}
+export interface IdmlPage {
+  id: string;
+  appliedMaster?: string;
+  stories: string[];
+}
+export interface IdmlSpread {
+  id: string;
+  pages: IdmlPage[];
+}
+export interface IdmlMasterSpread {
+  id: string;
+  pages: IdmlPage[];
+}
+export interface IdmlStory {
+  id: string;
+  part: string;
+}
+export interface IdmlModel {
+  id: string;
+  preferences: IdmlDocumentPreferences;
+  spreads: IdmlSpread[];
+  masterSpreads: IdmlMasterSpread[];
+  stories: IdmlStory[];
+  masterStoryIds: string[];
+  partsRead: string[];
+  unsupportedElements: Record<string, number>;
+}
+//#endregion

package/dist/model.js

@@ -0,0 +1,291 @@
+import { refusal } from "./refusal.js";
+import { IDML_LIMITS } from "./limits.js";
+import { isTag } from "domhandler";
+import { Parser, parseDocument } from "htmlparser2";
+//#region src/model.ts
+const MAPPED_ELEMENTS = /* @__PURE__ */ new Set([
+	"Document",
+	"DocumentPreference",
+	"MarginPreference",
+	"MasterSpread",
+	"Spread",
+	"Page",
+	"Story",
+	"TextFrame"
+]);
+function localName(name) {
+	return name.includes(":") ? name.split(":").at(-1) ?? name : name;
+}
+function elements(root, name) {
+	const found = [];
+	const pending = [root];
+	while (pending.length > 0) {
+		const node = pending.pop();
+		if (!node) continue;
+		if (isTag(node)) {
+			if (!name || localName(node.name) === name) found.push(node);
+		}
+		if ("children" in node) for (let index = node.children.length - 1; index >= 0; index -= 1) pending.push(node.children[index]);
+	}
+	return found;
+}
+function attribute(element, ...names) {
+	for (const name of names) {
+		const value = element.attribs[name];
+		if (value !== void 0) return value;
+	}
+}
+function numberAttribute(element, name, fallback) {
+	const raw = element && attribute(element, name);
+	const value = raw === void 0 ? fallback : Number(raw);
+	if (value === void 0 || !Number.isFinite(value) || value < 0) throw refusal(`IDML ${name} must be a non-negative number`, `set ${name} to a non-negative numeric value`);
+	return value;
+}
+function boolAttribute(element, name, fallback) {
+	const raw = attribute(element, name);
+	if (raw === void 0) return fallback;
+	if (raw === "true") return true;
+	if (raw === "false") return false;
+	throw refusal(`IDML ${name} must be true or false`, `set ${name} to true or false`);
+}
+function checkXmlDepth(source, part, limit) {
+	let depth = 0;
+	new Parser({
+		onopentag() {
+			depth += 1;
+			if (depth > limit) throw refusal(`IDML XML part ${part} exceeds the ${limit} level XML depth limit`, `reduce its nesting to ${limit} levels or fewer`);
+		},
+		onclosetag() {
+			depth -= 1;
+		}
+	}, {
+		xmlMode: true,
+		recognizeSelfClosing: true
+	}).end(source);
+}
+function parseParts(entries, limits) {
+	const decoder = new TextDecoder("utf-8", { fatal: true });
+	return entries.filter((entry) => entry.name.toLowerCase().endsWith(".xml")).map((entry) => {
+		let source;
+		try {
+			source = decoder.decode(entry.bytes);
+		} catch {
+			throw refusal(`IDML XML part ${entry.name} is not valid UTF-8`, "export that XML part as UTF-8");
+		}
+		let document;
+		try {
+			checkXmlDepth(source, entry.name, limits.xmlDepth);
+			document = parseDocument(source, {
+				xmlMode: true,
+				recognizeSelfClosing: true
+			});
+		} catch (error) {
+			if (error instanceof Error && error.message.includes("XML depth limit")) throw error;
+			throw refusal(`IDML XML part ${entry.name} could not be parsed: ${String(error)}`, "export well-formed XML");
+		}
+		const all = elements(document);
+		if (all.length === 0) throw refusal(`IDML XML part ${entry.name} has no root element`, "export a non-empty well-formed XML part");
+		return {
+			name: entry.name,
+			document,
+			all
+		};
+	});
+}
+function page(element) {
+	const id = attribute(element, "Self");
+	if (!id) throw refusal("an IDML Page has no Self identifier", "give every Page a Self identifier");
+	return {
+		id,
+		appliedMaster: attribute(element, "AppliedMaster"),
+		stories: []
+	};
+}
+const IDENTITY = [
+	1,
+	0,
+	0,
+	1,
+	0,
+	0
+];
+function transform(element) {
+	const values = (attribute(element, "ItemTransform") ?? "").trim().split(/\s+/).map(Number);
+	return values.length === 6 && values.every(Number.isFinite) ? values : IDENTITY;
+}
+function compose(parent, child) {
+	const [a, b, c, d, x, y] = parent;
+	const [e, f, g, h, u, v] = child;
+	return [
+		a * e + c * f,
+		b * e + d * f,
+		a * g + c * h,
+		b * g + d * h,
+		a * u + c * v + x,
+		b * u + d * v + y
+	];
+}
+function apply(value, point) {
+	return [value[0] * point[0] + value[2] * point[1] + value[4], value[1] * point[0] + value[3] * point[1] + value[5]];
+}
+function pageArea(element) {
+	const bounds = (attribute(element, "GeometricBounds") ?? "").trim().split(/\s+/).map(Number);
+	if (bounds.length !== 4 || !bounds.every(Number.isFinite)) return void 0;
+	const [top, left, bottom, right] = bounds;
+	const matrix = transform(element);
+	return [
+		apply(matrix, [left, top]),
+		apply(matrix, [right, top]),
+		apply(matrix, [right, bottom]),
+		apply(matrix, [left, bottom])
+	];
+}
+function frameCenter(element, matrix) {
+	const anchors = elements(element).map((candidate) => attribute(candidate, "Anchor")).filter((value) => value !== void 0).map((value) => value.trim().split(/\s+/).map(Number)).filter((value) => value.length === 2 && value.every(Number.isFinite)).map((point) => apply(matrix, point));
+	if (anchors.length === 0) return void 0;
+	const xs = anchors.map(([x]) => x);
+	const ys = anchors.map(([, y]) => y);
+	return [(Math.min(...xs) + Math.max(...xs)) / 2, (Math.min(...ys) + Math.max(...ys)) / 2];
+}
+function contains(area, [x, y]) {
+	let inside = false;
+	for (let index = 0, previous = area.length - 1; index < area.length; previous = index, index += 1) {
+		const [xi, yi] = area[index];
+		const [xj, yj] = area[previous];
+		if (yi === yj && y === yi && x >= Math.min(xi, xj) && x <= Math.max(xi, xj)) return true;
+		if (yi > y !== yj > y && x <= (xj - xi) * (y - yi) / (yj - yi) + xi) inside = !inside;
+	}
+	return inside;
+}
+function spreadFrames(spread) {
+	const result = [];
+	const pending = [...spread.children].reverse().map((node) => ({
+		node,
+		matrix: IDENTITY
+	}));
+	while (pending.length > 0) {
+		const current = pending.pop();
+		if (!current || !isTag(current.node)) continue;
+		const name = localName(current.node.name);
+		if (name === "Page" || name === "Spread" || name === "MasterSpread") continue;
+		const matrix = name === "Group" || name === "TextFrame" ? compose(current.matrix, transform(current.node)) : current.matrix;
+		if (name === "TextFrame") {
+			const story = attribute(current.node, "ParentStory");
+			if (story) result.push({
+				story,
+				center: frameCenter(current.node, matrix)
+			});
+			continue;
+		}
+		for (let index = current.node.children.length - 1; index >= 0; index -= 1) pending.push({
+			node: current.node.children[index],
+			matrix
+		});
+	}
+	return result;
+}
+function placeStories(element, pageElements, pages, unsupportedCounts) {
+	const areas = pageElements.map(pageArea);
+	const frameStories = /* @__PURE__ */ new Set();
+	for (const frame of spreadFrames(element)) {
+		frameStories.add(frame.story);
+		const pageIndex = frame.center ? areas.findIndex((area) => area !== void 0 && contains(area, frame.center)) : -1;
+		const target = pages[pageIndex];
+		if (target && !target.stories.includes(frame.story)) target.stories.push(frame.story);
+		else if (pageIndex < 0) unsupportedCounts.set("TextFrame off page", (unsupportedCounts.get("TextFrame off page") ?? 0) + 1);
+	}
+	return frameStories;
+}
+function spreads(parts, kind, orderedNames, unsupportedCounts) {
+	const result = [];
+	const frameStories = /* @__PURE__ */ new Set();
+	const byName = new Map(parts.map((part) => [part.name, part]));
+	const named = new Set(orderedNames);
+	const unlisted = parts.filter((part) => !named.has(part.name) && part.all.some((element) => localName(element.name) === kind && attribute(element, "Self"))).length;
+	if (unlisted > 0) unsupportedCounts.set("unlisted spread part", (unsupportedCounts.get("unlisted spread part") ?? 0) + unlisted);
+	for (const name of orderedNames) {
+		const part = byName.get(name);
+		if (!part) throw refusal(`designmap.xml ${kind} src ${name} has no matching ZIP entry`, `add the named ${kind} part to the package`);
+		for (const element of part.all.filter((candidate) => localName(candidate.name) === kind)) {
+			const id = attribute(element, "Self");
+			if (!id) continue;
+			const pageElements = elements(element, "Page");
+			const pages = pageElements.map(page);
+			for (const story of placeStories(element, pageElements, pages, unsupportedCounts)) frameStories.add(story);
+			result.push({
+				id,
+				pages
+			});
+		}
+	}
+	return {
+		values: result,
+		frameStories
+	};
+}
+function spreadSources(document, kind) {
+	return document.all.filter((element) => localName(element.name) === kind).map((element) => attribute(element, "src")).filter((source) => source !== void 0);
+}
+function stories(parts) {
+	const result = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const part of parts) for (const element of part.all.filter((candidate) => localName(candidate.name) === "Story")) {
+		const id = attribute(element, "Self");
+		if (!id || seen.has(id)) continue;
+		seen.add(id);
+		result.push({
+			id,
+			part: part.name
+		});
+	}
+	return result;
+}
+function unsupported(parts) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const part of parts) for (const element of part.all) {
+		const name = localName(element.name);
+		if (MAPPED_ELEMENTS.has(name)) continue;
+		counts.set(name, (counts.get(name) ?? 0) + 1);
+	}
+	return counts;
+}
+function idmlModel(entries, limits = IDML_LIMITS) {
+	const parts = parseParts(entries, limits);
+	const designmap = parts.find((part) => part.name === "designmap.xml");
+	if (!designmap) throw refusal("the IDML designmap.xml entry is missing", "add the required designmap.xml entry");
+	const document = parts.flatMap((part) => part.all).find((element) => localName(element.name) === "Document");
+	const preference = parts.flatMap((part) => part.all).find((element) => localName(element.name) === "DocumentPreference");
+	if (!document) throw refusal("designmap.xml has no IDML Document element", "export a valid IDML design map");
+	if (!preference) throw refusal("IDML DocumentPreference is missing", "export document preferences with the package");
+	const margin = parts.flatMap((part) => part.all).find((element) => localName(element.name) === "MarginPreference");
+	const binding = attribute(preference, "PageBinding") ?? attribute(document, "PageBinding") ?? "LeftToRight";
+	if (binding !== "LeftToRight" && binding !== "RightToLeft") throw refusal(`IDML PageBinding ${binding} is not supported`, "use LeftToRight or RightToLeft page binding");
+	const unsupportedCounts = unsupported(parts);
+	const spreadResult = spreads(parts, "Spread", spreadSources(designmap, "Spread"), unsupportedCounts);
+	const masterResult = spreads(parts, "MasterSpread", spreadSources(designmap, "MasterSpread"), unsupportedCounts);
+	const masterStoryIds = [...masterResult.frameStories].filter((story) => !spreadResult.frameStories.has(story));
+	if (masterStoryIds.length > 0) unsupportedCounts.set("master story", masterStoryIds.length);
+	return {
+		id: attribute(document, "Self") ?? "IDML document",
+		preferences: {
+			pageWidth: numberAttribute(preference, "PageWidth"),
+			pageHeight: numberAttribute(preference, "PageHeight"),
+			facingPages: boolAttribute(preference, "FacingPages", true),
+			binding: binding === "RightToLeft" ? "right-to-left" : "left-to-right",
+			margin: {
+				top: numberAttribute(margin, "Top", 0),
+				bottom: numberAttribute(margin, "Bottom", 0),
+				left: numberAttribute(margin, "Left", 0),
+				right: numberAttribute(margin, "Right", 0)
+			}
+		},
+		spreads: spreadResult.values,
+		masterSpreads: masterResult.values,
+		stories: stories(parts),
+		masterStoryIds,
+		partsRead: parts.map((part) => part.name),
+		unsupportedElements: Object.fromEntries([...unsupportedCounts].sort(([left], [right]) => left.localeCompare(right)))
+	};
+}
+//#endregion
+export { idmlModel };

package/dist/refusal.js

@@ -0,0 +1,6 @@
+//#region src/refusal.ts
+function refusal(subject, clear) {
+	return /* @__PURE__ */ new Error(`${subject}; ${clear} to clear this refusal`);
+}
+//#endregion
+export { refusal };

package/dist/zip.js

@@ -0,0 +1,142 @@
+import { refusal } from "./refusal.js";
+import { IDML_LIMITS } from "./limits.js";
+//#region src/zip.ts
+const END_SIGNATURE = 101010256;
+const CENTRAL_SIGNATURE = 33639248;
+const LOCAL_SIGNATURE = 67324752;
+const MAX_END_SEARCH = 65557;
+function range(view, offset, length, label) {
+	if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) || offset < 0 || length < 0 || offset + length > view.byteLength) throw refusal(`the ZIP ${label} is outside the package`, "export a complete IDML package");
+}
+function findEnd(view) {
+	const first = Math.max(0, view.byteLength - MAX_END_SEARCH);
+	for (let offset = view.byteLength - 22; offset >= first; offset -= 1) if (view.getUint32(offset, true) === END_SIGNATURE) return offset;
+	throw refusal("the ZIP end-of-central-directory record is missing", "export a complete IDML package");
+}
+function validateCentralEntry(entry, startDisk, names) {
+	if ((entry.flags & 65) !== 0) throw refusal(`ZIP entry ${entry.name} is encrypted`, "export the IDML without ZIP encryption");
+	if (startDisk !== 0) throw refusal(`ZIP entry ${entry.name} spans disks`, "place every entry in one ordinary ZIP disk");
+	if (entry.compressedSize === 4294967295 || entry.inflatedSize === 4294967295 || entry.localOffset === 4294967295) throw refusal(`ZIP entry ${entry.name} uses ZIP64`, "export an ordinary ZIP package within the named IDML limits");
+	if (entry.method !== 0 && entry.method !== 8) throw refusal(`ZIP entry ${entry.name} uses compression method ${entry.method}`, "store it or use the deflate compression method");
+	if (names.has(entry.name)) throw refusal(`the ZIP contains duplicate entry ${entry.name}`, "give every IDML part one unique package path");
+	names.add(entry.name);
+}
+function centralEntries(view, limits) {
+	const end = findEnd(view);
+	range(view, end, 22, "end-of-central-directory record");
+	const disk = view.getUint16(end + 4, true);
+	const centralDisk = view.getUint16(end + 6, true);
+	const diskEntries = view.getUint16(end + 8, true);
+	const entries = view.getUint16(end + 10, true);
+	const centralSize = view.getUint32(end + 12, true);
+	const centralOffset = view.getUint32(end + 16, true);
+	range(view, end, 22 + view.getUint16(end + 20, true), "end-of-central-directory record");
+	if (disk !== 0 || centralDisk !== 0 || diskEntries !== entries) throw refusal("ZIP entries spanning disks are not supported", "place every entry in one ordinary ZIP disk");
+	if (entries === 65535 || centralSize === 4294967295 || centralOffset === 4294967295) throw refusal("ZIP64 is not supported", "export an ordinary ZIP package within the named IDML limits");
+	if (entries > limits.entries) throw refusal(`the ZIP entry count ${entries} exceeds the ${limits.entries} entry limit`, `reduce the package to ${limits.entries} entries or fewer`);
+	range(view, centralOffset, centralSize, "central directory");
+	const decoder = new TextDecoder();
+	const result = [];
+	const names = /* @__PURE__ */ new Set();
+	let offset = centralOffset;
+	for (let index = 0; index < entries; index += 1) {
+		range(view, offset, 46, "central-directory entry");
+		if (view.getUint32(offset, true) !== CENTRAL_SIGNATURE) throw refusal(`ZIP central-directory entry ${index + 1} is invalid`, "export a complete IDML package");
+		const flags = view.getUint16(offset + 8, true);
+		const method = view.getUint16(offset + 10, true);
+		const compressedSize = view.getUint32(offset + 20, true);
+		const inflatedSize = view.getUint32(offset + 24, true);
+		const nameLength = view.getUint16(offset + 28, true);
+		const extraLength = view.getUint16(offset + 30, true);
+		const entryCommentLength = view.getUint16(offset + 32, true);
+		const startDisk = view.getUint16(offset + 34, true);
+		const localOffset = view.getUint32(offset + 42, true);
+		const recordLength = 46 + nameLength + extraLength + entryCommentLength;
+		range(view, offset, recordLength, "central-directory entry");
+		const entry = {
+			name: decoder.decode(new Uint8Array(view.buffer, view.byteOffset + offset + 46, nameLength)),
+			flags,
+			method,
+			compressedSize,
+			inflatedSize,
+			localOffset
+		};
+		validateCentralEntry(entry, startDisk, names);
+		result.push(entry);
+		offset += recordLength;
+	}
+	if (offset !== centralOffset + centralSize) throw refusal("the ZIP central-directory size does not match its entries", "export a complete IDML package");
+	return result;
+}
+async function inflatedStream(bytes, entry) {
+	const source = new Blob([bytes.slice().buffer]).stream();
+	if (entry.method === 0) return source;
+	if (typeof DecompressionStream === "undefined") throw refusal("DecompressionStream is unavailable at run time", "use a runtime with DecompressionStream deflate-raw support or store every ZIP entry");
+	try {
+		const decompressor = new DecompressionStream("deflate-raw");
+		return source.pipeThrough(decompressor);
+	} catch {
+		throw refusal("DecompressionStream does not support deflate-raw at run time", "use a runtime with DecompressionStream deflate-raw support or store every ZIP entry");
+	}
+}
+async function inflate(bytes, entry, limits, total) {
+	if (entry.inflatedSize > limits.partBytes) throw refusal(`ZIP entry ${entry.name} declares ${entry.inflatedSize} inflated bytes, exceeding the ${limits.partBytes} byte per-part limit`, `reduce that part to ${limits.partBytes} bytes or fewer`);
+	const reader = (await inflatedStream(bytes, entry)).getReader();
+	const chunks = [];
+	let size = 0;
+	while (true) {
+		let next;
+		try {
+			next = await reader.read();
+		} catch {
+			throw refusal(`ZIP entry ${entry.name} could not be inflated`, "export a complete IDML package");
+		}
+		if (next.done) break;
+		size += next.value.byteLength;
+		total.bytes += next.value.byteLength;
+		if (size > limits.partBytes) {
+			await reader.cancel();
+			throw refusal(`ZIP entry ${entry.name} exceeds the ${limits.partBytes} byte inflated per-part limit`, `reduce that part to ${limits.partBytes} bytes or fewer`);
+		}
+		if (total.bytes > limits.totalInflatedBytes) {
+			await reader.cancel();
+			throw refusal(`the ZIP exceeds the ${limits.totalInflatedBytes} byte total inflated limit`, `reduce all inflated parts to ${limits.totalInflatedBytes} bytes or fewer`);
+		}
+		chunks.push(next.value);
+	}
+	if (size !== entry.inflatedSize) throw refusal(`ZIP entry ${entry.name} declared ${entry.inflatedSize} inflated bytes but produced ${size}`, "export a complete IDML package");
+	const result = new Uint8Array(size);
+	let offset = 0;
+	for (const chunk of chunks) {
+		result.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return result;
+}
+function compressedBytes(bytes, view, entry) {
+	range(view, entry.localOffset, 30, `local header for ${entry.name}`);
+	if (view.getUint32(entry.localOffset, true) !== LOCAL_SIGNATURE) throw refusal(`the ZIP local header for ${entry.name} is invalid`, "export a complete IDML package");
+	const localFlags = view.getUint16(entry.localOffset + 6, true);
+	const localMethod = view.getUint16(entry.localOffset + 8, true);
+	if ((localFlags & 65) !== 0) throw refusal(`ZIP entry ${entry.name} is encrypted`, "export the IDML without ZIP encryption");
+	if (localMethod !== entry.method) throw refusal(`ZIP entry ${entry.name} has conflicting compression methods`, "export a complete IDML package");
+	const nameLength = view.getUint16(entry.localOffset + 26, true);
+	const extraLength = view.getUint16(entry.localOffset + 28, true);
+	const start = entry.localOffset + 30 + nameLength + extraLength;
+	range(view, start, entry.compressedSize, `data for ${entry.name}`);
+	return bytes.subarray(start, start + entry.compressedSize);
+}
+async function readZip(bytes, limits = IDML_LIMITS) {
+	if (bytes.byteLength > limits.packageBytes) throw refusal(`the IDML package has ${bytes.byteLength} bytes, exceeding the ${limits.packageBytes} byte package limit`, `reduce the package to ${limits.packageBytes} bytes or fewer`);
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const entries = centralEntries(view, limits);
+	const result = [];
+	const total = { bytes: 0 };
+	for (const entry of entries) result.push({
+		name: entry.name,
+		bytes: await inflate(compressedBytes(bytes, view, entry), entry, limits, total)
+	});
+	return result;
+}
+//#endregion
+export { readZip };

package/package.json

@@ -1,6 +1,35 @@
 {
   "name": "@segnavia/idml",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.28.0",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/modstudio/segnavia.git",
+    "directory": "packages/idml"
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "@segnavia/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@segnavia/format": "0.28.0",
+    "@segnavia/html": "0.28.0",
+    "dom-serializer": "^2.0.0",
+    "domhandler": "^5.0.3",
+    "htmlparser2": "^10.0.0"
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.