@segnavia/idml 0.0.0-stage → 0.29.0

package/dist/styles.js

@@ -0,0 +1,285 @@
+import { stylePropertyMapping } from "./style-mappings.js";
+import { reportableStyleProperties } from "./style-property-report.js";
+import { idmlDirection, localName } from "./xml.js";
+import { isTag } from "domhandler";
+//#region src/styles.ts
+const PARAGRAPH_ROOT = "$ID/[No paragraph style]";
+const CHARACTER_ROOT = "$ID/[No character style]";
+function text(element) {
+	return element.children.map((child) => "data" in child ? child.data : isTag(child) ? text(child) : "").join("").trim();
+}
+function properties(element) {
+	const result = { ...element.attribs };
+	const holder = element.children.find((child) => isTag(child) && localName(child.name) === "Properties");
+	for (const child of holder?.children ?? []) {
+		if (!isTag(child)) continue;
+		const value = text(child);
+		if (value || child.children.some(isTag)) result[localName(child.name)] = value || "[entry]";
+	}
+	return result;
+}
+function parseStyles(roots, part) {
+	const result = [];
+	for (const kind of ["ParagraphStyle", "CharacterStyle"]) for (const element of roots.filter((candidate) => localName(candidate.name) === kind)) {
+		const values = properties(element);
+		const id = values.Self;
+		if (!id) continue;
+		result.push({
+			id,
+			name: values.Name ?? id.split("/").at(-1) ?? id,
+			kind: kind === "ParagraphStyle" ? "paragraph" : "character",
+			...values.BasedOn ? { basedOn: values.BasedOn } : {},
+			properties: Object.fromEntries(Object.entries(values).filter(([name]) => ![
+				"Self",
+				"Name",
+				"BasedOn"
+			].includes(name))),
+			location: `${part}#${id}`
+		});
+	}
+	return result;
+}
+function parseSwatches(roots) {
+	const result = [];
+	for (const element of roots.filter((candidate) => localName(candidate.name) === "Color")) {
+		const id = element.attribs.Self;
+		if (!id) continue;
+		const name = element.attribs.Name ?? id;
+		const space = element.attribs.Space;
+		const values = (element.attribs.ColorValue ?? "").trim().split(/\s+/).map(Number).filter(Number.isFinite);
+		const model = element.attribs.Model === "Spot" ? "spot" : space === "RGB" ? "rgb" : space === "CMYK" ? "cmyk" : "named";
+		result.push({
+			id,
+			name,
+			model,
+			...values.length > 0 ? { values } : {}
+		});
+	}
+	return result;
+}
+function rootName(kind) {
+	return kind === "paragraph" ? PARAGRAPH_ROOT : CHARACTER_ROOT;
+}
+function slug(value) {
+	return value.normalize("NFKD").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "style";
+}
+const LANGUAGES = {
+	"$ID/Hebrew": "he",
+	"$ID/English: USA": "en-US",
+	"$ID/English: UK": "en-GB",
+	"$ID/French": "fr",
+	"$ID/German": "de",
+	"$ID/Spanish": "es",
+	"$ID/Italian": "it",
+	"$ID/Arabic": "ar"
+};
+function hasCssMapping(names, css) {
+	return [...names].some((name) => {
+		const mapping = stylePropertyMapping(name);
+		return mapping?.kind === "css" && mapping.css === css;
+	});
+}
+function textDeclarations(values, mapped, output) {
+	if (mapped.has("Capitalization") && values.Capitalization === "SmallCaps") output.push("font-variant-caps:small-caps");
+	if (mapped.has("Capitalization") && values.Capitalization === "AllCaps") output.push("text-transform:uppercase");
+	if (mapped.has("Underline") && (values.Underline === "true" || values.Underline === "Underline")) output.push("text-decoration-line:underline");
+}
+var StyleMapper = class {
+	swatches;
+	report;
+	bookDirection;
+	byId;
+	classes = /* @__PURE__ */ new Map();
+	used = /* @__PURE__ */ new Set();
+	overrides = /* @__PURE__ */ new Map();
+	reportedStyleProperties = /* @__PURE__ */ new Set();
+	constructor(styles, swatches, report, bookDirection) {
+		this.swatches = swatches;
+		this.report = report;
+		this.bookDirection = bookDirection;
+		this.byId = new Map(styles.map((style) => [style.id, style]));
+		const taken = /* @__PURE__ */ new Set();
+		for (const style of styles) {
+			const base = `${style.kind === "paragraph" ? "idml-p-" : "idml-c-"}${slug(style.name)}`;
+			let candidate = base;
+			let suffix = 2;
+			while (taken.has(candidate)) candidate = `${base}-${suffix++}`;
+			taken.add(candidate);
+			this.classes.set(style.id, candidate);
+		}
+	}
+	flattened(id, kind) {
+		return Object.assign({}, ...this.styleChain(id, kind).map((style) => style.properties));
+	}
+	styleChain(id, kind) {
+		const root = this.rootStyle(kind);
+		const chain = [];
+		const seen = /* @__PURE__ */ new Set();
+		let current = this.findStyle(id, kind);
+		while (current && !seen.has(current.id)) {
+			seen.add(current.id);
+			chain.unshift(current);
+			current = this.findStyle(current.basedOn, kind);
+		}
+		if (root && !chain.includes(root)) chain.unshift(root);
+		return chain;
+	}
+	styleClass(id, _kind) {
+		if (!id || id.includes("[None]") || id.includes("[No character style]")) return void 0;
+		const style = this.findStyle(id, _kind);
+		const value = style ? this.classes.get(style.id) : void 0;
+		if (value && style) this.used.add(style.id);
+		return value;
+	}
+	overrideClass(values, base, directionValue, location, styleDirection) {
+		const changed = Object.fromEntries(Object.entries(values).filter(([name, value]) => stylePropertyMapping(name)?.kind !== "non-formatting" && value !== base[name]));
+		const resolved = {
+			...base,
+			...values
+		};
+		for (const name of reportableStyleProperties(changed, resolved)) this.report.add(this.report.unsupportedOverrideProperties, name, location);
+		if (changed.AppliedFont !== void 0 || changed.FontStyle !== void 0) this.report.font(resolved.AppliedFont, resolved.FontStyle, location);
+		const cssProperties = Object.fromEntries(Object.entries(changed).filter(([name]) => stylePropertyMapping(name)?.kind === "css"));
+		if (styleDirection && styleDirection !== directionValue) {
+			for (const name of ["LeftIndent", "RightIndent"]) cssProperties[name] = base[name] ?? "0";
+			for (const name of ["Justification"]) if (base[name] !== void 0 && cssProperties[name] === void 0) cssProperties[name] = base[name];
+		}
+		if (Object.keys(cssProperties).length === 0) return void 0;
+		const key = JSON.stringify(Object.entries(cssProperties).sort(([a], [b]) => a.localeCompare(b))) + directionValue;
+		const found = this.overrides.get(key);
+		if (found) return found.name;
+		const name = `idml-o-${this.overrides.size + 1}`;
+		this.overrides.set(key, {
+			name,
+			properties: cssProperties,
+			direction: directionValue
+		});
+		return name;
+	}
+	paragraphDirection(properties) {
+		return idmlDirection(properties.ParagraphDirection);
+	}
+	paragraphStyleDirection(properties) {
+		return this.paragraphDirection(properties) ?? this.bookDirection;
+	}
+	language(value, location) {
+		if (!value) return void 0;
+		const known = LANGUAGES[value];
+		if (!known) this.report.add(this.report.unsupportedLanguages, value, location);
+		return known;
+	}
+	rootLanguage() {
+		const root = this.rootStyle("paragraph");
+		return this.language(root?.properties.AppliedLanguage, root?.location ?? "Resources/Styles.xml");
+	}
+	css() {
+		const rules = [];
+		for (const id of this.used) {
+			const style = this.byId.get(id);
+			const name = this.classes.get(id);
+			if (!style || !name) continue;
+			const values = this.flattened(id, style.kind);
+			this.reportUnmappedStyleProperties(style);
+			this.report.font(values.AppliedFont, values.FontStyle, style.location);
+			const dir = style.kind === "paragraph" ? this.paragraphStyleDirection(values) : this.bookDirection;
+			const declarations = this.declarations(values, dir, style.location);
+			rules.push(`.${name}{${declarations}}`);
+		}
+		for (const value of this.overrides.values()) {
+			const declarations = this.declarations(value.properties, value.direction, value.name, this.report.unsupportedOverrideProperties);
+			if (declarations) rules.push(`.${value.name}{${declarations}}`);
+		}
+		return rules.join("");
+	}
+	declarations(values, dir, location, unsupported = this.report.unsupportedStyleProperties) {
+		const output = [];
+		const mapped = new Set(Object.keys(values).filter((name) => stylePropertyMapping(name)?.kind === "css"));
+		const pt = (name, property) => {
+			if (!mapped.has(name)) return;
+			const value = Number(values[name]);
+			if (Number.isFinite(value)) output.push(`${property}:${value}pt`);
+		};
+		pt("PointSize", "font-size");
+		if (mapped.has("Leading") && values.Leading === "Auto") output.push(`line-height:${(Number(values.AutoLeading) || 120) / 100}`);
+		else pt("Leading", "line-height");
+		const tracking = Number(values.Tracking);
+		if (mapped.has("Tracking") && Number.isFinite(tracking)) output.push(`letter-spacing:${tracking / 1e3}em`);
+		pt("SpaceBefore", "margin-block-start");
+		pt("SpaceAfter", "margin-block-end");
+		pt("FirstLineIndent", "text-indent");
+		const startIndent = dir === "rtl" ? "RightIndent" : "LeftIndent";
+		const endIndent = dir === "rtl" ? "LeftIndent" : "RightIndent";
+		pt(startIndent, "padding-inline-start");
+		pt(endIndent, "padding-inline-end");
+		textDeclarations(values, mapped, output);
+		if (mapped.has("Justification")) this.justification(values.Justification, dir, output, location, unsupported);
+		if (hasCssMapping(mapped, "keeps")) this.keeps(values, output);
+		if (mapped.has("StartParagraph") && values.StartParagraph && values.StartParagraph !== "Anywhere") this.report.add(unsupported, `StartParagraph:${values.StartParagraph}`, location);
+		const color = mapped.has("FillColor") ? this.color(values.FillColor, location) : void 0;
+		if (color) output.push(`color:${color}`);
+		return output.join(";");
+	}
+	findStyle(id, kind) {
+		if (!id) return void 0;
+		const exact = this.byId.get(id);
+		if (exact?.kind === kind) return exact;
+		return [...this.byId.values()].find((style) => style.kind === kind && (style.name === id || style.id.endsWith(`/${id}`)));
+	}
+	rootStyle(kind) {
+		return [...this.byId.values()].find((style) => style.kind === kind && (style.name === rootName(kind) || style.id.endsWith(`/${rootName(kind)}`)));
+	}
+	reportUnmappedStyleProperties(style) {
+		const root = this.rootStyle(style.kind);
+		const resolved = {};
+		for (const source of this.styleChain(style.id, style.kind)) {
+			Object.assign(resolved, source.properties);
+			for (const name of reportableStyleProperties(source.properties, resolved, source === root)) {
+				const key = `${source.id}\u0000${name}`;
+				if (this.reportedStyleProperties.has(key)) continue;
+				this.reportedStyleProperties.add(key);
+				this.report.add(this.report.unsupportedStyleProperties, name, source.location);
+			}
+		}
+	}
+	justification(value, dir, output, location, bucket) {
+		if (!value) return;
+		const side = (physical) => physical === (dir === "rtl" ? "right" : "left") ? "start" : "end";
+		if (value === "LeftAlign" || value === "RightAlign") output.push(`text-align:${side(value === "LeftAlign" ? "left" : "right")}`);
+		else if (value === "CenterAlign") output.push("text-align:center");
+		else if (value === "FullyJustified") output.push("text-align:justify", "text-align-last:justify");
+		else if (value.endsWith("Justified")) {
+			output.push("text-align:justify");
+			if (value.startsWith("Left")) output.push(`text-align-last:${side("left")}`);
+			else if (value.startsWith("Right")) output.push(`text-align-last:${side("right")}`);
+			else if (value.startsWith("Center")) output.push("text-align-last:center");
+		} else if (value === "ToBindingSide" || value === "AwayFromBindingSide") this.report.add(bucket, `Justification:${value}`, location);
+	}
+	keeps(values, output) {
+		if ((Number(values.KeepWithNext) || 0) > 0) output.push("break-after:avoid");
+		if (values.KeepLinesTogether === "true" && values.KeepAllLinesTogether === "true") output.push("break-inside:avoid");
+		else if (values.KeepLinesTogether === "true") {
+			const first = Number(values.KeepFirstLines);
+			const last = Number(values.KeepLastLines);
+			if (Number.isInteger(first) && first > 0) output.push(`orphans:${first}`);
+			if (Number.isInteger(last) && last > 0) output.push(`widows:${last}`);
+		}
+	}
+	color(id, location) {
+		if (!id || id.endsWith("/None")) return void 0;
+		if (id.endsWith("/Black")) return "#000";
+		if (id.endsWith("/Paper")) return "#fff";
+		const swatch = this.swatches.find((value) => value.id === id || value.name === id);
+		if (!swatch) return void 0;
+		if (swatch.model === "spot") {
+			this.report.add(this.report.spotColors, swatch.name, location);
+			return;
+		}
+		if (swatch.model === "rgb" && swatch.values?.length === 3) return `rgb(${swatch.values.join(" ")})`;
+		if (swatch.model === "cmyk" && swatch.values?.length === 4) {
+			const [c, m, y, k] = swatch.values.map((value) => value / 100);
+			return `rgb(${Math.round(255 * (1 - c) * (1 - k))} ${Math.round(255 * (1 - m) * (1 - k))} ${Math.round(255 * (1 - y) * (1 - k))})`;
+		}
+	}
+};
+//#endregion
+export { StyleMapper, parseStyles, parseSwatches };

