@mark1russell7/layout-contract 0.0.0-stage → 0.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mark Russell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,47 @@
-# Temporary Holding Version
+# @mark1russell7/layout-contract
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The shared contract of two layout engines: [`packing`](https://github.com/mark1russell7/packing) places boxes, and [`highways`](https://github.com/mark1russell7/highways) routes the edges between them. Neither engine depends on the other. Both use this contract, so a placement and a routing compose.
+
+The package has no runtime dependencies.
+
+## The contents
+
+| Part | Exports |
+|---|---|
+| Geometry | `Point`, `Rect`, `Region`, `Side`, `Sides`, `Margin`, `marginSides`, `grow`, `boundsOf`, `translate`, `overlapOf` |
+| The input `layout-input/1` | `LayoutInput`, `LayoutBox` (`Item` for the packer), `Port`, `LayoutEdge`, `LayoutContainer`, `Obstacle`, `LayoutCell`, `LayoutGenerator` |
+| The packer | `PackInput`, `toPackInput`, `Placement`, `PackOutput`, `StageTrace`, `applyPack` |
+| The record `layout-record/1` | `LayoutRecord`, `Stage`, `Supports`, `RunFacts`, `RunEnv`, `toLayoutRecord` |
+| The strategies | `StrategyInfo` |
+| The measures | `MeasureSpec`, `Direction`, `JointMeasureId`, `JOINT_MEASURES`, `JOINT_MOVED_MIN` |
+| 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 rules
+
+- **The turn.** A turn is 90 degrees clockwise, with the y axis down. A point (`px`, `py`) of a box of height `h` goes to (`h - py`, `px`). Each side moves one step clockwise. The router gets the turned box and ports, and does not read `turn`.
+- **The margin.** A margin is a ring around a box. No other box and no route enters it. A route from a port of the box crosses the ring at a right angle.
+- **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 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
+
+```ts
+import { applyPack, packHard, toPackInput, type LayoutInput } from "@mark1russell7/layout-contract";
+
+const input: LayoutInput = {
+  schema: "layout-input/1",
+  id: "example",
+  container: { w: 200, fixed: "width" },
+  gap: 4,
+  boxes: [{ id: "a", w: 40, h: 20, margin: 2 }],
+};
+const output = myPacker(toPackInput(input));
+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.

package/build/index.d.ts

@@ -0,0 +1,421 @@
+/** A side of a box. The y axis points down, so `top` has the smallest y. */
+export type Side = "top" | "right" | "bottom" | "left";
+/** The sides in clockwise order, from the top. */
+export declare const SIDES: readonly Side[];
+export interface Point {
+  readonly x: number;
+  readonly y: number;
+}
+/** A rectangle: its top-left corner and its size. */
+export interface Rect {
+  readonly x: number;
+  readonly y: number;
+  readonly w: number;
+  readonly h: number;
+}
+/** A value for each side of a box. */
+export interface Sides {
+  readonly top: number;
+  readonly right: number;
+  readonly bottom: number;
+  readonly left: number;
+}
+/**
+ * A region. The forms and the rules are those of `docs/FORMAT.md` of `packing`.
+ * A ring of a polygon closes without a copy of its first point.
+ */
+export type Region = {
+  readonly kind: "rect";
+  readonly x: number;
+  readonly y: number;
+  readonly w: number;
+  readonly h: number;
+} | {
+  readonly kind: "polygon";
+  readonly points: readonly (readonly [number, number])[];
+  readonly holes?: readonly (readonly (readonly [number, number])[])[];
+} | {
+  readonly kind: "circle";
+  readonly cx: number;
+  readonly cy: number;
+  readonly r: number;
+} | {
+  readonly kind: "ellipse";
+  readonly cx: number;
+  readonly cy: number;
+  readonly rx: number;
+  readonly ry: number;
+};
+/** A margin: one value for the four sides, or one value for each side. */
+export type Margin = number | Sides;
+/** This function gives the value of each side of a margin. No margin gives 0 on each side. */
+export declare function marginSides(margin: Margin | undefined): Sides;
+/** This function gives the rectangle made larger by the margin on each side. */
+export declare function grow(rect: Rect, margin: Margin | undefined): Rect;
+/** This function gives the bounding box of a region. */
+export declare function boundsOf(region: Region): Rect;
+/** This function gives the region moved by `dx` and `dy`. */
+export declare function translate(region: Region, dx: number, dy: number): Region;
+/**
+ * This function gives the overlap of the insides of two rectangles on each axis.
+ * A value of 0 or less on an axis is no overlap. Two rectangles with a common edge have an overlap of 0.
+ */
+export declare function overlapOf(a: Rect, b: Rect): {
+  readonly x: number;
+  readonly y: number;
+};
+/** The epsilon for the float compares in an engine. */
+export declare const EPS = 1e-6;
+/**
+ * The epsilon for the float compares on a written file. A file rounds each number to 3 decimals,
+ * so a difference of two values can move by up to 0.001.
+ */
+export declare const RECORD_EPS = .001;
+/**
+ * The tolerance of each hard rule, in layout units. A record writes the tolerance that its run used,
+ * in its field `tolerance`, next to `hard`.
+ */
+export interface Tolerance {
+  /** Two boxes with their margins break `no-overlap` when their insides overlap by more than this on each axis. */
+  readonly overlap: number;
+  /** A route breaks `no-pass-through` when a part longer than this is inside a box made this much smaller. */
+  readonly through: number;
+}
+/**
+ * The default tolerance of each rule. The packer is exact, so `overlap` is one unit of the rounding.
+ * Routes are sampled curves that follow the margin line, so `through` is larger.
+ */
+export declare const DEFAULT_TOLERANCE: Tolerance;
+/**
+ * A port of a box: a place where edges go into the box.
+ * With `x` and `y`, the port is fixed on the border of the box, relative to its top-left corner.
+ * Without them, the router places the port on its `side`. Without a side, the router picks the side.
+ */
+export interface Port {
+  readonly id: string;
+  readonly side?: Side;
+  readonly x?: number;
+  readonly y?: number;
+}
+/** A box of an input. In the packer, its name is item. */
+export interface LayoutBox {
+  readonly id: string;
+  readonly w: number;
+  readonly h: number;
+  /** The packer writes the position. The router reads it. */
+  readonly x?: number;
+  readonly y?: number;
+  /** A locked box keeps `x` and `y`. The packer reads it as an obstacle. */
+  readonly locked?: boolean;
+  /** The reading order. Without it, the order of the array is the rank. */
+  readonly rank?: number;
+  readonly parent?: string;
+  readonly group?: string;
+  /** A region relative to the origin of the box. Without it, the box is the rectangle `w` by `h`. */
+  readonly shape?: Region;
+  readonly ports?: readonly Port[];
+  /** A ring around the box. No other box enters it. Only a route from a port of the box enters it, at a right angle. */
+  readonly margin?: Margin;
+  /** The packer can turn the box by 90 degrees. The output has the turned box and ports. */
+  readonly turnable?: boolean;
+  /** The free data of the node. The grouping rule `keys` of `highways` reads `data.group`. */
+  readonly data?: Readonly<Record<string, unknown>>;
+}
+/** The packer name of a box. It is the same type. */
+export type Item = LayoutBox;
+/** An edge between two boxes, with optional ports. */
+export interface LayoutEdge {
+  readonly id: string;
+  readonly source: string;
+  readonly target: string;
+  readonly sourcePort?: string;
+  readonly targetPort?: string;
+  readonly data?: Readonly<Record<string, unknown>>;
+}
+/** The container. `fixed` tells which sides of the size stay. */
+export interface LayoutContainer {
+  readonly w?: number;
+  readonly h?: number;
+  readonly fixed: "size" | "width" | "height" | "none";
+  /** The target aspect: the width divided by the height. The default is 1. */
+  readonly aspect?: number;
+  /** The weight of the aspect error in the objective. 0 gives the least area. The default is 1. */
+  readonly aspectWeight?: number;
+  /** The shape. Without it, the container is the rectangle from 0, 0 to `w`, `h`. */
+  readonly shape?: Region;
+  /** The space between the border and the boxes with their margins. */
+  readonly inset?: number;
+}
+/** An area that boxes and routes avoid. Without `move`, it stays. With `move`, the packer can move it for `cost` times the distance. */
+export interface Obstacle {
+  readonly id: string;
+  readonly region: Region;
+  readonly move?: {
+    readonly cost: number;
+  };
+}
+/** The generator of an input. The same name, version, parameters and seed give the same file, byte for byte. */
+export interface LayoutGenerator {
+  readonly name: string;
+  readonly version: number;
+  readonly params: Readonly<Record<string, unknown>>;
+  readonly seed: number;
+}
+/** The cell of an input in the taxonomy: one value for each dimension. The dimensions are in `docs/FORMAT.md` of `packing`. */
+export interface LayoutCell {
+  readonly containerSize?: "fixed" | "freeHeight" | "freeWidth" | "freeAspect" | "freeArea";
+  readonly containerShape?: "rect" | "convex" | "polygon" | "circle" | "ellipse" | "holes";
+  readonly obstacles?: "none" | "center" | "scattered" | "wall" | "corridors" | "touching" | "edge";
+  readonly sizes?: "identical" | "uniform" | "heavyTail" | "bimodal" | "extremeAspect" | "nearIdentical";
+  readonly count?: "1" | "10" | "100" | "1k" | "10k";
+  readonly mode?: "offline" | "online" | "incremental";
+  readonly edgeDensity?: "sparse" | "medium" | "dense";
+  readonly edgeShape?: "random" | "clustered" | "hubChain" | "longRange" | "tree" | "bundled";
+  readonly groups?: "none" | "flat" | "nested";
+  readonly ports?: "free" | "sides" | "fixed";
+}
+/** An input of the corpus: the format `layout-input/1`. */
+export interface LayoutInput {
+  readonly schema: "layout-input/1";
+  readonly id: string;
+  readonly set?: string;
+  readonly family?: string;
+  readonly seed?: number;
+  /** The origin: `made-up`, `published:<set>` or `known-best:<construction>`. */
+  readonly source?: string;
+  /** The first 16 hex characters of the SHA-256 of the canonical file without this field. */
+  readonly hash?: string;
+  /** The generator of the input. `null` or no value tells that a person made the input. */
+  readonly generator?: LayoutGenerator | null;
+  readonly cell?: LayoutCell;
+  /** The place of the input in a sequence of changes. */
+  readonly step?: number;
+  /** A router input can have no container. */
+  readonly container?: LayoutContainer;
+  /** The free space between two boxes with their margins. Routes use it. */
+  readonly gap?: number;
+  readonly boxes: readonly LayoutBox[];
+  readonly edges?: readonly LayoutEdge[];
+  readonly obstacles?: readonly Obstacle[];
+  /**
+   * A variant names its base input and its change.
+   * With `packed`, the variant is the packed output of its base input: the router routes the positions of that pack.
+   */
+  readonly base?: string;
+  readonly change?: "add" | "remove" | "resize" | "reorder" | "packed";
+}
+/** The input of a packer: a `layout-input/1` file without the edges. */
+export interface PackInput {
+  readonly container: LayoutContainer;
+  readonly items: readonly Item[];
+  readonly obstacles?: readonly Obstacle[];
+  readonly gap?: number;
+}
+/** This function gives the packer input of a file. An input without a container gets `{ fixed: "none" }`, so the packer picks the size. */
+export declare function toPackInput(input: LayoutInput): PackInput;
+/** The position of one item. `turn` is 90 when the packer turned a turnable item. */
+export interface Placement {
+  readonly id: string;
+  readonly x: number;
+  readonly y: number;
+  readonly turn?: 0 | 90;
+}
+/** The facts of one stage of a strategy, for the records and the site. */
+export interface StageTrace {
+  readonly id: string;
+  readonly ms?: number;
+  readonly measures?: Readonly<Record<string, number>>;
+}
+/** The output of a packer. It does not change the input. */
+export interface PackOutput {
+  readonly placements: readonly Placement[];
+  /** The ids of the items that the packer did not place. */
+  readonly overflow: readonly string[];
+  /** The size of the container after the pack. For a free size, the size that the search found. */
+  readonly size: {
+    readonly w: number;
+    readonly h: number;
+  };
+  /** The new top-left corner of the bounding box of each obstacle that moved. */
+  readonly moved: readonly {
+    readonly id: string;
+    readonly x: number;
+    readonly y: number;
+  }[];
+  readonly trace?: readonly StageTrace[];
+}
+/**
+ * This function gives the input with the output of a packer applied. Each placed box gets its position.
+ * A turned box gets its turned size, ports, margin and shape. Each moved obstacle moves.
+ * The container gets the size of the output. The router reads this result. It does not read `turn`.
+ */
+export declare function applyPack(input: LayoutInput, output: PackOutput): LayoutInput;
+/** The stage of a record: the packer, the router, or both together. */
+export type Stage = "pack" | "route" | "joint";
+/** One run of one strategy on one input and seed: the format `layout-record/1`. A run writes one line of JSON Lines. */
+export interface LayoutRecord {
+  readonly schema: "layout-record/1";
+  readonly stage: Stage;
+  readonly step: string;
+  readonly strategy: string;
+  /** The options in full, with the defaults. */
+  readonly options: Readonly<Record<string, unknown>>;
+  readonly corpus: string;
+  /** The id of the input. */
+  readonly input: string;
+  /** The `hash` of the input file. */
+  readonly inputHash: string;
+  readonly set: string;
+  readonly seed: number;
+  readonly nodes: number;
+  readonly edges: number;
+  /** The value of each measure, by its name: `pack.*`, `route.*` or `joint.*`. */
+  readonly measures: Readonly<Record<string, number>>;
+  /** The count of the breaks of each hard rule. A good run has 0 for each rule. */
+  readonly hard: Readonly<Record<string, number>>;
+  /** The tolerance of each hard rule of the run. */
+  readonly tolerance?: Readonly<Partial<Tolerance>>;
+  /** `true` when two runs with the same seed give the same positions. */
+  readonly deterministic: boolean;
+  /** The id of the prediction that was written before the run. */
+  readonly prediction?: string;
+  /** The median of `msRuns`, or the time of the one run. */
+  readonly ms: number;
+  /** The time of each timed repeat, in milliseconds. */
+  readonly msRuns?: readonly number[];
+  /**
+   * The first 16 hex characters of the SHA-256 of the canonical output of the stage.
+   * The packer hashes its placements by the order of the ids. The router hashes its routes by the order of the edge ids.
+   */
+  readonly outputHash?: string;
+  /** The facts of the computer of the run. */
+  readonly env?: RunEnv;
+  /** The reason when the strategy did not run, for example an input over its `maxNodes`. Then the record has no measures. */
+  readonly skipped?: string;
+  readonly commit?: string;
+}
+/**
+ * The values that a strategy supports, for each dimension of a taxonomy.
+ * The dimension names are in `docs/FORMAT.md` of `packing` and `docs/LAYOUT-RECORDS.md` of `highways`.
+ */
+export type Supports = Readonly<Record<string, readonly string[]>>;
+/** The facts of the computer of a run. */
+export interface RunEnv {
+  readonly node: string;
+  readonly os: string;
+  readonly arch: string;
+  /** The name of the runner, for example `ubuntu-latest` or `local`. */
+  readonly runner: string;
+  /** The model of the processor. */
+  readonly cpu: string;
+  /** The count of the logical processors. */
+  readonly cpus: number;
+}
+/** The facts of a run that the input does not give. */
+export type RunFacts = Omit<LayoutRecord, "schema" | "input" | "inputHash" | "set" | "nodes" | "edges">;
+/** This function gives the record of a run. The input gives its id, its hash, its set and the counts of the nodes and the edges. */
+export declare function toLayoutRecord(input: LayoutInput, run: RunFacts): LayoutRecord;
+/** This function gives the area of a placed box: its shape or its rectangle, at its position. A box without a position gives `undefined`. */
+export declare function placedRect(box: LayoutBox): Rect | undefined;
+/**
+ * This function counts the pairs of placed boxes whose insides, with their margins, overlap by more than `tolerance` on each axis.
+ * 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;
+/**
+ * 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.
+ * An input without a container gives 0.
+ */
+export declare function countOutside(input: LayoutInput, tolerance?: number): 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. */
+export interface PackHard {
+  readonly "no-overlap": number;
+  readonly "in-container": number;
+  readonly "locked-kept": number;
+  readonly complete: number;
+}
+/** 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 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.
+ */
+export declare function countObstacleHits(boxes: readonly LayoutBox[], obstacles: readonly Obstacle[] | undefined, tolerance?: number): number;
+/**
+ * This function gives the count of each hard rule of the output of a packer.
+ * It applies the output with `applyPack`. Only the placed boxes and the locked boxes count for the overlaps and the container.
+ * `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`.
+ * 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`.
+ */
+export declare function packHard(input: LayoutInput, output: PackOutput, tolerance?: number): 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.
+ */
+export declare function checkInput(input: LayoutInput): readonly string[];
+/** This function gives the side after a turn of 90 degrees clockwise. */
+export declare function turnSide(side: Side): Side;
+/** This function gives a point of a box of height `h` after the turn. */
+export declare function turnPoint(x: number, y: number, h: number): [number, number];
+/** This function gives a port of a box of height `h` after the turn. Each value of the port turns, also a port with only `x` or only `y`. */
+export declare function turnPort(port: Port, h: number): Port;
+/** This function gives a margin after the turn: the value of each side moves one side clockwise. */
+export declare function turnMargin(margin: Margin): Margin;
+/** This function gives a region relative to the origin of a box of height `h` after the turn. */
+export declare function turnRegion(region: Region, h: number): Region;
+/** This function gives a box after the turn: the size, the ports, the margin and the shape turn. The position stays. */
+export declare function turnBox(box: LayoutBox): LayoutBox;
+/** The direction of a measure: the side of the better values. */
+export type Direction = "lower" | "higher";
+/**
+ * The facts of one measure: its unit, its direction and its range.
+ * `floor` and `tol` are the parameters of the floor rule of the promotion rule (`docs/PROMOTION.md` of `highways`).
+ * Each engine exports the specs of its own measures. This package exports the specs of the `joint.*` measures.
+ */
+export interface MeasureSpec<Id extends string = string> {
+  readonly id: Id;
+  readonly unit: string;
+  readonly direction: Direction;
+  /** The lowest value. */
+  readonly min: number;
+  /** The highest value. The value `Infinity` tells that the measure has no upper limit. */
+  readonly max: number;
+  /** The family of the measure in the measure note of its engine. */
+  readonly family?: string;
+  /** The best value. Without it, the measure has no floor. */
+  readonly floor?: number;
+  /** The absolute tolerance at the floor. */
+  readonly tol?: number;
+  /** The role of the measure in the joint selector. */
+  readonly role?: "guard" | "change-guard" | "diagnostic" | "time";
+}
+/** The id of a joint measure. `docs/JOINT-MEASURES.md` gives the definitions. */
+export type JointMeasureId = "joint.fill" | "joint.aspectError" | "joint.spill" | "joint.straight.crossings" | "joint.straight.length" | "joint.stability.mean" | "joint.stability.moved" | "joint.proxy.rank" | "joint.ms";
+/** The specs of the joint measures, in the order of `docs/JOINT-MEASURES.md`. */
+export declare const JOINT_MEASURES: readonly MeasureSpec<JointMeasureId>[];
+/** The threshold of `joint.stability.moved`, in widths `W` of the base. */
+export declare const JOINT_MOVED_MIN = .01;
+/**
+ * The common fields of a strategy of an engine. Each engine adds its own function, for example `pack` or `route`.
+ * `O` is the type of the options, and `S` is the type of `supports`.
+ */
+export interface StrategyInfo<O = unknown, S extends Supports = Supports> {
+  /** A stable name, for example `shelf`. The records use it. */
+  readonly id: string;
+  /** The family of the catalog of the engine. */
+  readonly family: string;
+  /** The ids of the catalog rows that the strategy builds. */
+  readonly catalog: readonly string[];
+  /** For each dimension of the taxonomy, the values that the strategy supports. */
+  readonly supports: S;
+  /** The default options. A record writes the options in full. */
+  readonly defaults: O;
+  /** The value is `true` when the result depends only on the input, the options and the seed. */
+  readonly deterministic: boolean;
+}
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +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"],"mappings":"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"}