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

package/dist/derive-BbsDk_Kz.cjs

@@ -0,0 +1,880 @@
+const require_format = require("./format-D_epWlob.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_format.EngineErrorCode.Aborted : require_format.EngineErrorCode.Unknown,
+		message: err.message
+	};
+	return {
+		name: "EngineError",
+		code: require_format.EngineErrorCode.Unknown,
+		message: String(err ?? "unknown error")
+	};
+}
+function deserializeError(payload) {
+	return new EngineError(payload.code, payload.message, { details: payload.details });
+}
+//#endregion
+//#region src/annotation/relationships.ts
+/**
+* Classify one annotation by its relationship edge alone. Mirrors the
+* spec's "practical parser rule": no `/IRT` is top-level; `/RT /Group` is
+* a grouped subordinate; anything else with an `/IRT` is a reply (the
+* engine has already normalized a missing `/RT` to `'reply'`).
+*/
+function classifyRelation(a) {
+	if (!a.inReplyTo) return "top-level";
+	return a.replyType === "group" ? "grouped-subordinate" : "reply";
+}
+/**
+* Stable string key for an {@link AnnotationRef}, used to match a child's
+* `inReplyTo` against a candidate parent's `ref`. Both sides are produced
+* by the engine with the same identity precedence (objectNumber, then nm,
+* then index), so equal keys mean "same annotation".
+*/
+function refKey(ref) {
+	switch (ref.kind) {
+		case "objectNumber": return `obj:${ref.pageObjectNumber}:${ref.annotObjectNumber}`;
+		case "nm": return `nm:${ref.pageObjectNumber}:${ref.nm}`;
+		case "index": return `idx:${ref.pageObjectNumber}:${ref.index}`;
+	}
+}
+/**
+* Compose a flat annotation list (one page, or a whole document via
+* `listRawAll()` flattened) into {@link AnnotationThread}s in primary
+* order.
+*
+* Rules (ISO 32000 §12.5.6.2 + the spec's UI rule):
+*   - Annotations with no `/IRT` become thread primaries, in input order.
+*   - A `/RT /Group` child is attached to its primary's `groupedParts`.
+*   - A `/RT /R` (or default) child is attached to its primary's `replies`.
+*   - A child whose parent is not in the input set is treated as an
+*     orphan primary (defensive — e.g. a partial/filtered page slice).
+*
+* Limitations (v1, matches the legacy stack): threading is one level deep
+* — a reply-to-a-reply is keyed to its direct parent, so it only appears
+* nested if that direct parent is itself a primary. Callers that want a
+* sidebar of "most annotations, not widgets/popups" should pre-filter the
+* input; this helper is intentionally unopinionated about eligibility.
+*/
+function buildThreads(annotations) {
+	const byKey = /* @__PURE__ */ new Map();
+	for (const a of annotations) {
+		byKey.set(refKey(a.ref), a);
+		if (a.nm && a.nm.length > 0) byKey.set(`nm:${a.ref.pageObjectNumber}:${a.nm}`, a);
+	}
+	const threads = [];
+	const threadByPrimaryKey = /* @__PURE__ */ new Map();
+	const primaryThread = (primary) => {
+		const key = refKey(primary.ref);
+		let thread = threadByPrimaryKey.get(key);
+		if (!thread) {
+			thread = {
+				primary,
+				groupedParts: [],
+				replies: []
+			};
+			threadByPrimaryKey.set(key, thread);
+			threads.push(thread);
+		}
+		return thread;
+	};
+	for (const a of annotations) if (!a.inReplyTo) primaryThread(a);
+	for (const a of annotations) {
+		if (!a.inReplyTo) continue;
+		const parent = byKey.get(refKey(a.inReplyTo));
+		if (!parent || parent.inReplyTo) {
+			primaryThread(a);
+			continue;
+		}
+		const thread = primaryThread(parent);
+		if (a.replyType === "group") thread.groupedParts.push(a);
+		else thread.replies.push(a);
+	}
+	return threads;
+}
+//#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) — or are dropped
+*     entirely with `dropWhitespace` (ignoreWhitespace),
+*   - 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 (options.dropWhitespace || 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
+//#region src/measure/validate.ts
+/** Shared preflight for HTTP, workers and calibration helpers. Does not write. */
+function assertWritableMeasure(value) {
+	if (value.subtype !== "RL") throw new RangeError("Only rectilinear measures can be authored");
+	if (value.ratio !== void 0 && (typeof value.ratio !== "string" || value.ratio.includes("\0"))) throw new RangeError("Invalid scale ratio");
+	for (const key of [
+		"x",
+		"y",
+		"distance",
+		"area",
+		"angle",
+		"slope"
+	]) {
+		const list = value[key];
+		if (list === void 0 && (key === "y" || key === "angle" || key === "slope")) continue;
+		if (!Array.isArray(list)) throw new RangeError(`Missing ${key} formats`);
+		for (const nf of list) {
+			if (!nf || typeof nf.unit !== "string" || !require_format.validNumberFormat(nf)) throw new RangeError("Invalid number format");
+			if (nf.fraction !== void 0 && ![
+				"decimal",
+				"fraction",
+				"round",
+				"truncate"
+			].includes(nf.fraction)) throw new RangeError("Invalid fraction mode");
+			if (nf.labelPosition !== void 0 && !["prefix", "suffix"].includes(nf.labelPosition)) throw new RangeError("Invalid label position");
+			if (nf.fixed !== void 0 && typeof nf.fixed !== "boolean") throw new RangeError("Invalid fixed precision");
+			for (const key of [
+				"unit",
+				"thousands",
+				"decimal",
+				"prefixSpacing",
+				"suffixSpacing"
+			]) {
+				const text = nf[key];
+				if (text !== void 0 && (typeof text !== "string" || text.includes("\0"))) throw new RangeError("Invalid measurement text");
+			}
+		}
+	}
+	if (value.origin !== void 0) for (const n of [value.origin.x, value.origin.y]) assertPdfFloat(n);
+	if (value.cyx !== void 0) {
+		assertPdfFloat(value.cyx);
+		if (Math.fround(value.cyx) <= 0) throw new RangeError("Invalid CYX");
+	}
+}
+function assertPdfFloat(n) {
+	if (typeof n !== "number" || !Number.isFinite(Math.fround(n))) throw new RangeError("Value is outside PDF float range");
+}
+//#endregion
+//#region src/measure/units.ts
+const METRES = {
+	pt: .0254 / 72,
+	mm: .001,
+	cm: .01,
+	m: 1,
+	km: 1e3,
+	in: .0254,
+	ft: .3048,
+	yd: .9144,
+	mi: 1609.344
+};
+const squareOf = (unit) => `${unit}2`;
+function squareMetres(unit) {
+	return unit === "ha" ? 1e4 : unit === "acre" ? 4046.8564224 : METRES[unit.slice(0, -1)] ** 2;
+}
+const areaUnitLabel = (unit) => unit.endsWith("2") ? unit.slice(0, -1) + "²" : unit;
+//#endregion
+//#region src/measure/calibrate.ts
+function positive$1(value) {
+	if (!Number.isFinite(value) || value <= 0) throw new RangeError("Calibration requires finite positive lengths and scales");
+}
+function build(perPoint, unit, ratio, format) {
+	positive$1(Math.fround(perPoint));
+	if (!Number.isInteger(Math.log10(format.precision)) || format.precision < 1 || format.precision > 1e9) throw new RangeError("Invalid decimal precision");
+	const areaUnit = format.areaUnit ?? squareOf(unit);
+	const common = {
+		precision: format.precision,
+		...format.fixed === void 0 ? {} : { fixed: format.fixed }
+	};
+	const distance = format.imperialFeetInches ? [{
+		unit: "ft",
+		conversion: Math.fround(METRES[unit] / METRES.ft)
+	}, {
+		unit: "in",
+		conversion: 12,
+		fraction: "fraction",
+		precision: format.fractionalPrecision ?? 16,
+		..."fixed" in common ? { fixed: common.fixed } : {}
+	}] : [{
+		unit,
+		conversion: 1,
+		...common
+	}];
+	if (format.imperialFeetInches && (!Number.isInteger(distance[1].precision) || distance[1].precision < 1 || distance[1].precision > 2147483647)) throw new RangeError("Invalid fraction denominator");
+	const measure = {
+		subtype: "RL",
+		ratio,
+		x: [{
+			unit,
+			conversion: Math.fround(perPoint),
+			...common
+		}],
+		distance,
+		area: [{
+			unit: areaUnitLabel(areaUnit),
+			conversion: Math.fround(METRES[unit] ** 2 / squareMetres(areaUnit)),
+			...common
+		}]
+	};
+	assertWritableMeasure(measure);
+	return measure;
+}
+function measureFromKnownLength(userSpaceLength, real, format = { precision: 100 }) {
+	positive$1(userSpaceLength);
+	positive$1(real.value);
+	const perPoint = real.value / userSpaceLength;
+	return build(perPoint, real.unit, `1 in = ${Number((perPoint * 72).toPrecision(8))} ${real.unit}`, format);
+}
+function measureFromRatio(paper, real, unit, userUnit = 1, format = { precision: 100 }) {
+	positive$1(paper);
+	positive$1(real);
+	positive$1(userUnit);
+	return build(userUnit / 72 * .0254 * (real / paper) / METRES[unit], unit, `${paper}:${real}`, format);
+}
+//#endregion
+//#region src/measure/compute.ts
+const positive = (n) => Number.isFinite(n) && n > 0;
+function scaleOf(measure) {
+	const sx = Math.fround(measure.x[0]?.conversion ?? NaN);
+	if (!positive(sx)) return null;
+	if (!measure.y) return {
+		sx,
+		sy: sx
+	};
+	const cy = Math.fround(measure.y[0]?.conversion ?? NaN);
+	const cyx = Math.fround(measure.cyx ?? NaN);
+	const sy = cy * cyx;
+	return positive(cy) && positive(cyx) && positive(sy) ? {
+		sx,
+		sy
+	} : null;
+}
+const measurementPoint = (p) => ({
+	x: Math.fround(p.x),
+	y: Math.fround(p.y)
+});
+function pathLength(points, closed, scale) {
+	let total = 0;
+	const normalized = points.map(measurementPoint);
+	for (let i = 0; i < (closed ? normalized.length : normalized.length - 1); i++) {
+		const a = normalized[i], b = normalized[(i + 1) % normalized.length];
+		total += Math.hypot((b.x - a.x) * scale.sx, (b.y - a.y) * scale.sy);
+	}
+	return total;
+}
+function polygonArea(points, scale) {
+	if (points.length < 3) return 0;
+	const normalized = points.map(measurementPoint);
+	const origin = normalized[0];
+	let twice = 0;
+	for (let i = 1; i < normalized.length - 1; i++) {
+		const a = normalized[i], b = normalized[i + 1];
+		twice += (a.x - origin.x) * (b.y - origin.y) - (b.x - origin.x) * (a.y - origin.y);
+	}
+	return Math.abs(twice * scale.sx * scale.sy) / 2;
+}
+/** A measured area must have one simple, nonzero boundary. Repeated closing
+*  vertices are allowed in imported PDFs; crossings and overlapping edges are not. */
+function validAreaBoundary(points) {
+	const boundary = points.map(measurementPoint);
+	const same = (a, b) => a.x === b.x && a.y === b.y;
+	if (boundary.length > 1 && same(boundary[0], boundary[boundary.length - 1])) boundary.pop();
+	if (boundary.length < 3 || polygonArea(boundary, {
+		sx: 1,
+		sy: 1
+	}) === 0) return false;
+	const cross = (a, b, c) => (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
+	const onSegment = (a, b, p) => cross(a, b, p) === 0 && p.x >= Math.min(a.x, b.x) && p.x <= Math.max(a.x, b.x) && p.y >= Math.min(a.y, b.y) && p.y <= Math.max(a.y, b.y);
+	for (let i = 0; i < boundary.length; i++) {
+		const a = boundary[i];
+		const b = boundary[(i + 1) % boundary.length];
+		if (same(a, b)) return false;
+		const next = boundary[(i + 2) % boundary.length];
+		const doublesBack = (b.x - a.x) * (next.x - b.x) + (b.y - a.y) * (next.y - b.y) < 0;
+		if (cross(a, b, next) === 0 && doublesBack) return false;
+		for (let j = i + 1; j < boundary.length; j++) {
+			if (j === i + 1 || i === 0 && j === boundary.length - 1) continue;
+			const c = boundary[j];
+			const d = boundary[(j + 1) % boundary.length];
+			if (onSegment(a, b, c) || onSegment(a, b, d) || onSegment(c, d, a) || onSegment(c, d, b)) return false;
+			if (Math.sign(cross(a, b, c)) !== Math.sign(cross(a, b, d)) && Math.sign(cross(c, d, a)) !== Math.sign(cross(c, d, b))) return false;
+		}
+	}
+	return true;
+}
+//#endregion
+//#region src/measure/derive.ts
+function isDimension(dto) {
+	return dto.subtype === "line" && dto.intent === "LineDimension" || dto.subtype === "polyline" && dto.intent === "PolyLineDimension" || dto.subtype === "polygon" && dto.intent === "PolygonDimension";
+}
+const isReadout = (r) => !("unavailable" in r);
+function measurementReadout(dto) {
+	if (!isDimension(dto)) return { unavailable: "not-dimension" };
+	if (!dto.measure) return { unavailable: "no-measure" };
+	if (dto.measure.subtype !== "RL") return { unavailable: "foreign-measure" };
+	const m = dto.measure, scale = scaleOf(m);
+	if (!scale) return { unavailable: "no-scale" };
+	const points = dto.subtype === "line" ? dto.linePoints ? [dto.linePoints.start, dto.linePoints.end] : [] : dto.vertices ?? [];
+	if (points.length < (dto.subtype === "polygon" ? 3 : 2) || points.some((p) => !Number.isFinite(Math.fround(p.x)) || !Number.isFinite(Math.fround(p.y)))) return { unavailable: "invalid-geometry" };
+	const area = dto.subtype === "polygon";
+	if (area && !validAreaBoundary(points)) return { unavailable: "invalid-geometry" };
+	const formats = area ? m.area : m.distance;
+	if (!formats.length) return { unavailable: area ? "no-area-format" : "no-distance-format" };
+	if (!formats.every(require_format.validNumberFormat)) return { unavailable: "invalid-format" };
+	const value = area ? polygonArea(points, scale) : pathLength(points, false, scale);
+	try {
+		return {
+			kind: area ? "area" : dto.subtype === "line" ? "distance" : "perimeter",
+			value: value * Math.fround(formats[0].conversion),
+			label: require_format.formatMeasurement(value, formats),
+			...area && m.distance.length && m.distance.every(require_format.validNumberFormat) ? { perimeter: require_format.formatMeasurement(pathLength(points, true, scale), m.distance) } : {}
+		};
+	} catch {
+		return { unavailable: "invalid-format" };
+	}
+}
+function deriveMeasurementLabel(dto) {
+	const readout = measurementReadout(dto);
+	return isReadout(readout) && dto.contents !== readout.label ? {
+		...dto,
+		contents: readout.label
+	} : dto;
+}
+//#endregion
+Object.defineProperty(exports, "EngineError", {
+	enumerable: true,
+	get: function() {
+		return EngineError;
+	}
+});
+Object.defineProperty(exports, "METRES", {
+	enumerable: true,
+	get: function() {
+		return METRES;
+	}
+});
+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, "areaUnitLabel", {
+	enumerable: true,
+	get: function() {
+		return areaUnitLabel;
+	}
+});
+Object.defineProperty(exports, "assertPdfFloat", {
+	enumerable: true,
+	get: function() {
+		return assertPdfFloat;
+	}
+});
+Object.defineProperty(exports, "assertWritableMeasure", {
+	enumerable: true,
+	get: function() {
+		return assertWritableMeasure;
+	}
+});
+Object.defineProperty(exports, "buildThreads", {
+	enumerable: true,
+	get: function() {
+		return buildThreads;
+	}
+});
+Object.defineProperty(exports, "classifyRelation", {
+	enumerable: true,
+	get: function() {
+		return classifyRelation;
+	}
+});
+Object.defineProperty(exports, "deriveMeasurementLabel", {
+	enumerable: true,
+	get: function() {
+		return deriveMeasurementLabel;
+	}
+});
+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, "isDimension", {
+	enumerable: true,
+	get: function() {
+		return isDimension;
+	}
+});
+Object.defineProperty(exports, "isReadout", {
+	enumerable: true,
+	get: function() {
+		return isReadout;
+	}
+});
+Object.defineProperty(exports, "isRotatedGeometryRun", {
+	enumerable: true,
+	get: function() {
+		return isRotatedGeometryRun;
+	}
+});
+Object.defineProperty(exports, "measureFromKnownLength", {
+	enumerable: true,
+	get: function() {
+		return measureFromKnownLength;
+	}
+});
+Object.defineProperty(exports, "measureFromRatio", {
+	enumerable: true,
+	get: function() {
+		return measureFromRatio;
+	}
+});
+Object.defineProperty(exports, "measurementPoint", {
+	enumerable: true,
+	get: function() {
+		return measurementPoint;
+	}
+});
+Object.defineProperty(exports, "measurementReadout", {
+	enumerable: true,
+	get: function() {
+		return measurementReadout;
+	}
+});
+Object.defineProperty(exports, "normalizePdfRect", {
+	enumerable: true,
+	get: function() {
+		return normalizePdfRect;
+	}
+});
+Object.defineProperty(exports, "pathLength", {
+	enumerable: true,
+	get: function() {
+		return pathLength;
+	}
+});
+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, "polygonArea", {
+	enumerable: true,
+	get: function() {
+		return polygonArea;
+	}
+});
+Object.defineProperty(exports, "refKey", {
+	enumerable: true,
+	get: function() {
+		return refKey;
+	}
+});
+Object.defineProperty(exports, "scaleOf", {
+	enumerable: true,
+	get: function() {
+		return scaleOf;
+	}
+});
+Object.defineProperty(exports, "serializeError", {
+	enumerable: true,
+	get: function() {
+		return serializeError;
+	}
+});
+Object.defineProperty(exports, "squareMetres", {
+	enumerable: true,
+	get: function() {
+		return squareMetres;
+	}
+});
+Object.defineProperty(exports, "squareOf", {
+	enumerable: true,
+	get: function() {
+		return squareOf;
+	}
+});
+Object.defineProperty(exports, "toOriginalRange", {
+	enumerable: true,
+	get: function() {
+		return toOriginalRange;
+	}
+});
+Object.defineProperty(exports, "validAreaBoundary", {
+	enumerable: true,
+	get: function() {
+		return validAreaBoundary;
+	}
+});
+
+//# sourceMappingURL=derive-BbsDk_Kz.cjs.map