@mark1russell7/layout-contract 0.2.9 → 0.2.11

package/README.md

@@ -21,7 +21,11 @@ The package has no runtime dependencies.
 | 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 families | `familyOf`, `FamilyBy`, `FamilyCell`, `FAMILY_ANY_KIND` |
+| The verdict | `verdict`, `VerdictOptions`, `VerdictResult`, `VerdictRecord`, `VerdictSide`, `VerdictInterval`, `FamilyVerdict`, `VerdictPermutation`, `VerdictSignTest`, `VerdictLabel`, `VERDICT_EXACT_MAX`, `VERDICT_EXACT_CAP`, `VERDICT_RUNS`, `VERDICT_DRAWS`, `VERDICT_SEED` |
 | The split files | `checkSplit`, `splitFolds`, `leaveOneSeedOut`, `splitFileName`, `SPLIT_SCHEMA`, `CorpusSplit`, `SplitFold`, `SplitCorpus` |
+| The strategy space | `StrategySpace`, `SpaceStage`, `StageOption`, `SpaceParam`, `ParamWhen`, `MemberRule`, `SpaceConstraint`, `OptionRef`, `StrategyConfig`, `StageChoice`, `ParamKind`, `ParamValue`, `STRATEGY_SPACE_SCHEMA` |
+| The space functions | `checkSpace`, `checkConfig`, `canonicalConfig`, `configId`, `spaceSize`, `paramLevels`, `enumerateSpace`, `productSpace`, `joinConfigs`, `splitConfig`, `SpaceSize`, `SpaceSizeOptions`, `EnumerateOptions`, `GridOptions`, `SampleOptions` |
 | 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` |
@@ -37,6 +41,7 @@ The package has no runtime dependencies.
 - **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 verdict.** `verdict` compares two strategies on one measure, with the family as the unit. A verdict counts only when it holds for the mean of the family means and for the mean of the inputs.
 - **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
@@ -56,4 +61,6 @@ 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 corpus checks and the split files are in `docs/CORPUS-CHECKS.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`. The strategy space is in [`docs/STRATEGY-SPACE.md`](https://github.com/mark1russell7/layout-contract/blob/main/docs/STRATEGY-SPACE.md).
+
+The verdict over families is in [`docs/VERDICT.md`](https://github.com/mark1russell7/layout-contract/blob/main/docs/VERDICT.md).

package/build/index.d.ts

@@ -714,7 +714,30 @@ export interface DeclaredClaim {
   readonly thin: readonly string[];
   /** The count of the inputs for each property id. */
   readonly counts: Readonly<Record<string, number>>;
+  /** The key of the family of an input. `familyOf` gives the key of one cell. The family is the unit of a verdict. */
+  readonly familyBy?: FamilyBy;
+  /** The minimum count of the inputs of each family. Without it, `checkDeclared` does not count the families. */
+  readonly familyMin?: number;
 }
+/**
+ * The key of the family of a cell (`docs/CORPUS-CHECKS.md`).
+ *
+ * - The flat form is a list of dimensions. The key is the values of these dimensions of the cell, in order, with `/` between them.
+ * - The map form chooses an entry by the field `kind` of the cell, or the entry `"*"`. The key is the kind, then the values of the dimensions of the entry.
+ */
+export type FamilyBy = readonly string[] | {
+  readonly [kind: string]: readonly string[];
+};
+/** A cell of an input: one value for each dimension. The map form of `FamilyBy` also reads the field `kind`. */
+export type FamilyCell = Readonly<Record<string, unknown>>;
+/** The entry of the map form of `FamilyBy` for each kind without its own entry. */
+export declare const FAMILY_ANY_KIND = "*";
+/**
+ * This function gives the family key of a cell. It throws a `RangeError` when the cell does not have a dimension of the key.
+ * In the map form, it also throws for a cell without `kind`, and for a kind with no entry and no entry `"*"`.
+ * For example, `{ "rect-grid": ["obstacles"], "*": [] }` gives `rect-grid/wall` for a `rect-grid` cell and `gallery` for a `gallery` cell.
+ */
+export declare function familyOf(cell: FamilyCell, familyBy: FamilyBy): string;
 /** The hook that gives the ids of the properties that one input declares. */
 export type Declares<I> = (input: I) => readonly string[];
 /**
@@ -734,8 +757,14 @@ export declare function declaredClaimOf(manifest: object): DeclaredClaim | undef
  * - 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`.
