@mark1russell7/layout-contract 0.2.7 → 0.2.9

package/README.md

@@ -20,6 +20,8 @@ The package has no runtime dependencies.
 | The promotion guards | `outputGroups`, `OutputGroup`, `exercised`, `ExerciseEvidence` |
 | The portfolio | `portfolio`, `Portfolio`, `PortfolioKey`, `PortfolioLevel`, `PortfolioOptions`, `PortfolioPick`, `PortfolioTrace`, `Member`, `MemberTrace`, `MemberStatus`, `pickMoves` |
 | The pick rule | `selectBest`, `SelectCandidate`, `SelectLevel`, `Selection`, `PickSpec` |
+| The corpus checks | `ClaimBreak`, `checkDeclared`, `declaredCounts`, `declaredClaimOf`, `DeclaredClaim`, `Declares`, `corpusHashOf`, `CorpusEntry` |
+| The split files | `checkSplit`, `splitFolds`, `leaveOneSeedOut`, `splitFileName`, `SPLIT_SCHEMA`, `CorpusSplit`, `SplitFold`, `SplitCorpus` |
 | The turn | `turnBox`, `turnPort`, `turnMargin`, `turnRegion`, `turnSide`, `turnPoint` |
 | The tolerances | `EPS`, `RECORD_EPS`, `RECORD_SCALE`, `Tolerance`, `DEFAULT_TOLERANCE` |
 | The hard rules | `countOverlaps`, `countObstacleHits`, `regionHitsRect`, `rectInRegion`, `countOutside`, `ContainerTest`, `countPortsOffBorder`, `packHard`, `PackHard`, `placedRect`, `checkInput` |
@@ -34,6 +36,7 @@ The package has no runtime dependencies.
 - **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 corpus checks.** `checkDeclared` and `checkSplit` give a list of `ClaimBreak`. An empty list tells that each claim is true. `corpusHashOf` gives the corpus hash of `packing`.
 - **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
@@ -53,4 +56,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 promotion guards are in `docs/PROMOTION.md`. The portfolio and its pick rule are in `docs/PORTFOLIO.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`. The portfolio and its pick rule are in `docs/PORTFOLIO.md`. The corpus checks and the split files are in `docs/CORPUS-CHECKS.md`.

package/build/index.d.ts

@@ -595,6 +595,11 @@ export interface PortfolioOptions {
   readonly maxMembers?: number;
   /** The clock in milliseconds. The default is `performance.now`, or `Date.now` without `performance`. */
   readonly now?: () => number;
+  /**
+   * The members that get an output hash. The default `all` hashes each member with the status `ran`. A hash that throws then gives the status `error`.
+   * With `pick`, only member 0 and the winner get a hash, and only when the winner is not member 0. Then a hash that throws makes `pick` throw.
+   */
+  readonly hashes?: "all" | "pick";
 }
 /** The status of a member in a pick. */
 export type MemberStatus = "ran" | "cut" | "error";
