@embedpdf/engine-core 3.0.0-next.13 → 3.0.0-next.14

package/dist/fold-2V29cxCV.cjs

@@ -1,447 +0,0 @@
-const require_PageInsertBlankInput = require("./PageInsertBlankInput-CqXBmFhN.cjs");
-//#region src/geometry/convert.ts
-/**
-* Normalize a `PdfRect` to the y-up invariant (`left <= right`, `bottom <= top`),
-* regardless of how the PDF ordered the corners (a `/Rect` array or `FS_RECTF`
-* may carry them in any order). THE enforcement point for the "PdfRect is always
-* normalized" rule: every producer that reads a raw box from PDFium passes it
-* through here, so the invariant holds once, centrally — downstream `width =
-* right - left` is never negative.
-*/
-function normalizePdfRect(r) {
-	return {
-		left: Math.min(r.left, r.right),
-		right: Math.max(r.left, r.right),
-		bottom: Math.min(r.top, r.bottom),
-		top: Math.max(r.top, r.bottom)
-	};
-}
-function pdfRectWidth(r) {
-	return r.right - r.left;
-}
-function pdfRectHeight(r) {
-	return r.top - r.bottom;
-}
-function pdfRectSize(r) {
-	return {
-		width: r.right - r.left,
-		height: r.top - r.bottom
-	};
-}
-/** Convert edges -> origin+size, staying y-up (origin at bottom-left). */
-function pdfRectToOriginSize(r) {
-	return {
-		x: r.left,
-		y: r.bottom,
-		width: r.right - r.left,
-		height: r.top - r.bottom
-	};
-}
-/** Convert y-up origin+size back to edges. */
-function pdfRectFromOriginSize(o) {
-	return {
-		left: o.x,
-		bottom: o.y,
-		right: o.x + o.width,
-		top: o.y + o.height
-	};
-}
-/**
-* Enclosing axis-aligned box of a quad, in PDF user space. Orientation
-* agnostic (correct for rotated/skewed quads) — this is what highlight
-* rendering and hit-testing want.
-*/
-function pdfQuadBounds(q) {
-	const xs = [
-		q.p1.x,
-		q.p2.x,
-		q.p3.x,
-		q.p4.x
-	];
-	const ys = [
-		q.p1.y,
-		q.p2.y,
-		q.p3.y,
-		q.p4.y
-	];
-	return {
-		left: Math.min(...xs),
-		right: Math.max(...xs),
-		bottom: Math.min(...ys),
-		top: Math.max(...ys)
-	};
-}
-/**
-* Axis-aligned named-corner interpretation of a quad.
-*
-* VALID ONLY for upright (non-rotated, non-skewed) quads: it is derived from
-* the enclosing bounds, so for rotated/skewed quads it returns the bounding
-* box corners, not the true geometric corners. For arbitrary quads use the
-* positional `p1..p4` or `pdfQuadBounds` directly.
-*/
-function pdfQuadCorners(q) {
-	const b = pdfQuadBounds(q);
-	return {
-		topLeft: {
-			x: b.left,
-			y: b.top
-		},
-		topRight: {
-			x: b.right,
-			y: b.top
-		},
-		bottomLeft: {
-			x: b.left,
-			y: b.bottom
-		},
-		bottomRight: {
-			x: b.right,
-			y: b.bottom
-		}
-	};
-}
-/**
-* Build a quad from named corners, in PDFium `FS_QUADPOINTSF` slot order
-* (`p1 = topLeft`, `p2 = topRight`, `p3 = bottomLeft`, `p4 = bottomRight`).
-* The inverse of `pdfQuadCorners` for upright quads.
-*/
-function pdfQuadFromCorners(c) {
-	return {
-		p1: c.topLeft,
-		p2: c.topRight,
-		p3: c.bottomLeft,
-		p4: c.bottomRight
-	};
-}
-//#endregion
-//#region src/dto/PageGeometrySnapshot.ts
-/** Narrowing guard: is this run the rotated (non-upright) variant? */
-function isRotatedGeometryRun(run) {
-	return "rotation" in run;
-}
-/**
-* Uniform oriented-cell view over either run variant: the glyph's loose cell
-* as a quad (synthesized from the box corners when the run is upright, in
-* the same frame-geometric slot order).
-*/
-function glyphLooseQuad(run, index) {
-	if (isRotatedGeometryRun(run)) return run.glyphs[index].looseQuad;
-	const b = run.glyphs[index].looseBox;
-	return {
-		p1: {
-			x: b.left,
-			y: b.top
-		},
-		p2: {
-			x: b.right,
-			y: b.top
-		},
-		p3: {
-			x: b.left,
-			y: b.bottom
-		},
-		p4: {
-			x: b.right,
-			y: b.bottom
-		}
-	};
-}
-/**
-* Uniform AABB view over either run variant: the glyph's loose box, or the
-* enclosing bounds of its oriented cell when the run is rotated. The
-* conservative envelope for consumers that genuinely want a box (culling,
-* scroll targets) — never a substitute for handling orientation in geometry
-* that gets DRAWN.
-*/
-function glyphLooseBounds(run, index) {
-	if (isRotatedGeometryRun(run)) return pdfQuadBounds(run.glyphs[index].looseQuad);
-	return run.glyphs[index].looseBox;
-}
-//#endregion
-//#region \0@oxc-project+runtime@0.140.0/helpers/esm/typeof.js
-function _typeof(o) {
-	"@babel/helpers - typeof";
-	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
-		return typeof o;
-	} : function(o) {
-		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
-	}, _typeof(o);
-}
-//#endregion
-//#region \0@oxc-project+runtime@0.140.0/helpers/esm/toPrimitive.js
-function toPrimitive(t, r) {
-	if ("object" != _typeof(t) || !t) return t;
-	var e = t[Symbol.toPrimitive];
-	if (void 0 !== e) {
-		var i = e.call(t, r || "default");
-		if ("object" != _typeof(i)) return i;
-		throw new TypeError("@@toPrimitive must return a primitive value.");
-	}
-	return ("string" === r ? String : Number)(t);
-}
-//#endregion
-//#region \0@oxc-project+runtime@0.140.0/helpers/esm/toPropertyKey.js
-function toPropertyKey(t) {
-	var i = toPrimitive(t, "string");
-	return "symbol" == _typeof(i) ? i : i + "";
-}
-//#endregion
-//#region \0@oxc-project+runtime@0.140.0/helpers/esm/defineProperty.js
-function _defineProperty(e, r, t) {
-	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
-		value: t,
-		enumerable: !0,
-		configurable: !0,
-		writable: !0
-	}) : e[r] = t, e;
-}
-//#endregion
-//#region src/errors/EngineError.ts
-/**
-* Single error class shared across engine implementations. Has a stable
-* machine-readable `code` (see EngineErrorCode) so callers can match without
-* sniffing message strings.
-*/
-var EngineError = class EngineError extends Error {
-	constructor(code, message, opts = {}) {
-		super(message ?? code, opts.cause === void 0 ? void 0 : { cause: opts.cause });
-		_defineProperty(this, "name", "EngineError");
-		_defineProperty(this, "code", void 0);
-		_defineProperty(this, "details", void 0);
-		this.code = code;
-		this.details = opts.details;
-	}
-	static is(value, code) {
-		if (!(value instanceof EngineError) && value?.name !== "EngineError") return false;
-		if (code === void 0) return true;
-		return value.code === code;
-	}
-	toJSON() {
-		return {
-			name: "EngineError",
-			code: this.code,
-			message: this.message,
-			details: this.details
-		};
-	}
-};
-function serializeError(err) {
-	if (EngineError.is(err)) return err.toJSON();
-	if (err instanceof Error) return {
-		name: "EngineError",
-		code: err.name === "AbortError" ? require_PageInsertBlankInput.EngineErrorCode.Aborted : require_PageInsertBlankInput.EngineErrorCode.Unknown,
-		message: err.message
-	};
-	return {
-		name: "EngineError",
-		code: require_PageInsertBlankInput.EngineErrorCode.Unknown,
-		message: String(err ?? "unknown error")
-	};
-}
-function deserializeError(payload) {
-	return new EngineError(payload.code, payload.message, { details: payload.details });
-}
-//#endregion
-//#region src/search/fold.ts
-/**
-* Text folding for literal search: the deterministic normalization applied
-* to BOTH the page text and the needle so that "Café" finds "cafe" and a
-* line-wrapped "hello\n  world" finds "hello world".
-*
-* Fold version 1:
-*   - whitespace runs collapse to a single space (any `\s`, including the
-*     spaces some compatibility decompositions emit),
-*   - each code point is NFKD-decomposed (ligatures split: "fi" → "fi",
-*     "²" → "2"),
-*   - combining marks are stripped unless `keepMarks`,
-*   - case is folded via upper→lower round-trip unless `keepCase` (this
-*     poor-man's full fold catches "ß"→"ss" and "ς"→"σ", which a plain
-*     `toLowerCase` misses).
-*
-* Every folded code unit remembers which original code point produced it
-* (`map`), so match ranges found in folded space translate back to exact
-* original-text ranges — the property the whole anchor stage rests on.
-*
-* Pre-folded corpus artifacts store this fold's output; bump
-* `SEARCH_FOLD_VERSION` on ANY semantic change so stored corpora are
-* rebuilt instead of silently mismatching fresh needles.
-*/
-/** Version stamp for persisted pre-folded corpus artifacts. */
-const SEARCH_FOLD_VERSION = 1;
-const WHITESPACE = /\s/;
-const MARKS = /\p{M}/gu;
-function foldText(original, options = {}) {
-	const units = [];
-	const map = [];
-	let lastWasSpace = false;
-	let index = 0;
-	for (const cp of original) {
-		let piece;
-		if (WHITESPACE.test(cp)) piece = " ";
-		else {
-			piece = cp.normalize("NFKD");
-			if (!options.keepMarks) piece = piece.replace(MARKS, "");
-			if (!options.keepCase) piece = piece.toUpperCase().toLowerCase();
-		}
-		for (let u = 0; u < piece.length; u++) {
-			const unit = piece[u];
-			if (WHITESPACE.test(unit)) {
-				if (lastWasSpace) continue;
-				units.push(" ");
-				map.push(index);
-				lastWasSpace = true;
-			} else {
-				units.push(unit);
-				map.push(index);
-				lastWasSpace = false;
-			}
-		}
-		index += cp.length;
-	}
-	return {
-		folded: units.join(""),
-		map: Uint32Array.from(map),
-		original
-	};
-}
-/** Code-unit length of the code point starting at `index` (1 or 2). */
-function codePointLengthAt(text, index) {
-	const unit = text.charCodeAt(index);
-	if (unit >= 55296 && unit <= 56319 && index + 1 < text.length) {
-		const next = text.charCodeAt(index + 1);
-		if (next >= 56320 && next <= 57343) return 2;
-	}
-	return 1;
-}
-/**
-* Translate a match found in folded space back to the original text.
-* The range covers whole original code points: a hit on either folded
-* half of "fi" spans the full ligature, and a hit ending on a collapsed
-* space extends only through the first whitespace char of the run (the
-* remainder is presentation, not match).
-*/
-function toOriginalRange(folded, foldedStart, foldedLength) {
-	const start = folded.map[foldedStart];
-	const lastOriginal = folded.map[foldedStart + foldedLength - 1];
-	return {
-		start,
-		length: lastOriginal + codePointLengthAt(folded.original, lastOriginal) - start
-	};
-}
-//#endregion
-Object.defineProperty(exports, "EngineError", {
-	enumerable: true,
-	get: function() {
-		return EngineError;
-	}
-});
-Object.defineProperty(exports, "SEARCH_FOLD_VERSION", {
-	enumerable: true,
-	get: function() {
-		return SEARCH_FOLD_VERSION;
-	}
-});
-Object.defineProperty(exports, "_defineProperty", {
-	enumerable: true,
-	get: function() {
-		return _defineProperty;
-	}
-});
-Object.defineProperty(exports, "deserializeError", {
-	enumerable: true,
-	get: function() {
-		return deserializeError;
-	}
-});
-Object.defineProperty(exports, "foldText", {
-	enumerable: true,
-	get: function() {
-		return foldText;
-	}
-});
-Object.defineProperty(exports, "glyphLooseBounds", {
-	enumerable: true,
-	get: function() {
-		return glyphLooseBounds;
-	}
-});
-Object.defineProperty(exports, "glyphLooseQuad", {
-	enumerable: true,
-	get: function() {
-		return glyphLooseQuad;
-	}
-});
-Object.defineProperty(exports, "isRotatedGeometryRun", {
-	enumerable: true,
-	get: function() {
-		return isRotatedGeometryRun;
-	}
-});
-Object.defineProperty(exports, "normalizePdfRect", {
-	enumerable: true,
-	get: function() {
-		return normalizePdfRect;
-	}
-});
-Object.defineProperty(exports, "pdfQuadBounds", {
-	enumerable: true,
-	get: function() {
-		return pdfQuadBounds;
-	}
-});
-Object.defineProperty(exports, "pdfQuadCorners", {
-	enumerable: true,
-	get: function() {
-		return pdfQuadCorners;
-	}
-});
-Object.defineProperty(exports, "pdfQuadFromCorners", {
-	enumerable: true,
-	get: function() {
-		return pdfQuadFromCorners;
-	}
-});
-Object.defineProperty(exports, "pdfRectFromOriginSize", {
-	enumerable: true,
-	get: function() {
-		return pdfRectFromOriginSize;
-	}
-});
-Object.defineProperty(exports, "pdfRectHeight", {
-	enumerable: true,
-	get: function() {
-		return pdfRectHeight;
-	}
-});
-Object.defineProperty(exports, "pdfRectSize", {
-	enumerable: true,
-	get: function() {
-		return pdfRectSize;
-	}
-});
-Object.defineProperty(exports, "pdfRectToOriginSize", {
-	enumerable: true,
-	get: function() {
-		return pdfRectToOriginSize;
-	}
-});
-Object.defineProperty(exports, "pdfRectWidth", {
-	enumerable: true,
-	get: function() {
-		return pdfRectWidth;
-	}
-});
-Object.defineProperty(exports, "serializeError", {
-	enumerable: true,
-	get: function() {
-		return serializeError;
-	}
-});
-Object.defineProperty(exports, "toOriginalRange", {
-	enumerable: true,
-	get: function() {
-		return toOriginalRange;
-	}
-});
-
-//# sourceMappingURL=fold-2V29cxCV.cjs.map

