@segnavia/format 0.1.0 → 0.2.0

package/dist/imposition.d.ts

@@ -0,0 +1,62 @@
+import { PaperBox } from "./paper.js";
+import { Imposition, Page, Print } from "./index.js";
+//#region src/imposition.d.ts
+export interface MillimeterEdges {
+  top: number;
+  right: number;
+  bottom: number;
+  left: number;
+}
+export interface Placement {
+  page: number;
+  paper: number;
+  side: 'front' | 'back';
+  column: number;
+  row: number;
+  trim: PaperBox;
+  bleed: MillimeterEdges;
+  bleedBox: PaperBox;
+  safeBox: PaperBox;
+  clipped: Array<'top' | 'right' | 'bottom' | 'left'>;
+}
+export interface Imposed {
+  paper: {
+    width: number;
+    height: number;
+  };
+  papers: number;
+  sides: 1 | 2;
+  placements: Placement[];
+}
+export interface PageFit {
+  flow: boolean;
+  width: number;
+  height: number | null;
+  scale: number;
+  x: number;
+  y: number;
+  bands: {
+    inline: number;
+    block: number;
+  };
+  crop: MillimeterEdges;
+  differs: boolean;
+}
+export type PagePlacementKind = 'fluid' | 'growing' | 'fixed';
+export interface PagePlacementLayout {
+  kind: PagePlacementKind;
+  piece: {
+    width: number;
+    height: number;
+  };
+  inset: boolean;
+  paper: PaperBox;
+}
+export declare function mirrorPlacement(front: Placement, paper: Imposed['paper'], flip: Imposition['flip'], page?: number): Placement;
+export declare function impose(imposition: Imposition, pageCount: number): Imposed;
+export declare function fitPage(page: {
+  size: Page['size'];
+  print?: Print;
+}, placement: Placement, fit: 'contain' | 'cover'): PageFit;
+export declare function pagePlacementLayout(size: Page['size'], placement: Placement, fit: PageFit): PagePlacementLayout;
+//#endregion

package/dist/imposition.js