@@ -606,7 +611,10 @@ export interface MemberTrace {
   readonly values?: Readonly<Record<string, number>>;
   /** The time of the run of the member, in milliseconds. */
   readonly ms?: number;
-  /** The hash of the output of the member. */
+  /**
+   * The hash of the output of the member. Under the option `hashes` "all" (the default), each member with the status `ran` has it.
+   * Under `hashes` "pick", it is absent, except for member 0 and the winner when the winner is not member 0.
+   */
   readonly outputHash?: string;
   /** The message of the error of a member with the status `error`. */
   readonly error?: string;
@@ -689,4 +697,97 @@ export declare function pickMoves(trace: Pick<PortfolioTrace, "picked">): {
  * It also throws a `RangeError` for an empty list of members, or for two members with the same id.
  */
 export declare function portfolio<I, O>(id: string, members: readonly Member<I, O>[] | ((input: I) => readonly Member<I, O>[]), key: PortfolioKey<I, O>, options?: PortfolioOptions): Portfolio<I, O>;
+/** One broken claim of a corpus, with the ids of the inputs that break it. */
+export interface ClaimBreak {
+  /** The name of the claim, for example `declared`, `split` or `index`. */
+  readonly claim: string;
+  /** The text of the break. */
+  readonly detail: string;
+  /** The ids of the inputs that break the claim. The list is empty when the break has no input. */
+  readonly inputs: readonly string[];
+}
+/** The claim `claims.declared` of a manifest: the count of the inputs for each declared property. */
+export interface DeclaredClaim {
+  /** A property with fewer inputs than this count is thin. */
+  readonly minCount: number;
+  /** The ids of the properties with a count below `minCount`. */
+  readonly thin: readonly string[];
+  /** The count of the inputs for each property id. */
+  readonly counts: Readonly<Record<string, number>>;
+}
+/** The hook that gives the ids of the properties that one input declares. */
+export type Declares<I> = (input: I) => readonly string[];
+/**
+ * This function gives the count of the inputs for each property id. Each id of `ids` has a count, also when the count is 0.
+ * An id from `declares` that is not in `ids` comes after the ids of `ids`, in the order of the first input that declares it.
+ */
+export declare function declaredCounts<I>(inputs: Iterable<I>, declares: Declares<I>, ids?: readonly string[]): Record<string, number>;
+/**
+ * This function reads the field `claims.declared` of a manifest. A manifest without it gives `undefined`.
+ * It throws an `Error` for a claim without a whole `minCount`, a list `thin` of ids and a whole count for each id.
+ */
+export declare function declaredClaimOf(manifest: object): DeclaredClaim | undefined;
+/**
+ * This function checks the claim `claims.declared` against the inputs. It gives one break `declared` for each problem. An empty list tells that the claim is true.
+ *
+ * - `ids` are the property ids. The default is the ids of `claim.counts`.
+ * - Each id of `ids` has a count in `claim.counts`, and `claim.counts` has no other id. Each count is the count of the inputs.
+ * - An id with a count below `minCount` is in `thin`. Each id of `thin` is an id of `ids`.
+ * - Each id that `declares` gives is an id of `ids`.
+ */
+export declare function checkDeclared<I>(inputs: Iterable<I>, declares: Declares<I>, claim: DeclaredClaim, ids?: readonly string[]): ClaimBreak[];
+/** The id and the hash of one input of a corpus. */
+export interface CorpusEntry {
+  readonly id: string;
+  readonly hash: string;
+}
+/**
+ * This function gives the hash of a corpus: the first 16 hex characters of a SHA-256. The text of the SHA-256 is `canonicalJson`
+ * of the corpus id and the `[id, hash]` of each input, in the order of the manifest. A change of one input changes the hash.
+ */
+export declare function corpusHashOf(corpus: string, inputs: readonly CorpusEntry[]): string;
+/** The schema of a split file. */
+export declare const SPLIT_SCHEMA = "corpus-split/1";
+/** One fold of a split: the seeds that fit a selector and the seeds that score it. */
+export interface SplitFold {
+  readonly train: readonly number[];
+  readonly heldOut: readonly number[];
+}
+/** A split file `corpus-split/1`. Its name is `<corpus id>.<corpus hash>.json`. It is beside the corpus, so the corpus does not change. */
+export interface CorpusSplit {
+  readonly schema: typeof SPLIT_SCHEMA;
+  readonly corpus: string;
+  /** The hash of the corpus: `corpusHashOf` of its manifest. */
+  readonly corpusHash: string;
+  /** The splits by name. Each split has one fold or more. */
+  readonly splits: Readonly<Record<string, {
+    readonly folds: readonly SplitFold[];
+  }>>;
+}
+/** The fields of a manifest that the split check reads. */
+export interface SplitCorpus {
+  readonly corpus: string;
+  readonly specs: readonly {
+    readonly seeds: readonly number[];
+  }[];
+  readonly inputs: readonly CorpusEntry[];
+}
+/** This function gives the name of the split file of a corpus. */
+export declare function splitFileName(corpus: string, hash: string): string;
+/**
+ * This function checks a split file against a manifest. It gives one break `split` for each problem. An empty list tells that the file is good.
+ *
+ * - The schema is `corpus-split/1`, the corpus is the id of the manifest and `corpusHash` is `corpusHashOf` of the manifest.
+ * - Each split has one fold or more. In each fold, `train` and `heldOut` are lists of seeds, not empty and with no common seed.
+ * - Each seed is a seed of a spec of the manifest.
+ * - With `name`, the file has the split `name`.
+ */
+export declare function checkSplit(split: unknown, corpus: SplitCorpus, name?: string): ClaimBreak[];
+/**
+ * This function gives a copy of the folds of the split `name` of a split file. `where` names the file in the text of an error.
+ * It throws an `Error` for each problem of `checkSplit`, and then for an unknown split name.
+ */
+export declare function splitFolds(split: unknown, corpus: SplitCorpus, name: string, where?: string): SplitFold[];
+/** This function gives the folds that hold out one seed each, in the order of the seeds. Each fold trains on the other seeds. */
+export declare function leaveOneSeedOut(seeds: readonly number[]): SplitFold[];
 //# 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","../src/hash.ts","../src/portfolio.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","../src/portfolio.ts","../src/corpus.ts"],"mappings":"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"}

package/build/index.js

@@ -1233,9 +1233,10 @@ function portfolio(id, members, key, options = {}) {
 		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;
+	const { budgetMs, maxMembers, hashes = "all" } = 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 (hashes !== "all" && hashes !== "pick") throw new RangeError(`The portfolio "${id}" has the hashes ${String(hashes)}. It must be "all" or "pick".`);
 	if (typeof members !== "function") checkMembers(id, members);
 	const levels = [{
 		id: "hard",
@@ -1248,6 +1249,14 @@ function portfolio(id, members, key, options = {}) {
 		spec: l.spec
 	}))];
 	const now = options.now ?? defaultClock();
+	/** This function gives the hash of the output of a member. A hash that throws causes a `RangeError`. */
+	const hashOf = (m, output) => {
+		try {
+			return 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 });
+		}
+	};
 	const evaluate = (m, input, output) => {
 		const values = {};
 		const measure = (level, f) => {
@@ -1263,17 +1272,16 @@ function portfolio(id, members, key, options = {}) {
 		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 });
-			}
+			if (hashes === "pick") return {
+				ok: true,
+				output,
+				values
+			};
 			return {
 				ok: true,
 				output,
 				values,
-				hash
+				hash: hashOf(m, output)
 			};
 		} catch (e) {
 			return {
@@ -1326,7 +1334,12 @@ function portfolio(id, members, key, options = {}) {
 				};
 			}
 			if (result.ok) {
-				traces.push({
+				traces.push(result.hash === void 0 ? {
+					id: m.id,
+					status: "ran",
+					values: result.values,
+					ms
+				} : {
 					id: m.id,
 					status: "ran",
 					values: result.values,
@@ -1351,6 +1364,10 @@ function portfolio(id, members, key, options = {}) {
 		if (ran.length === 0) throw firstError.error;
 		const { winner, kept } = selectBest(ran, levels);
 		const winnerIndex = traces.findIndex((t) => t.id === winner);
+		if (hashes === "pick" && winnerIndex > 0 && traces[0].status === "ran") for (const i of [0, winnerIndex]) traces[i] = {
+			...traces[i],
+			outputHash: hashOf(list[i], outputs.get(traces[i].id))
+		};
 		const base = traces[0];
 		const trace = {
 			members: traces,
@@ -1376,6 +1393,153 @@ function portfolio(id, members, key, options = {}) {
 		run: (input) => pick(input).output
 	};
 }
-export { DEFAULT_TOLERANCE, EDGE_DENSITY, EDGE_STEP_VERSION, EPS, JOINT_MEASURES, JOINT_MOVED_MIN, RECORD_EPS, RECORD_SCALE, 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 };
+// src/corpus.ts
+/**
+* This function gives the count of the inputs for each property id. Each id of `ids` has a count, also when the count is 0.
+* An id from `declares` that is not in `ids` comes after the ids of `ids`, in the order of the first input that declares it.
+*/
+function declaredCounts(inputs, declares, ids = []) {
+	const out = Object.fromEntries(ids.map((id) => [id, 0]));
+	for (const input of inputs) for (const id of declares(input)) out[id] = (out[id] ?? 0) + 1;
+	return out;
+}
+/** This function tells if a value is a plain object. */
+const isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+/**
+* This function reads the field `claims.declared` of a manifest. A manifest without it gives `undefined`.
+* It throws an `Error` for a claim without a whole `minCount`, a list `thin` of ids and a whole count for each id.
+*/
+function declaredClaimOf(manifest) {
+	const claims = manifest["claims"];
+	if (claims === void 0) return void 0;
+	if (!isObject(claims)) throw new Error("The field claims of a corpus file is an object.");
+	const declared = claims["declared"];
+	if (declared === void 0) return void 0;
+	if (!isObject(declared)) throw new Error("The field claims.declared of a corpus file is an object.");
+	const { minCount, thin, counts } = declared;
+	if (!Number.isInteger(minCount) || minCount < 0) throw new Error("The field claims.declared.minCount is a whole number of 0 or more.");
+	if (!Array.isArray(thin) || !thin.every((id) => typeof id === "string")) throw new Error("The field claims.declared.thin is a list of property ids.");
+	if (!isObject(counts) || !Object.values(counts).every((n) => Number.isInteger(n) && n >= 0)) throw new Error("The field claims.declared.counts gives a whole count for each property id.");
+	return {
+		minCount,
+		thin: [...thin],
+		counts: { ...counts }
+	};
+}
+/**
+* This function checks the claim `claims.declared` against the inputs. It gives one break `declared` for each problem. An empty list tells that the claim is true.
+*
+* - `ids` are the property ids. The default is the ids of `claim.counts`.
+* - Each id of `ids` has a count in `claim.counts`, and `claim.counts` has no other id. Each count is the count of the inputs.
+* - An id with a count below `minCount` is in `thin`. Each id of `thin` is an id of `ids`.
+* - Each id that `declares` gives is an id of `ids`.
+*/
+function checkDeclared(inputs, declares, claim, ids = Object.keys(claim.counts)) {
+	const computed = declaredCounts(inputs, declares, ids);
+	const out = [];
+	for (const id of ids) if (!(id in claim.counts)) out.push(`the property "${id}" has no count`);
+	else if (claim.counts[id] !== computed[id]) out.push(`the property "${id}" has the count ${claim.counts[id]}, but the inputs give ${computed[id]}`);
+	for (const id of Object.keys(claim.counts)) if (!ids.includes(id)) out.push(`"${id}" is not a declared property`);
+	for (const id of ids) if ((computed[id] ?? 0) < claim.minCount && !claim.thin.includes(id)) out.push(`the property "${id}" has ${computed[id]} inputs, below minCount ${claim.minCount}, and it is not in thin`);
+	for (const id of claim.thin) if (!ids.includes(id)) out.push(`"${id}" of thin is not a declared property`);
+	for (const id of Object.keys(computed)) if (!ids.includes(id)) out.push(`${computed[id]} inputs declare "${id}", which is not a declared property`);
+	return out.map((detail) => ({
+		claim: "declared",
+		detail,
+		inputs: []
+	}));
+}
+/**
+* This function gives the hash of a corpus: the first 16 hex characters of a SHA-256. The text of the SHA-256 is `canonicalJson`
+* of the corpus id and the `[id, hash]` of each input, in the order of the manifest. A change of one input changes the hash.
+*/
+function corpusHashOf(corpus, inputs) {
+	return sha256Hex(canonicalJson({
+		corpus,
+		inputs: inputs.map((i) => [i.id, i.hash])
+	})).slice(0, 16);
+}
+/** The schema of a split file. */
+const SPLIT_SCHEMA = "corpus-split/1";
+/** This function gives the name of the split file of a corpus. */
+function splitFileName(corpus, hash) {
+	return `${corpus}.${hash}.json`;
+}
+/** This function tells if a value is a list of whole numbers. */
+const isSeeds = (value) => Array.isArray(value) && value.every((s) => Number.isInteger(s));
+/**
+* This function checks a split file against a manifest. It gives one break `split` for each problem. An empty list tells that the file is good.
+*
+* - The schema is `corpus-split/1`, the corpus is the id of the manifest and `corpusHash` is `corpusHashOf` of the manifest.
+* - Each split has one fold or more. In each fold, `train` and `heldOut` are lists of seeds, not empty and with no common seed.
+* - Each seed is a seed of a spec of the manifest.
+* - With `name`, the file has the split `name`.
+*/
+function checkSplit(split, corpus, name) {
+	const out = [];
+	const done = () => out.map((detail) => ({
+		claim: "split",
+		detail,
+		inputs: []
+	}));
+	const f = split;
+	if (f === null || typeof f !== "object") {
+		out.push("the split file is not an object");
+		return done();
+	}
+	if (f.schema !== "corpus-split/1") out.push(`the schema is ${String(f.schema)}, not ${SPLIT_SCHEMA}`);
+	if (f.corpus !== corpus.corpus) out.push(`the corpus is ${String(f.corpus)}, not ${corpus.corpus}`);
+	const hash = corpusHashOf(corpus.corpus, corpus.inputs);
+	if (f.corpusHash !== hash) out.push(`the corpusHash is ${String(f.corpusHash)}, but the corpus gives ${hash}`);
+	const seeds = new Set(corpus.specs.flatMap((s) => s.seeds));
+	if (f.splits === null || typeof f.splits !== "object") {
+		out.push("the field splits is not an object");
+		return done();
+	}
+	for (const [key, value] of Object.entries(f.splits)) {
+		const folds = value?.folds;
+		if (!Array.isArray(folds) || folds.length === 0) {
+			out.push(`the split ${key} has no folds`);
+			continue;
+		}
+		folds.forEach((fold, k) => {
+			const at = `the fold ${k} of the split ${key}`;
+			const { train, heldOut } = fold ?? {};
+			if (!isSeeds(train) || train.length === 0) out.push(`${at} has no train seeds`);
+			if (!isSeeds(heldOut) || heldOut.length === 0) out.push(`${at} has no heldOut seeds`);
+			if (!isSeeds(train) || !isSeeds(heldOut)) return;
+			const common = train.filter((s) => heldOut.includes(s));
+			if (common.length > 0) out.push(`${at} has the seeds ${common.join(", ")} in train and in heldOut`);
+			const unknown = [...train, ...heldOut].filter((s) => !seeds.has(s));
+			if (unknown.length > 0) out.push(`${at} has the seeds ${unknown.join(", ")}, which are not in the corpus`);
+		});
+	}
+	if (name !== void 0 && !Object.hasOwn(f.splits, name)) out.push(`the split file has no split ${name}. Its splits are ${Object.keys(f.splits).join(", ")}`);
+	return done();
+}
+/**
+* This function gives a copy of the folds of the split `name` of a split file. `where` names the file in the text of an error.
+* It throws an `Error` for each problem of `checkSplit`, and then for an unknown split name.
+*/
+function splitFolds(split, corpus, name, where = "The split file") {
+	const breaks = checkSplit(split, corpus);
+	if (breaks.length > 0) throw new Error(`${where} is not good: ${breaks.map((b) => b.detail).join("; ")}.`);
+	const splits = split.splits;
+	const found = Object.hasOwn(splits, name) ? splits[name] : void 0;
+	if (found === void 0) throw new Error(`${where} has no split ${name}. Its splits are ${Object.keys(splits).join(", ")}.`);
+	return found.folds.map((f) => ({
+		train: [...f.train],
+		heldOut: [...f.heldOut]
+	}));
+}
+/** This function gives the folds that hold out one seed each, in the order of the seeds. Each fold trains on the other seeds. */
+function leaveOneSeedOut(seeds) {
+	const sorted = [...new Set(seeds)].sort((a, b) => a - b);
+	return sorted.map((s) => ({
+		train: sorted.filter((t) => t !== s),
+		heldOut: [s]
+	}));
+}
+export { DEFAULT_TOLERANCE, EDGE_DENSITY, EDGE_STEP_VERSION, EPS, JOINT_MEASURES, JOINT_MOVED_MIN, RECORD_EPS, RECORD_SCALE, SIDES, SPLIT_SCHEMA, applyPack, boundsOf, canonicalJson, checkDeclared, checkInput, checkSplit, compareMeasure, corpusHashOf, countObstacleHits, countOutside, countOverlaps, countPortsOffBorder, declaredClaimOf, declaredCounts, documentHash, edgeStep, exercised, fnv1a32, grow, leaveOneSeedOut, marginSides, minEffectOf, mulberry32, outputGroups, outputHash, overlapOf, packHard, pickMoves, placedRect, portfolio, randomInt, rectInRegion, regionHitsRect, selectBest, sha256Hex, splitFileName, splitFolds, stepRandom, toLayoutRecord, toPackInput, translate, turnBox, turnMargin, turnPoint, turnPort, turnRegion, turnSide };
 
 //# sourceMappingURL=index.js.map