@mark1russell7/layout-contract 0.2.3 → 0.2.5

package/README.md

@@ -16,9 +16,11 @@ The package has no runtime dependencies.
 | The measures | `MeasureSpec`, `Direction`, `JointMeasureId`, `JOINT_MEASURES`, `JOINT_MOVED_MIN`, `Verdict`, `compareMeasure`, `minEffectOf` |
 | The edges step | `edgeStep`, `EdgeShape`, `EdgeStepParams`, `EDGE_DENSITY`, `EDGE_STEP_VERSION` |
 | The random numbers | `mulberry32`, `fnv1a32`, `stepRandom`, `randomInt` |
+| The hashes | `sha256Hex`, `canonicalJson`, `documentHash`, `outputHash`, `HashOptions` |
+| The promotion guards | `outputGroups`, `OutputGroup`, `exercised`, `ExerciseEvidence` |
 | The turn | `turnBox`, `turnPort`, `turnMargin`, `turnRegion`, `turnSide`, `turnPoint` |
 | The tolerances | `EPS`, `RECORD_EPS`, `Tolerance`, `DEFAULT_TOLERANCE` |
-| The hard rules | `countOverlaps`, `countObstacleHits`, `regionHitsRect`, `countOutside`, `countPortsOffBorder`, `packHard`, `PackHard`, `placedRect`, `checkInput` |
+| The hard rules | `countOverlaps`, `countObstacleHits`, `regionHitsRect`, `rectInRegion`, `countOutside`, `ContainerTest`, `countPortsOffBorder`, `packHard`, `PackHard`, `placedRect`, `checkInput` |
 
 ## The rules
 
@@ -27,6 +29,9 @@ The package has no runtime dependencies.
 - **The gap.** The gap is the free space between two boxes with their margins. Routes use it. Two boxes are `mA + gap + mB` apart.
 - **The ports.** A port can have a side. Without a side, the router picks the side. A fixed port has `x` and `y` on the border of the box, relative to its top-left corner.
 - **The hard rules of a pack.** `no-overlap` counts the pairs of boxes and the pairs of a box and an obstacle. A locked box without a placement, or with a move of more than `RECORD_EPS`, breaks `locked-kept`. `checkInput` refuses a locked box without a position. Another box without a placement and not in `overflow` breaks `complete`.
+- **The container rule.** `in-container` counts each box that goes out of the container made smaller by `inset`. The box counts with its margin. By default, a shaped container counts as its bounding box.
+- **The exact container.** Give `{ exactContainer: true }` to `packHard` or `countOutside`. Then a box of a shaped container with the size `fixed` must stay inside the shape. A cut corner, a notch and a hole count. A container with a free side keeps the bounding test. The default changes to the exact test at the next breaking version.
+- **The output hash.** `outputHash` gives the first 16 hex characters of the SHA-256 of the canonical JSON of an output. Each number goes to the grid of `RECORD_EPS` first.
 - **The tolerances.** `EPS` (`1e-6`) is for the float compares in an engine. `RECORD_EPS` (`1e-3`) is for the compares on a written file. A record writes the tolerance of each hard rule in its field `tolerance`. The defaults are `overlap` `0.001` and `through` `0.5`.
 
 ## An example