@@ -0,0 +1,294 @@
+import { PX_PER_MM, roundMillimeters, sheetMm, toMillimeters } from "./paper.js";
+//#region src/imposition.ts
+const zeroCrop = () => ({
+	top: 0,
+	right: 0,
+	bottom: 0,
+	left: 0
+});
+function placementAt(imposition, paper, cell, page, paperSize) {
+	const mm = (value) => toMillimeters(value, imposition.unit);
+	const column = cell % imposition.columns;
+	const row = Math.floor(cell / imposition.columns);
+	const physicalColumn = imposition.dir === "rtl" ? imposition.columns - column - 1 : column;
+	const cellWidth = mm(imposition.cell.width);
+	const cellHeight = mm(imposition.cell.height);
+	const columnGap = mm(imposition.gap.column);
+	const rowGap = mm(imposition.gap.row);
+	const x = imposition.dir === "rtl" ? paperSize.width - mm(imposition.margin.right) - cellWidth - column * (cellWidth + columnGap) : mm(imposition.margin.left) + column * (cellWidth + columnGap);
+	const y = mm(imposition.margin.top) + row * (cellHeight + rowGap);
+	const requested = mm(imposition.bleed);
+	const bleed = {
+		top: Math.min(requested, row > 0 ? rowGap / 2 : y),
+		right: Math.min(requested, physicalColumn < imposition.columns - 1 ? columnGap / 2 : Math.max(0, paperSize.width - x - cellWidth)),
+		bottom: Math.min(requested, row < imposition.rows - 1 ? rowGap / 2 : Math.max(0, paperSize.height - y - cellHeight)),
+		left: Math.min(requested, physicalColumn > 0 ? columnGap / 2 : Math.max(0, x))
+	};
+	const clipped = [
+		"top",
+		"right",
+		"bottom",
+		"left"
+	].filter((side) => bleed[side] < requested);
+	const trim = {
+		x: roundMillimeters(x),
+		y: roundMillimeters(y),
+		width: roundMillimeters(cellWidth),
+		height: roundMillimeters(cellHeight)
+	};
+	const roundedBleed = {
+		top: roundMillimeters(bleed.top),
+		right: roundMillimeters(bleed.right),
+		bottom: roundMillimeters(bleed.bottom),
+		left: roundMillimeters(bleed.left)
+	};
+	const safe = mm(imposition.safe);
+	return {
+		page,
+		paper,
+		side: "front",
+		column,
+		row,
+		trim,
+		bleed: roundedBleed,
+		bleedBox: {
+			x: roundMillimeters(x - bleed.left),
+			y: roundMillimeters(y - bleed.top),
+			width: roundMillimeters(cellWidth + bleed.left + bleed.right),
+			height: roundMillimeters(cellHeight + bleed.top + bleed.bottom)
+		},
+		safeBox: {
+			x: roundMillimeters(x + safe),
+			y: roundMillimeters(y + safe),
+			width: roundMillimeters(cellWidth - safe * 2),
+			height: roundMillimeters(cellHeight - safe * 2)
+		},
+		clipped
+	};
+}
+const mirrorBox = (box, paper, axis) => axis === "x" ? {
+	...box,
+	x: roundMillimeters(paper.width - box.x - box.width)
+} : {
+	...box,
+	y: roundMillimeters(paper.height - box.y - box.height)
+};
+const EDGE_ORDER = [
+	"top",
+	"right",
+	"bottom",
+	"left"
+];
+function mirrorEdge(edge, axis) {
+	if (axis === "x") return edge === "left" ? "right" : edge === "right" ? "left" : edge;
+	return edge === "top" ? "bottom" : edge === "bottom" ? "top" : edge;
+}
+function mirrorEdges(edges, axis) {
+	const mirrored = { ...edges };
+	for (const edge of EDGE_ORDER) mirrored[mirrorEdge(edge, axis)] = edges[edge];
+	return mirrored;
+}
+function mirrorPlacement(front, paper, flip, page = front.page) {
+	const portrait = paper.width <= paper.height;
+	const axis = flip === "long" === portrait ? "x" : "y";
+	const mirroredClipped = new Set(front.clipped.map((edge) => mirrorEdge(edge, axis)));
+	return {
+		...front,
+		page,
+		side: "back",
+		trim: mirrorBox(front.trim, paper, axis),
+		bleed: mirrorEdges(front.bleed, axis),
+		bleedBox: mirrorBox(front.bleedBox, paper, axis),
+		safeBox: mirrorBox(front.safeBox, paper, axis),
+		clipped: EDGE_ORDER.filter((edge) => mirroredClipped.has(edge))
+	};
+}
+function assignPieces(imposition, pieces, papers) {
+	const cells = imposition.columns * imposition.rows;
+	const assignments = [];
+	let piece = 0;
+	for (let paperIndex = 0; paperIndex < papers; paperIndex += 1) {
+		const firstCell = paperIndex === 0 ? imposition.skip : 0;
+		for (let cell = firstCell; cell < cells; cell += 1) {
+			const assignedPiece = imposition.fill === "repeat" ? paperIndex : piece;
+			if (assignedPiece >= pieces) break;
+			assignments.push({
+				paper: paperIndex,
+				cell,
+				piece: assignedPiece
+			});
+			if (imposition.fill === "sequence") piece += 1;
+		}
+	}
+	return assignments;
+}
+function expandAssignments(imposition, assignments, pageCount, paper) {
+	const placements = [];
+	let currentPaper = -1;
+	let fronts = [];
+	let backs = [];
+	const flush = () => {
+		placements.push(...fronts, ...backs);
+		fronts = [];
+		backs = [];
+	};
+	for (const assignment of assignments) {
+		if (assignment.paper !== currentPaper) {
+			flush();
+			currentPaper = assignment.paper;
+		}
+		const frontPage = imposition.sides === "two" ? assignment.piece * 2 : assignment.piece;
+		const front = placementAt(imposition, assignment.paper, assignment.cell, frontPage, paper);
+		fronts.push(front);
+		if (imposition.sides === "two" && frontPage + 1 < pageCount) backs.push(mirrorPlacement(front, paper, imposition.flip, frontPage + 1));
+	}
+	flush();
+	return placements;
+}
+function impose(imposition, pageCount) {
+	if (!Number.isInteger(pageCount) || pageCount < 0) throw new RangeError(`pageCount must be a nonnegative integer; received ${String(pageCount)}`);
+	const paper = sheetMm({
+		paper: imposition.paper,
+		orientation: imposition.orientation
+	});
+	const sides = imposition.sides === "two" ? 2 : 1;
+	if (pageCount === 0) return {
+		paper,
+		papers: 0,
+		sides,
+		placements: []
+	};
+	const cells = imposition.columns * imposition.rows;
+	const pieces = imposition.sides === "two" ? Math.ceil(pageCount / 2) : pageCount;
+	const papers = imposition.fill === "repeat" ? pieces : Math.ceil((pieces + imposition.skip) / cells);
+	return {
+		paper,
+		papers,
+		sides,
+		placements: expandAssignments(imposition, assignPieces(imposition, pieces, papers), pageCount, paper)
+	};
+}
+function trimDiffers(page, placement) {
+	if (!page.print) return false;
+	const trim = sheetMm(page.print);
+	return Math.abs(trim.width - placement.trim.width) > .01 || Math.abs(trim.height - placement.trim.height) > .01;
+}
+function fitPage(page, placement, fit) {
+	const differs = trimDiffers(page, placement);
+	if (page.size === "fluid") return {
+		flow: true,
+		width: placement.bleedBox.width * PX_PER_MM,
+		height: null,
+		scale: 1,
+		x: placement.bleedBox.x,
+		y: placement.bleedBox.y,
+		bands: {
+			inline: 0,
+			block: 0
+		},
+		crop: zeroCrop(),
+		differs
+	};
+	if (page.size.height === "auto") return {
+		flow: true,
+		width: page.size.width,
+		height: null,
+		scale: placement.trim.width * PX_PER_MM / page.size.width,
+		x: placement.trim.x,
+		y: placement.trim.y,
+		bands: {
+			inline: 0,
+			block: 0
+		},
+		crop: zeroCrop(),
+		differs
+	};
+	if (fit === "contain") {
+		const scale = Math.min(placement.trim.width * PX_PER_MM / page.size.width, placement.trim.height * PX_PER_MM / page.size.height);
+		const width = page.size.width * scale / PX_PER_MM;
+		const height = page.size.height * scale / PX_PER_MM;
+		const inline = (placement.trim.width - width) / 2;
+		const block = (placement.trim.height - height) / 2;
+		return {
+			flow: false,
+			width: page.size.width,
+			height: page.size.height,
+			scale,
+			x: roundMillimeters(placement.trim.x + inline),
+			y: roundMillimeters(placement.trim.y + block),
+			bands: {
+				inline: roundMillimeters(inline),
+				block: roundMillimeters(block)
+			},
+			crop: zeroCrop(),
+			differs
+		};
+	}
+	const horizontalBleed = Math.max(placement.bleed.left, placement.bleed.right);
+	const verticalBleed = Math.max(placement.bleed.top, placement.bleed.bottom);
+	const scale = Math.max((placement.trim.width + horizontalBleed * 2) * PX_PER_MM / page.size.width, (placement.trim.height + verticalBleed * 2) * PX_PER_MM / page.size.height);
+	const width = page.size.width * scale / PX_PER_MM;
+	const height = page.size.height * scale / PX_PER_MM;
+	const x = placement.trim.x + (placement.trim.width - width) / 2;
+	const y = placement.trim.y + (placement.trim.height - height) / 2;
+	return {
+		flow: false,
+		width: page.size.width,
+		height: page.size.height,
+		scale,
+		x: roundMillimeters(x),
+		y: roundMillimeters(y),
+		bands: {
+			inline: 0,
+			block: 0
+		},
+		crop: {
+			top: roundMillimeters(Math.max(0, placement.bleedBox.y - y)),
+			right: roundMillimeters(Math.max(0, x + width - placement.bleedBox.x - placement.bleedBox.width)),
+			bottom: roundMillimeters(Math.max(0, y + height - placement.bleedBox.y - placement.bleedBox.height)),
+			left: roundMillimeters(Math.max(0, placement.bleedBox.x - x))
+		},
+		differs
+	};
+}
+function pagePlacementLayout(size, placement, fit) {
+	if (size === "fluid") return {
+		kind: "fluid",
+		piece: {
+			width: placement.bleedBox.width * PX_PER_MM,
+			height: placement.bleedBox.height * PX_PER_MM
+		},
+		inset: true,
+		paper: placement.bleedBox
+	};
+	if (size.height === "auto") return {
+		kind: "growing",
+		piece: {
+			width: size.width,
+			height: placement.trim.height * PX_PER_MM / fit.scale
+		},
+		inset: false,
+		paper: {
+			x: fit.x,
+			y: fit.y,
+			width: placement.trim.width,
+			height: placement.trim.height
+		}
+	};
+	return {
+		kind: "fixed",
+		piece: {
+			width: size.width,
+			height: size.height
+		},
+		inset: false,
+		paper: {
+			x: fit.x,
+			y: fit.y,
+			width: size.width * fit.scale / PX_PER_MM,
+			height: size.height * fit.scale / PX_PER_MM
+		}
+	};
+}
+//#endregion
+export { fitPage, impose, mirrorPlacement, pagePlacementLayout };

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 import { TextDirection, firstStrongDirection, languageDirection, resolveDirection } from "./direction.js";
+import { MARK_GAP_MM, MARK_LENGTH_MM, MM_PER_PT, PAPER_MM, PX_PER_MM, PaperBox, printBoxes, printPadding, printProperties, roundMillimeters, sheetMm, toMillimeters } from "./paper.js";
+import { Imposed, MillimeterEdges, PageFit, PagePlacementKind, PagePlacementLayout, Placement, fitPage, impose, mirrorPlacement, pagePlacementLayout } from "./imposition.js";
 import { z } from "zod";
 //#region src/index.d.ts
 export declare const Size: z.ZodObject<{
@@ -30,6 +32,7 @@ export declare const Paper: z.ZodUnion<readonly [z.ZodEnum<{
   unit: z.ZodEnum<{
     mm: "mm";
     in: "in";
+    pt: "pt";
   }>;
 }, z.core.$strip>]>;
 export type Paper = z.infer<typeof Paper>;
@@ -53,6 +56,7 @@ export declare const Print: z.ZodObject<{
     unit: z.ZodEnum<{
       mm: "mm";
       in: "in";
+      pt: "pt";
     }>;
   }, z.core.$strip>]>;
   orientation: z.ZodDefault<z.ZodEnum<{
@@ -65,8 +69,81 @@ export declare const Print: z.ZodObject<{
     bottom: z.ZodDefault<z.ZodNumber>;
     left: z.ZodDefault<z.ZodNumber>;
   }, z.core.$strip>>;
+  bleed: z.ZodDefault<z.ZodNumber>;
+  safe: z.ZodDefault<z.ZodNumber>;
+  marks: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
 export type Print = z.infer<typeof Print>;
+export type PrintInput = z.input<typeof Print>;
+export declare const MAX_IMPOSITION_CELLS = 10000;
+export declare const Imposition: z.ZodObject<{
+  paper: z.ZodUnion<readonly [z.ZodEnum<{
+    letter: "letter";
+    legal: "legal";
+    tabloid: "tabloid";
+    a3: "a3";
+    a4: "a4";
+    a5: "a5";
+  }>, 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.ZodNumber;
+  rows: z.ZodNumber;
+  cell: z.ZodObject<{
+    width: 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.ZodDefault<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";
+  }>>;
+}, z.core.$strip>;
+export type Imposition = z.infer<typeof Imposition>;
+export type ImpositionInput = z.input<typeof Imposition>;
 export declare const PageSize: z.ZodUnion<readonly [z.ZodLiteral<"fluid">, z.ZodObject<{
   width: z.ZodNumber;
   height: z.ZodNumber;
@@ -108,6 +185,7 @@ export declare const Page: z.ZodObject<{
       unit: z.ZodEnum<{
         mm: "mm";
         in: "in";
+        pt: "pt";
       }>;
     }, z.core.$strip>]>;
     orientation: z.ZodDefault<z.ZodEnum<{
@@ -120,6 +198,9 @@ export declare const Page: z.ZodObject<{
       bottom: z.ZodDefault<z.ZodNumber>;
       left: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
+    bleed: z.ZodDefault<z.ZodNumber>;
+    safe: z.ZodDefault<z.ZodNumber>;
+    marks: z.ZodDefault<z.ZodBoolean>;
   }, z.core.$strip>>;
 }, z.core.$strip>;
 export type Page = z.infer<typeof Page>;
@@ -655,6 +736,7 @@ export declare function jsonSchemas(): {
         unit: z.ZodEnum<{
           mm: "mm";
           in: "in";
+          pt: "pt";
         }>;
       }, z.core.$strip>]>;
       orientation: z.ZodDefault<z.ZodEnum<{
@@ -667,7 +749,76 @@ export declare function jsonSchemas(): {
         bottom: z.ZodDefault<z.ZodNumber>;
         left: z.ZodDefault<z.ZodNumber>;
       }, z.core.$strip>>;
+      bleed: z.ZodDefault<z.ZodNumber>;
+      safe: z.ZodDefault<z.ZodNumber>;
+      marks: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+  imposition: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+    paper: z.ZodUnion<readonly [z.ZodEnum<{
+      letter: "letter";
+      legal: "legal";
+      tabloid: "tabloid";
+      a3: "a3";
+      a4: "a4";
+      a5: "a5";
+    }>, 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.ZodNumber;
+    rows: z.ZodNumber;
+    cell: z.ZodObject<{
+      width: 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.ZodDefault<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";
+    }>>;
   }, z.core.$strip>>;
   deck: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
     title: z.ZodString;
@@ -872,14 +1023,5 @@ export declare function jsonSchemas(): {
     }, z.core.$strip>;
   }, z.core.$strip>>;
 };
-export declare const PAPER_MM: Record<(typeof NAMED_PAPERS)[number], {
-  width: number;
-  height: number;
-}>;
-export declare function sheetMm(print: Print): {
-  width: number;
-  height: number;
-};
-export declare const PX_PER_MM: number;
 //#endregion
-export { type TextDirection, firstStrongDirection, languageDirection, resolveDirection };
+export { type Imposed, MARK_GAP_MM, MARK_LENGTH_MM, MM_PER_PT, type MillimeterEdges, PAPER_MM, PX_PER_MM, type PageFit, type PagePlacementKind, type PagePlacementLayout, type PaperBox, type Placement, type TextDirection, firstStrongDirection, fitPage, impose, languageDirection, mirrorPlacement, pagePlacementLayout, printBoxes, printPadding, printProperties, resolveDirection, roundMillimeters, sheetMm, toMillimeters };

package/dist/index.js

@@ -1,4 +1,6 @@
+import { MARK_GAP_MM, MARK_LENGTH_MM, MM_PER_PT, PAPER_MM, PX_PER_MM, printBoxes, printPadding, printProperties, roundMillimeters, sheetMm, toMillimeters } from "./paper.js";
 import { firstStrongDirection, languageDirection, resolveDirection } from "./direction.js";
+import { fitPage, impose, mirrorPlacement, pagePlacementLayout } from "./imposition.js";
 import { z } from "zod";
 //#region src/index.ts
 const Size = z.object({
@@ -22,7 +24,11 @@ const NAMED_PAPERS = [
 const Paper = z.union([z.enum(NAMED_PAPERS), z.object({
 	width: z.number().positive(),
 	height: z.number().positive(),
-	unit: z.enum(["mm", "in"])
+	unit: z.enum([
+		"mm",
+		"in",
+		"pt"
+	])
 })]);
 const Margin = z.object({
 	top: z.number().nonnegative().default(0),
@@ -33,7 +39,106 @@ const Margin = z.object({
 const Print = z.object({
 	paper: Paper,
 	orientation: z.enum(["portrait", "landscape"]).default("portrait"),
-	margin: Margin.optional()
+	margin: Margin.optional(),
+	bleed: z.number().nonnegative().default(0),
+	safe: z.number().nonnegative().default(0),
+	marks: z.boolean().default(false)
+}).superRefine((print, ctx) => {
+	const trim = sheetMm(print);
+	if (print.safe * 2 >= trim.width) ctx.addIssue({
+		code: "custom",
+		path: ["safe"],
+		message: `safe is ${print.safe}mm on the left and right, but the trim is ${trim.width}mm wide; safe must leave area inside the trim`
+	});
+	if (print.safe * 2 >= trim.height) ctx.addIssue({
+		code: "custom",
+		path: ["safe"],
+		message: `safe is ${print.safe}mm on the top and bottom, but the trim is ${trim.height}mm high; safe must leave area inside the trim`
+	});
+});
+const ImpositionGap = z.object({
+	column: z.number().nonnegative().default(0),
+	row: z.number().nonnegative().default(0)
+});
+const MAX_IMPOSITION_CELLS = 1e4;
+const Imposition = z.object({
+	paper: Paper,
+	orientation: z.enum(["portrait", "landscape"]).default("portrait"),
+	unit: z.enum([
+		"mm",
+		"in",
+		"pt"
+	]).default("mm"),
+	margin: Margin.default({
+		top: 0,
+		right: 0,
+		bottom: 0,
+		left: 0
+	}),
+	columns: z.number().int().positive(),
+	rows: z.number().int().positive(),
+	cell: z.object({
+		width: z.number().positive(),
+		height: z.number().positive()
+	}),
+	gap: ImpositionGap.default({
+		column: 0,
+		row: 0
+	}),
+	bleed: z.number().nonnegative().default(0),
+	safe: z.number().nonnegative().default(0),
+	fit: z.enum(["contain", "cover"]).default("contain"),
+	fill: z.enum(["sequence", "repeat"]).default("sequence"),
+	sides: z.enum(["one", "two"]).default("one"),
+	flip: z.enum(["long", "short"]).default("long"),
+	skip: z.number().int().nonnegative().default(0),
+	dir: z.enum(["ltr", "rtl"]).default("ltr")
+}).superRefine((imposition, ctx) => {
+	const cellCount = BigInt(imposition.columns) * BigInt(imposition.rows);
+	if (imposition.columns > 1e4 || imposition.rows > 1e4 || cellCount > BigInt(1e4)) {
+		ctx.addIssue({
+			code: "custom",
+			path: ["columns"],
+			message: `the grid has ${cellCount} cells and the ceiling is ${MAX_IMPOSITION_CELLS}; fewer columns or rows clears this refusal`
+		});
+		return;
+	}
+	const mm = (value) => toMillimeters(value, imposition.unit);
+	const paper = sheetMm({
+		paper: imposition.paper,
+		orientation: imposition.orientation
+	});
+	const gridWidth = mm(imposition.margin.left + imposition.columns * imposition.cell.width + (imposition.columns - 1) * imposition.gap.column + imposition.margin.right);
+	const gridHeight = mm(imposition.margin.top + imposition.rows * imposition.cell.height + (imposition.rows - 1) * imposition.gap.row + imposition.margin.bottom);
+	if (gridWidth - paper.width > .01) ctx.addIssue({
+		code: "custom",
+		path: ["columns"],
+		message: `the grid is ${roundMillimeters(gridWidth)}mm wide and the paper is ${paper.width}mm wide, an overflow of ${roundMillimeters(gridWidth - paper.width)}mm; reduce the horizontal margins, columns, cell width or column gap`
+	});
+	if (gridHeight - paper.height > .01) ctx.addIssue({
+		code: "custom",
+		path: ["rows"],
+		message: `the grid is ${roundMillimeters(gridHeight)}mm high and the paper is ${paper.height}mm high, an overflow of ${roundMillimeters(gridHeight - paper.height)}mm; reduce the vertical margins, rows, cell height or row gap`
+	});
+	const safe = mm(imposition.safe);
+	const cellWidth = mm(imposition.cell.width);
+	const cellHeight = mm(imposition.cell.height);
+	if (safe * 2 >= cellWidth) ctx.addIssue({
+		code: "custom",
+		path: ["safe"],
+		message: `safe is ${roundMillimeters(safe)}mm on the left and right, but the cell is ${roundMillimeters(cellWidth)}mm wide; safe must leave area inside the cell`
+	});
+	if (safe * 2 >= cellHeight) ctx.addIssue({
+		code: "custom",
+		path: ["safe"],
+		message: `safe is ${roundMillimeters(safe)}mm on the top and bottom, but the cell is ${roundMillimeters(cellHeight)}mm high; safe must leave area inside the cell`
+	});
+	const cells = imposition.columns * imposition.rows;
+	if (imposition.skip >= cells) ctx.addIssue({
+		code: "custom",
+		path: ["skip"],
+		message: `skip is ${imposition.skip}, but the grid has ${cells} cells; skip must be less than ${cells}`
+	});
 });
 const PageSize = z.union([
 	z.literal("fluid"),
@@ -229,55 +334,11 @@ function shotsUsed(deck) {
 function jsonSchemas() {
 	return {
 		page: z.toJSONSchema(Page, { io: "input" }),
+		imposition: z.toJSONSchema(Imposition, { io: "input" }),
 		deck: z.toJSONSchema(DeckShape, { io: "input" }),
 		manifest: z.toJSONSchema(Manifest, { io: "input" }),
 		publishedShot: z.toJSONSchema(PublishedShot, { io: "input" })
 	};
 }
-const PAPER_MM = {
-	letter: {
-		width: 215.9,
-		height: 279.4
-	},
-	legal: {
-		width: 215.9,
-		height: 355.6
-	},
-	tabloid: {
-		width: 279.4,
-		height: 431.8
-	},
-	a3: {
-		width: 297,
-		height: 420
-	},
-	a4: {
-		width: 210,
-		height: 297
-	},
-	a5: {
-		width: 148,
-		height: 210
-	}
-};
-function sheetMm(print) {
-	const portrait = typeof print.paper === "string" ? PAPER_MM[print.paper] : print.paper.unit === "in" ? {
-		width: print.paper.width * 25.4,
-		height: print.paper.height * 25.4
-	} : {
-		width: print.paper.width,
-		height: print.paper.height
-	};
-	const [short, long] = [Math.min(portrait.width, portrait.height), Math.max(portrait.width, portrait.height)];
-	const round = (mm) => Math.round(mm * 100) / 100;
-	return print.orientation === "landscape" ? {
-		width: round(long),
-		height: round(short)
-	} : {
-		width: round(short),
-		height: round(long)
-	};
-}
-const PX_PER_MM = 96 / 25.4;
 //#endregion
-export { Annotation, Box, Cue, DECK_SIZE, Deck, Direction, Manifest, Margin, NAMED_PAPERS, Narration, PAPER_MM, PX_PER_MM, Page, PageSize, Paper, Point, Print, PublishedShot, SHOT_KEY, Scripts, Shot, Size, Slide, SlideContent, Word, annotationCueIssues, exceedsLimits, firstStrongDirection, jsonSchemas, languageDirection, resolveDirection, sheetMm, shotsUsed };
+export { Annotation, Box, Cue, DECK_SIZE, Deck, Direction, Imposition, MARK_GAP_MM, MARK_LENGTH_MM, MAX_IMPOSITION_CELLS, MM_PER_PT, Manifest, Margin, NAMED_PAPERS, Narration, PAPER_MM, PX_PER_MM, Page, PageSize, Paper, Point, Print, PublishedShot, SHOT_KEY, Scripts, Shot, Size, Slide, SlideContent, Word, annotationCueIssues, exceedsLimits, firstStrongDirection, fitPage, impose, jsonSchemas, languageDirection, mirrorPlacement, pagePlacementLayout, printBoxes, printPadding, printProperties, resolveDirection, roundMillimeters, sheetMm, shotsUsed, toMillimeters };

package/dist/paper.d.ts

@@ -0,0 +1,47 @@
+import { Paper, Print } from "./index.js";
+//#region src/paper.d.ts
+export declare const MM_PER_PT: number;
+export declare const MARK_LENGTH_MM = 5;
+export declare const MARK_GAP_MM = 1;
+export declare const PAPER_MM: Record<Extract<Paper, string>, {
+  width: number;
+  height: number;
+}>;
+export declare const roundMillimeters: (mm: number) => number;
+export declare function toMillimeters(value: number, unit: 'mm' | 'in' | 'pt'): number;
+export declare function sheetMm(print: Pick<Print, 'paper' | 'orientation'>): {
+  width: number;
+  height: number;
+};
+export declare const PX_PER_MM: number;
+export declare function printProperties(print: Pick<Print, 'bleed' | 'safe'>, unit?: 'mm' | 'in' | 'pt'): string;
+export declare function printPadding(edges: {
+  top: number;
+  right: number;
+  bottom: number;
+  left: number;
+}): string;
+export interface PaperBox {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+export interface MarkSegment {
+  x1: number;
+  y1: number;
+  x2: number;
+  y2: number;
+}
+export interface PrintBoxes {
+  media: {
+    width: number;
+    height: number;
+  };
+  bleedBox: PaperBox;
+  trim: PaperBox;
+  safeBox: PaperBox;
+  marks: MarkSegment[];
+}
+export declare function printBoxes(print: Print): PrintBoxes;
+//#endregion

package/dist/paper.js

@@ -0,0 +1,159 @@
+//#region src/paper.ts
+const MM_PER_PT = 25.4 / 72;
+const MARK_LENGTH_MM = 5;
+const MARK_GAP_MM = 1;
+const PAPER_MM = {
+	letter: {
+		width: 215.9,
+		height: 279.4
+	},
+	legal: {
+		width: 215.9,
+		height: 355.6
+	},
+	tabloid: {
+		width: 279.4,
+		height: 431.8
+	},
+	a3: {
+		width: 297,
+		height: 420
+	},
+	a4: {
+		width: 210,
+		height: 297
+	},
+	a5: {
+		width: 148,
+		height: 210
+	}
+};
+const roundMillimeters = (mm) => Math.round(mm * 100) / 100;
+function toMillimeters(value, unit) {
+	return value * (unit === "in" ? 25.4 : unit === "pt" ? MM_PER_PT : 1);
+}
+function sheetMm(print) {
+	const portrait = typeof print.paper === "string" ? PAPER_MM[print.paper] : {
+		width: toMillimeters(print.paper.width, print.paper.unit),
+		height: toMillimeters(print.paper.height, print.paper.unit)
+	};
+	const [short, long] = [Math.min(portrait.width, portrait.height), Math.max(portrait.width, portrait.height)];
+	return print.orientation === "landscape" ? {
+		width: roundMillimeters(long),
+		height: roundMillimeters(short)
+	} : {
+		width: roundMillimeters(short),
+		height: roundMillimeters(long)
+	};
+}
+const PX_PER_MM = 96 / 25.4;
+function printProperties(print, unit = "mm") {
+	return `:root{--segnavia-bleed:${roundMillimeters(toMillimeters(print.bleed, unit))}mm;--segnavia-safe:${roundMillimeters(toMillimeters(print.safe, unit))}mm}`;
+}
+function printPadding(edges) {
+	return `:where(html){padding:${[
+		edges.top,
+		edges.right,
+		edges.bottom,
+		edges.left
+	].map((value) => `${value}mm`).join(" ")}}`;
+}
+function printBoxes(print) {
+	const sheet = sheetMm(print);
+	const outside = print.marks ? 6 : 0;
+	const bleedBox = {
+		x: outside,
+		y: outside,
+		width: roundMillimeters(sheet.width + print.bleed * 2),
+		height: roundMillimeters(sheet.height + print.bleed * 2)
+	};
+	const trim = {
+		x: roundMillimeters(outside + print.bleed),
+		y: roundMillimeters(outside + print.bleed),
+		width: sheet.width,
+		height: sheet.height
+	};
+	const safeBox = {
+		x: roundMillimeters(trim.x + print.safe),
+		y: roundMillimeters(trim.y + print.safe),
+		width: roundMillimeters(trim.width - print.safe * 2),
+		height: roundMillimeters(trim.height - print.safe * 2)
+	};
+	const media = {
+		width: roundMillimeters(bleedBox.width + outside * 2),
+		height: roundMillimeters(bleedBox.height + outside * 2)
+	};
+	if (!print.marks) return {
+		media,
+		bleedBox,
+		trim,
+		safeBox,
+		marks: []
+	};
+	const leftStart = roundMillimeters(bleedBox.x - 1);
+	const rightStart = roundMillimeters(bleedBox.x + bleedBox.width + 1);
+	const topStart = roundMillimeters(bleedBox.y - 1);
+	const bottomStart = roundMillimeters(bleedBox.y + bleedBox.height + 1);
+	const right = roundMillimeters(rightStart + 5);
+	const bottom = roundMillimeters(bottomStart + 5);
+	const trimRight = roundMillimeters(trim.x + trim.width);
+	const trimBottom = roundMillimeters(trim.y + trim.height);
+	return {
+		media,
+		bleedBox,
+		trim,
+		safeBox,
+		marks: [
+			{
+				x1: roundMillimeters(leftStart - 5),
+				y1: trim.y,
+				x2: leftStart,
+				y2: trim.y
+			},
+			{
+				x1: trim.x,
+				y1: roundMillimeters(topStart - 5),
+				x2: trim.x,
+				y2: topStart
+			},
+			{
+				x1: rightStart,
+				y1: trim.y,
+				x2: right,
+				y2: trim.y
+			},
+			{
+				x1: trimRight,
+				y1: roundMillimeters(topStart - 5),
+				x2: trimRight,
+				y2: topStart
+			},
+			{
+				x1: roundMillimeters(leftStart - 5),
+				y1: trimBottom,
+				x2: leftStart,
+				y2: trimBottom
+			},
+			{
+				x1: trim.x,
+				y1: bottomStart,
+				x2: trim.x,
+				y2: bottom
+			},
+			{
+				x1: rightStart,
+				y1: trimBottom,
+				x2: right,
+				y2: trimBottom
+			},
+			{
+				x1: trimRight,
+				y1: bottomStart,
+				x2: trimRight,
+				y2: bottom
+			}
+		]
+	};
+}
+//#endregion
+export { MARK_GAP_MM, MARK_LENGTH_MM, MM_PER_PT, PAPER_MM, PX_PER_MM, printBoxes, printPadding, printProperties, roundMillimeters, sheetMm, toMillimeters };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@segnavia/format",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "license": "MIT",
   "repository": {