@segnavia/html 0.27.0 → 0.28.0

package/dist/book/paginate-sequence.js

@@ -0,0 +1,267 @@
+import { paginateColumns } from "./paginate-columns.js";
+import { paginateMarks } from "./paginate-marks.js";
+//#region src/book/paginate-sequence.ts
+function paginateSequence(input, fillPage) {
+	function emptyMarks() {
+		return Object.create(null);
+	}
+	function columnRefusal(block) {
+		const ceiling = 12;
+		const count = block.columns;
+		if (count === void 0) return void 0;
+		if (Number.isInteger(count) && count >= 1 && count <= ceiling) return void 0;
+		const position = `chapter ${block.position.chapter} block ${block.position.block}`;
+		return {
+			tag: block.tag,
+			position: block.position,
+			message: `The ${block.tag} at ${position} could not establish a column count; use an integer from 1 to 12 to clear this refusal.`
+		};
+	}
+	function pagesRefusal(flow) {
+		if (flow.kind !== "fixed") return void 0;
+		if (Number.isSafeInteger(flow.pages) && flow.pages >= 0) return void 0;
+		return {
+			flow: flow.id,
+			message: `The ${flow.id} flow could not establish a page count; use a safe integer of 0 or more to clear this refusal.`
+		};
+	}
+	function boundsRefusal() {
+		for (const flow of input.flows) {
+			const pages = pagesRefusal(flow);
+			if (pages) return pages;
+			if (flow.kind === "fixed") continue;
+			for (const block of flow.blocks) {
+				const columns = columnRefusal(block);
+				if (columns) return columns;
+			}
+		}
+	}
+	function isFront(flow) {
+		if (flow.kind === "fixed") return flow.sequence === "front";
+		return flow.kind === "front" || flow.kind === "contents";
+	}
+	function unitsOf(flow) {
+		if (flow.kind === "fixed") return [];
+		const units = [];
+		for (const block of flow.blocks) for (const [index, line] of block.lines.entries()) {
+			const previous = units[units.length - 1];
+			const refs = (block.footnoteRefs ?? []).filter((ref) => ref.line === index).map((ref) => ref.note);
+			const unit = {
+				flowId: flow.id,
+				block,
+				index,
+				top: line.top,
+				bottom: line.bottom,
+				refs
+			};
+			if (previous) {
+				unit.prevBottom = previous.bottom;
+				previous.nextTop = line.top;
+			}
+			units.push(unit);
+		}
+		return units;
+	}
+	function flowParents(flow) {
+		return flow.parents === void 0 ? {} : { parents: flow.parents };
+	}
+	function openingOf(flow) {
+		if (flow.opens === "recto" || flow.opens === "verso" || flow.opens === "any") return flow.opens;
+		return input.settings.rectoOpenings ? "recto" : "any";
+	}
+	function needsOpeningBlank(opens, count) {
+		const nextIsRecto = count % 2 === 0;
+		if (opens === "recto") return !nextIsRecto;
+		if (opens === "verso") return nextIsRecto;
+		return false;
+	}
+	function makeBlank(number, sequence, flow) {
+		return {
+			kind: "blank",
+			number,
+			sequence,
+			flow: flow.id,
+			role: "blank",
+			windows: [],
+			notes: [],
+			blank: true,
+			sectionOpening: false,
+			...flowParents(flow)
+		};
+	}
+	function makeContent(part, number, flow, opener, placed, fragments, marks) {
+		const layout = paginateColumns(placed);
+		return {
+			kind: part,
+			number,
+			sequence: part,
+			flow: flow.id,
+			role: opener ? "opener" : "body",
+			windows: layout.windows,
+			notes: fragments,
+			...layout.headerRepeat ? { headerRepeat: layout.headerRepeat } : {},
+			blank: false,
+			sectionOpening: opener,
+			...opener || flow.runningHead === void 0 ? {} : { runningHead: flow.runningHead },
+			marks,
+			...flowParents(flow)
+		};
+	}
+	function makeFixed(part, number, flow, opener, marks) {
+		const templated = flow.kind === "fixed" && flow.role === "body";
+		return {
+			kind: part,
+			number,
+			sequence: part,
+			flow: flow.id,
+			role: templated ? "body" : "fixed",
+			windows: [],
+			notes: [],
+			blank: false,
+			sectionOpening: opener,
+			...opener && !templated || flow.runningHead === void 0 ? {} : { runningHead: flow.runningHead },
+			marks,
+			...flowParents(flow)
+		};
+	}
+	function emitMarked(part, flow, opener, placed, fragments, pages, carried) {
+		const marked = paginateMarks(placed, carried);
+		pages.push(makeContent(part, pages.length + 1, flow, opener, placed, fragments, marked.marks));
+		return marked.carried;
+	}
+	function appendFixed(flow, part, pages, continued, carried) {
+		const count = flow.kind === "fixed" ? flow.pages : 0;
+		let next = carried;
+		for (let index = 0; index < count; index += 1) {
+			const opener = index === 0;
+			const marked = paginateMarks([], next);
+			next = marked.carried;
+			pages.push(makeFixed(part, pages.length + 1, flow, opener, marked.marks));
+		}
+		return {
+			pending: continued,
+			carried: next
+		};
+	}
+	function paginateFlow(flow, part, pages, continued, carried) {
+		if (flow.kind === "fixed") return appendFixed(flow, part, pages, continued, carried);
+		const units = unitsOf(flow);
+		let index = 0;
+		let pending = continued;
+		let opener = true;
+		let nextCarried = carried;
+		while (index < units.length || pending.length > 0) {
+			const page = fillPage(units, index, pending);
+			if (page.refusal) return {
+				refusal: page.refusal,
+				pending,
+				carried: nextCarried
+			};
+			if (page.done || page.placed.length === 0 && page.fragments.length === 0) return {
+				pending,
+				carried: nextCarried
+			};
+			nextCarried = emitMarked(part, flow, opener && page.placed.length > 0, page.placed, page.fragments, pages, nextCarried);
+			opener = opener && page.placed.length === 0;
+			index = page.index;
+			pending = page.pending;
+		}
+		return {
+			pending,
+			carried: nextCarried
+		};
+	}
+	function flushNotes(continued, flow, part, pages, carried) {
+		let pending = continued;
+		let nextCarried = carried;
+		while (pending.length > 0) {
+			const page = fillPage([], 0, pending);
+			if (page.refusal) return {
+				refusal: page.refusal,
+				carried: nextCarried
+			};
+			if (page.done || page.placed.length === 0 && page.fragments.length === 0) return { carried: nextCarried };
+			nextCarried = emitMarked(part, flow, false, page.placed, page.fragments, pages, nextCarried);
+			pending = page.pending;
+		}
+		return { carried: nextCarried };
+	}
+	function flushBeforeFixed(flow, previous, continued, carried, part, pages) {
+		if (flow.kind !== "fixed" || continued.length === 0 || !previous) return {
+			continued,
+			carried
+		};
+		const flushed = flushNotes(continued, previous, part, pages, carried);
+		if ("refusal" in flushed && flushed.refusal) return { refusal: flushed.refusal };
+		return {
+			continued: [],
+			carried: flushed.carried
+		};
+	}
+	function emitFlow(flow, previous, continued, carried, part, pages, physicalOffset) {
+		const held = flushBeforeFixed(flow, previous, continued, carried, part, pages);
+		if ("refusal" in held && held.refusal) return { refusal: held.refusal };
+		if (needsOpeningBlank(openingOf(flow), physicalOffset + pages.length)) pages.push(makeBlank(pages.length + 1, part, flow));
+		const result = paginateFlow(flow, part, pages, held.continued, held.carried);
+		if ("refusal" in result && result.refusal) return { refusal: result.refusal };
+		return {
+			continued: result.pending,
+			carried: result.carried
+		};
+	}
+	function paginatePart(flows, part, physicalOffset = 0) {
+		const pages = [];
+		let continued = [];
+		let carried = emptyMarks();
+		let previous;
+		for (const flow of flows) {
+			const result = emitFlow(flow, previous, continued, carried, part, pages, physicalOffset);
+			if ("refusal" in result && result.refusal) return {
+				pages,
+				refusals: [result.refusal]
+			};
+			continued = result.continued;
+			carried = result.carried;
+			previous = flow;
+		}
+		const last = flows[flows.length - 1];
+		if (last) {
+			const flushed = flushNotes(continued, last, part, pages, carried);
+			if ("refusal" in flushed && flushed.refusal) return {
+				pages,
+				refusals: [flushed.refusal]
+			};
+		}
+		return {
+			pages,
+			refusals: []
+		};
+	}
+	const bounded = boundsRefusal();
+	if (bounded) return {
+		pages: [],
+		refusals: [bounded]
+	};
+	const frontFlows = input.flows.filter(isFront);
+	const bodyFlows = input.flows.filter((flow) => !isFront(flow));
+	const front = paginatePart(frontFlows, "front");
+	const firstBody = bodyFlows[0];
+	const lastFront = frontFlows[frontFlows.length - 1];
+	const padFront = input.settings.rectoOpenings ? front.pages.length % 2 === 1 : firstBody !== void 0 && needsOpeningBlank(openingOf(firstBody), front.pages.length);
+	if (front.pages.length > 0 && lastFront && padFront) front.pages.push(makeBlank(front.pages.length + 1, "front", lastFront));
+	const body = paginatePart(bodyFlows, "body", front.pages.length);
+	if (body.refusals.length > 0) return {
+		pages: [...front.pages, ...body.pages],
+		refusals: body.refusals
+	};
+	if (front.refusals.length > 0) return {
+		pages: [...front.pages, ...body.pages],
+		refusals: front.refusals
+	};
+	return {
+		pages: [...front.pages, ...body.pages],
+		refusals: []
+	};
+}
+//#endregion
+export { paginateSequence };

