@mark1russell7/layout-contract 0.2.4 → 0.2.6

package/build/index.js

@@ -681,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) {
@@ -698,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}`));
@@ -914,6 +915,449 @@ 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, rectInRegion, 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;
+}
+// src/portfolio.ts
+/**
+* This function picks the best candidate. For each level, it finds the best value of the candidates that stay in.
+* It keeps each candidate that is not worse than that best value by `compareMeasure`.
+* The winner is the first candidate, in the given order, that stays in after the last level.
+* Without levels, the winner is the first candidate and `kept` is empty.
+*
+* The reason for the rule: a scan that compares each candidate with the current winner is not transitive, because of the `minEffect` ties.
+* Such a scan can drift away from the best value. An example: "a" is lower with the `minEffect` 0.005, and "b" is higher.
+* The candidates A (0, 1), B (0.004, 2) and C (0.008, 3) give the winner B.
+* The scan picks C, but A is better than C on "a".
+*
+* The function throws a `RangeError` for an empty list of candidates, for a missing value, and for a value that is not finite.
+*/
+function selectBest(candidates, levels) {
+	if (candidates.length === 0) throw new RangeError("selectBest: the list of candidates is empty.");
+	for (const level of levels) for (const c of candidates) {
+		const v = c.values[level.id];
+		if (typeof v !== "number") throw new RangeError(`selectBest: the candidate "${c.id}" has no value for the level "${level.id}".`);
+		if (!Number.isFinite(v)) throw new RangeError(`selectBest: the candidate "${c.id}" has the value ${v} for the level "${level.id}".`);
+	}
+	let alive = candidates;
+	const kept = [];
+	for (const level of levels) {
+		const at = (c) => c.values[level.id];
+		let best = at(alive[0]);
+		for (const c of alive) best = level.spec.direction === "lower" ? Math.min(best, at(c)) : Math.max(best, at(c));
+		alive = alive.filter((c) => compareMeasure(at(c), best, level.spec) !== "worse");
+		kept.push(alive.map((c) => c.id));
+	}
+	return {
+		winner: alive[0].id,
+		kept
+	};
+}
+/** This function gives the move `pick` of a pick: 1 when `picked` is true, else 0. A record keeps it as the trace measure `move.pick`. */
+function pickMoves(trace) {
+	return { pick: trace.picked ? 1 : 0 };
+}
+/** This function gives the default clock: `performance.now`, or `Date.now` without `performance`. */
+function defaultClock() {
+	const perf = globalThis.performance;
+	return perf ? () => perf.now() : () => Date.now();
+}
+/** This function gives the message of an error value. */
+function messageOf(e) {
+	return e instanceof Error ? e.message : String(e);
+}
+/** This function throws a `RangeError` for an empty list of members or for two members with the same id. */
+function checkMembers(id, members) {
+	if (members.length === 0) throw new RangeError(`The portfolio "${id}" has no members.`);
+	const seen = /* @__PURE__ */ new Set();
+	for (const m of members) {
+		if (seen.has(m.id)) throw new RangeError(`The portfolio "${id}" has two members with the id "${m.id}".`);
+		seen.add(m.id);
+	}
+}
+/**
+* This function makes a portfolio. Its `pick` starts the members in their order. `selectBest` picks the winner of the members with the status `ran`.
+* The first level is the hard level, then the levels of the key follow.
+* `members` is a list, or a function of the input that gives the list.
+*
+* A member that throws, or that gives a value that is not finite, gets the status `error`. It does not win.
+* When each member has an error, `pick` throws the error of the first member.
+* `docs/PORTFOLIO.md` tells the rules of the time limit, the trace and `picked`.
+*
+* The function throws a `RangeError` for a level with the id `hard`, for two levels with the same id and for a bad option.
+* It also throws a `RangeError` for an empty list of members, or for two members with the same id.
+*/
+function portfolio(id, members, key, options = {}) {
+	const levelIds = /* @__PURE__ */ new Set();
+	for (const level of key.levels) {
+		if (level.id === "hard") throw new RangeError(`The portfolio "${id}" has a level with the reserved id "hard".`);
+		if (levelIds.has(level.id)) throw new RangeError(`The portfolio "${id}" has two levels with the id "${level.id}".`);
+		levelIds.add(level.id);
+	}
+	const { budgetMs, maxMembers } = options;
+	if (budgetMs !== void 0 && !(budgetMs >= 0)) throw new RangeError(`The portfolio "${id}" has the budgetMs ${budgetMs}. It must be 0 or more.`);
+	if (maxMembers !== void 0 && !(Number.isInteger(maxMembers) && maxMembers >= 1)) throw new RangeError(`The portfolio "${id}" has the maxMembers ${maxMembers}. It must be a whole number of 1 or more.`);
+	if (typeof members !== "function") checkMembers(id, members);
+	const levels = [{
+		id: "hard",
+		spec: {
+			direction: "lower",
+			minEffect: 0
+		}
+	}, ...key.levels.map((l) => ({
+		id: l.id,
+		spec: l.spec
+	}))];
+	const now = options.now ?? defaultClock();
+	const evaluate = (m, input, output) => {
+		const values = {};
+		const measure = (level, f) => {
+			let v;
+			try {
+				v = f();
+			} catch (e) {
+				throw new RangeError(`The level "${level}" of the member "${m.id}" of the portfolio "${id}" throws: ${messageOf(e)}`, { cause: e });
+			}
+			if (typeof v !== "number" || !Number.isFinite(v)) throw new RangeError(`The member "${m.id}" of the portfolio "${id}" has the value ${v} for the level "${level}".`);
+			values[level] = v;
+		};
+		try {
+			measure("hard", () => key.hard(input, output));
+			for (const level of key.levels) measure(level.id, () => level.value(input, output));
+			let hash;
+			try {
+				hash = key.hash ? key.hash(output) : outputHash(output);
+			} catch (e) {
+				throw new RangeError(`The hash of the member "${m.id}" of the portfolio "${id}" throws: ${messageOf(e)}`, { cause: e });
+			}
+			return {
+				ok: true,
+				output,
+				values,
+				hash
+			};
+		} catch (e) {
+			return {
+				ok: false,
+				error: e
+			};
+		}
+	};
+	const pick = (input) => {
+		const list = typeof members === "function" ? members(input) : members;
+		if (typeof members === "function") checkMembers(id, list);
+		const start = now();
+		const traces = [];
+		const outputs = /* @__PURE__ */ new Map();
+		const ran = [];
+		let firstError;
+		let cut = 0;
+		let outOfTime = false;
+		for (let i = 0; i < list.length; i++) {
+			const m = list[i];
+			if (maxMembers !== void 0 && i >= maxMembers) {
+				traces.push({
+					id: m.id,
+					status: "cut"
+				});
+				cut++;
+				continue;
+			}
+			if (i > 0 && budgetMs !== void 0 && (outOfTime || now() - start >= budgetMs)) {
+				outOfTime = true;
+				traces.push({
+					id: m.id,
+					status: "cut"
+				});
+				cut++;
+				continue;
+			}
+			const t0 = now();
+			let result;
+			let ms;
+			try {
+				const output = m.run(input);
+				ms = now() - t0;
+				result = evaluate(m, input, output);
+			} catch (e) {
+				ms = now() - t0;
+				result = {
+					ok: false,
+					error: e
+				};
+			}
+			if (result.ok) {
+				traces.push({
+					id: m.id,
+					status: "ran",
+					values: result.values,
+					ms,
+					outputHash: result.hash
+				});
+				outputs.set(m.id, result.output);
+				ran.push({
+					id: m.id,
+					values: result.values
+				});
+			} else {
+				traces.push({
+					id: m.id,
+					status: "error",
+					ms,
+					error: messageOf(result.error)
+				});
+				firstError ??= { error: result.error };
+			}
+		}
+		if (ran.length === 0) throw firstError.error;
+		const { winner, kept } = selectBest(ran, levels);
+		const winnerIndex = traces.findIndex((t) => t.id === winner);
+		const base = traces[0];
+		const trace = {
+			members: traces,
+			winner,
+			winnerIndex,
+			picked: winnerIndex > 0 && (base.status !== "ran" || traces[winnerIndex].outputHash !== base.outputHash),
+			totalMs: now() - start,
+			...budgetMs !== void 0 ? { budgetMs } : {},
+			...maxMembers !== void 0 ? { maxMembers } : {},
+			cut,
+			deterministic: !outOfTime,
+			kept
+		};
+		return {
+			output: outputs.get(winner),
+			winner,
+			trace
+		};
+	};
+	return {
+		id,
+		pick,
+		run: (input) => pick(input).output
+	};
+}
+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, pickMoves, placedRect, portfolio, randomInt, rectInRegion, regionHitsRect, selectBest, sha256Hex, stepRandom, toLayoutRecord, toPackInput, translate, turnBox, turnMargin, turnPoint, turnPort, turnRegion, turnSide };
 
 //# sourceMappingURL=index.js.map