@segnavia/format 0.37.0 → 0.39.0

package/dist/font-collection.js

@@ -0,0 +1,191 @@
+import { FontFaceRefusedError } from "./font-refusal.js";
+import { classifyFont } from "./font-signature.js";
+//#region src/font-collection.ts
+const MAX_COLLECTION_FACES = 64;
+const MAX_FACE_TABLES = 64;
+const MAX_FACE_NAME_RECORDS = 1024;
+const MAX_FACE_NAME_BYTES = 1048576;
+const CHECKSUM_MAGIC = 2981146554;
+function tagAt(bytes, offset) {
+	return String.fromCharCode(bytes[offset] ?? 0, bytes[offset + 1] ?? 0, bytes[offset + 2] ?? 0, bytes[offset + 3] ?? 0);
+}
+function refuse(message, remedy) {
+	throw new FontFaceRefusedError(`${message}; ${remedy} to clear this refusal.`);
+}
+function malformedCollection(offset) {
+	refuse(`font collection header is malformed at byte ${offset}`, "supply a complete font collection");
+}
+function malformedFace(offset) {
+	refuse(`font face table directory is malformed at byte ${offset}`, "supply a complete supported font face");
+}
+function collectionView(bytes) {
+	return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+function requireCollectionRange(bytes, offset, length) {
+	const end = offset + length;
+	if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) || !Number.isSafeInteger(end) || offset < 0 || length < 0 || end > bytes.length) malformedCollection(Math.max(0, offset));
+}
+function requireFaceRange(bytes, offset, length) {
+	const end = offset + length;
+	if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) || !Number.isSafeInteger(end) || offset < 0 || length < 0 || end > bytes.length) malformedFace(Math.max(0, offset));
+}
+function collectionOffsets(bytes) {
+	requireCollectionRange(bytes, 0, 12);
+	if (tagAt(bytes, 0) !== "ttcf") malformedCollection(0);
+	const view = collectionView(bytes);
+	const version = view.getUint32(4);
+	if (version !== 65536 && version !== 131072) malformedCollection(4);
+	const count = view.getUint32(8);
+	if (count > MAX_COLLECTION_FACES) refuse(`font collection declares ${count} faces, above the limit ${MAX_COLLECTION_FACES}`, `supply a collection with at most ${MAX_COLLECTION_FACES} faces`);
+	requireCollectionRange(bytes, 12, count * 4);
+	const offsets = [];
+	for (let index = 0; index < count; index += 1) offsets.push(view.getUint32(12 + index * 4));
+	if (version === 131072) requireCollectionRange(bytes, 12 + count * 4, 12);
+	return offsets;
+}
+function sfntFormat(bytes, offset) {
+	requireFaceRange(bytes, offset, 4);
+	const format = classifyFont(bytes, offset);
+	if (format === "opentype" || format === "truetype") return format;
+	malformedFace(offset);
+}
+function faceTables(bytes, offset) {
+	requireFaceRange(bytes, offset, 12);
+	const view = collectionView(bytes);
+	const count = view.getUint16(offset + 4);
+	if (count > MAX_FACE_TABLES) refuse(`font face declares ${count} tables, above the limit ${MAX_FACE_TABLES}`, `supply a face with at most ${MAX_FACE_TABLES} tables`);
+	requireFaceRange(bytes, offset + 12, count * 16);
+	const tables = [];
+	for (let index = 0; index < count; index += 1) {
+		const record = offset + 12 + index * 16;
+		const table = {
+			tag: tagAt(bytes, record),
+			offset: view.getUint32(record + 8),
+			length: view.getUint32(record + 12)
+		};
+		const end = table.offset + table.length;
+		if (!Number.isSafeInteger(end) || end > bytes.length) refuse(`font table ${table.tag} lies outside the font file`, "supply table offsets and lengths within the font data");
+		tables.push(table);
+	}
+	const ordered = tables.filter((table) => table.length > 0).sort((left, right) => left.offset - right.offset);
+	for (let index = 1; index < ordered.length; index += 1) {
+		const previous = ordered[index - 1];
+		const table = ordered[index];
+		if (previous && table && table.offset < previous.offset + previous.length) refuse(`font table ${table.tag} overlaps font table ${previous.tag}`, "supply a face whose table byte ranges do not overlap");
+	}
+	return tables;
+}
+function decodeUtf16Be(bytes) {
+	let value = "";
+	for (let index = 0; index + 1 < bytes.length; index += 2) value += String.fromCharCode((bytes[index] ?? 0) * 256 + (bytes[index + 1] ?? 0));
+	return value;
+}
+function decodeMacRoman(bytes) {
+	return new TextDecoder("macintosh").decode(bytes);
+}
+function sfntPostScriptNames(bytes, faceOffset = 0) {
+	sfntFormat(bytes, faceOffset);
+	const name = faceTables(bytes, faceOffset).find((table) => table.tag === "name");
+	if (!name) return [];
+	if (name.length < 6) refuse("font table name lies outside the font file", "supply a complete name table");
+	requireFaceRange(bytes, name.offset, name.length);
+	const view = collectionView(bytes);
+	const count = view.getUint16(name.offset + 2);
+	if (count > MAX_FACE_NAME_RECORDS) refuse(`font name table declares ${count} records, above the limit ${MAX_FACE_NAME_RECORDS}`, `supply a face with at most ${MAX_FACE_NAME_RECORDS} name records`);
+	const strings = view.getUint16(name.offset + 4);
+	if (6 + count * 12 > name.length) refuse("font table name lies outside the font file", "supply a complete name table");
+	const records = /* @__PURE__ */ new Map();
+	let decodedBytes = 0;
+	for (let index = 0; index < count; index += 1) {
+		const record = name.offset + 6 + index * 12;
+		const platform = view.getUint16(record);
+		if (view.getUint16(record + 6) !== 6 || platform !== 1 && platform !== 3) continue;
+		const length = view.getUint16(record + 8);
+		const relative = view.getUint16(record + 10);
+		if (strings + relative + length > name.length) refuse("font table name lies outside the font file", "supply a complete name table");
+		const start = name.offset + strings + relative;
+		const key = `${platform}:${start}:${length}`;
+		if (records.has(key)) continue;
+		decodedBytes += length;
+		if (decodedBytes > MAX_FACE_NAME_BYTES) refuse(`font name table requires ${decodedBytes} decoded bytes, above the limit ${MAX_FACE_NAME_BYTES}`, `supply a face whose PostScript names occupy at most ${MAX_FACE_NAME_BYTES} bytes`);
+		records.set(key, {
+			platform,
+			start,
+			length
+		});
+	}
+	const names = [...records.values()].map(({ platform, start, length }) => {
+		const encoded = bytes.subarray(start, start + length);
+		return {
+			platform,
+			value: platform === 3 ? decodeUtf16Be(encoded) : decodeMacRoman(encoded)
+		};
+	});
+	const preferred = names.filter((name) => name.platform === 3);
+	return [...new Set((preferred.length > 0 ? preferred : names).map((name) => name.value))];
+}
+function collectionFaces(bytes) {
+	return collectionOffsets(bytes).flatMap((offset) => sfntPostScriptNames(bytes, offset));
+}
+function checksum(bytes, offset = 0, length = bytes.length) {
+	let sum = 0;
+	for (let index = 0; index < length; index += 4) {
+		const word = ((bytes[offset + index] ?? 0) << 24 | (bytes[offset + index + 1] ?? 0) << 16 | (bytes[offset + index + 2] ?? 0) << 8 | (bytes[offset + index + 3] ?? 0)) >>> 0;
+		sum = sum + word >>> 0;
+	}
+	return sum;
+}
+function directoryFields(count) {
+	const power = 2 ** Math.floor(Math.log2(Math.max(1, count)));
+	return {
+		searchRange: power * 16,
+		entrySelector: Math.log2(power),
+		rangeShift: count * 16 - power * 16
+	};
+}
+function extractAt(bytes, faceOffset) {
+	const format = sfntFormat(bytes, faceOffset);
+	const tables = faceTables(bytes, faceOffset).filter((table) => table.tag !== "DSIG");
+	const directoryLength = 12 + tables.length * 16;
+	let total = directoryLength;
+	for (const table of tables) total += Math.ceil(table.length / 4) * 4;
+	if (!Number.isSafeInteger(total) || total > bytes.length) refuse(`font face extraction requires ${total} bytes, above the font file size ${bytes.length}`, "supply a face whose table data fits within the font file");
+	const data = new Uint8Array(total);
+	const view = new DataView(data.buffer);
+	data.set(bytes.subarray(faceOffset, faceOffset + 4), 0);
+	view.setUint16(4, tables.length);
+	const fields = directoryFields(tables.length);
+	view.setUint16(6, fields.searchRange);
+	view.setUint16(8, fields.entrySelector);
+	view.setUint16(10, fields.rangeShift);
+	let outputOffset = directoryLength;
+	let headOffset;
+	for (let index = 0; index < tables.length; index += 1) {
+		const table = tables[index];
+		if (!table) continue;
+		const record = 12 + index * 16;
+		for (let byte = 0; byte < 4; byte += 1) data[record + byte] = table.tag.charCodeAt(byte);
+		data.set(bytes.subarray(table.offset, table.offset + table.length), outputOffset);
+		if (table.tag === "head") {
+			if (table.length < 12) refuse("font table head lies outside the font file", "supply a complete head table");
+			new DataView(data.buffer).setUint32(outputOffset + 8, 0);
+			headOffset = outputOffset;
+		}
+		view.setUint32(record + 4, checksum(data, outputOffset, table.length));
+		view.setUint32(record + 8, outputOffset);
+		view.setUint32(record + 12, table.length);
+		outputOffset += Math.ceil(table.length / 4) * 4;
+	}
+	if (headOffset !== void 0) view.setUint32(headOffset + 8, CHECKSUM_MAGIC - checksum(data) >>> 0);
+	return {
+		data,
+		format
+	};
+}
+function extractFace(bytes, postscriptName) {
+	const offsets = collectionOffsets(bytes);
+	for (const offset of offsets) if (sfntPostScriptNames(bytes, offset).includes(postscriptName)) return extractAt(bytes, offset);
+	refuse(`font collection has no face named ${postscriptName}; it holds ${collectionFaces(bytes).join(", ").slice(0, 1024) || "(none)"}`, "send the PostScript name of a face the collection holds");
+}
+//#endregion
+export { collectionFaces, extractFace, sfntPostScriptNames };