package/dist/book/paginate-target.d.ts

@@ -0,0 +1,13 @@
+import { PaginateBookPage } from "./paginate-types.js";
+//#region src/book/paginate-target.d.ts
+export type PaginateTargetPage = Pick<PaginateBookPage, 'blank' | 'flow' | 'role' | 'sectionOpening' | 'windows'>;
+export interface PaginateTarget {
+  flow: string;
+  heldPage?: number;
+  top?: number;
+}
+export declare function heldPageNumber(pages: PaginateTargetPage[], index: number): number;
+export declare function windowPageIndex(pages: PaginateTargetPage[], flow: string, top: number): number | undefined;
+export declare function openerPageIndex(pages: PaginateTargetPage[], flow: string): number | undefined;
+export declare function pageIndexForTarget(pages: PaginateTargetPage[], target: PaginateTarget): number | undefined;
+//#endregion

package/dist/book/paginate-target.js

@@ -0,0 +1,36 @@
+//#region src/book/paginate-target.ts
+function heldPageNumber(pages, index) {
+	const page = pages[index];
+	if (!page) return 0;
+	let seen = 0;
+	for (let i = 0; i <= index; i++) {
+		const held = pages[i];
+		if (!held || held.flow !== page.flow || held.blank) continue;
+		if (held.role !== "fixed" && !(held.role === "body" && held.windows.length === 0)) continue;
+		seen += 1;
+	}
+	return seen;
+}
+function windowPageIndex(pages, flow, top) {
+	for (const [index, page] of pages.entries()) {
+		if (page.blank) continue;
+		for (const win of page.windows) if (win.flow === flow && top >= win.start && top < win.end) return index;
+	}
+}
+function openerPageIndex(pages, flow) {
+	for (const [index, page] of pages.entries()) if (!page.blank && page.flow === flow && page.sectionOpening) return index;
+}
+function pageIndexForTarget(pages, target) {
+	const held = target.heldPage;
+	if (held !== void 0 && Number.isSafeInteger(held) && held > 0) {
+		for (let index = 0; index < pages.length; index++) if (pages[index]?.flow === target.flow && heldPageNumber(pages, index) === held) return index;
+		return;
+	}
+	if (target.top !== void 0) {
+		const windowed = windowPageIndex(pages, target.flow, target.top);
+		if (windowed !== void 0) return windowed;
+	}
+	return openerPageIndex(pages, target.flow);
+}
+//#endregion
+export { heldPageNumber, openerPageIndex, pageIndexForTarget, windowPageIndex };