package/dist/fold-2V29cxCV.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"fold-2V29cxCV.cjs","names":["EngineErrorCode"],"sources":["../src/geometry/convert.ts","../src/dto/PageGeometrySnapshot.ts","../src/errors/EngineError.ts","../src/search/fold.ts"],"sourcesContent":["/**\n * PDF-space-internal geometry helpers.\n *\n * These operate ENTIRELY within PDF user space (y-up, edges). They never\n * produce viewer-local (y-down) geometry — that conversion needs the crop box\n * plus rotation/scale and lives in the v3 viewer layer (the `Mat2D` matrix\n * model), never here.\n */\n\nimport type { PdfPoint, PdfQuad, PdfRect, PdfSize } from './primitives';\n\n/** Origin + size form of a `PdfRect`, still y-up (origin = bottom-left). */\nexport interface PdfOriginSize {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/**\n * Normalize a `PdfRect` to the y-up invariant (`left <= right`, `bottom <= top`),\n * regardless of how the PDF ordered the corners (a `/Rect` array or `FS_RECTF`\n * may carry them in any order). THE enforcement point for the \"PdfRect is always\n * normalized\" rule: every producer that reads a raw box from PDFium passes it\n * through here, so the invariant holds once, centrally — downstream `width =\n * right - left` is never negative.\n */\nexport function normalizePdfRect(r: PdfRect): PdfRect {\n  return {\n    left: Math.min(r.left, r.right),\n    right: Math.max(r.left, r.right),\n    bottom: Math.min(r.top, r.bottom),\n    top: Math.max(r.top, r.bottom),\n  };\n}\n\nexport function pdfRectWidth(r: PdfRect): number {\n  return r.right - r.left;\n}\n\nexport function pdfRectHeight(r: PdfRect): number {\n  return r.top - r.bottom;\n}\n\nexport function pdfRectSize(r: PdfRect): PdfSize {\n  return { width: r.right - r.left, height: r.top - r.bottom };\n}\n\n/** Convert edges -> origin+size, staying y-up (origin at bottom-left). */\nexport function pdfRectToOriginSize(r: PdfRect): PdfOriginSize {\n  return { x: r.left, y: r.bottom, width: r.right - r.left, height: r.top - r.bottom };\n}\n\n/** Convert y-up origin+size back to edges. */\nexport function pdfRectFromOriginSize(o: PdfOriginSize): PdfRect {\n  return { left: o.x, bottom: o.y, right: o.x + o.width, top: o.y + o.height };\n}\n\n/**\n * Enclosing axis-aligned box of a quad, in PDF user space. Orientation\n * agnostic (correct for rotated/skewed quads) — this is what highlight\n * rendering and hit-testing want.\n */\nexport function pdfQuadBounds(q: PdfQuad): PdfRect {\n  const xs = [q.p1.x, q.p2.x, q.p3.x, q.p4.x];\n  const ys = [q.p1.y, q.p2.y, q.p3.y, q.p4.y];\n  return {\n    left: Math.min(...xs),\n    right: Math.max(...xs),\n    bottom: Math.min(...ys),\n    top: Math.max(...ys),\n  };\n}\n\n/** Named corners of a quad, in PDF user space (y-up). */\nexport interface PdfQuadCorners {\n  topLeft: PdfPoint;\n  topRight: PdfPoint;\n  bottomLeft: PdfPoint;\n  bottomRight: PdfPoint;\n}\n\n/**\n * Axis-aligned named-corner interpretation of a quad.\n *\n * VALID ONLY for upright (non-rotated, non-skewed) quads: it is derived from\n * the enclosing bounds, so for rotated/skewed quads it returns the bounding\n * box corners, not the true geometric corners. For arbitrary quads use the\n * positional `p1..p4` or `pdfQuadBounds` directly.\n */\nexport function pdfQuadCorners(q: PdfQuad): PdfQuadCorners {\n  const b = pdfQuadBounds(q);\n  return {\n    topLeft: { x: b.left, y: b.top },\n    topRight: { x: b.right, y: b.top },\n    bottomLeft: { x: b.left, y: b.bottom },\n    bottomRight: { x: b.right, y: b.bottom },\n  };\n}\n\n/**\n * Build a quad from named corners, in PDFium `FS_QUADPOINTSF` slot order\n * (`p1 = topLeft`, `p2 = topRight`, `p3 = bottomLeft`, `p4 = bottomRight`).\n * The inverse of `pdfQuadCorners` for upright quads.\n */\nexport function pdfQuadFromCorners(c: PdfQuadCorners): PdfQuad {\n  return { p1: c.topLeft, p2: c.topRight, p3: c.bottomLeft, p4: c.bottomRight };\n}\n","import { pdfQuadBounds } from '../geometry/convert';\nimport type { PdfQuad, PdfRect } from '../geometry/primitives';\n\n/**\n * One upright glyph's geometry in PDF user space (y-up edges).\n *\n * `looseBox` is the loose char cell (pdfium `FPDFText_GetLooseCharBox`): the\n * font-metric box covering the full glyph cell without regard to the actual\n * glyph shape. Always present (zeroed + flagged empty for degenerate glyphs);\n * it's the box selection envelopes are built from.\n *\n * `tightBox` is the tight char box (pdfium `FPDFText_GetCharBox`): the box\n * hugging the actual glyph shape. Optional — absent for empty/whitespace\n * glyphs that have no real outline.\n *\n * `flags` carries slim per-glyph state (bit 1 = space, bit 2 = empty).\n */\nexport interface PageGeometryGlyph {\n  looseBox: PdfRect;\n  flags: number;\n  tightBox?: PdfRect;\n}\n\n/**\n * One non-upright glyph's geometry: the exact oriented cells, in PDF user\n * space (page coordinates — NOT a local frame). The corner SLOTS are\n * frame-geometric in the glyph's own upright frame:\n * `p1` = upper-start, `p2` = upper-end, `p3` = lower-start, `p4` = lower-end,\n * where \"upper\" is the ascent side and \"start\" is the frame's minimum-x side.\n * Deliberately NOT a bidi/reading-order statement — advance direction is a\n * glyph-sequence concern, carried separately where consumers need it.\n *\n * Degenerate glyphs carry a zeroed `looseQuad` plus the empty flag (bit 2),\n * mirroring the upright variant's zeroed-box convention. `flags` bits match\n * {@link PageGeometryGlyph.flags}.\n */\nexport interface RotatedGeometryGlyph {\n  looseQuad: PdfQuad;\n  flags: number;\n  tightQuad?: PdfQuad;\n}\n\n/**\n * A run whose char matrix is upright — byte-identical to the wire shape that\n * predates orientation support, so upright documents never pay for it.\n */\nexport interface UprightGeometryRun {\n  rect: PdfRect;\n  charStart: number;\n  glyphs: PageGeometryGlyph[];\n  fontSize?: number;\n}\n\n/**\n * A run whose char matrix is NOT upright (rotated, sheared, or mirrored).\n *\n * `rect` stays a page-space AABB (culling), like every other wire rect.\n * `rotation` is the baseline angle in radians, CCW in PDF y-up space\n * (`atan2(m.b, m.a)` of the run's char matrix). Note a shear-only run has\n * `rotation === 0` and still uses this variant — its cells are\n * parallelograms an AABB would misrepresent. `ascentFlip` is true when the\n * ascent vector maps opposite the rotated frame's +y (mirrored /\n * negative-determinant content).\n */\nexport interface RotatedGeometryRun {\n  rect: PdfRect;\n  charStart: number;\n  glyphs: RotatedGeometryGlyph[];\n  rotation: number;\n  ascentFlip: boolean;\n  fontSize?: number;\n}\n\n/**\n * One text run (contiguous glyphs sharing a text object and orientation).\n * A discriminated union so consumers CANNOT read axis-aligned boxes off\n * rotated text by accident — handling orientation is a compile-time\n * obligation, not a runtime discovery. Narrow with\n * {@link isRotatedGeometryRun}, or use the uniform {@link glyphLooseQuad} /\n * {@link glyphLooseBounds} views.\n */\nexport type PageGeometryRun = UprightGeometryRun | RotatedGeometryRun;\n\n/**\n * Geometry-only text layout for one page, in PDF user space (y-up). The v3\n * viewer converts to content/view space via the page geometry matrix.\n *\n * Pure content, addressed and cached by `contentVersion`. Carries NO\n * annotation liveness envelope (`PageState`) — see `PageTextSnapshot` for\n * the rationale; liveness lives on annotation reads.\n */\nexport interface PageGeometrySnapshot {\n  runs: PageGeometryRun[];\n}\n\n/** Narrowing guard: is this run the rotated (non-upright) variant? */\nexport function isRotatedGeometryRun(run: PageGeometryRun): run is RotatedGeometryRun {\n  return 'rotation' in run;\n}\n\n/**\n * Uniform oriented-cell view over either run variant: the glyph's loose cell\n * as a quad (synthesized from the box corners when the run is upright, in\n * the same frame-geometric slot order).\n */\nexport function glyphLooseQuad(run: PageGeometryRun, index: number): PdfQuad {\n  if (isRotatedGeometryRun(run)) return run.glyphs[index].looseQuad;\n  const b = run.glyphs[index].looseBox;\n  return {\n    p1: { x: b.left, y: b.top },\n    p2: { x: b.right, y: b.top },\n    p3: { x: b.left, y: b.bottom },\n    p4: { x: b.right, y: b.bottom },\n  };\n}\n\n/**\n * Uniform AABB view over either run variant: the glyph's loose box, or the\n * enclosing bounds of its oriented cell when the run is rotated. The\n * conservative envelope for consumers that genuinely want a box (culling,\n * scroll targets) — never a substitute for handling orientation in geometry\n * that gets DRAWN.\n */\nexport function glyphLooseBounds(run: PageGeometryRun, index: number): PdfRect {\n  if (isRotatedGeometryRun(run)) return pdfQuadBounds(run.glyphs[index].looseQuad);\n  return run.glyphs[index].looseBox;\n}\n","import { EngineErrorCode } from './EngineErrorCode';\n\nexport interface EngineErrorOptions {\n  cause?: unknown;\n  details?: Record<string, unknown>;\n}\n\n/**\n * Single error class shared across engine implementations. Has a stable\n * machine-readable `code` (see EngineErrorCode) so callers can match without\n * sniffing message strings.\n */\nexport class EngineError extends Error {\n  override readonly name = 'EngineError';\n  readonly code: EngineErrorCode;\n  readonly details?: Record<string, unknown>;\n\n  constructor(code: EngineErrorCode, message?: string, opts: EngineErrorOptions = {}) {\n    super(message ?? code, opts.cause === undefined ? undefined : { cause: opts.cause });\n    this.code = code;\n    this.details = opts.details;\n  }\n\n  static is(value: unknown, code?: EngineErrorCode): value is EngineError {\n    if (\n      !(value instanceof EngineError) &&\n      (value as { name?: string } | null)?.name !== 'EngineError'\n    ) {\n      return false;\n    }\n    if (code === undefined) return true;\n    return (value as EngineError).code === code;\n  }\n\n  toJSON(): {\n    name: 'EngineError';\n    code: EngineErrorCode;\n    message: string;\n    details?: Record<string, unknown>;\n  } {\n    return {\n      name: 'EngineError',\n      code: this.code,\n      message: this.message,\n      details: this.details,\n    };\n  }\n}\n\nexport interface SerializedEngineError {\n  name: 'EngineError';\n  code: EngineErrorCode;\n  message: string;\n  details?: Record<string, unknown>;\n}\n\nexport function serializeError(err: unknown): SerializedEngineError {\n  if (EngineError.is(err)) {\n    return err.toJSON();\n  }\n  if (err instanceof Error) {\n    const code: EngineErrorCode =\n      err.name === 'AbortError' ? EngineErrorCode.Aborted : EngineErrorCode.Unknown;\n    return { name: 'EngineError', code, message: err.message };\n  }\n  return {\n    name: 'EngineError',\n    code: EngineErrorCode.Unknown,\n    message: String(err ?? 'unknown error'),\n  };\n}\n\nexport function deserializeError(payload: SerializedEngineError): EngineError {\n  return new EngineError(payload.code, payload.message, { details: payload.details });\n}\n","/**\n * Text folding for literal search: the deterministic normalization applied\n * to BOTH the page text and the needle so that \"Café\" finds \"cafe\" and a\n * line-wrapped \"hello\\n  world\" finds \"hello world\".\n *\n * Fold version 1:\n *   - whitespace runs collapse to a single space (any `\\s`, including the\n *     spaces some compatibility decompositions emit),\n *   - each code point is NFKD-decomposed (ligatures split: \"fi\" → \"fi\",\n *     \"²\" → \"2\"),\n *   - combining marks are stripped unless `keepMarks`,\n *   - case is folded via upper→lower round-trip unless `keepCase` (this\n *     poor-man's full fold catches \"ß\"→\"ss\" and \"ς\"→\"σ\", which a plain\n *     `toLowerCase` misses).\n *\n * Every folded code unit remembers which original code point produced it\n * (`map`), so match ranges found in folded space translate back to exact\n * original-text ranges — the property the whole anchor stage rests on.\n *\n * Pre-folded corpus artifacts store this fold's output; bump\n * `SEARCH_FOLD_VERSION` on ANY semantic change so stored corpora are\n * rebuilt instead of silently mismatching fresh needles.\n */\n\n/** Version stamp for persisted pre-folded corpus artifacts. */\nexport const SEARCH_FOLD_VERSION = 1;\n\nexport interface FoldOptions {\n  /** Preserve case (matchCase). */\n  keepCase?: boolean;\n  /** Preserve combining marks (matchDiacritics). */\n  keepMarks?: boolean;\n}\n\nexport interface FoldedText {\n  folded: string;\n  /** Folded code unit i → code-unit index of the original code point it came from. */\n  map: Uint32Array;\n  original: string;\n}\n\n/** A half-open match range in ORIGINAL code-unit space. */\nexport interface SearchMatchRange {\n  start: number;\n  length: number;\n}\n\nconst WHITESPACE = /\\s/;\nconst MARKS = /\\p{M}/gu;\n\nexport function foldText(original: string, options: FoldOptions = {}): FoldedText {\n  const units: string[] = [];\n  const map: number[] = [];\n  let lastWasSpace = false;\n\n  let index = 0;\n  for (const cp of original) {\n    let piece: string;\n    if (WHITESPACE.test(cp)) {\n      piece = ' ';\n    } else {\n      piece = cp.normalize('NFKD');\n      if (!options.keepMarks) piece = piece.replace(MARKS, '');\n      if (!options.keepCase) piece = piece.toUpperCase().toLowerCase();\n    }\n    // A decomposition can itself contain whitespace (U+00A8 → space +\n    // combining diaeresis), so collapse runs at the unit level, not just\n    // for source whitespace.\n    for (let u = 0; u < piece.length; u++) {\n      const unit = piece[u];\n      if (WHITESPACE.test(unit)) {\n        if (lastWasSpace) continue;\n        units.push(' ');\n        map.push(index);\n        lastWasSpace = true;\n      } else {\n        units.push(unit);\n        map.push(index);\n        lastWasSpace = false;\n      }\n    }\n    index += cp.length;\n  }\n\n  return { folded: units.join(''), map: Uint32Array.from(map), original };\n}\n\n/** Code-unit length of the code point starting at `index` (1 or 2). */\nfunction codePointLengthAt(text: string, index: number): number {\n  const unit = text.charCodeAt(index);\n  if (unit >= 0xd800 && unit <= 0xdbff && index + 1 < text.length) {\n    const next = text.charCodeAt(index + 1);\n    if (next >= 0xdc00 && next <= 0xdfff) return 2;\n  }\n  return 1;\n}\n\n/**\n * Translate a match found in folded space back to the original text.\n * The range covers whole original code points: a hit on either folded\n * half of \"fi\" spans the full ligature, and a hit ending on a collapsed\n * space extends only through the first whitespace char of the run (the\n * remainder is presentation, not match).\n */\nexport function toOriginalRange(\n  folded: FoldedText,\n  foldedStart: number,\n  foldedLength: number,\n): SearchMatchRange {\n  const start = folded.map[foldedStart];\n  const lastOriginal = folded.map[foldedStart + foldedLength - 1];\n  const end = lastOriginal + codePointLengthAt(folded.original, lastOriginal);\n  return { start, length: end - start };\n}\n"],"mappings":";;;;;;;;;;AA2BA,SAAgB,iBAAiB,GAAqB;CACpD,OAAO;EACL,MAAM,KAAK,IAAI,EAAE,MAAM,EAAE,KAAK;EAC9B,OAAO,KAAK,IAAI,EAAE,MAAM,EAAE,KAAK;EAC/B,QAAQ,KAAK,IAAI,EAAE,KAAK,EAAE,MAAM;EAChC,KAAK,KAAK,IAAI,EAAE,KAAK,EAAE,MAAM;CAC/B;AACF;AAEA,SAAgB,aAAa,GAAoB;CAC/C,OAAO,EAAE,QAAQ,EAAE;AACrB;AAEA,SAAgB,cAAc,GAAoB;CAChD,OAAO,EAAE,MAAM,EAAE;AACnB;AAEA,SAAgB,YAAY,GAAqB;CAC/C,OAAO;EAAE,OAAO,EAAE,QAAQ,EAAE;EAAM,QAAQ,EAAE,MAAM,EAAE;CAAO;AAC7D;;AAGA,SAAgB,oBAAoB,GAA2B;CAC7D,OAAO;EAAE,GAAG,EAAE;EAAM,GAAG,EAAE;EAAQ,OAAO,EAAE,QAAQ,EAAE;EAAM,QAAQ,EAAE,MAAM,EAAE;CAAO;AACrF;;AAGA,SAAgB,sBAAsB,GAA2B;CAC/D,OAAO;EAAE,MAAM,EAAE;EAAG,QAAQ,EAAE;EAAG,OAAO,EAAE,IAAI,EAAE;EAAO,KAAK,EAAE,IAAI,EAAE;CAAO;AAC7E;;;;;;AAOA,SAAgB,cAAc,GAAqB;CACjD,MAAM,KAAK;EAAC,EAAE,GAAG;EAAG,EAAE,GAAG;EAAG,EAAE,GAAG;EAAG,EAAE,GAAG;CAAC;CAC1C,MAAM,KAAK;EAAC,EAAE,GAAG;EAAG,EAAE,GAAG;EAAG,EAAE,GAAG;EAAG,EAAE,GAAG;CAAC;CAC1C,OAAO;EACL,MAAM,KAAK,IAAI,GAAG,EAAE;EACpB,OAAO,KAAK,IAAI,GAAG,EAAE;EACrB,QAAQ,KAAK,IAAI,GAAG,EAAE;EACtB,KAAK,KAAK,IAAI,GAAG,EAAE;CACrB;AACF;;;;;;;;;AAkBA,SAAgB,eAAe,GAA4B;CACzD,MAAM,IAAI,cAAc,CAAC;CACzB,OAAO;EACL,SAAS;GAAE,GAAG,EAAE;GAAM,GAAG,EAAE;EAAI;EAC/B,UAAU;GAAE,GAAG,EAAE;GAAO,GAAG,EAAE;EAAI;EACjC,YAAY;GAAE,GAAG,EAAE;GAAM,GAAG,EAAE;EAAO;EACrC,aAAa;GAAE,GAAG,EAAE;GAAO,GAAG,EAAE;EAAO;CACzC;AACF;;;;;;AAOA,SAAgB,mBAAmB,GAA4B;CAC7D,OAAO;EAAE,IAAI,EAAE;EAAS,IAAI,EAAE;EAAU,IAAI,EAAE;EAAY,IAAI,EAAE;CAAY;AAC9E;;;;ACXA,SAAgB,qBAAqB,KAAiD;CACpF,OAAO,cAAc;AACvB;;;;;;AAOA,SAAgB,eAAe,KAAsB,OAAwB;CAC3E,IAAI,qBAAqB,GAAG,GAAG,OAAO,IAAI,OAAO,MAAM,CAAC;CACxD,MAAM,IAAI,IAAI,OAAO,MAAM,CAAC;CAC5B,OAAO;EACL,IAAI;GAAE,GAAG,EAAE;GAAM,GAAG,EAAE;EAAI;EAC1B,IAAI;GAAE,GAAG,EAAE;GAAO,GAAG,EAAE;EAAI;EAC3B,IAAI;GAAE,GAAG,EAAE;GAAM,GAAG,EAAE;EAAO;EAC7B,IAAI;GAAE,GAAG,EAAE;GAAO,GAAG,EAAE;EAAO;CAChC;AACF;;;;;;;;AASA,SAAgB,iBAAiB,KAAsB,OAAwB;CAC7E,IAAI,qBAAqB,GAAG,GAAG,OAAO,cAAc,IAAI,OAAO,MAAM,CAAC,SAAS;CAC/E,OAAO,IAAI,OAAO,MAAM,CAAC;AAC3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AClHA,IAAa,cAAb,MAAa,oBAAoB,MAAM;CAKrC,YAAY,MAAuB,SAAkB,OAA2B,CAAC,GAAG;EAClF,MAAM,WAAW,MAAM,KAAK,UAAU,KAAA,IAAY,KAAA,IAAY,EAAE,OAAO,KAAK,MAAM,CAAC;EALnE,gBAAA,MAAA,QAAO,aAAA;EAChB,gBAAA,MAAA,QAAA,KAAA,CAAA;EACA,gBAAA,MAAA,WAAA,KAAA,CAAA;EAIP,KAAK,OAAO;EACZ,KAAK,UAAU,KAAK;CACtB;CAEA,OAAO,GAAG,OAAgB,MAA8C;EACtE,IACE,EAAE,iBAAiB,gBAClB,OAAoC,SAAS,eAE9C,OAAO;EAET,IAAI,SAAS,KAAA,GAAW,OAAO;EAC/B,OAAQ,MAAsB,SAAS;CACzC;CAEA,SAKE;EACA,OAAO;GACL,MAAM;GACN,MAAM,KAAK;GACX,SAAS,KAAK;GACd,SAAS,KAAK;EAChB;CACF;AACF;AASA,SAAgB,eAAe,KAAqC;CAClE,IAAI,YAAY,GAAG,GAAG,GACpB,OAAO,IAAI,OAAO;CAEpB,IAAI,eAAe,OAGjB,OAAO;EAAE,MAAM;EAAe,MAD5B,IAAI,SAAS,eAAeA,6BAAAA,gBAAgB,UAAUA,6BAAAA,gBAAgB;EACpC,SAAS,IAAI;CAAQ;CAE3D,OAAO;EACL,MAAM;EACN,MAAMA,6BAAAA,gBAAgB;EACtB,SAAS,OAAO,OAAO,eAAe;CACxC;AACF;AAEA,SAAgB,iBAAiB,SAA6C;CAC5E,OAAO,IAAI,YAAY,QAAQ,MAAM,QAAQ,SAAS,EAAE,SAAS,QAAQ,QAAQ,CAAC;AACpF;;;;;;;;;;;;;;;;;;;;;;;;;;;ACjDA,MAAa,sBAAsB;AAsBnC,MAAM,aAAa;AACnB,MAAM,QAAQ;AAEd,SAAgB,SAAS,UAAkB,UAAuB,CAAC,GAAe;CAChF,MAAM,QAAkB,CAAC;CACzB,MAAM,MAAgB,CAAC;CACvB,IAAI,eAAe;CAEnB,IAAI,QAAQ;CACZ,KAAK,MAAM,MAAM,UAAU;EACzB,IAAI;EACJ,IAAI,WAAW,KAAK,EAAE,GACpB,QAAQ;OACH;GACL,QAAQ,GAAG,UAAU,MAAM;GAC3B,IAAI,CAAC,QAAQ,WAAW,QAAQ,MAAM,QAAQ,OAAO,EAAE;GACvD,IAAI,CAAC,QAAQ,UAAU,QAAQ,MAAM,YAAY,CAAC,CAAC,YAAY;EACjE;EAIA,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;GACrC,MAAM,OAAO,MAAM;GACnB,IAAI,WAAW,KAAK,IAAI,GAAG;IACzB,IAAI,cAAc;IAClB,MAAM,KAAK,GAAG;IACd,IAAI,KAAK,KAAK;IACd,eAAe;GACjB,OAAO;IACL,MAAM,KAAK,IAAI;IACf,IAAI,KAAK,KAAK;IACd,eAAe;GACjB;EACF;EACA,SAAS,GAAG;CACd;CAEA,OAAO;EAAE,QAAQ,MAAM,KAAK,EAAE;EAAG,KAAK,YAAY,KAAK,GAAG;EAAG;CAAS;AACxE;;AAGA,SAAS,kBAAkB,MAAc,OAAuB;CAC9D,MAAM,OAAO,KAAK,WAAW,KAAK;CAClC,IAAI,QAAQ,SAAU,QAAQ,SAAU,QAAQ,IAAI,KAAK,QAAQ;EAC/D,MAAM,OAAO,KAAK,WAAW,QAAQ,CAAC;EACtC,IAAI,QAAQ,SAAU,QAAQ,OAAQ,OAAO;CAC/C;CACA,OAAO;AACT;;;;;;;;AASA,SAAgB,gBACd,QACA,aACA,cACkB;CAClB,MAAM,QAAQ,OAAO,IAAI;CACzB,MAAM,eAAe,OAAO,IAAI,cAAc,eAAe;CAE7D,OAAO;EAAE;EAAO,QADJ,eAAe,kBAAkB,OAAO,UAAU,YAAY,IAC5C;CAAM;AACtC"}