package/dist/font-face.d.ts

@@ -0,0 +1,8 @@
+import { FontFormat } from "./fonts.js";
+//#region src/font-face.d.ts
+export interface ResolvedFontFace {
+  data: Uint8Array;
+  format: Exclude<FontFormat, 'collection'>;
+}
+export declare function resolveFontFace(data: Uint8Array, format: FontFormat, postscriptName?: string): ResolvedFontFace;
+//#endregion

package/dist/font-face.js

@@ -0,0 +1,24 @@
+import { FontFaceRefusedError } from "./font-refusal.js";
+import { classifyFont } from "./font-signature.js";
+import { collectionFaces, extractFace, sfntPostScriptNames } from "./font-collection.js";
+//#region src/font-face.ts
+function resolveFontFace(data, format, postscriptName) {
+	const detected = classifyFont(data);
+	if (detected === "collection") {
+		if (!postscriptName) throw new FontFaceRefusedError(`font collection requires a PostScript name; it holds ${collectionFaces(data).join(", ").slice(0, 1024) || "(none)"}; send one of those PostScript names to clear this refusal.`);
+		return extractFace(data, postscriptName);
+	}
+	if (format === "collection") throw new FontFaceRefusedError("font declared as a collection does not contain a font collection; send bytes with a ttcf signature to clear this refusal.");
+	if (!postscriptName || detected === "woff" || detected === "woff2") return {
+		data,
+		format
+	};
+	const names = sfntPostScriptNames(data);
+	if (names.includes(postscriptName) && (detected === "opentype" || detected === "truetype")) return {
+		data,
+		format: detected
+	};
+	throw new FontFaceRefusedError(`font face has PostScript name ${names.join(", ").slice(0, 1024) || "(none)"}, not ${postscriptName}; send its matching PostScript name to clear this refusal.`);
+}
+//#endregion
+export { resolveFontFace };

