@segnavia/format 0.38.0 → 0.39.0

package/dist/json-schemas.js

@@ -0,0 +1,43 @@
+import { Media } from "./media.js";
+import { PlacementShape } from "./placement.js";
+import { SlotDeclaration, SlotDeclarationInput } from "./slots.js";
+import { DeckShape, Manifest, PublishedShot } from "./deck.js";
+import { Board } from "./board.js";
+import { FontReference, FontReferenceInput, LocalFaceTransport, LocalFacesTransport } from "./fonts.js";
+import { Motif, MotifInput } from "./motif.js";
+import { PrintSetting, PrintSettingInput } from "./paper.js";
+import { BookShape, BookView } from "./book.js";
+import { Page } from "./page.js";
+import { Cover } from "./cover.js";
+import { Imposition } from "./imposition-schema.js";
+import { Lexicon } from "./lexicon.js";
+import { z } from "zod";
+//#region src/json-schemas.ts
+function jsonSchemas() {
+	return {
+		book: z.toJSONSchema(BookShape, { io: "input" }),
+		bookView: z.toJSONSchema(BookView, { io: "input" }),
+		page: z.toJSONSchema(Page, { io: "input" }),
+		lexicon: z.toJSONSchema(Lexicon, { 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" }),
+		board: z.toJSONSchema(Board, { io: "input" }),
+		printSetting: z.toJSONSchema(PrintSetting, { io: "input" }),
+		printSettingInput: z.toJSONSchema(PrintSettingInput, { io: "input" }),
+		slotDeclaration: z.toJSONSchema(SlotDeclaration, { io: "input" }),
+		slotDeclarationInput: z.toJSONSchema(SlotDeclarationInput, { io: "input" }),
+		fontReference: z.toJSONSchema(FontReference, { io: "input" }),
+		fontReferenceInput: z.toJSONSchema(FontReferenceInput, { io: "input" }),
+		localFaceTransport: z.toJSONSchema(LocalFaceTransport, { io: "input" }),
+		localFacesTransport: z.toJSONSchema(LocalFacesTransport, { io: "input" }),
+		motif: z.toJSONSchema(Motif, { io: "input" }),
+		motifInput: z.toJSONSchema(MotifInput, { io: "input" }),
+		media: z.toJSONSchema(Media, { io: "input" }),
+		placement: z.toJSONSchema(PlacementShape, { io: "input" }),
+		cover: z.toJSONSchema(Cover, { io: "input" })
+	};
+}
+//#endregion
+export { jsonSchemas };

package/dist/media.d.ts

@@ -0,0 +1,152 @@
+import { TextDirection } from "./direction.js";
+import { z } from "zod";
+//#region src/media.d.ts
+export declare const MediaFormat: z.ZodEnum<{
+  png: "png";
+  jpeg: "jpeg";
+  gif: "gif";
+  webp: "webp";
+  svg: "svg";
+  pdf: "pdf";
+  ai: "ai";
+}>;
+export type MediaFormat = z.infer<typeof MediaFormat>;
+export declare const MEDIA_FORMATS: Record<MediaFormat, {
+  pages: boolean;
+  raster: boolean;
+}>;
+export declare const MediaText: z.ZodObject<{
+  text: z.ZodString;
+  lang: z.ZodOptional<z.ZodString>;
+  dir: z.ZodOptional<z.ZodEnum<{
+    auto: "auto";
+    ltr: "ltr";
+    rtl: "rtl";
+  }>>;
+}, z.core.$strip>;
+export type MediaText = z.infer<typeof MediaText>;
+export declare function mediaTextDirection(text: MediaText): TextDirection;
+export declare const PageSelector: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+export type PageSelector = z.infer<typeof PageSelector>;
+export declare const MediaPage: z.ZodObject<{
+  name: z.ZodOptional<z.ZodString>;
+  boxes: z.ZodObject<{
+    media: z.ZodObject<{
+      x: z.ZodNumber;
+      y: z.ZodNumber;
+      width: z.ZodNumber;
+      height: z.ZodNumber;
+    }, z.core.$strip>;
+    crop: z.ZodOptional<z.ZodObject<{
+      x: z.ZodNumber;
+      y: z.ZodNumber;
+      width: z.ZodNumber;
+      height: z.ZodNumber;
+    }, z.core.$strip>>;
+    trim: z.ZodOptional<z.ZodObject<{
+      x: z.ZodNumber;
+      y: z.ZodNumber;
+      width: z.ZodNumber;
+      height: z.ZodNumber;
+    }, z.core.$strip>>;
+    bleed: z.ZodOptional<z.ZodObject<{
+      x: z.ZodNumber;
+      y: z.ZodNumber;
+      width: z.ZodNumber;
+      height: z.ZodNumber;
+    }, z.core.$strip>>;
+    art: z.ZodOptional<z.ZodObject<{
+      x: z.ZodNumber;
+      y: z.ZodNumber;
+      width: z.ZodNumber;
+      height: z.ZodNumber;
+    }, z.core.$strip>>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+export type MediaPage = z.infer<typeof MediaPage>;
+export declare const Media: z.ZodObject<{
+  format: z.ZodEnum<{
+    png: "png";
+    jpeg: "jpeg";
+    gif: "gif";
+    webp: "webp";
+    svg: "svg";
+    pdf: "pdf";
+    ai: "ai";
+  }>;
+  size: z.ZodObject<{
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+  }, z.core.$strip>;
+  pages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    boxes: z.ZodObject<{
+      media: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+      }, z.core.$strip>;
+      crop: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+      }, z.core.$strip>>;
+      trim: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+      }, z.core.$strip>>;
+      bleed: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+      }, z.core.$strip>>;
+      art: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  }, z.core.$strip>>>;
+  resolution: z.ZodOptional<z.ZodNumber>;
+  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>>;
+  caption: 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>>;
+  credit: 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>>;
+  derivedFrom: z.ZodOptional<z.ZodObject<{
+    address: z.ZodString;
+    page: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    name: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Media = z.infer<typeof Media>;
+export type MediaInput = z.input<typeof Media>;
+//#endregion

package/dist/media.js

@@ -0,0 +1,119 @@
+import { Direction, resolveDirection } from "./direction.js";
+import { Box } from "./geometry.js";
+import { z } from "zod";
+//#region src/media.ts
+const MediaFormat = z.enum([
+	"png",
+	"jpeg",
+	"gif",
+	"webp",
+	"svg",
+	"pdf",
+	"ai"
+]);
+const MEDIA_FORMATS = {
+	png: {
+		pages: false,
+		raster: true
+	},
+	jpeg: {
+		pages: false,
+		raster: true
+	},
+	gif: {
+		pages: false,
+		raster: true
+	},
+	webp: {
+		pages: false,
+		raster: true
+	},
+	svg: {
+		pages: false,
+		raster: false
+	},
+	pdf: {
+		pages: true,
+		raster: false
+	},
+	ai: {
+		pages: true,
+		raster: false
+	}
+};
+const MediaText = z.object({
+	text: z.string().min(1),
+	lang: z.string().optional(),
+	dir: Direction.optional()
+});
+function mediaTextDirection(text) {
+	return resolveDirection(text.dir, text.lang, text.text);
+}
+const PageSelector = z.union([z.string().trim().min(1), z.number().int().positive()]);
+const PageBox = Box.superRefine((box, ctx) => {
+	if (box.width <= 0) ctx.addIssue({
+		code: "custom",
+		path: ["width"],
+		message: "box width must be positive; pass a positive width to clear this refusal"
+	});
+	if (box.height <= 0) ctx.addIssue({
+		code: "custom",
+		path: ["height"],
+		message: "box height must be positive; pass a positive height to clear this refusal"
+	});
+});
+const PAGE_BOXES = [
+	"media",
+	"crop",
+	"trim",
+	"bleed",
+	"art"
+];
+const PageBoxName = z.enum(PAGE_BOXES);
+const MediaPageBoxesShape = {
+	media: PageBox,
+	crop: PageBox.optional(),
+	trim: PageBox.optional(),
+	bleed: PageBox.optional(),
+	art: PageBox.optional()
+};
+const MediaPage = z.object({
+	name: z.string().min(1).optional(),
+	boxes: z.object(MediaPageBoxesShape)
+});
+const Media = z.object({
+	format: MediaFormat,
+	size: z.object({
+		width: z.number().positive("size.width could not be accepted; pass a positive width to clear this refusal"),
+		height: z.number().positive("size.height could not be accepted; pass a positive height to clear this refusal")
+	}),
+	pages: z.array(MediaPage).optional(),
+	resolution: z.number().positive("resolution could not be accepted; pass a positive resolution to clear this refusal").optional(),
+	alt: MediaText.optional(),
+	caption: MediaText.optional(),
+	credit: MediaText.optional(),
+	derivedFrom: z.object({
+		address: z.string().min(1),
+		page: PageSelector,
+		name: z.string().min(1).optional()
+	}).optional()
+}).superRefine((media, ctx) => {
+	const capabilities = MEDIA_FORMATS[media.format];
+	if (media.pages !== void 0 && !capabilities.pages) ctx.addIssue({
+		code: "custom",
+		path: ["pages"],
+		message: `pages could not be accepted for ${media.format}; remove pages or use a format with pages to clear this refusal`
+	});
+	if (media.resolution !== void 0 && !capabilities.raster) ctx.addIssue({
+		code: "custom",
+		path: ["resolution"],
+		message: `resolution could not be accepted for ${media.format}; remove resolution or use a raster format to clear this refusal`
+	});
+	if (media.derivedFrom !== void 0 && capabilities.pages) ctx.addIssue({
+		code: "custom",
+		path: ["derivedFrom"],
+		message: `derivedFrom could not be accepted for ${media.format}; remove derivedFrom or use a format without pages to clear this refusal`
+	});
+});
+//#endregion
+export { MEDIA_FORMATS, Media, MediaFormat, MediaPage, MediaText, PAGE_BOXES, PageBoxName, PageSelector, mediaTextDirection };

package/dist/note-series.d.ts

@@ -3,14 +3,14 @@ import { z } from "zod";
 //#region src/note-series.d.ts
 export declare const NotePlacement: z.ZodEnum<{
   page: "page";
-  chapter: "chapter";
   book: "book";
+  chapter: "chapter";
   part: "part";
 }>;
 export type NotePlacement = z.infer<typeof NotePlacement>;
 export declare const NoteNumbering: z.ZodEnum<{
-  chapter: "chapter";
   book: "book";
+  chapter: "chapter";
   part: "part";
 }>;
 export type NoteNumbering = z.infer<typeof NoteNumbering>;
@@ -18,13 +18,13 @@ export declare const NoteSeries: z.ZodObject<{
   name: z.ZodString;
   placement: z.ZodOptional<z.ZodEnum<{
     page: "page";
-    chapter: "chapter";
     book: "book";
+    chapter: "chapter";
     part: "part";
   }>>;
   numbering: z.ZodOptional<z.ZodEnum<{
-    chapter: "chapter";
     book: "book";
+    chapter: "chapter";
     part: "part";
   }>>;
   marker: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{

package/dist/note-series.js

@@ -134,11 +134,6 @@ function noteSeriesIssues(series, mode) {
 			message: `note series ${item.name} uses ${item.placement} placement only available in paginated mode; use page or book placement, or paginated mode`
 		});
 	});
-	const page = series.filter(({ placement }) => placement === "page");
-	if (page.length > 1) issues.push({
-		path: ["notes"],
-		message: `note series ${page.map(({ name }) => name).join(" and ")} are both page-placed; declare one page-placed series`
-	});
 	return issues;
 }
 function noteMarkerIssues(series, used) {

package/dist/page.d.ts

@@ -0,0 +1,174 @@
+import { z } from "zod";
+//#region src/page.d.ts
+export declare const FLUID_WIDTH = 1024;
+export declare const PageSize: z.ZodUnion<readonly [z.ZodLiteral<"fluid">, z.ZodObject<{
+  width: z.ZodNumber;
+  height: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+  width: z.ZodNumber;
+  height: z.ZodLiteral<"auto">;
+}, z.core.$strip>]>;
+export type PageSize = z.infer<typeof PageSize>;
+export declare const Page: z.ZodObject<{
+  id: z.ZodOptional<z.ZodString>;
+  html: z.ZodString;
+  size: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"fluid">, z.ZodObject<{
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+  }, z.core.$strip>, z.ZodObject<{
+    width: z.ZodNumber;
+    height: z.ZodLiteral<"auto">;
+  }, z.core.$strip>]>>;
+  scripts: z.ZodDefault<z.ZodEnum<{
+    refuse: "refuse";
+    sandboxed: "sandboxed";
+  }>>;
+  dir: z.ZodOptional<z.ZodEnum<{
+    auto: "auto";
+    ltr: "ltr";
+    rtl: "rtl";
+  }>>;
+  lang: z.ZodOptional<z.ZodString>;
+  print: z.ZodOptional<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";
+    }>>;
+    margin: z.ZodOptional<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>>;
+    bleed: z.ZodDefault<z.ZodNumber>;
+    safe: z.ZodDefault<z.ZodNumber>;
+    marks: z.ZodDefault<z.ZodBoolean>;
+    markColor: z.ZodDefault<z.ZodEnum<{
+      black: "black";
+      registration: "registration";
+    }>>;
+  }, z.core.$strip>>;
+  printedPages: z.ZodOptional<z.ZodObject<{
+    parents: z.ZodArray<z.ZodObject<{
+      name: z.ZodString;
+      basedOn: z.ZodOptional<z.ZodString>;
+      margin: z.ZodOptional<z.ZodObject<{
+        top: z.ZodNumber;
+        bottom: z.ZodNumber;
+        inner: z.ZodNumber;
+        outer: z.ZodNumber;
+      }, z.core.$strip>>;
+      head: z.ZodOptional<z.ZodString>;
+      foot: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    rules: z.ZodPipe<z.ZodObject<{
+      every: z.ZodString;
+      first: z.ZodOptional<z.ZodString>;
+      recto: z.ZodOptional<z.ZodString>;
+      verso: z.ZodOptional<z.ZodString>;
+      last: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>, z.ZodTransform<{
+      last?: string | undefined;
+      verso?: string | undefined;
+      recto?: string | undefined;
+      first?: string | undefined;
+      every: string;
+    }, {
+      [x: string]: unknown;
+      every: string;
+      first?: string | undefined;
+      recto?: string | undefined;
+      verso?: string | undefined;
+      last?: string | undefined;
+    }>>;
+    numbering: z.ZodOptional<z.ZodEnum<{
+      arabic: "arabic";
+      "roman-lower": "roman-lower";
+      "roman-upper": "roman-upper";
+      hebrew: "hebrew";
+    }>>;
+  }, z.core.$strip>>;
+  slots: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    type: z.ZodEnum<{
+      text: "text";
+      image: "image";
+      phone: "phone";
+      email: "email";
+      link: "link";
+      qr: "qr";
+    }>;
+    required: z.ZodDefault<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    overflow: z.ZodDefault<z.ZodEnum<{
+      refuse: "refuse";
+      shrink: "shrink";
+      truncate: "truncate";
+      wrap: "wrap";
+    }>>;
+    minSize: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>, z.ZodTransform<{
+    key: string;
+    label: string;
+    type: "text" | "image" | "phone" | "email" | "link" | "qr";
+    required: boolean;
+    overflow: "refuse" | "shrink" | "truncate" | "wrap";
+    placeholder?: string | undefined;
+    minSize?: number | undefined;
+  }, {
+    key: string;
+    label: string;
+    type: "text" | "image" | "phone" | "email" | "link" | "qr";
+    required: boolean;
+    overflow: "refuse" | "shrink" | "truncate" | "wrap";
+    placeholder?: string | undefined;
+    minSize?: number | undefined;
+  }>>>>;
+  fonts: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+    app: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    local: z.ZodString;
+    fallback: z.ZodString;
+  }, z.core.$strip>]>>>;
+}, z.core.$strip>;
+export type Page = z.infer<typeof Page>;
+export type PageInput = z.input<typeof Page>;
+//#endregion