package/dist/types.d.ts

@@ -0,0 +1,35 @@
+//#region src/types.d.ts
+export interface IdmlTextNode {
+  name: string;
+  attributes: Record<string, string>;
+  text?: string;
+  children: IdmlTextNode[];
+  location: string;
+}
+export interface IdmlStyle {
+  id: string;
+  name: string;
+  kind: 'paragraph' | 'character';
+  basedOn?: string;
+  properties: Record<string, string>;
+  location: string;
+}
+export interface IdmlSwatch {
+  id: string;
+  name: string;
+  model: 'rgb' | 'cmyk' | 'spot' | 'named';
+  values?: number[];
+}
+export interface IdmlFramePreference {
+  columns: number;
+  gutter: number;
+  location?: string;
+}
+export interface IdmlStory {
+  id: string;
+  part: string;
+  direction?: 'ltr' | 'rtl';
+  root?: IdmlTextNode;
+  frame?: IdmlFramePreference;
+}
+//#endregion

package/dist/unsupported-elements.js

@@ -0,0 +1,49 @@
+import { localName } from "./xml.js";
+//#region src/unsupported-elements.ts
+const MAPPED_ELEMENTS = /* @__PURE__ */ new Set([
+	"Document",
+	"DocumentPreference",
+	"MarginPreference",
+	"MasterSpread",
+	"Spread",
+	"Page",
+	"Story",
+	"TextFrame",
+	"Group",
+	"TextFramePreference",
+	"PathGeometry",
+	"GeometryPathType",
+	"PathPointArray",
+	"PathPointType",
+	"Styles",
+	"Graphic",
+	"RootParagraphStyleGroup",
+	"ParagraphStyleGroup",
+	"RootCharacterStyleGroup",
+	"CharacterStyleGroup",
+	"ParagraphStyle",
+	"CharacterStyle",
+	"Color",
+	"Properties"
+]);
+function insideMappedResource(element) {
+	let parent = element.parent;
+	while (parent && "name" in parent) {
+		const name = localName(parent.name);
+		if (name === "ParagraphStyle" || name === "CharacterStyle" || name === "Color") return true;
+		parent = parent.parent;
+	}
+	return false;
+}
+function collectUnsupportedElements(parts, report) {
+	for (const part of parts) {
+		if (part.name.startsWith("Stories/")) continue;
+		for (const element of part.all) {
+			const name = localName(element.name);
+			if (!MAPPED_ELEMENTS.has(name) && !insideMappedResource(element)) report.add(report.unsupportedElements, name, part.name);
+		}
+	}
+	return report.unsupportedElements;
+}
+//#endregion
+export { collectUnsupportedElements };

package/dist/xml.js

@@ -0,0 +1,18 @@
+import { refusal } from "./refusal.js";
+//#region src/xml.ts
+function localName(name) {
+	return name.includes(":") ? name.split(":").at(-1) ?? name : name;
+}
+function numberAttribute(element, name, fallback) {
+	const raw = element?.attribs[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 idmlDirection(value) {
+	const normalized = value?.toLowerCase();
+	if (normalized?.includes("righttoleft")) return "rtl";
+	if (normalized?.includes("lefttoright")) return "ltr";
+}
+//#endregion
+export { idmlDirection, localName, numberAttribute };

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.29.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.29.0",
+    "@segnavia/html": "0.29.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.