package/dist/book/paginate-types.d.ts

@@ -0,0 +1,170 @@
+import { BookOpens, BookSectionParents } from "@segnavia/format";
+//#region src/book/paginate-types.d.ts
+export type PaginateSequence = 'front' | 'body';
+export type PaginatePageRole = 'opener' | 'body' | 'blank' | 'fixed';
+export interface PaginateLine {
+  top: number;
+  bottom: number;
+}
+export interface PaginateNoteRef {
+  note: string;
+  line: number;
+}
+export interface PaginateMark {
+  name: string;
+  value: string;
+  line: number;
+}
+export interface PaginateBlock {
+  kind: 'heading' | 'figure' | 'table' | 'text';
+  tag: string;
+  position: {
+    chapter: number;
+    block: number;
+  };
+  lines: PaginateLine[];
+  columns?: number;
+  orphans?: number;
+  widows?: number;
+  keepWithNext?: boolean;
+  keepTogether?: boolean;
+  headerHeight?: number;
+  footnoteRefs?: PaginateNoteRef[];
+  marks?: PaginateMark[];
+}
+export type PaginateFlowParents = BookSectionParents;
+export type PaginateOpens = BookOpens;
+interface PaginateFlowBase {
+  id: string;
+  runningHead?: string;
+  opens?: PaginateOpens;
+  parents?: PaginateFlowParents;
+}
+export type PaginateFlow = (PaginateFlowBase & {
+  kind: 'front' | 'contents' | 'chapter' | 'endnotes';
+  blocks: PaginateBlock[];
+}) | (PaginateFlowBase & {
+  kind: 'fixed';
+  pages: number;
+  sequence?: PaginateSequence;
+  role?: 'fixed' | 'body';
+});
+export interface PaginateNote {
+  id: string;
+  lines: PaginateLine[];
+}
+export interface PaginateBookInput {
+  flows: PaginateFlow[];
+  notes: PaginateNote[];
+  geometry: {
+    textHeight: number;
+    notesGap: number;
+  };
+  settings: {
+    orphans?: number;
+    widows?: number;
+    rectoOpenings: boolean;
+    direction: 'ltr' | 'rtl';
+    endnotePlacement: 'chapter' | 'book';
+  };
+}
+export interface PaginateWindow {
+  flow: string;
+  start: number;
+  end: number;
+  top: number;
+  column: number;
+  columns: number;
+}
+export interface PaginatePageNote {
+  id: string;
+  whole: boolean;
+  start: number;
+  end: number;
+}
+export type PaginatePageMarks = Record<string, {
+  first: string;
+  last: string;
+}>;
+export interface PaginateBookPage {
+  kind: 'front' | 'body' | 'blank';
+  number: number;
+  sequence: PaginateSequence;
+  flow: string;
+  role: PaginatePageRole;
+  windows: PaginateWindow[];
+  notes: PaginatePageNote[];
+  headerRepeat?: number;
+  blank: boolean;
+  sectionOpening: boolean;
+  runningHead?: string;
+  marks?: PaginatePageMarks;
+  parents?: PaginateFlowParents;
+}
+export type PaginateBookRefusal = {
+  tag: string;
+  position: {
+    chapter: number;
+    block: number;
+  };
+  message: string;
+} | {
+  flow: string;
+  message: string;
+} | {
+  note: string;
+  message: string;
+};
+export interface PaginateBookResult {
+  pages: PaginateBookPage[];
+  refusals: PaginateBookRefusal[];
+}
+export interface PaginateUnit {
+  flowId: string;
+  block: PaginateBlock;
+  index: number;
+  top: number;
+  bottom: number;
+  refs: string[];
+  prevBottom?: number;
+  nextTop?: number;
+}
+export interface PaginatePageFill {
+  placed: PaginateUnit[];
+  fragments: PaginatePageNote[];
+  index: number;
+  pending: PaginatePageNote[];
+  refusal?: PaginateBookRefusal;
+  done?: boolean;
+}
+export type PaginateNotesUsed = (placed: PaginateUnit[], fragments: PaginatePageNote[]) => number;
+interface PaginateNotesBase {
+  notes: PaginateNote[];
+  geometry: {
+    textHeight: number;
+    notesGap: number;
+  };
+}
+export type PaginateNotesOp = (PaginateNotesBase & {
+  op: 'space';
+  fragments: PaginatePageNote[];
+}) | (PaginateNotesBase & {
+  op: 'continue';
+  pending: PaginatePageNote[];
+  used: PaginateNotesUsed;
+}) | (PaginateNotesBase & {
+  op: 'allocate';
+  placed: PaginateUnit[];
+  fragments: PaginatePageNote[];
+  unit: PaginateUnit;
+  used: PaginateNotesUsed;
+}) | (PaginateNotesBase & {
+  op: 'recompute';
+  placed: PaginateUnit[];
+  seed: PaginatePageNote[];
+  used: PaginateNotesUsed;
+}) | (PaginateNotesBase & {
+  op: 'leftover';
+  fragments: PaginatePageNote[];
+});
+//#endregion