package/dist/page.js

@@ -0,0 +1,37 @@
+import { Direction } from "./direction.js";
+import { Size } from "./geometry.js";
+import { Scripts } from "./scripts.js";
+import { Slots } from "./slots.js";
+import { FontReference } from "./fonts.js";
+import { PrintedPages, pagePrintedPagesIssues } from "./printed-pages.js";
+import { Print } from "./print.js";
+import { z } from "zod";
+//#region src/page.ts
+const FLUID_WIDTH = 1024;
+const PageSize = z.union([
+	z.literal("fluid"),
+	Size,
+	z.object({
+		width: z.number().int().positive(),
+		height: z.literal("auto")
+	})
+]);
+const Page = z.object({
+	id: z.string().optional(),
+	html: z.string(),
+	size: PageSize.default("fluid"),
+	scripts: Scripts.default("refuse"),
+	dir: Direction.optional(),
+	lang: z.string().optional(),
+	print: Print.optional(),
+	printedPages: PrintedPages.optional(),
+	slots: Slots.optional(),
+	fonts: z.array(FontReference).optional()
+}).superRefine((page, ctx) => {
+	for (const issue of pagePrintedPagesIssues(page)) ctx.addIssue({
+		code: "custom",
+		...issue
+	});
+});
+//#endregion
+export { FLUID_WIDTH, Page, PageSize };