package/dist/font-refusal.d.ts

@@ -0,0 +1,5 @@
+//#region src/font-refusal.d.ts
+export declare class FontFaceRefusedError extends Error {
+  constructor(message: string);
+}
+//#endregion

package/dist/font-refusal.js

@@ -0,0 +1,9 @@
+//#region src/font-refusal.ts
+var FontFaceRefusedError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "FontFaceRefusedError";
+	}
+};
+//#endregion
+export { FontFaceRefusedError };

package/dist/font-signature.d.ts

@@ -0,0 +1,5 @@
+import { FontFormat } from "./fonts.js";
+//#region src/font-signature.d.ts
+export declare const COLLECTION_TAG = "ttcf";
+export declare function classifyFont(bytes: Uint8Array, offset?: number): FontFormat | undefined;
+//#endregion

package/dist/font-signature.js

@@ -0,0 +1,13 @@
+//#region src/font-signature.ts
+const COLLECTION_TAG = "ttcf";
+function classifyFont(bytes, offset = 0) {
+	if (!Number.isSafeInteger(offset) || offset < 0 || offset > bytes.length - 4) return;
+	const tag = String.fromCharCode(bytes[offset] ?? 0, bytes[offset + 1] ?? 0, bytes[offset + 2] ?? 0, bytes[offset + 3] ?? 0);
+	if (tag === "wOF2") return "woff2";
+	if (tag === "wOFF") return "woff";
+	if (tag === "OTTO") return "opentype";
+	if (tag === "ttcf") return "collection";
+	if (tag === "true" || tag === "\0
\0\0") return "truetype";
+}
+//#endregion
+export { COLLECTION_TAG, classifyFont };

package/dist/fonts.d.ts

@@ -20,7 +20,7 @@ export declare function localFontReferences(references: readonly FontReference[]
   local: string;
   fallback: string;
 }>;
-export declare const FONT_FORMATS: readonly ["woff2", "woff", "truetype", "opentype"];
+export declare const FONT_FORMATS: readonly ["woff2", "woff", "truetype", "opentype", "collection"];
 export type FontFormat = (typeof FONT_FORMATS)[number];
 export declare const LocalFaceTransport: z.ZodObject<{
   family: z.ZodString;
@@ -29,12 +29,14 @@ export declare const LocalFaceTransport: z.ZodObject<{
     woff: "woff";
     truetype: "truetype";
     opentype: "opentype";
+    collection: "collection";
   }>;
   weight: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
   style: z.ZodOptional<z.ZodEnum<{
     normal: "normal";
     italic: "italic";
   }>>;
+  postscriptName: z.ZodOptional<z.ZodString>;
   data: z.ZodString;
 }, z.core.$strict>;
 export type LocalFaceTransport = z.infer<typeof LocalFaceTransport>;
@@ -45,12 +47,14 @@ export declare const LocalFacesTransport: z.ZodArray<z.ZodObject<{
     woff: "woff";
     truetype: "truetype";
     opentype: "opentype";
+    collection: "collection";
   }>;
   weight: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
   style: z.ZodOptional<z.ZodEnum<{
     normal: "normal";
     italic: "italic";
   }>>;
+  postscriptName: z.ZodOptional<z.ZodString>;
   data: z.ZodString;
 }, z.core.$strict>>;
 export type LocalFacesInput = LocalFaceTransport[];