package/dist/book/types.d.ts

@@ -8,7 +8,7 @@ export interface BookDocumentOptions {
 }
 export interface BookSectionInfo {
   id: string;
-  kind: 'front' | 'contents' | 'chapter' | 'endnotes';
+  kind: 'front' | 'contents' | 'chapter' | 'endnotes' | 'designed' | 'templated';
   title?: string;
   runningHead?: string;
 }

package/dist/book-css.d.ts

@@ -0,0 +1,5 @@
+import { CssSanitizeResult } from "./sanitize-css.js";
+//#region src/book-css.d.ts
+export declare function sanitizeBookCss(css: string | undefined): CssSanitizeResult;
+export declare function bookStylesheet(fontCss: string | undefined, bookCss: string | undefined, hostCss: string | undefined): string;
+//#endregion

package/dist/book-css.js

@@ -0,0 +1,14 @@
+import { sanitizeCss } from "./sanitize-css.js";
+//#region src/book-css.ts
+function sanitizeBookCss(css) {
+	const sanitized = sanitizeCss(css ?? "", false, false);
+	return {
+		css: sanitized.css.replaceAll("<", "\\3c "),
+		removed: sanitized.removed
+	};
+}
+function bookStylesheet(fontCss, bookCss, hostCss) {
+	return `${fontCss ?? ""}${sanitizeBookCss(bookCss).css}${hostCss ?? ""}`;
+}
+//#endregion
+export { bookStylesheet, sanitizeBookCss };

