@segnavia/format 0.38.0 → 0.40.0

package/dist/deck.d.ts

@@ -1,29 +1,7 @@
+import { Box, Point, Size } from "./geometry.js";
+import { ImageFit } from "./image-fit.js";
 import { z } from "zod";
 //#region src/deck.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>;
-export declare const ImageFit: z.ZodEnum<{
-  width: "width";
-  contain: "contain";
-  cover: "cover";
-  focus: "focus";
-}>;
-export type ImageFit = z.infer<typeof ImageFit>;
 export declare const Annotation: z.ZodObject<{
   ring: z.ZodNullable<z.ZodObject<{
     x: z.ZodNumber;
@@ -163,9 +141,9 @@ export declare const Narration: z.ZodObject<{
   text: z.ZodString;
   lang: z.ZodOptional<z.ZodString>;
   dir: z.ZodOptional<z.ZodEnum<{
+    auto: "auto";
     ltr: "ltr";
     rtl: "rtl";
-    auto: "auto";
   }>>;
   voice: z.ZodOptional<z.ZodString>;
   words: z.ZodArray<z.ZodObject<{
@@ -183,7 +161,7 @@ export declare const Narration: z.ZodObject<{
   }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type Narration = z.infer<typeof Narration>;
-export declare const SlideContent: z.ZodDiscriminatedUnion<[z.ZodObject<{
+export declare const SlideContent: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
   kind: z.ZodLiteral<"html">;
   html: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
@@ -265,11 +243,52 @@ export declare const SlideContent: z.ZodDiscriminatedUnion<[z.ZodObject<{
     focus: "focus";
   }>>;
   frame: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>], "kind">;
+}, z.core.$strip>], "kind">, z.ZodObject<{
+  media: z.ZodObject<{
+    kind: z.ZodEnum<{
+      deck: "deck";
+      page: "page";
+      paper: "paper";
+      book: "book";
+      media: "media";
+      shot: "shot";
+    }>;
+    address: z.ZodString;
+    page: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    box: z.ZodOptional<z.ZodEnum<{
+      media: "media";
+      crop: "crop";
+      trim: "trim";
+      bleed: "bleed";
+      art: "art";
+    }>>;
+    crop: z.ZodOptional<z.ZodObject<{
+      top: z.ZodOptional<z.ZodString>;
+      right: z.ZodOptional<z.ZodString>;
+      bottom: z.ZodOptional<z.ZodString>;
+      left: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    fit: z.ZodOptional<z.ZodEnum<{
+      width: "width";
+      contain: "contain";
+      cover: "cover";
+      focus: "focus";
+    }>>;
+    alt: z.ZodOptional<z.ZodObject<{
+      text: z.ZodString;
+      lang: z.ZodOptional<z.ZodString>;
+      dir: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        ltr: "ltr";
+        rtl: "rtl";
+      }>>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>;
+}, z.core.$strip>]>;
 export type SlideContent = z.infer<typeof SlideContent>;
 export declare const Slide: z.ZodObject<{
   id: z.ZodString;
-  content: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  content: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"html">;
     html: z.ZodString;
   }, z.core.$strip>, z.ZodObject<{
@@ -351,15 +370,56 @@ export declare const Slide: z.ZodObject<{
       focus: "focus";
     }>>;
     frame: z.ZodOptional<z.ZodBoolean>;
-  }, z.core.$strip>], "kind">;
+  }, z.core.$strip>], "kind">, z.ZodObject<{
+    media: z.ZodObject<{
+      kind: z.ZodEnum<{
+        deck: "deck";
+        page: "page";
+        paper: "paper";
+        book: "book";
+        media: "media";
+        shot: "shot";
+      }>;
+      address: z.ZodString;
+      page: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+      box: z.ZodOptional<z.ZodEnum<{
+        media: "media";
+        crop: "crop";
+        trim: "trim";
+        bleed: "bleed";
+        art: "art";
+      }>>;
+      crop: z.ZodOptional<z.ZodObject<{
+        top: z.ZodOptional<z.ZodString>;
+        right: z.ZodOptional<z.ZodString>;
+        bottom: z.ZodOptional<z.ZodString>;
+        left: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>;
+      fit: z.ZodOptional<z.ZodEnum<{
+        width: "width";
+        contain: "contain";
+        cover: "cover";
+        focus: "focus";
+      }>>;
+      alt: z.ZodOptional<z.ZodObject<{
+        text: z.ZodString;
+        lang: z.ZodOptional<z.ZodString>;
+        dir: z.ZodOptional<z.ZodEnum<{
+          auto: "auto";
+          ltr: "ltr";
+          rtl: "rtl";
+        }>>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  }, z.core.$strip>]>;
   notes: z.ZodOptional<z.ZodString>;
   narration: z.ZodOptional<z.ZodObject<{
     text: z.ZodString;
     lang: z.ZodOptional<z.ZodString>;
     dir: z.ZodOptional<z.ZodEnum<{
+      auto: "auto";
       ltr: "ltr";
       rtl: "rtl";
-      auto: "auto";
     }>>;
     voice: z.ZodOptional<z.ZodString>;
     words: z.ZodArray<z.ZodObject<{
@@ -389,9 +449,9 @@ export declare const DECK_SIZE: {
 export declare const PLAYBACK_MODES: readonly ["segmented", "continuous"];
 export type PlaybackMode = (typeof PLAYBACK_MODES)[number];
 export declare const Playback: z.ZodUnion<readonly [z.ZodEnum<{
-  continuous: "continuous";
   segmented: "segmented";
-}>, z.ZodPipe<z.ZodLiteral<"step">, z.ZodTransform<"continuous" | "segmented", "step">>]>;
+  continuous: "continuous";
+}>, z.ZodPipe<z.ZodLiteral<"step">, z.ZodTransform<"segmented" | "continuous", "step">>]>;
 export declare function parsePlayback(value: unknown): PlaybackMode | undefined;
 export declare function annotationCueIssues(narration: Slide['narration'], annotations: number): string[];
 export declare const Deck: z.ZodObject<{
@@ -416,9 +476,9 @@ export declare const Deck: z.ZodObject<{
     sandboxed: "sandboxed";
   }>>;
   dir: z.ZodOptional<z.ZodEnum<{
+    auto: "auto";
     ltr: "ltr";
     rtl: "rtl";
-    auto: "auto";
   }>>;
   lang: z.ZodOptional<z.ZodString>;
   transition: z.ZodOptional<z.ZodObject<{
@@ -430,9 +490,9 @@ export declare const Deck: z.ZodObject<{
     duration: z.ZodDefault<z.ZodNumber>;
   }, z.core.$strip>>;
   playback: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
-    continuous: "continuous";
     segmented: "segmented";
-  }>, z.ZodPipe<z.ZodLiteral<"step">, z.ZodTransform<"continuous" | "segmented", "step">>]>>;
+    continuous: "continuous";
+  }>, z.ZodPipe<z.ZodLiteral<"step">, z.ZodTransform<"segmented" | "continuous", "step">>]>>;
   captions: z.ZodOptional<z.ZodEnum<{
     on: "on";
     off: "off";
@@ -443,11 +503,11 @@ export declare const Deck: z.ZodObject<{
     label: z.ZodString;
     type: z.ZodEnum<{
       text: "text";
+      image: "image";
       phone: "phone";
       email: "email";
       link: "link";
       qr: "qr";
-      image: "image";
     }>;
     required: z.ZodDefault<z.ZodBoolean>;
     placeholder: z.ZodOptional<z.ZodString>;
@@ -461,7 +521,7 @@ export declare const Deck: z.ZodObject<{
   }, z.core.$strip>, z.ZodTransform<{
     key: string;
     label: string;
-    type: "text" | "phone" | "email" | "link" | "qr" | "image";
+    type: "text" | "image" | "phone" | "email" | "link" | "qr";
     required: boolean;
     overflow: "refuse" | "shrink" | "truncate" | "wrap";
     placeholder?: string | undefined;
@@ -469,7 +529,7 @@ export declare const Deck: z.ZodObject<{
   }, {
     key: string;
     label: string;
-    type: "text" | "phone" | "email" | "link" | "qr" | "image";
+    type: "text" | "image" | "phone" | "email" | "link" | "qr";
     required: boolean;
     overflow: "refuse" | "shrink" | "truncate" | "wrap";
     placeholder?: string | undefined;
@@ -477,7 +537,7 @@ export declare const Deck: z.ZodObject<{
   }>>>>;
   slides: z.ZodArray<z.ZodObject<{
     id: z.ZodString;
-    content: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    content: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
       kind: z.ZodLiteral<"html">;
       html: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
@@ -559,15 +619,56 @@ export declare const Deck: z.ZodObject<{
         focus: "focus";
       }>>;
       frame: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>], "kind">;
+    }, z.core.$strip>], "kind">, z.ZodObject<{
+      media: z.ZodObject<{
+        kind: z.ZodEnum<{
+          deck: "deck";
+          page: "page";
+          paper: "paper";
+          book: "book";
+          media: "media";
+          shot: "shot";
+        }>;
+        address: z.ZodString;
+        page: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+        box: z.ZodOptional<z.ZodEnum<{
+          media: "media";
+          crop: "crop";
+          trim: "trim";
+          bleed: "bleed";
+          art: "art";
+        }>>;
+        crop: z.ZodOptional<z.ZodObject<{
+          top: z.ZodOptional<z.ZodString>;
+          right: z.ZodOptional<z.ZodString>;
+          bottom: z.ZodOptional<z.ZodString>;
+          left: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        fit: z.ZodOptional<z.ZodEnum<{
+          width: "width";
+          contain: "contain";
+          cover: "cover";
+          focus: "focus";
+        }>>;
+        alt: z.ZodOptional<z.ZodObject<{
+          text: z.ZodString;
+          lang: z.ZodOptional<z.ZodString>;
+          dir: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            ltr: "ltr";
+            rtl: "rtl";
+          }>>;
+        }, z.core.$strip>>;
+      }, z.core.$strip>;
+    }, z.core.$strip>]>;
     notes: z.ZodOptional<z.ZodString>;
     narration: z.ZodOptional<z.ZodObject<{
       text: z.ZodString;
       lang: z.ZodOptional<z.ZodString>;
       dir: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
         ltr: "ltr";
         rtl: "rtl";
-        auto: "auto";
       }>>;
       voice: z.ZodOptional<z.ZodString>;
       words: z.ZodArray<z.ZodObject<{
@@ -647,4 +748,5 @@ export interface DeckLimits {
   maxNotesBytes?: number;
 }
 export declare function exceedsLimits(deck: Deck, limits: DeckLimits): string[];
-//#endregion
+//#endregion
+export { Box, ImageFit, Point, Size };

package/dist/deck.js

@@ -1,30 +1,13 @@
 import { Direction } from "./direction.js";
+import { Box, Point, Size } from "./geometry.js";
+import { ImageFit } from "./image-fit.js";
+import { Placement, PlacementShape } from "./placement.js";
 import { Scripts } from "./scripts.js";
 import { Slots } from "./slots.js";
 import { SlideTiming, slideTimingIssues } from "./timing.js";
 import { Transition } from "./transition.js";
 import { z } from "zod";
 //#region src/deck.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()
-});
-const ImageFit = z.enum([
-	"contain",
-	"cover",
-	"width",
-	"focus"
-]);
 const Annotation = z.object({
 	ring: Box.nullable(),
 	badge: z.object({
@@ -77,7 +60,7 @@ const Narration = z.object({
 	live: z.boolean().default(false),
 	cues: z.array(Cue).default([])
 });
-const SlideContent = z.discriminatedUnion("kind", [
+const DirectSlideContent = z.discriminatedUnion("kind", [
 	z.object({
 		kind: z.literal("html"),
 		html: z.string()
@@ -107,6 +90,7 @@ const SlideContent = z.discriminatedUnion("kind", [
 		frame: z.boolean().optional()
 	})
 ]);
+const SlideContent = z.union([DirectSlideContent, z.object({ media: PlacementShape })]);
 const Slide = z.object({
 	id: z.string(),
 	content: SlideContent,
@@ -153,18 +137,32 @@ function annotationCueIssues(narration, annotations) {
 function cueIssues(slide) {
 	const narration = slide.narration;
 	if (!narration) return [];
-	const annotations = slide.content.kind === "shot" ? slide.content.shot.annotations.length : null;
+	const annotations = "kind" in slide.content && slide.content.kind === "shot" ? slide.content.shot.annotations.length : null;
 	const words = narration.live ? null : narration.words.length;
 	const issues = [];
 	for (const cue of narration.cues) {
 		for (const word of [cue.word, cue.untilWord]) if (word !== void 0 && words !== null && word >= words) issues.push(`a cue names word ${word}, but the narration has ${words} words`);
-		if (slide.content.kind !== "shot" && slide.content.kind !== "shot-ref") issues.push("a cue names an annotation, but only a shot carries annotations");
+		if (!("kind" in slide.content) || slide.content.kind !== "shot" && slide.content.kind !== "shot-ref") issues.push("a cue names an annotation, but only a shot carries annotations");
 	}
 	if (annotations !== null) issues.push(...annotationCueIssues(narration, annotations));
 	return issues;
 }
 const Deck = DeckShape.superRefine((deck, ctx) => {
 	deck.slides.forEach((slide, index) => {
+		if ("media" in slide.content) try {
+			Placement.parse(slide.content.media, "deck");
+		} catch (error) {
+			ctx.addIssue({
+				code: "custom",
+				path: [
+					"slides",
+					index,
+					"content",
+					"media"
+				],
+				message: error instanceof Error ? error.message : String(error)
+			});
+		}
 		for (const message of cueIssues(slide)) ctx.addIssue({
 			code: "custom",
 			path: [
@@ -211,7 +209,7 @@ function exceedsLimits(deck, limits) {
 	const bytes = (text) => new TextEncoder().encode(text).length;
 	if (limits.maxSlides !== void 0 && deck.slides.length > limits.maxSlides) reasons.push(`the deck has ${deck.slides.length} slides; the limit is ${limits.maxSlides}`);
 	deck.slides.forEach((slide, index) => {
-		if (limits.maxSlideBytes !== void 0 && slide.content.kind === "html" && bytes(slide.content.html) > limits.maxSlideBytes) reasons.push(`slide ${index + 1} is ${bytes(slide.content.html)} bytes; the limit is ${limits.maxSlideBytes}`);
+		if (limits.maxSlideBytes !== void 0 && "kind" in slide.content && slide.content.kind === "html" && bytes(slide.content.html) > limits.maxSlideBytes) reasons.push(`slide ${index + 1} is ${bytes(slide.content.html)} bytes; the limit is ${limits.maxSlideBytes}`);
 		if (limits.maxNotesBytes !== void 0 && slide.notes && bytes(slide.notes) > limits.maxNotesBytes) reasons.push(`slide ${index + 1} has ${bytes(slide.notes)} bytes of notes; the limit is ${limits.maxNotesBytes}`);
 	});
 	return reasons;

package/dist/direction.d.ts

@@ -1,9 +1,9 @@
 import { z } from "zod";
 //#region src/direction.d.ts
 export declare const Direction: z.ZodEnum<{
+  auto: "auto";
   ltr: "ltr";
   rtl: "rtl";
-  auto: "auto";
 }>;
 export declare const TextDirection: z.ZodEnum<{
   ltr: "ltr";

package/dist/font-collection.d.ts

@@ -0,0 +1,8 @@
+//#region src/font-collection.d.ts
+export type ExtractedFontFace = {
+  data: Uint8Array;
+  format: 'truetype' | 'opentype';
+};
+export declare function collectionFaces(bytes: Uint8Array): string[];
+export declare function extractFace(bytes: Uint8Array, postscriptName: string): ExtractedFontFace;
+//#endregion

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