@@ -63,6 +67,7 @@ export interface FontFace {
   weight?: number | string;
   style?: 'normal' | 'italic';
   unicodeRange?: string;
+  postscriptName?: string;
 }
 export interface AppFont {
   family: string;

package/dist/fonts.js

@@ -26,13 +26,15 @@ const FONT_FORMATS = [
 	"woff2",
 	"woff",
 	"truetype",
-	"opentype"
+	"opentype",
+	"collection"
 ];
 const LocalFaceTransportShape = {
 	family: z.string().min(1),
 	format: z.enum(FONT_FORMATS),
 	weight: z.union([z.number(), z.string()]).optional(),
 	style: z.enum(["normal", "italic"]).optional(),
+	postscriptName: z.string().min(1).optional(),
 	data: z.string()
 };
 const LocalFaceTransport = z.strictObject(LocalFaceTransportShape);

package/dist/geometry.d.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+//#region src/geometry.d.ts
+export declare const Size: z.ZodObject<{
+  width: z.ZodNumber;
+  height: z.ZodNumber;
+}, z.core.$strip>;
+export type Size = z.infer<typeof Size>;
+export declare const Box: z.ZodObject<{
+  x: z.ZodNumber;
+  y: z.ZodNumber;
+  width: z.ZodNumber;
+  height: z.ZodNumber;
+}, z.core.$strip>;
+export type Box = z.infer<typeof Box>;
+export declare const Point: z.ZodObject<{
+  x: z.ZodNumber;
+  y: z.ZodNumber;
+}, z.core.$strip>;
+export type Point = z.infer<typeof Point>;
+//#endregion

package/dist/geometry.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+//#region src/geometry.ts
+const Size = z.object({
+	width: z.number().int().positive(),
+	height: z.number().int().positive()
+});
+const Box = z.object({
+	x: z.number(),
+	y: z.number(),
+	width: z.number(),
+	height: z.number()
+});
+const Point = z.object({
+	x: z.number(),
+	y: z.number()
+});
+//#endregion
+export { Box, Point, Size };

package/dist/image-fit.d.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+//#region src/image-fit.d.ts
+export declare const ImageFit: z.ZodEnum<{
+  width: "width";
+  contain: "contain";
+  cover: "cover";
+  focus: "focus";
+}>;
+export type ImageFit = z.infer<typeof ImageFit>;
+//#endregion

package/dist/image-fit.js

@@ -0,0 +1,10 @@
+import { z } from "zod";
+//#region src/image-fit.ts
+const ImageFit = z.enum([
+	"contain",
+	"cover",
+	"width",
+	"focus"
+]);
+//#endregion
+export { ImageFit };

package/dist/imposition-marks.d.ts

@@ -1,5 +1,5 @@
 import { MarkSegment } from "./paper.js";
-import { Imposition } from "./index.js";
+import { Imposition } from "./imposition-schema.js";
 //#region src/imposition-marks.d.ts
 export declare const MIN_MARK_LENGTH_MM = 2;
 export type ImpositionMarkEdge = 'top' | 'right' | 'bottom' | 'left';

package/dist/imposition-schema.d.ts

@@ -0,0 +1,185 @@
+import { z } from "zod";
+//#region src/imposition-schema.d.ts
+export declare const MAX_IMPOSITION_CELLS = 10000;
+export declare const Imposition: z.ZodPipe<z.ZodObject<{
+  paper: z.ZodUnion<readonly [z.ZodEnum<{
+    letter: "letter";
+    legal: "legal";
+    tabloid: "tabloid";
+    a3: "a3";
+    a4: "a4";
+    a5: "a5";
+    "business-card-us": "business-card-us";
+    "business-card-eu": "business-card-eu";
+    "business-card-square-us": "business-card-square-us";
+    "business-card-slim-us": "business-card-slim-us";
+    "postcard-4x6": "postcard-4x6";
+    "postcard-5x7": "postcard-5x7";
+    "postcard-6x9": "postcard-6x9";
+    "postcard-6x11": "postcard-6x11";
+    "card-square-4in": "card-square-4in";
+    "half-letter": "half-letter";
+    a6: "a6";
+    dl: "dl";
+    "rack-card-4x9": "rack-card-4x9";
+    "rack-card-3.5x8.5": "rack-card-3.5x8.5";
+    "poster-12x18": "poster-12x18";
+    "poster-16x20": "poster-16x20";
+    "poster-18x24": "poster-18x24";
+    "poster-24x36": "poster-24x36";
+    a2: "a2";
+    a1: "a1";
+    a0: "a0";
+  }>, z.ZodObject<{
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    unit: z.ZodEnum<{
+      mm: "mm";
+      in: "in";
+      pt: "pt";
+    }>;
+  }, z.core.$strip>]>;
+  orientation: z.ZodDefault<z.ZodEnum<{
+    portrait: "portrait";
+    landscape: "landscape";
+  }>>;
+  unit: z.ZodDefault<z.ZodEnum<{
+    mm: "mm";
+    in: "in";
+    pt: "pt";
+  }>>;
+  margin: z.ZodDefault<z.ZodObject<{
+    top: z.ZodDefault<z.ZodNumber>;
+    right: z.ZodDefault<z.ZodNumber>;
+    bottom: z.ZodDefault<z.ZodNumber>;
+    left: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strip>>;
+  columns: z.ZodOptional<z.ZodNumber>;
+  rows: z.ZodOptional<z.ZodNumber>;
+  cell: z.ZodObject<{
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodNumber;
+  }, z.core.$strip>;
+  gap: z.ZodDefault<z.ZodObject<{
+    column: z.ZodDefault<z.ZodNumber>;
+    row: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strip>>;
+  bleed: z.ZodDefault<z.ZodNumber>;
+  safe: z.ZodDefault<z.ZodNumber>;
+  fit: z.ZodDefault<z.ZodEnum<{
+    contain: "contain";
+    cover: "cover";
+  }>>;
+  fill: z.ZodDefault<z.ZodEnum<{
+    sequence: "sequence";
+    repeat: "repeat";
+  }>>;
+  sides: z.ZodOptional<z.ZodEnum<{
+    one: "one";
+    two: "two";
+  }>>;
+  flip: z.ZodDefault<z.ZodEnum<{
+    long: "long";
+    short: "short";
+  }>>;
+  skip: z.ZodDefault<z.ZodNumber>;
+  dir: z.ZodDefault<z.ZodEnum<{
+    ltr: "ltr";
+    rtl: "rtl";
+  }>>;
+  marks: z.ZodDefault<z.ZodBoolean>;
+  markColor: z.ZodDefault<z.ZodEnum<{
+    black: "black";
+    registration: "registration";
+  }>>;
+  cornerMarks: z.ZodDefault<z.ZodBoolean>;
+  fold: z.ZodOptional<z.ZodEnum<{
+    custom: "custom";
+    letter: "letter";
+    half: "half";
+    z: "z";
+    gate: "gate";
+  }>>;
+  panels: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strip>, z.ZodTransform<{
+  paper: "letter" | "legal" | "tabloid" | "a3" | "a4" | "a5" | "business-card-us" | "business-card-eu" | "business-card-square-us" | "business-card-slim-us" | "postcard-4x6" | "postcard-5x7" | "postcard-6x9" | "postcard-6x11" | "card-square-4in" | "half-letter" | "a6" | "dl" | "rack-card-4x9" | "rack-card-3.5x8.5" | "poster-12x18" | "poster-16x20" | "poster-18x24" | "poster-24x36" | "a2" | "a1" | "a0" | {
+    width: number;
+    height: number;
+    unit: "mm" | "in" | "pt";
+  };
+  orientation: "portrait" | "landscape";
+  unit: "mm" | "in" | "pt";
+  margin: {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+  };
+  cell: {
+    height: number;
+    width?: number | undefined;
+  };
+  gap: {
+    column: number;
+    row: number;
+  };
+  bleed: number;
+  safe: number;
+  fit: "contain" | "cover";
+  fill: "sequence" | "repeat";
+  flip: "long" | "short";
+  skip: number;
+  dir: "ltr" | "rtl";
+  marks: boolean;
+  markColor: "black" | "registration";
+  cornerMarks: boolean;
+  columns?: number | undefined;
+  rows?: number | undefined;
+  sides?: "one" | "two" | undefined;
+  fold?: "custom" | "letter" | "half" | "z" | "gate" | undefined;
+  panels?: number[] | undefined;
+} & {
+  columns: number;
+  rows: number;
+  sides: "one" | "two";
+}, {
+  paper: "letter" | "legal" | "tabloid" | "a3" | "a4" | "a5" | "business-card-us" | "business-card-eu" | "business-card-square-us" | "business-card-slim-us" | "postcard-4x6" | "postcard-5x7" | "postcard-6x9" | "postcard-6x11" | "card-square-4in" | "half-letter" | "a6" | "dl" | "rack-card-4x9" | "rack-card-3.5x8.5" | "poster-12x18" | "poster-16x20" | "poster-18x24" | "poster-24x36" | "a2" | "a1" | "a0" | {
+    width: number;
+    height: number;
+    unit: "mm" | "in" | "pt";
+  };
+  orientation: "portrait" | "landscape";
+  unit: "mm" | "in" | "pt";
+  margin: {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+  };
+  cell: {
+    height: number;
+    width?: number | undefined;
+  };
+  gap: {
+    column: number;
+    row: number;
+  };
+  bleed: number;
+  safe: number;
+  fit: "contain" | "cover";
+  fill: "sequence" | "repeat";
+  flip: "long" | "short";
+  skip: number;
+  dir: "ltr" | "rtl";
+  marks: boolean;
+  markColor: "black" | "registration";
+  cornerMarks: boolean;
+  columns?: number | undefined;
+  rows?: number | undefined;
+  sides?: "one" | "two" | undefined;
+  fold?: "custom" | "letter" | "half" | "z" | "gate" | undefined;
+  panels?: number[] | undefined;
+}>>;
+export type Imposition = z.infer<typeof Imposition>;
+export type ImpositionInput = z.input<typeof Imposition>;
+//#endregion