package/dist/css-tokens.js

@@ -0,0 +1,189 @@
+//#region src/css-tokens.ts
+function newlineEnd(source, at) {
+	return source[at] === "\r" && source[at + 1] === "\n" ? at + 2 : at + 1;
+}
+function cssEscape(source, at) {
+	let end = at + 1;
+	if (end >= source.length) return ["", end];
+	if (/[0-9a-f]/i.test(source[end] ?? "")) {
+		const start = end;
+		while (end < source.length && end - start < 6 && /[0-9a-f]/i.test(source[end] ?? "")) end++;
+		const point = Number.parseInt(source.slice(start, end), 16);
+		if (source[end] === "\r" && source[end + 1] === "\n") end += 2;
+		else if (/\s/.test(source[end] ?? "")) end++;
+		return [point === 0 || point > 1114111 ? "�" : String.fromCodePoint(point), end];
+	}
+	if (source[end] === "\n" || source[end] === "\r" || source[end] === "\f") return ["", newlineEnd(source, end)];
+	return [source[end] ?? "", end + 1];
+}
+function name(source, at) {
+	let value = "";
+	let end = at;
+	while (end < source.length) {
+		const character = source[end] ?? "";
+		if (/[\w-]/.test(character) || character.charCodeAt(0) >= 128) {
+			value += character;
+			end++;
+			continue;
+		}
+		if (character !== "\\") break;
+		const escaped = cssEscape(source, end);
+		value += escaped[0];
+		end = escaped[1];
+	}
+	return [value.toLowerCase(), end];
+}
+function skipTrivia(source, at) {
+	if (/\s/.test(source[at] ?? "")) return at + 1;
+	if (!source.startsWith("/*", at)) return at;
+	const close = source.indexOf("*/", at + 2);
+	return close < 0 ? source.length : close + 2;
+}
+function stringToken(source, start) {
+	const quote = source[start] ?? "";
+	let at = start + 1;
+	let value = "";
+	while (at < source.length && source[at] !== quote) {
+		if (source[at] === "\n" || source[at] === "\r" || source[at] === "\f") break;
+		if (source[at] === "\\") {
+			const escaped = cssEscape(source, at);
+			value += escaped[0];
+			at = escaped[1];
+		} else value += source[at++] ?? "";
+	}
+	if (source[at] === quote) at++;
+	return {
+		end: at,
+		kind: "string",
+		start,
+		value
+	};
+}
+function badUrlEnd(source, at) {
+	while (at < source.length) {
+		if (source[at] === ")") return at + 1;
+		if (source[at] === "\\") at = cssEscape(source, at)[1];
+		else at++;
+	}
+	return at;
+}
+function invalidUrlCharacter(character) {
+	const code = character.charCodeAt(0);
+	return character === "\"" || character === "'" || character === "(" || code <= 8 || code === 11 || code >= 14 && code <= 31 || code === 127;
+}
+function urlAfterWhitespace(source, start, at, value) {
+	let end = at;
+	while (/\s/.test(source[end] ?? "")) end++;
+	if (source[end] === ")") return {
+		end: end + 1,
+		kind: "url",
+		start,
+		value: value.trim().toLowerCase()
+	};
+	return {
+		end: badUrlEnd(source, end),
+		kind: "bad-url",
+		start,
+		value
+	};
+}
+function escapedUrlPart(source, start, at, value) {
+	const escaped = cssEscape(source, at);
+	if (escaped[1] === at + 1 || escaped[0] === "") return {
+		end: badUrlEnd(source, escaped[1]),
+		kind: "bad-url",
+		start,
+		value
+	};
+	return [escaped[0], escaped[1]];
+}
+function urlToken(source, start, content) {
+	let at = content;
+	let value = "";
+	while (/\s/.test(source[at] ?? "")) at++;
+	if (source[at] === "\"" || source[at] === "'") return {
+		end: content,
+		kind: "function",
+		start,
+		value: "url"
+	};
+	while (at < source.length) {
+		const character = source[at] ?? "";
+		if (character === ")") return {
+			end: at + 1,
+			kind: "url",
+			start,
+			value: value.trim().toLowerCase()
+		};
+		if (/\s/.test(character)) return urlAfterWhitespace(source, start, at, value);
+		if (invalidUrlCharacter(character)) return {
+			end: badUrlEnd(source, at + 1),
+			kind: "bad-url",
+			start,
+			value
+		};
+		if (character === "\\") {
+			const escaped = escapedUrlPart(source, start, at, value);
+			if (!Array.isArray(escaped)) return escaped;
+			value += escaped[0];
+			at = escaped[1];
+		} else {
+			value += character;
+			at++;
+		}
+	}
+	return {
+		end: at,
+		kind: "url",
+		start,
+		value: value.trim().toLowerCase()
+	};
+}
+function tokenAt(source, at) {
+	const character = source[at] ?? "";
+	if (character === "\"" || character === "'") return stringToken(source, at);
+	const offset = character === "@" ? 1 : 0;
+	const parsed = name(source, at + offset);
+	if (parsed[0]) {
+		const isFunction = offset === 0 && source[parsed[1]] === "(";
+		if (isFunction && parsed[0] === "url") return urlToken(source, at, parsed[1] + 1);
+		const kind = offset === 1 ? "at" : isFunction ? "function" : "word";
+		return {
+			end: parsed[1] + (isFunction ? 1 : 0),
+			kind,
+			start: at,
+			value: parsed[0]
+		};
+	}
+	return {
+		end: at + 1,
+		kind: {
+			"{": "open",
+			"}": "close",
+			";": "semicolon",
+			"(": "open",
+			"[": "open",
+			")": "close",
+			"]": "close"
+		}[character] ?? "word",
+		start: at,
+		value: character
+	};
+}
+function cssTokens(source) {
+	const found = [];
+	let at = 0;
+	while (at < source.length) {
+		const significant = skipTrivia(source, at);
+		if (significant !== at) {
+			at = significant;
+			continue;
+		}
+		const token = tokenAt(source, at);
+		found.push(token);
+		at = token.end;
+	}
+	return found;
+}
+//#endregion
+export { cssEscape, cssTokens };