+ *
+ * With `claim.familyBy`, the hook `cellOf` gives the cell of each input. The default reads the field `cell` of the input.
+ *
+ * - Each cell has each dimension of its key. In the map form, each cell has a `kind`, and the kind has an entry or the entry `"*"` is there.
+ * - Two cells with different dimension values do not give the same key.
+ * - With `claim.familyMin`, each family has `familyMin` inputs or more.
  */
-export declare function checkDeclared<I>(inputs: Iterable<I>, declares: Declares<I>, claim: DeclaredClaim, ids?: readonly string[]): ClaimBreak[];
+export declare function checkDeclared<I>(inputs: Iterable<I>, declares: Declares<I>, claim: DeclaredClaim, ids?: readonly string[], cellOf?: (input: I) => FamilyCell | undefined): ClaimBreak[];
 /** The id and the hash of one input of a corpus. */
 export interface CorpusEntry {
   readonly id: string;
@@ -790,4 +819,289 @@ export declare function checkSplit(split: unknown, corpus: SplitCorpus, name?: s
 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[];
+/** The schema of a strategy space. */
+export declare const STRATEGY_SPACE_SCHEMA = "strategy-space/1";
+/** The kind of a param: a whole number, a real number, one value of a list, or `true` and `false`. */
+export type ParamKind = "int" | "real" | "enum" | "bool";
+/** The value of one param in a config. */
+export type ParamValue = number | string | boolean;
+/** The condition of a conditional param: the param is active only when an earlier param of the same option has one of the values `in`. */
+export interface ParamWhen {
+  /** The name of an earlier param of the same option. */
+  readonly param: string;
+  /** The values of that param that make this param active. */
+  readonly in: readonly ParamValue[];
+}
+/** One param of a stage option, with its range. */
+export interface SpaceParam {
+  readonly name: string;
+  readonly kind: ParamKind;
+  /** The smallest value of an `int` or `real` param. */
+  readonly min?: number;
+  /** The largest value of an `int` or `real` param. */
+  readonly max?: number;
+  /** The step of the values from `min`. An `int` param has the step 1 by default. */
+  readonly step?: number;
+  /** The scale of the grid and of the samples. The scale `log` needs a `min` above 0. The default is `linear`. */
+  readonly scale?: "linear" | "log";
+  /** The values of an `enum` param. */
+  readonly values?: readonly (string | number)[];
+  /** The value that a config gets when it does not set the param. */
+  readonly default: ParamValue;
+  /** Without `when`, the param is active each time its option is chosen. */
+  readonly when?: ParamWhen;
+}
+/** The rule of the members of a meta option: a count from `min` to `max`. Members with `ordered: false` are sorted by their `configId`. */
+export interface MemberRule {
+  readonly min: number;
+  readonly max: number;
+  readonly ordered: boolean;
+}
+/** One implementation of a stage. An option with `members` is a meta option: it chooses between whole configs, or wraps them. */
+export interface StageOption {
+  readonly id: string;
+  readonly params: readonly SpaceParam[];
+  readonly members?: MemberRule;
+}
+/** One stage of the pipeline of an engine. A config of an `optional` stage can have no option. */
+export interface SpaceStage {
+  readonly name: string;
+  readonly options: readonly StageOption[];
+  readonly optional?: boolean;
+}
+/** A reference to one option of a stage. The option `null` refers to an optional stage that a config does not use. */
+export interface OptionRef {
+  readonly stage: string;
+  readonly option: string | null;
+}
+/** A rule that keeps out invalid combinations. A config with the option `if` also has the option `then`, or does not have the option `then.not`. */
+export interface SpaceConstraint {
+  readonly if: OptionRef;
+  readonly then: OptionRef | {
+    readonly not: OptionRef;
+  };
+}
+/** The strategy space of an engine: the stages, the constraints and the named configs. `docs/STRATEGY-SPACE.md` tells the rules. */
+export interface StrategySpace {
+  readonly schema: typeof STRATEGY_SPACE_SCHEMA;
+  /** The name of the space. A config names the space with this value. */
+  readonly engine: string;
+  /** The version of the space. It is not part of a config or of its id. A record writes it. */
+  readonly version: string;
+  readonly stages: readonly SpaceStage[];
+  readonly constraints?: readonly SpaceConstraint[];
+  /** The named strategies of the engine, as points of the space. Old records stay comparable through them. */
+  readonly named?: Readonly<Record<string, StrategyConfig>>;
+  /** The spaces of a product space, from `productSpace`. A meta option of a part takes members of that part. */
+  readonly parts?: readonly StrategySpace[];
+}
+/** The choice of one stage in a config: an option, its params and, for a meta option, its members. */
+export interface StageChoice {
+  readonly option: string;
+  /** The values of the active params. A param that is not set gets its default. */
+  readonly params?: Readonly<Record<string, ParamValue>>;
+  /** The members of a meta option: configs of the same space, with no meta option. */
+  readonly members?: readonly StrategyConfig[];
+}
+/** One point of a strategy space. The value `null` of a stage tells that the config does not use the optional stage. */
+export interface StrategyConfig {
+  /** The `engine` of the space, without its version. */
+  readonly space: string;
+  readonly stages: Readonly<Record<string, StageChoice | null>>;
+}
+/** The count of the grid points of a space. */
+export interface SpaceSize {
+  /** The count of the configs without a meta option. */
+  readonly base: bigint;
+  /** The count of the configs with a meta option. The value is `null` when the count is more than `maxMeta`. */
+  readonly meta: bigint | null;
+}
+/** The options of `spaceSize`. */
+export interface SpaceSizeOptions {
+  /** The count of the levels of each numeric param, a whole number of 1 or more. */
+  readonly levels: number;
+  /** The largest meta count that `spaceSize` gives. The default is `10n ** 18n`. */
+  readonly maxMeta?: bigint;
+}
+/** The options of a grid. The grid gives only the configs without a meta option. */
+export interface GridOptions {
+  readonly mode: "grid";
+  readonly levels: number;
+  /** The largest count of configs. A larger grid causes a `RangeError`. The default is 100000. */
+  readonly limit?: number;
+}
+/** The options of a sample. */
+export interface SampleOptions {
+  readonly mode: "sample";
+  /** The count of the configs, a whole number of 0 or more. */
+  readonly n: number;
+  readonly seed: number;
+  /** With `skip` (the default), the sample has no meta option. With `sample`, a meta option draws its members from base samples. */
+  readonly meta?: "skip" | "sample";
+  /** The largest count of option draws. The default is the larger value of 1000 and `100 * n`. */
+  readonly maxTries?: number;
+}
+/** The options of `enumerateSpace`. */
+export type EnumerateOptions = GridOptions | SampleOptions;
+/**
+ * This function checks one config of a space. It gives one break for each problem. An empty list tells that the config is good.
+ * The `claim` of a break is the kind of the problem, for example `missing`, `unknown`, `inactive`, `param`, `constraint`, `members` or `depth`.
+ */
+export declare function checkConfig(space: StrategySpace, config: StrategyConfig): ClaimBreak[];
+/**
+ * This function checks a space. It gives one break for each problem. An empty list tells that the space is good.
+ * It finds duplicate names, empty ranges, defaults out of range, enums without values, bad log scales, unknown names and bad named configs.
+ * The `inputs` of a break of a named config have the name of the config.
+ */
+export declare function checkSpace(space: StrategySpace): ClaimBreak[];
+/**
+ * This function gives the canonical form of a config: each stage of the space, the active params only, the defaults, and stable numbers.
+ * An unused optional stage is `null`. The members of an unordered meta option are sorted by their `configId`.
+ * It throws an `Error` for a config with a break of `checkConfig`.
+ */
+export declare function canonicalConfig(space: StrategySpace, config: StrategyConfig): StrategyConfig;
+/**
+ * This function gives the id of a config: the first 16 hex characters of the SHA-256 of `canonicalJson` of `canonicalConfig`.
+ * Two spellings of one config get one id. The version of the space is not part of the id.
+ */
+export declare function configId(space: StrategySpace, config: StrategyConfig): string;
+/**
+ * This function gives the grid values of one param, in increasing order. An `enum` gives its values, and a `bool` gives `false` and `true`.
+ * With 1 level, a numeric param gives its default. With k levels, it gives k points from `min` to `max` on its scale and step, without repeats.
+ */
+export declare function paramLevels(param: SpaceParam, levels: number): ParamValue[];
+/**
+ * This function gives the count of the grid points of a space, with `levels` levels for each numeric param.
+ * It counts only the active params and the combinations that keep the constraints. It gives the meta configs apart.
+ */
+export declare function spaceSize(space: StrategySpace, options: SpaceSizeOptions): SpaceSize;
+/**
+ * This function gives configs of a space, in their canonical form. Each config keeps the constraints. The result is deterministic.
+ *
+ * - The mode `grid` gives each grid point without a meta option, in a stable order. Stages, options and values go in the order of the space.
+ * - The mode `sample` gives `n` configs of a seeded Latin hypercube. The options of a stage get equal strata, and each active param gets its own strata.
+ * - A sample draws again when a point breaks a constraint. After `maxTries` draws, it throws an `Error`. Two sampled configs can be equal.
+ */
+export declare function enumerateSpace(space: StrategySpace, options: EnumerateOptions): StrategyConfig[];
+/**
+ * This function joins configs of the parts of a product space into one config of the space `space`.
+ * The name of each stage gets the prefix `<space of the part>.`. The members of a meta option do not change.
+ */
+export declare function joinConfigs(space: string, parts: readonly StrategyConfig[]): StrategyConfig;
+/** This function gives the config of the part `engine` of a joint config. It throws a `RangeError` when no stage has the prefix `<engine>.`. */
+export declare function splitConfig(config: StrategyConfig, engine: string): StrategyConfig;
+/**
+ * This function joins two spaces, for example a packer and a router, into the space `name`. The stages of `a` and `b` get the prefixes `<a.engine>.` and `<b.engine>.`.
+ * The constraints get the same prefixes. The named configs are the pairs `<name of a>+<name of b>`. It throws a `RangeError` when the two engines have the same name.
+ */
+export declare function productSpace(a: StrategySpace, b: StrategySpace, name: string): StrategySpace;
+/**
+ * The largest count of inputs for the exact permutation test. Up to this count, the test enumerates all `2^n` sign sets.
+ * At 16 inputs, that is 65 536 sign sets, approximately 3 times the default draws. Above it, the cost doubles with each input, so the test uses seeded draws.
+ */
+export declare const VERDICT_EXACT_MAX = 16;
+/** The largest value of the option `exactMax`. At 20 inputs, the exact test has approximately 1 million sign sets. */
+export declare const VERDICT_EXACT_CAP = 20;
+/** The default count of the samples of each bootstrap. It is the parameter `bootstrapRuns` of `docs/PROMOTION.md`. */
+export declare const VERDICT_RUNS = 1e4;
+/** The default count of the random sign sets of the permutation test above `VERDICT_EXACT_MAX` inputs. */
+export declare const VERDICT_DRAWS = 2e4;
+/** The default seed of the bootstraps and of the random sign sets. */
+export declare const VERDICT_SEED = 1;
+/** The fields of a record that the verdict reads. */
+export type VerdictRecord = Pick<LayoutRecord, "strategy" | "input" | "seed" | "measures"> & {
+  readonly skipped?: string;
+};
+/** One side of a verdict: a strategy id, or a test that selects the records of the side. */
+export type VerdictSide<R extends VerdictRecord = VerdictRecord> = string | ((record: R) => boolean);
+/** The arguments of `verdict`. `tie` and `level` have no default. */
+export interface VerdictOptions<R extends VerdictRecord = VerdictRecord> {
+  /** The unit of the verdict. The family is the only unit. */
+  readonly by: "family";
+  /** The hook that gives the family of a record, for example `familyOf` of the cell of its input. */
+  readonly family: (record: R) => string;
+  /** The measure. Its direction tells which side is better. */
+  readonly measure: Pick<MeasureSpec, "id" | "direction">;
+  /** The baseline side. */
+  readonly a: VerdictSide<R>;
+  /** The candidate side. A positive difference tells that `b` is better than `a`. */
+  readonly b: VerdictSide<R>;
+  /**
+   * The minimum effect of the sign of a family, as `minEffect` of `MeasureSpec`. A smaller change of the family mean is a tie.
+   * `compareMeasure` compares the two family means, so the smallest tie is one grid step of `RECORD_EPS`.
+   */
+  readonly tie: number | {
+    readonly rel: number;
+  };
+  /** The significance level, from 0 to 1. The permutation p must be below it. The intervals have the level `1 - level`. */
+  readonly level: number;
+  /** The count of the samples of each bootstrap. The default is `VERDICT_RUNS`. */
+  readonly runs?: number;
+  /** The count of the random sign sets above the exact limit. The default is `VERDICT_DRAWS`. */
+  readonly draws?: number;
+  /** The seed of the bootstraps and of the random sign sets. The default is `VERDICT_SEED`. */
+  readonly seed?: number;
+  /** The largest count of inputs for the exact test. The default is `VERDICT_EXACT_MAX`. The value 0 always uses draws. */
+  readonly exactMax?: number;
+}
+/** A mean with its bootstrap interval. The interval is clear of 0 when `lo > 0` or `hi < 0`. */
+export interface VerdictInterval {
+  readonly mean: number;
+  readonly lo: number;
+  readonly hi: number;
+}
+/** The difference of one family: the count of its inputs, the mean of their differences and its sign. */
+export interface FamilyVerdict {
+  readonly family: string;
+  readonly n: number;
+  readonly mean: number;
+  /** The value 1 tells that `b` is better, -1 that `b` is worse, and 0 a tie by `tie`. */
+  readonly sign: -1 | 0 | 1;
+}
+/** The stratified paired permutation test. With `exact`, `draws` is the count of all the sign sets. */
+export interface VerdictPermutation {
+  readonly p: number;
+  readonly exact: boolean;
+  readonly draws: number;
+  readonly seed: number;
+}
+/** The two-sided exact sign test of the family signs. It is a report only. Ties do not count. */
+export interface VerdictSignTest {
+  readonly wins: number;
+  readonly losses: number;
+  readonly ties: number;
+  readonly p: number;
+}
+/** The label of a verdict. `better` and `worse` tell the side of `b`. */
+export type VerdictLabel = "better" | "worse" | "depends on the mix" | "no verdict";
+/** The result of `verdict`. */
+export interface VerdictResult {
+  readonly measure: string;
+  /** The count of the paired inputs. */
+  readonly n: number;
+  /** The mean of the family means, with a bootstrap of the seeds inside each family. */
+  readonly stratified: VerdictInterval;
+  /** The mean of the inputs, with a bootstrap of the inputs. */
+  readonly pooled: VerdictInterval;
+  readonly permutation: VerdictPermutation;
+  /** The families, in sort order. */
+  readonly families: readonly FamilyVerdict[];
+  readonly signTest: VerdictSignTest;
+  /** `true` only when the two means have the same sign, the two intervals are clear of 0 and the permutation p is below `level`. */
+  readonly agree: boolean;
+  readonly label: VerdictLabel;
+  /** The inputs without a pair: one side has no record, a skipped record or no value of the measure. */
+  readonly dropped: readonly string[];
+}
+/**
+ * This function gives the verdict of the candidate `b` against the baseline `a` on one measure, with the family as the unit (`docs/VERDICT.md`).
+ *
+ * - It pairs the records by input and seed. The difference of a pair is `b - a` for a measure where more is better, else `a - b`.
+ * - `stratified` is the mean of the family means. Its bootstrap draws the seeds inside each family. `pooled` is the mean of the inputs.
+ * - The permutation test changes the sign of each difference inside its family. Its statistic is the mean of the family means.
+ * - The label is `better` or `worse` only when `agree` is `true`. Opposite signs of the two means give `depends on the mix`.
+ *
+ * It throws a `RangeError` for a missing `tie` or `level`, and for no pair. Two records of one side and input, or a value that is not finite, also cause a `RangeError`.
+ */
+export declare function verdict<R extends VerdictRecord>(records: Iterable<R>, options: VerdictOptions<R>): VerdictResult;
 //# 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","../src/corpus.ts"],"mappings":";YACY;;qBAGC,gBAAgB;iBAEZ;WACN;WACA;;;iBAIM;WACN;WACA;WACA;WACA;;;iBAIM;WACN;WACA;WACA;WACA;;;;;;YAOC;WACG;WAAuB;WAAoB;WAAoB;WAAoB;;WAEnF;WACA;WACA;;WAEA;WAAyB;WAAqB;WAAqB;;WACnE;WAA0B;WAAqB;WAAqB;WAAqB;;;YAG5F,kBAAkB;;wBAGd,YAAY,QAAQ,qBAAqB;;wBAOzC,KAAK,MAAM,MAAM,QAAQ,qBAAqB;;wBAM9C,SAAS,QAAQ,SAAS;;wBAyB1B,UAAU,QAAQ,QAAQ,YAAY,aAAa;;;;;wBAoBnD,UAAU,GAAG,MAAM,GAAG;WAAkB;WAAoB;;;qBCtG/D;;;;;qBAMA;;;;;qBAMA;;;;;iBAMI;;WAEN;;WAEA;;;;;;qBAOE,mBAAmB;;;;;;iBCvBf;WACN;WACA,OAAO;WACP;WACA;;;iBAIM;WACN;WACA;WACA;;WAEA;WACA;;WAEA;;WAEA;WACA;WACA;;WAEA,QAAQ;WACR,iBAAiB;;WAEjB,SAAS;;WAET;;WAEA,OAAO,SAAS;;;YAIf,OAAO;;iBAGF;WACN;WACA;WACA;WACA;WACA;WACA,OAAO,SAAS;;;iBAIV;WACN;WACA;WACA;;WAEA;;WAEA;;WAEA,QAAQ;;WAER;;;iBAIM;WACN;WACA,QAAQ;WACR;aAAkB;;;;iBAIZ;WACN;WACA;WACA,QAAQ,SAAS;WACjB;;;iBAIM;WACN;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;;iBAIM;WACN;WACA;WACA;WACA;WACA;;WAEA;;WAEA;;WAEA,YAAY;;WAEZ,iBAAiB;WACjB,OAAO;;WAEP;;WAEA,YAAY;;WAEZ;WACA,gBAAgB;WAChB,iBAAiB;WACjB,qBAAqB;;;;;WAKrB;WACA;;;iBAIM;WACN,WAAW;WACX,gBAAgB;WAChB,qBAAqB;WACrB;;;wBAIK,YAAY,OAAO,cAAc;;iBCrIhC;WACN;WACA;WACA;WACA;;;iBAIM;WACN;WACA;WACA,WAAW,SAAS;;;iBAId;WACN,qBAAqB;;WAErB;;WAEA;aAAiB;aAAoB;;;WAErC;aAA2B;aAAqB;aAAoB;;WACpE,iBAAiB;;;;;;;wBAQZ,UAAU,OAAO,aAAa,QAAQ,aAAa;;YChCvD;;iBAGK;WACN;WACA,OAAO;WACP;WACA;;WAEA,SAAS,SAAS;WAClB;;WAEA;;WAEA;WACA;WACA;WACA;WACA;;WAEA,UAAU,SAAS;;WAEnB,MAAM,SAAS;;WAEf,YAAY,SAAS,QAAQ;;WAE7B;;WAEA;;WAEA;;WAEA;;;;;WAKA;;WAEA,MAAM;;WAEN;WACA;;;;;;YAOC,WAAW,SAAS;;iBAGf;WACN;WACA;WACA;;WAEA;;WAEA;;WAEA;;;YAIC,WAAW,KAAK;;wBAGZ,eAAe,OAAO,aAAa,KAAK,WAAW;;wBClEnD,WAAW,KAAK,YAAY;;;;;wBAW5B,cAAc,gBAAgB,aAAa;;iBAqB1C;;;;;WAKN;;;;;;;;;;wBAWK,aAAa,OAAO,aAAa,oBAA+C,UAAS;;wBAsBzF,oBAAoB,gBAAgB,aAAa;;iBAehD;WACN;WACA;WACA;WACA;;;wBAIK,eAAe,QAAQ,QAAQ,MAAM;;;;;wBAgCrC,aAAa,QAAQ,QAAQ,MAAM;;;;;wBAqHnC,kBACd,gBAAgB,aAChB,oBAAoB,wBACpB;;;;;;;;;;;wBAwBc,SAAS,OAAO,aAAa,QAAQ,YAAY,oBAA+C,UAAS,gBAAqB;;;;;wBAiC9H,WAAW,OAAO;;wBCzSlB,SAAS,MAAM,OAAO;;wBAKtB,UAAU,WAAW,WAAW;;wBAKhC,SAAS,MAAM,MAAM,YAAY;;wBAWjC,WAAW,QAAQ,SAAS;;wBAO5B,WAAW,QAAQ,QAAQ,YAAY;;wBAkBvC,QAAQ,KAAK,YAAY;;YCtD7B;;;;;;iBAOK,YAAY;WAClB,IAAI;WACJ;WACA,WAAW;;WAEX;;WAEA;;WAEA;;WAEA;;WAEA;;;;;WAKA;aAAgC;;;WAEhC;;;YAIC;;qBAYC,yBAAyB,YAAY;;qBAarC;;YAGD;;;;;;wBAOI,YAAY,MAAM,KAAK,2BAA2B,YAAO;;;;;;;wBAezD,eAAe,mBAAmB,kBAAkB,MAAM,KAAK,0CAA0C;;;;;iBC9ExG,aAAa,aAAa,UAAU,WAAW;;WAErD;;WAEA;;WAEA;;WAEA,UAAU;;WAEV,UAAU;;WAEV;;;wBCfK,WAAW;;wBAWX,QAAQ;;wBAOR,WAAW,cAAc;;wBAKzB,UAAU,iBAAiB,YAAY;;;;;YClB3C;;iBAGK;WACN;WACA,WAAW;;WAEX;;WAEA;;WAEA;;;qBAIE,cAAc,SAAS,OAAO;;qBAG9B;;;;;;wBAgBG,SAAS,OAAO,aAAa,QAAQ,gBAAgB,gBAAiC;;;;;wBC1BtF,UAAU;;;;;wBAuDV,cAAc;;iBAWb;;;;;WAKN;;;;;;;;;;;wBAuCK,WAAW,gBAAgB,UAAS;;;;;wBAQpC,aAAa,aAAa,UAAS;;iBAMlC;;WAEN;;WAEA;;;;;;;;wBASK,aAAa,QAAQ,SAAS,qCAAqC;;iBAqBlE;;WAEN,QAAQ,SAAS;;WAEjB;;WAEA;;;;;;;;wBASK,UAAU,UAAU;;YCzLxB,WAAW,KAAK;;iBAGX,OAAO,GAAG;WAChB;;EAET,IAAI,OAAO,IAAI;;;iBAIA,eAAe,GAAG;;WAExB;WACA,MAAM;;EAEf,MAAM,OAAO,GAAG,QAAQ;;;iBAIT,aAAa,GAAG;;EAE/B,KAAK,OAAO,GAAG,QAAQ;;WAEd,iBAAiB,eAAe,GAAG;;EAE5C,MAAM,QAAQ;;;iBAIC;;WAEN;;WAEA;;WAEA;;;;;WAKA;;;YAIC;;iBAGK;WACN;WACA,QAAQ;;WAER,SAAS,SAAS;;WAElB;;;;;WAKA;;WAEA;;;iBAIM;;WAEN,kBAAkB;WAClB;;WAEA;;WAEA;;WAEA;WACA;WACA;;WAEA;;WAEA;;WAEA;;;iBAIM,cAAc;WACpB,QAAQ;WACR;WACA,OAAO;;;iBAID,UAAU,GAAG,WAAW,OAAO,GAAG;;EAEjD,KAAK,OAAO,IAAI,cAAc;;;iBAIf;WACN;WACA,QAAQ,SAAS;;;iBAIX;WACN;WACA,MAAM;;;iBAIA;WACN;;WAEA;;;;;;;;;;;;;;;wBAgBK,WAAW,qBAAqB,mBAAmB,iBAAiB,gBAAgB;;wBAsBpF,UAAU,OAAO,KAAK;EAA8B;;;;;;;;;;;;;;wBAwCpD,UAAU,GAAG,GAC3B,YACA,kBAAkB,OAAO,GAAG,SAAS,OAAO,eAAe,OAAO,GAAG,OACrE,KAAK,aAAa,GAAG,IACrB,UAAS,mBACR,UAAU,GAAG;;iBCpMC;;WAEN;;WAEA;;WAEA;;;iBAIM;;WAEN;;WAEA;;WAEA,QAAQ,SAAS;;;YAIhB,SAAS,MAAM,OAAO;;;;;wBAMlB,eAAe,GAAG,QAAQ,SAAS,IAAI,UAAU,SAAS,IAAI,0BAA8B;;;;;wBAa5F,gBAAgB,mBAAmB;;;;;;;;;wBAwBnC,cAAc,GAAG,QAAQ,SAAS,IAAI,UAAU,SAAS,IAAI,OAAO,eAAe,0BAAqD;;iBAkBvI;WACN;WACA;;;;;;wBAOK,aAAa,gBAAgB,iBAAiB;;qBAKjD;;iBAGI;WACN;WACA;;;iBAIM;WACN,eAAe;WACf;;WAEA;;WAEA,QAAQ,SAAS;aAA0B,gBAAgB;;;;iBAIrD;WACN;WACA;aAA2B;;WAC3B,iBAAiB;;;wBAIZ,cAAc,gBAAgB;;;;;;;;;wBAe9B,WAAW,gBAAgB,QAAQ,aAAa,gBAAgB;;;;;wBA2ChE,WAAW,gBAAgB,QAAQ,aAAa,cAAc,iBAAmC;;wBAUjG,gBAAgB,2BAA2B"}
+{"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","../src/strategy-space.ts","../src/verdict.ts"],"mappings":"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"}