package/dist/paper.d.ts

@@ -1,4 +1,4 @@
-import { Print } from "./index.js";
+import { Print } from "./print.js";
 import { z } from "zod";
 //#region src/paper.d.ts
 export declare const NAMED_PAPERS: readonly ["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"];

package/dist/placement-cycle.d.ts

@@ -0,0 +1,5 @@
+//#region src/placement-cycle.d.ts
+export type PlacementGraph = Readonly<Record<string, readonly string[]>>;
+export declare function findPlacementCycle(graph: PlacementGraph): string[] | undefined;
+export declare function checkPlacementCycles(graph: PlacementGraph): void;
+//#endregion

package/dist/placement-cycle.js

@@ -0,0 +1,30 @@
+import { PlacementRefusedError } from "./placement-refusal.js";
+//#region src/placement-cycle.ts
+function findPlacementCycle(graph) {
+	const visiting = /* @__PURE__ */ new Set();
+	const visited = /* @__PURE__ */ new Set();
+	const path = [];
+	const visit = (address) => {
+		if (visiting.has(address)) return [...path.slice(path.indexOf(address)), address];
+		if (visited.has(address)) return void 0;
+		visiting.add(address);
+		path.push(address);
+		for (const child of graph[address] ?? []) {
+			const cycle = visit(child);
+			if (cycle) return cycle;
+		}
+		path.pop();
+		visiting.delete(address);
+		visited.add(address);
+	};
+	for (const address of Object.keys(graph)) {
+		const cycle = visit(address);
+		if (cycle) return cycle;
+	}
+}
+function checkPlacementCycles(graph) {
+	const cycle = findPlacementCycle(graph);
+	if (cycle) throw new PlacementRefusedError(`address could not be accepted because the placement chain ${cycle.join(" → ")} is a cycle; remove any one placement in the chain to clear this refusal`);
+}
+//#endregion
+export { checkPlacementCycles, findPlacementCycle };

package/dist/placement-refusal.d.ts

@@ -0,0 +1,5 @@
+//#region src/placement-refusal.d.ts
+export declare class PlacementRefusedError extends Error {
+  name: string;
+}
+//#endregion

package/dist/placement-refusal.js

@@ -0,0 +1,6 @@
+//#region src/placement-refusal.ts
+var PlacementRefusedError = class extends Error {
+	name = "PlacementRefusedError";
+};
+//#endregion
+export { PlacementRefusedError };