@@ -46,4 +51,4 @@ const placed = applyPack(input, output);
 const hard = packHard(input, output);
 ```
 
-The formats are in `docs/FORMAT.md` of `packing` and `docs/LAYOUT-RECORDS.md` of `highways`. The joint measures are in `docs/JOINT-MEASURES.md` of this repository, and the joint corpus is in `docs/JOINT-CORPUS.md`.
+The formats are in `docs/FORMAT.md` of `packing` and `docs/LAYOUT-RECORDS.md` of `highways`. The joint measures are in `docs/JOINT-MEASURES.md` of this repository, and the joint corpus is in `docs/JOINT-CORPUS.md`. The promotion guards are in `docs/PROMOTION.md`.

package/build/index.d.ts

@@ -324,12 +324,23 @@ export declare function placedRect(box: LayoutBox): Rect | undefined;
  * A box with a shape counts as its bounding box. That area is larger, thus the count is safe.
  */
 export declare function countOverlaps(boxes: readonly LayoutBox[], tolerance?: number): number;
+/** The options of the container test of `countOutside` and `packHard`. */
+export interface ContainerTest {
+  /**
+   * With `true`, a box of a shaped container with the size `fixed` must stay inside the shape, not only inside its bounding box.
+   * The default is `false`. The default changes to `true` at the next breaking version.
+   */
+  readonly exactContainer?: boolean;
+}
 /**
  * This function counts the placed boxes that go out of the container.
  * Each box with its margin must stay inside the container made smaller by `inset`. Only the fixed sides of the size count. A shaped container counts as its bounding box.
+ *
+ * With `exactContainer`, a box of a shaped container with the size `fixed` also counts when `rectInRegion` tells that it is not inside the shape.
+ * For that test, the box grows by `inset` and becomes smaller by `tolerance` on each side. A shaped container with a free side keeps the bounding test only.
  * An input without a container gives 0.
  */
-export declare function countOutside(input: LayoutInput, tolerance?: number): number;
+export declare function countOutside(input: LayoutInput, tolerance?: number, options?: ContainerTest): number;
 /** This function counts the fixed ports that are not on the border of their box, with the epsilon of a written file. A port without a side does not count. */
 export declare function countPortsOffBorder(boxes: readonly LayoutBox[], eps?: number): number;
 /** The count of the breaks of each hard rule of a pack. */
@@ -341,6 +352,11 @@ export interface PackHard {
 }
 /** This function tells if the inside of `region` and the inside of `rect` have a common point. */
 export declare function regionHitsRect(region: Region, rect: Rect): boolean;
+/**
+ * This function tells if all of `rect` is inside `region`. A point on the border counts as inside. No part of `rect` can overlap a hole.
+ * The test of a circle, an ellipse or a polygon accepts an error of `EPS` on the border. A polygon can be concave.
+ */
+export declare function rectInRegion(region: Region, rect: Rect): boolean;
 /**
  * This function counts the pairs of a placed box and an obstacle that overlap by more than `tolerance`.
  * The box counts with its margin. A box with a shape counts as its bounding box.
@@ -353,8 +369,10 @@ export declare function countObstacleHits(boxes: readonly LayoutBox[], obstacles
  * A locked box without a placement, or with a move of more than `RECORD_EPS`, breaks `locked-kept`.
  * A locked box without a position in the input is a bad input, not a break. `checkInput` finds it.
  * Another box without a placement that is not in `overflow` breaks `complete`.
+ *
+ * `options` goes to `countOutside` for `in-container`.
  */
-export declare function packHard(input: LayoutInput, output: PackOutput, tolerance?: number): PackHard;
+export declare function packHard(input: LayoutInput, output: PackOutput, tolerance?: number, options?: ContainerTest): PackHard;
 /**
  * This function gives the problems of an input file. An empty list tells that the file is good.
  * A problem is a bad input, not a break of a hard rule. Thus an engine refuses the input.
@@ -475,4 +493,67 @@ export declare const EDGE_STEP_VERSION = 1;
  * The rules of each shape are in `docs/JOINT-CORPUS.md`.
  */
 export declare function edgeStep(input: LayoutInput, params: EdgeStepParams, seed?: number): LayoutInput;
+/**
+ * This function gives the SHA-256 digest of the UTF-8 bytes of a string, as 64 lowercase hex characters.
+ * It uses no API of Node or of the browser.
+ */
+export declare function sha256Hex(text: string): string;
+/**
+ * This function gives the canonical form of a value: sorted keys and no whitespace, with the numbers of `JSON.stringify`.
+ * A key with the value `undefined` is not in the form. An `undefined` in an array becomes `null`.
+ */
+export declare function canonicalJson(value: unknown): string;
+/** The options of `outputHash` and `documentHash`. */
+export interface HashOptions {
+  /**
+   * The step of the grid of the numbers. The default is `RECORD_EPS`, so a number keeps 3 decimals.
+   * The value `0` keeps the exact numbers. A negative value or a value that is not finite causes a `RangeError`.
+   */
+  readonly grid?: number;
+}
+/**
+ * This function gives the hash of an output: the first 16 hex characters of the SHA-256 of its canonical form.
+ * Before the canonical form, each number goes to the nearest point of the grid, and `-0` becomes `0`.
+ * With the default grid, the rounding is `round3` of `packing`: `Math.round(x * 1000) / 1000`.
+ * The function throws a `RangeError` for `NaN` and for an infinite number.
+ *
+ * The grid can split two outputs. Two numbers near a rounding boundary can go to two different points.
+ * The grid can also merge two outputs whose numbers go to the same points. This merge is intentional: it removes the noise of floating-point numbers.
+ */
+export declare function outputHash(value: unknown, options?: HashOptions): string;
+/**
+ * This function gives the hash of a document. It uses the rule of `outputHash`, but the form does not include the field `hash` of the document.
+ * With the default grid, it is the input hash of `docs/FORMAT.md` of `packing`.
+ */
+export declare function documentHash(doc: object, options?: HashOptions): string;
+/** One output group: the candidates with the same output hash on each decision input. */
+export interface OutputGroup {
+  /** The id of the group: its first member. */
+  readonly id: string;
+  /** The ids of the candidates of the group, in sorted order. */
+  readonly members: readonly string[];
+}
+/**
+ * This function gives the output groups of the candidates. The key of `hashes` is the id of a candidate.
+ * Its value is the list of the output hashes of the candidate, in the order of the decision inputs.
+ * Candidates with equal lists make one group. The groups are in the order of their ids.
+ * The function throws a `RangeError` when two lists have different lengths.
+ */
+export declare function outputGroups(hashes: Readonly<Record<string, readonly string[]>>): OutputGroup[];
+/** The evidence that a candidate is exercised on its decision inputs. */
+export interface ExerciseEvidence {
+  /** The move counts of the candidate, by name. A record keeps each one as the trace measure `move.<name>`. */
+  readonly moves?: Readonly<Record<string, number>>;
+  /** The output hashes of the candidate, in the order of the decision inputs. */
+  readonly hashes?: readonly string[];
+  /** The output hashes of the base of the candidate, in the same order. */
+  readonly baseHashes?: readonly string[];
+}
+/**
+ * This function tells if a candidate is exercised. It gives `true` when a move count is more than 0.
+ * It also gives `true` when `hashes` and `baseHashes` are different at one place or more.
+ * Without evidence, it gives `false`.
+ * The function throws a `RangeError` when only one of the two lists is given, or when their lengths are different.
+ */
+export declare function exercised(evidence: ExerciseEvidence): boolean;
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/geometry.ts","../src/tolerance.ts","../src/input.ts","../src/output.ts","../src/record.ts","../src/rules.ts","../src/turn.ts","../src/measures.ts","../src/strategy.ts","../src/random.ts","../src/edges.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/geometry.ts","../src/tolerance.ts","../src/input.ts","../src/output.ts","../src/record.ts","../src/rules.ts","../src/turn.ts","../src/measures.ts","../src/strategy.ts","../src/random.ts","../src/edges.ts","../src/hash.ts"],"mappings":"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"}

package/build/index.js

@@ -307,11 +307,15 @@ function countOverlaps(boxes, tolerance = DEFAULT_TOLERANCE.overlap) {
 /**
 * This function counts the placed boxes that go out of the container.
 * Each box with its margin must stay inside the container made smaller by `inset`. Only the fixed sides of the size count. A shaped container counts as its bounding box.
+*
+* With `exactContainer`, a box of a shaped container with the size `fixed` also counts when `rectInRegion` tells that it is not inside the shape.
+* For that test, the box grows by `inset` and becomes smaller by `tolerance` on each side. A shaped container with a free side keeps the bounding test only.
 * An input without a container gives 0.
 */
-function countOutside(input, tolerance = DEFAULT_TOLERANCE.overlap) {
+function countOutside(input, tolerance = DEFAULT_TOLERANCE.overlap, options = {}) {
 	const c = input.container;
 	if (c === void 0) return 0;
+	const shape = options.exactContainer === true && c.fixed === "size" ? c.shape : void 0;
 	const area = c.shape === void 0 ? {
 		x: 0,
 		y: 0,
@@ -329,6 +333,7 @@ function countOutside(input, tolerance = DEFAULT_TOLERANCE.overlap) {
 		const outX = r.x < area.x + inset - tolerance || r.x + r.w > area.x + area.w - inset + tolerance;
 		const outY = r.y < area.y + inset - tolerance || r.y + r.h > area.y + area.h - inset + tolerance;
 		if (fixW && outX || fixH && outY) count++;
+		else if (shape !== void 0 && !rectInRegion(shape, shrink(grow(r, inset), tolerance))) count++;
 	}
 	return count;
 }
@@ -373,6 +378,72 @@ function regionHitsRect(region, rect) {
 		}
 	}
 }
+/**
+* This function tells if all of `rect` is inside `region`. A point on the border counts as inside. No part of `rect` can overlap a hole.
+* The test of a circle, an ellipse or a polygon accepts an error of `EPS` on the border. A polygon can be concave.
+*/
+function rectInRegion(region, rect) {
+	const x1 = rect.x + rect.w;
+	const y1 = rect.y + rect.h;
+	const corners = [
+		[rect.x, rect.y],
+		[x1, rect.y],
+		[x1, y1],
+		[rect.x, y1]
+	];
+	switch (region.kind) {
+		case "rect": return rect.x >= region.x && rect.y >= region.y && x1 <= region.x + region.w && y1 <= region.y + region.h;
+		case "circle": return corners.every(([x, y]) => inEllipse(region.cx, region.cy, region.r, region.r, x, y));
+		case "ellipse": return corners.every(([x, y]) => inEllipse(region.cx, region.cy, region.rx, region.ry, x, y));
+		case "polygon": {
+			const ring = region.points;
+			if (ring.length < 3) return false;
+			if (![...corners, [rect.x + rect.w / 2, rect.y + rect.h / 2]].every(([x, y]) => onRing(x, y, ring) || pointInRings(x, y, [ring]))) return false;
+			const deep = (x, y) => x > rect.x + 1e-6 && x < x1 - 1e-6 && y > rect.y + 1e-6 && y < y1 - 1e-6;
+			for (let i = 0; i < ring.length; i++) {
+				const a = ring[i];
+				const b = ring[(i + 1) % ring.length];
+				const m = clipMid(a[0], a[1], b[0], b[1], rect);
+				if (m !== void 0 && deep(m[0], m[1])) return false;
+			}
+			return (region.holes ?? []).every((hole) => !regionHitsRect({
+				kind: "polygon",
+				points: hole
+			}, rect));
+		}
+	}
+}
+/** This function gives the rectangle made smaller by `d` on each side. A side does not become smaller than 0. */
+function shrink(r, d) {
+	const dx = Math.min(d, r.w / 2);
+	const dy = Math.min(d, r.h / 2);
+	return {
+		x: r.x + dx,
+		y: r.y + dy,
+		w: r.w - 2 * dx,
+		h: r.h - 2 * dy
+	};
+}
+/** This function tells if a point is inside an ellipse or on its border, with an error of `EPS`. */
+function inEllipse(cx, cy, rx, ry, x, y) {
+	if (rx <= 0 || ry <= 0) return false;
+	const u = (x - cx) / rx;
+	const v = (y - cy) / ry;
+	return u * u + v * v <= 1.000001;
+}
+/** This function tells if a point is on a ring of a polygon, with an error of `EPS`. */
+function onRing(x, y, ring) {
+	for (let i = 0; i < ring.length; i++) {
+		const [ax, ay] = ring[i];
+		const [bx, by] = ring[(i + 1) % ring.length];
+		const dx = bx - ax;
+		const dy = by - ay;
+		const len2 = dx * dx + dy * dy;
+		const t = len2 === 0 ? 0 : Math.max(0, Math.min(1, ((x - ax) * dx + (y - ay) * dy) / len2));
+		if (Math.hypot(x - (ax + t * dx), y - (ay + t * dy)) <= 1e-6) return true;
+	}
+	return false;
+}
 /** An ellipse with the radii `rx` and `ry` scales to a unit circle. The rectangle scales with it. */
 function circleHitsRect(cx, cy, rx, ry, rect) {
 	if (rx <= 0 || ry <= 0) return false;
@@ -442,8 +513,10 @@ function countObstacleHits(boxes, obstacles, tolerance = DEFAULT_TOLERANCE.overl
 * A locked box without a placement, or with a move of more than `RECORD_EPS`, breaks `locked-kept`.
 * A locked box without a position in the input is a bad input, not a break. `checkInput` finds it.
 * Another box without a placement that is not in `overflow` breaks `complete`.
+*
+* `options` goes to `countOutside` for `in-container`.
 */
-function packHard(input, output, tolerance = DEFAULT_TOLERANCE.overlap) {
+function packHard(input, output, tolerance = DEFAULT_TOLERANCE.overlap, options = {}) {
 	const after = applyPack(input, output);
 	const placed = new Set(output.placements.map((p) => p.id));
 	const out = new Set(output.overflow);
@@ -466,7 +539,7 @@ function packHard(input, output, tolerance = DEFAULT_TOLERANCE.overlap) {
 		"in-container": countOutside({
 			...after,
 			boxes: kept
-		}, tolerance),
+		}, tolerance, options),
 		"locked-kept": lockedMoved,
 		complete: incomplete
 	};
@@ -608,6 +681,19 @@ function compareMeasure(candidate, baseline, spec) {
 	if (!(Math.abs(delta) > minEffectOf(spec, candidate, baseline))) return "tie";
 	return (spec.direction === "lower" ? delta < 0 : delta > 0) ? "better" : "worse";
 }
+// src/utf8.ts
+/** This function gives the UTF-8 bytes of a string. The package has no runtime dependencies, thus it does not use `TextEncoder`. */
+function utf8(text) {
+	const bytes = [];
+	for (const ch of text) {
+		const c = ch.codePointAt(0);
+		if (c < 128) bytes.push(c);
+		else if (c < 2048) bytes.push(192 | c >> 6, 128 | c & 63);
+		else if (c < 65536) bytes.push(224 | c >> 12, 128 | c >> 6 & 63, 128 | c & 63);
+		else bytes.push(240 | c >> 18, 128 | c >> 12 & 63, 128 | c >> 6 & 63, 128 | c & 63);
+	}
+	return bytes;
+}
 // src/random.ts
 /** This function gives a generator of random numbers in [0, 1). It is `mulberry32`, as in `docs/FORMAT.md` of `packing`. */
 function mulberry32(seed) {
@@ -625,18 +711,6 @@ function fnv1a32(text) {
 	for (const b of utf8(text)) h = Math.imul(h ^ b, 16777619) >>> 0;
 	return h;
 }
-/** The UTF-8 bytes of a string. The package has no runtime dependencies, thus it does not use `TextEncoder`. */
-function utf8(text) {
-	const bytes = [];
-	for (const ch of text) {
-		const c = ch.codePointAt(0);
-		if (c < 128) bytes.push(c);
-		else if (c < 2048) bytes.push(192 | c >> 6, 128 | c & 63);
-		else if (c < 65536) bytes.push(224 | c >> 12, 128 | c >> 6 & 63, 128 | c & 63);
-		else bytes.push(240 | c >> 18, 128 | c >> 12 & 63, 128 | c >> 6 & 63, 128 | c & 63);
-	}
-	return bytes;
-}
 /** This function gives the generator of one step of a seeded generator: `mulberry32(fnv1a32("<seed>:<step>"))`. */
 function stepRandom(seed, step) {
 	return mulberry32(fnv1a32(`${seed}:${step}`));
@@ -841,6 +915,230 @@ function edgeStep(input, params, seed = input.seed ?? 0) {
 		steps: [...input.steps ?? [], stamp]
 	};
 }
-export { DEFAULT_TOLERANCE, EDGE_DENSITY, EDGE_STEP_VERSION, EPS, JOINT_MEASURES, JOINT_MOVED_MIN, RECORD_EPS, SIDES, applyPack, boundsOf, checkInput, compareMeasure, countObstacleHits, countOutside, countOverlaps, countPortsOffBorder, edgeStep, fnv1a32, grow, marginSides, minEffectOf, mulberry32, overlapOf, packHard, placedRect, randomInt, regionHitsRect, stepRandom, toLayoutRecord, toPackInput, translate, turnBox, turnMargin, turnPoint, turnPort, turnRegion, turnSide };
+// src/hash.ts
+/** The round constants of SHA-256. */
+const K = [
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+];
+/**
+* This function gives the SHA-256 digest of the UTF-8 bytes of a string, as 64 lowercase hex characters.
+* It uses no API of Node or of the browser.
+*/
+function sha256Hex(text) {
+	const bytes = utf8(text);
+	const bits = bytes.length * 8;
+	const total = Math.ceil((bytes.length + 9) / 64) * 64;
+	const data = new Uint8Array(total);
+	data.set(bytes);
+	data[bytes.length] = 128;
+	const view = new DataView(data.buffer);
+	view.setUint32(total - 8, Math.floor(bits / 4294967296));
+	view.setUint32(total - 4, bits >>> 0);
+	const h = [
+		1779033703,
+		3144134277,
+		1013904242,
+		2773480762,
+		1359893119,
+		2600822924,
+		528734635,
+		1541459225
+	];
+	const w = /* @__PURE__ */ new Uint32Array(64);
+	const rotr = (x, n) => x >>> n | x << 32 - n;
+	for (let off = 0; off < total; off += 64) {
+		for (let i = 0; i < 16; i++) w[i] = view.getUint32(off + 4 * i);
+		for (let i = 16; i < 64; i++) {
+			const a = w[i - 15];
+			const b = w[i - 2];
+			const s0 = rotr(a, 7) ^ rotr(a, 18) ^ a >>> 3;
+			const s1 = rotr(b, 17) ^ rotr(b, 19) ^ b >>> 10;
+			w[i] = w[i - 16] + s0 + w[i - 7] + s1 >>> 0;
+		}
+		let [a, b, c, d, e, f, g, k] = h;
+		for (let i = 0; i < 64; i++) {
+			const s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+			const ch = e & f ^ ~e & g;
+			const t1 = k + s1 + ch + K[i] + w[i] >>> 0;
+			const t2 = (rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + (a & b ^ a & c ^ b & c) >>> 0;
+			k = g;
+			g = f;
+			f = e;
+			e = d + t1 >>> 0;
+			d = c;
+			c = b;
+			b = a;
+			a = t1 + t2 >>> 0;
+		}
+		h[0] = h[0] + a >>> 0;
+		h[1] = h[1] + b >>> 0;
+		h[2] = h[2] + c >>> 0;
+		h[3] = h[3] + d >>> 0;
+		h[4] = h[4] + e >>> 0;
+		h[5] = h[5] + f >>> 0;
+		h[6] = h[6] + g >>> 0;
+		h[7] = h[7] + k >>> 0;
+	}
+	return h.map((x) => x.toString(16).padStart(8, "0")).join("");
+}
+/**
+* This function gives the canonical form of a value: sorted keys and no whitespace, with the numbers of `JSON.stringify`.
+* A key with the value `undefined` is not in the form. An `undefined` in an array becomes `null`.
+*/
+function canonicalJson(value) {
+	if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+	if (Array.isArray(value)) return `[${value.map((v) => v === void 0 ? "null" : canonicalJson(v)).join(",")}]`;
+	const o = value;
+	return `{${Object.keys(o).filter((k) => o[k] !== void 0).sort().map((k) => `${JSON.stringify(k)}:${canonicalJson(o[k])}`).join(",")}}`;
+}
+/** This function gives the factor of a grid: `1 / grid`, or `undefined` for the exact numbers. */
+function gridFactor(options) {
+	const grid = options.grid ?? .001;
+	if (!Number.isFinite(grid) || grid < 0) throw new RangeError(`The grid ${grid} is not a finite number of 0 or more.`);
+	return grid === 0 ? void 0 : 1 / grid;
+}
+/**
+* This function gives a copy of a value with each number on the grid. The value `-0` becomes `0`.
+* It throws a `RangeError` for a number that is not finite.
+*/
+function onGrid(value, path, k) {
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw new RangeError(`The value has the number ${value} at ${path}. JSON has no form for it.`);
+		if (k === void 0) return value;
+		const r = Math.round(value * k) / k;
+		if (!Number.isFinite(r)) throw new RangeError(`The number at ${path} is too large for the grid.`);
+		return r === 0 ? 0 : r;
+	}
+	if (value === null || typeof value !== "object") return value;
+	if (Array.isArray(value)) return value.map((v, i) => onGrid(v, `${path}[${i}]`, k));
+	const o = value;
+	const out = {};
+	for (const key of Object.keys(o)) out[key] = onGrid(o[key], `${path}.${key}`, k);
+	return out;
+}
+/**
+* This function gives the hash of an output: the first 16 hex characters of the SHA-256 of its canonical form.
+* Before the canonical form, each number goes to the nearest point of the grid, and `-0` becomes `0`.
+* With the default grid, the rounding is `round3` of `packing`: `Math.round(x * 1000) / 1000`.
+* The function throws a `RangeError` for `NaN` and for an infinite number.
+*
+* The grid can split two outputs. Two numbers near a rounding boundary can go to two different points.
+* The grid can also merge two outputs whose numbers go to the same points. This merge is intentional: it removes the noise of floating-point numbers.
+*/
+function outputHash(value, options = {}) {
+	return sha256Hex(canonicalJson(onGrid(value, "$", gridFactor(options)))).slice(0, 16);
+}
+/**
+* This function gives the hash of a document. It uses the rule of `outputHash`, but the form does not include the field `hash` of the document.
+* With the default grid, it is the input hash of `docs/FORMAT.md` of `packing`.
+*/
+function documentHash(doc, options = {}) {
+	const { hash: _hash, ...rest } = doc;
+	return outputHash(rest, options);
+}
+/**
+* This function gives the output groups of the candidates. The key of `hashes` is the id of a candidate.
+* Its value is the list of the output hashes of the candidate, in the order of the decision inputs.
+* Candidates with equal lists make one group. The groups are in the order of their ids.
+* The function throws a `RangeError` when two lists have different lengths.
+*/
+function outputGroups(hashes) {
+	const byList = /* @__PURE__ */ new Map();
+	let first;
+	for (const id of Object.keys(hashes)) {
+		const list = hashes[id];
+		if (first === void 0) first = id;
+		else if (list.length !== hashes[first].length) throw new RangeError(`The candidate "${id}" has ${list.length} hashes, but "${first}" has ${hashes[first].length}.`);
+		const key = JSON.stringify(list);
+		const members = byList.get(key);
+		if (members) members.push(id);
+		else byList.set(key, [id]);
+	}
+	return [...byList.values()].map((members) => {
+		const sorted = [...members].sort();
+		return {
+			id: sorted[0],
+			members: sorted
+		};
+	}).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+}
+/**
+* This function tells if a candidate is exercised. It gives `true` when a move count is more than 0.
+* It also gives `true` when `hashes` and `baseHashes` are different at one place or more.
+* Without evidence, it gives `false`.
+* The function throws a `RangeError` when only one of the two lists is given, or when their lengths are different.
+*/
+function exercised(evidence) {
+	const { moves, hashes, baseHashes } = evidence;
+	if (hashes === void 0 !== (baseHashes === void 0)) throw new RangeError("The evidence must have both hashes and baseHashes, or neither of them.");
+	if (hashes && baseHashes && hashes.length !== baseHashes.length) throw new RangeError(`The candidate has ${hashes.length} hashes, but its base has ${baseHashes.length}.`);
+	if (moves && Object.values(moves).some((n) => n > 0)) return true;
+	if (hashes && baseHashes) return hashes.some((h, i) => h !== baseHashes[i]);
+	return false;
+}
+export { DEFAULT_TOLERANCE, EDGE_DENSITY, EDGE_STEP_VERSION, EPS, JOINT_MEASURES, JOINT_MOVED_MIN, RECORD_EPS, SIDES, applyPack, boundsOf, canonicalJson, checkInput, compareMeasure, countObstacleHits, countOutside, countOverlaps, countPortsOffBorder, documentHash, edgeStep, exercised, fnv1a32, grow, marginSides, minEffectOf, mulberry32, outputGroups, outputHash, overlapOf, packHard, placedRect, randomInt, rectInRegion, regionHitsRect, sha256Hex, stepRandom, toLayoutRecord, toPackInput, translate, turnBox, turnMargin, turnPoint, turnPort, turnRegion, turnSide };
 
 //# sourceMappingURL=index.js.map