@mark1russell7/highways 0.9.4 → 0.9.6

package/build/index.d.ts

@@ -98,6 +98,13 @@ export interface Port {
    * A plug with `along` needs a `side` and has no `at`. `resolvePorts` throws a `RangeError` for a bad value.
    */
   readonly along?: number;
+  /**
+   * This interval of the side holds a free plug of the port (PORT-RANGE). Its values go from 0 to 1, as the values of `along`.
+   * Each plug rule and `fixPorts` keep the plug in this interval, and keep the order and the gap of the rule.
+   * When the interval is too short for the gap, the gap shrinks evenly. A fixed plug does not read the range.
+   * `resolvePorts` throws a `RangeError` for a bad range.
+   */
+  readonly range?: readonly [number, number];
 }
 /** A node: a box that routes must not go through. */
 export interface Node {
@@ -210,12 +217,15 @@ export declare function nodeIndex(g: Graph): Map<string, Node>;
  * A plug with `at` gives `at`. A plug with `side` and `along` gives the point of `portPoint` of `@mark1russell7/layout-contract`.
  */
 export declare function portOffset(box: Box, port: Port): Point | undefined;
-/** This function throws a `RangeError` when the `along` of a plug is bad: not finite, outside 0 to 1, without `side` or with `at`. */
+/**
+ * This function throws a `RangeError` when the `along` of a plug is bad: not finite, outside 0 to 1, without `side` or with `at`.
+ * It also throws a `RangeError` for a bad `range` of a plug. A bad range has a value that is not finite or is outside 0 to 1, or a start after its end.
+ */
 export declare function checkPort(node: Node, port: Port): void;
 /**
  * This function checks the plugs of a graph, and gives each plug with `side` and `along` a fixed `at`. The plug keeps its `side`.
  * Each router calls it at the start of `route`, so all routers agree. A graph without `along` comes back as the same object.
- * It throws a `RangeError` for a bad `along` (`checkPort`).
+ * It throws a `RangeError` for a bad `along` or a bad `range` (`checkPort`).
  */
 export declare function resolvePorts(graph: Graph): Graph;
 /** This function gives the absolute place of a fixed plug, or `undefined` for a free plug or no plug. A plug with `side` and `along` is fixed. */
@@ -395,7 +405,7 @@ export declare function sideToward(box: Box, toward: Point): Side;
 export declare function pointOnSide(box: Box, side: Side, toward: Point, inset?: number): Point;
 /**
  * This function places the plug of one end of an edge. A fixed plug stays at its point. A plug with a side stays on that side.
- * The router places a free plug on the side that faces `toward`.
+ * The router places a free plug on the side that faces `toward`. A free plug of a port with a `range` stays in that range (`clampToRange`).
  */
 export declare function placePlug(node: Node, end: End, toward: Point): Plug;
 /** The options of the inflection rule. */
@@ -1914,6 +1924,8 @@ interface SharedSearch {
     seq: Point[];
     ids: number[];
   } | undefined;
+  /** This function gives the free space across the link from corner `i` to corner `j` (`channelWidth`). The router keeps each width that it finds. */
+  width(i: number, j: number): number;
 }
 /**
  * The hooks of a router that `shared` runs (WILD-023, RULE-021). The router `shared` itself has no hooks.
@@ -1983,6 +1995,147 @@ export declare function annealingRouter(options: Partial<AnnealingOptions> & {
  * A screen module or a consumer adds it to a registry.
  */
 export declare const annealingStrategy: Strategy<"router", AnnealingOptions>;
+/** The options of the router `canals` (NAT-004: canalization feeder trees to hubs). */
+interface CanalOptions {
+  /** The exponent `mu` of the flux in the growth of a conductance, from 1 to 3 in steps of 0.5. A value above 1 gives a tree. The default is 2. */
+  readonly mu: number;
+  /** The largest number of updates of the conductances, from 30 to 150. The updates stop when the ways do not change for 3 updates. The default is 60. */
+  readonly steps: number;
+  /** The decay `r` of a conductance, from 0.5 to 2. The default is 1. */
+  readonly decay: number;
+  /** A hub has this number of edges of one key or more, from 2 to 8. The default is 3. */
+  readonly minMembers: number;
+}
+/** The default options of the router `canals`. */
+export declare const CANAL_DEFAULTS: Readonly<CanalOptions>;
+/** The declarations of the options of the router `canals` (NAT-004). */
+export declare const CANAL_SCHEMA: OptionSchema<CanalOptions>;
+/**
+ * This function gives `x^mu` for `x` from 0 to 1 and `mu` in steps of 0.5, with only `*` and `Math.sqrt`.
+ * These operations are exact to the last bit on each platform, so a decision does not depend on the engine.
+ */
+export declare function halfPower(x: number, mu: number): number;
+/** A hub: a node, the key of its edges, and the ways of those edges. */
+interface CanalHub {
+  readonly node: string;
+  readonly key: string;
+  readonly ways: readonly Way[];
+}
+/**
+ * This function gives the hubs of the ways. In each key, the node with the most ends is a hub when it has `minMembers` edges or more.
+ * Its edges leave the key, and the next hub of the key comes from the edges that stay. A tie goes to the smaller node id.
+ * An edge with no key is in no hub.
+ */
+export declare function canalHubs(ways: readonly Way[], minMembers: number): CanalHub[];
+/**
+ * This function grows a feeder tree to each hub (NAT-004, after the canalization of Sachs 1981 and Mitchison 1980).
+ * Each member edge is a source of one unit of flux, and the hub is the sink. The flux of a link is the share of the members whose ways use it.
+ * At each update, each conductance changes by `DT × (flux^mu - decay × D)`, and each member finds its way again with the cost `d / (1 + GAIN × D)`.
+ * A link that another way of the key uses costs half, as in `shared`.
+ * With `mu` above 1, a link with more flux grows faster, so the ways gather into one tree. The updates stop after `steps`, or when no way changes for 3 updates.
+ */
+export declare function canalWays(ways: readonly Way[], search: SharedSearch, options?: Partial<CanalOptions>): void;
+/**
+ * This function makes the router `canals` (NAT-004). It is the router `shared`, then the feeder trees of `canalWays` to the hubs of each key.
+ * The runs and the bundles come from the ways after the trees.
+ */
+export declare function canalRouter(options: Partial<CanalOptions> & {
+  readonly name: string;
+  readonly rule?: GroupRule;
+  readonly maxNodes?: number;
+}): Router;
+/**
+ * The router strategy `canals` (NAT-004), with the rule `byCollection` of `shared`. It is not a built-in router, so the benchmark and the hashes of `ROUTERS` do not change.
+ * A screen module or a consumer adds it to a registry.
+ */
+export declare const canalStrategy: Strategy<"router", CanalOptions>;
+/** The options of the router `adam` (RULE-020: Adam with a seeded sample of pairs). */
+interface AdamOptions {
+  /** The first step size `eta0`, in units of `clearance`, from 0.01 to 1. The step size falls to a tenth of it at the last step. The default is 0.1. */
+  readonly eta: number;
+  /** The number of other legs that each leg samples at each step, from 4 to 32. The default is 8. */
+  readonly samples: number;
+  /** The number of steps: the budget of the search, from 100 to 2000. The default is 200. */
+  readonly steps: number;
+  /** The seed of the samples, a whole number from 0. The same seed gives the same routes. The default is 1. */
+  readonly seed: number;
+  /** A leg nearer than this distance to another leg or to a box gets a push, from 4 to 32. The default is 8. */
+  readonly clearance: number;
+}
+/** The default options of the router `adam`. */
+export declare const ADAM_DEFAULTS: Readonly<AdamOptions>;
+/** The declarations of the options of the router `adam` (RULE-020). */
+export declare const ADAM_SCHEMA: OptionSchema<AdamOptions>;
+/**
+ * This function moves the free legs of the routes of `result` with Adam (RULE-020, after Kingma and Ba 2015, and the SGD layouts of Zheng, Pawar and Goodman 2019).
+ * A leg is free when its two points are inside its route, and no other route, run or trunk holds them. The variable of a leg is a shift along its normal.
+ * The energy of a leg is `Σ (1 - d / c)²` over a seeded sample of `samples` other legs nearer than `c`. The near boxes add the same term times 4.
+ * A term `0.05 × (t / c)²` holds each leg near its first place. The step size falls from `eta` to a tenth of it, with only `+`, `*` and `/`.
+ * A moved route goes back to its first points when it has more crossings than before, or a break of a hard rule.
+ * When the output still has more crossings than the routes of `shared`, it is the routes of `shared`.
+ */
+export declare function adamRoutes(input: Graph, result: Result, options?: Partial<AdamOptions>): Result;
+/**
+ * This function makes the router `adam` (RULE-020). It is the router `shared`, then the steps of Adam of `adamRoutes`.
+ * The runs and the bundles of `shared` stay, because no point of a run or of a trunk moves.
+ */
+export declare function adamRouter(options: Partial<AdamOptions> & {
+  readonly name: string;
+  readonly rule?: GroupRule;
+  readonly maxNodes?: number;
+}): Router;
+/**
+ * The router strategy `adam` (RULE-020), with the rule `byCollection` of `shared`. It is not a built-in router, so the benchmark and the hashes of `ROUTERS` do not change.
+ * A screen module or a consumer adds it to a registry.
+ */
+export declare const adamStrategy: Strategy<"router", AdamOptions>;
+/** The options of the router `reroute` (RULE-044: a corner graph with the prices of the rules, and rounds of rip-up and reroute). */
+interface RerouteOptions {
+  /** The price of a link in a narrow channel, from 0 to 2. The default is 1. */
+  readonly alpha: number;
+  /** The price of each edge of another key on a link, from 0 to 2. The default is 0.5. */
+  readonly beta: number;
+  /** The discount of a link that an edge of the same key uses, from 0 to 2. The default is 0.5. */
+  readonly gamma: number;
+  /** The price of a turn, in units of `clearance`, from 0 to 2. The default is 0.25. */
+  readonly tau: number;
+  /** The number of rounds of rip-up and reroute, from 1 to 5. The default is 2. */
+  readonly rounds: number;
+  /** The share of the edges that each round rips up: the edges with the largest price over their direct length, from 0.05 to 0.3. The default is 0.15. */
+  readonly q: number;
+  /** A channel narrower than this width gets the price `alpha`, from 4 to 64. The default is 16. */
+  readonly clearance: number;
+}
+/** The default options of the router `reroute`. */
+export declare const REROUTE_DEFAULTS: Readonly<RerouteOptions>;
+/** The declarations of the options of the router `reroute` (RULE-044). */
+export declare const REROUTE_SCHEMA: OptionSchema<RerouteOptions>;
+/** This function gives the number of turns of a way: the points where the direction changes by more than 1 degree. */
+export declare function turnsOf(seq: readonly Point[]): number;
+/**
+ * This function rips up and reroutes the ways of `shared` (RULE-044, after the rip-up and reroute of PathFinder, McMurchie 1995).
+ * The price factor of a link is `max(0.05, 1 + alpha × narrow + beta × others - gamma × same)`.
+ * `narrow` is `max(0, 1 - width / clearance)`. `others` counts the edges of the other keys on the link.
+ * `same` is 1 when an edge of the same key uses the link.
+ * The price of a way is the sum of the price factor times the length of each link, plus `tau × clearance` for each turn.
+ * Each round takes the share `q` of the ways with the largest price over their direct length. Each one gets a new search with the prices of the links.
+ * The new way stays only when its price is lower. The search has no state for the turns, so only the comparison reads `tau`.
+ */
+export declare function rerouteWays(ways: readonly Way[], search: SharedSearch, options?: Partial<RerouteOptions>): void;
+/**
+ * This function makes the router `reroute` (RULE-044). It is the router `shared`, then the rounds of rip-up and reroute of `rerouteWays`.
+ * The runs and the bundles come from the ways after the rounds.
+ */
+export declare function rerouteRouter(options: Partial<RerouteOptions> & {
+  readonly name: string;
+  readonly rule?: GroupRule;
+  readonly maxNodes?: number;
+}): Router;
+/**
+ * The router strategy `reroute` (RULE-044), with the rule `byCollection` of `shared`. It is not a built-in router, so the benchmark and the hashes of `ROUTERS` do not change.
+ * A screen module or a consumer adds it to a registry.
+ */
+export declare const rerouteStrategy: Strategy<"router", RerouteOptions>;
 /** The edges that go first: the edges with few good ways (`tight`), or the edges with many good ways (`loose`). */
 type TightFirst = "tight" | "loose";
 /** The values of `TightFirst`. */
@@ -2275,6 +2428,92 @@ export declare const SPREAD_DEFAULTS: Required<SpreadOptions>;
  * The output has one entry for each edge with two known nodes, in the order of the edges.
  */
 export declare function spreadEnds(input: PlugInput, options?: SpreadOptions): PlugPair[];
+/**
+ * The order and the places of the plugs of one wall in the strategy `leaders` (EDA-041).
+ * With `po`, the sort key of a far end in front of the wall is its place on the axis along the wall.
+ * With `opo`, the plugs of a wall go at even places in the order of the keys of `spread`.
+ */
+export type WallLeader = "po" | "opo";
+/**
+ * This function does the work of `spreadEnds`, and of the strategy `leaders` with the argument `leader`.
+ * Without `leader`, it gives the plugs of `spread`.
+ */
+export declare function spreadWith(input: PlugInput, options?: SpreadOptions, leader?: WallLeader): PlugPair[];
+/** The options of the plug strategy `assign`. */
+export interface AssignOptions {
+  /** The least gap between two plugs of one wall. When the room of the wall is too small for all its plugs, the gap shrinks evenly. The default is 8. */
+  readonly plugGap?: number;
+  /** The distance from a plug to a corner of its box, or a quarter of the wall when the wall is short. The default is 6. */
+  readonly inset?: number;
+}
+/** The defaults of the plug strategy `assign`. */
+export declare const ASSIGN_DEFAULTS: Required<AssignOptions>;
+/** One end of a wall for `assignWall`. The places are on the axis along the wall. */
+export interface WallEnd {
+  /** The start of the interval of the end. */
+  readonly lo: number;
+  /** The end of the interval of the end. */
+  readonly hi: number;
+  /** The place of the plug that faces the far end. The plan moves the plugs the least distance from these places. */
+  readonly ideal: number;
+  /** The sort key of the far end. Plugs in the order of the keys do not cross at the wall. */
+  readonly key: number;
+}
+/** The plan of one wall: the place of each plug, and the ends with their plug in their interval. */
+export interface WallPlan {
+  /** The place of the plug of each end, in the order of the ends. */
+  readonly at: number[];
+  /** For each end, `true` when its plug is in its interval. */
+  readonly anchored: boolean[];
+  /** The gap of the wall: the option `gap`, or less when the room of the wall is too short for all its plugs. */
+  readonly gap: number;
+}
+/**
+ * This function gives the plan of one wall (PLUG-ASSIGN). Each end has an interval on the axis along the wall. The plugs keep at least `gap` between two of them,
+ * and between a plug and a fixed plug at a place of `fixed`. When the room is too short for all the plugs, the gap shrinks evenly. The plan has three goals, in this order:
+ * 1. the most ends with their plug in their interval (exact).
+ * 2. no crossing at the wall: the order of the keys, when that order lets the count of goal 1.
+ * 3. the least sum of the squares of the moves from the ideal places, for the order and the ends of goals 1 and 2.
+ *
+ * An end that cannot get a plug in its interval still gets a plug in the room. When the order of the keys loses ends, the plugs swap their places
+ * to come nearer to that order, while each end keeps its interval.
+ */
+export declare function assignWall(ends: readonly WallEnd[], room: readonly [number, number], gap: number, fixed?: readonly number[]): WallPlan;
+/**
+ * This function gives the plugs of the plug strategy `assign` (PLUG-ASSIGN). A fixed plug stays at its point, and a plug with a side stays on that side.
+ * Each free plug goes on the side that faces the other end (`sideToward`). Each end of a wall has an interval: the range of its port, or the room of the wall.
+ * Then `assignWall` places the plugs of each wall, with at least `plugGap` between two of them. The ends of one port share one plug.
+ *
+ * The output has one entry for each edge with two known nodes, in the order of the edges.
+ */
+export declare function assignEnds(input: PlugInput, options?: AssignOptions): PlugPair[];
+/**
+ * The type of leader of a plug. With `s`, the order of a wall is the order of the angles of the far ends, as in `spread`.
+ * With `po`, the stub leaves along the normal and turns once, so the order is the order of the far ends along the wall.
+ * With `opo`, the plugs of a wall go at even places, in the order of the angles.
+ */
+export type LeaderType = "s" | "po" | "opo";
+/** The values of `LeaderType`. */
+export declare const LEADER_TYPES: readonly LeaderType[];
+/** The options of the plug strategy `leaders`. */
+export interface LeaderOptions {
+  /** The type of leader. The default is `po`. */
+  readonly leader: LeaderType;
+  /** The least gap between two plugs of one wall, from 2 to 8. The default is 8. */
+  readonly slotSpacing: number;
+  /** The distance from a plug to a corner of its box, or a quarter of the wall when the wall is short. The default is 6. */
+  readonly inset: number;
+  /** The number of passes that sort each wall again by the new places of the far ends, from 0 to 4. The default is 2. */
+  readonly rounds: number;
+}
+/** The defaults of the plug strategy `leaders`. */
+export declare const LEADER_DEFAULTS: Readonly<LeaderOptions>;
+/**
+ * This function gives the plugs of the plug strategy `leaders` (EDA-041, after Bekos 2007). A fixed plug stays at its point, and a plug with a side stays on that side.
+ * Each free plug goes on the side that faces the other end. The plugs of each wall keep at least `slotSpacing` between two of them.
+ * The type of leader sets their order and their places. The output has one entry for each edge with two known nodes, in the order of the edges.
+ */
+export declare function leaderEnds(input: PlugInput, options?: Partial<LeaderOptions>): PlugPair[];
 /** The options of `fixPorts`. */
 export interface FixPortsOptions {
   /** The options of the plug rule. The rule gets its `defaults` for each option that this object does not give. */
@@ -2288,6 +2527,11 @@ export interface FixPortsOptions {
    * The default is `false`: such an end stays free.
    */
   readonly newPorts?: boolean;
+  /**
+   * The plugs of ports with a `range` (PORT-RANGE). With `keep`, a plug out of its range moves into it, and the new plugs of its side keep their order.
+   * With `rule`, each plug stays where the rule puts it. The default is `keep`, but `rule` for the rule `assign`: its plugs out of their ranges are on purpose.
+   */
+  readonly ranges?: "keep" | "rule";
 }
 /**
  * This function runs the plug rule. It gives each free port a fixed `at` and a `side` from the plugs of the rule.
@@ -2296,6 +2540,7 @@ export interface FixPortsOptions {
  *
  * The rule sees the graph of `corners`: the plugs of `resolvePorts`, without the inner edges of the frames.
  * The rule is a strategy of the step `plugs`, or the name of one in the registry.
+ * A new fixed port with a `range` is in its range (PORT-RANGE). When the rule gives a plug out of the range, the new plugs of that side move into their ranges.
  * The output is a new graph. The function does not change the input.
  */
 export declare function fixPorts(graph: Graph, rule: Strategy<"plugs"> | string, options?: FixPortsOptions): Graph;
@@ -2398,6 +2643,40 @@ export declare function venationLinks(items: readonly LevelItem[], direct: reado
  * In each level with groups, the links take their ways along a closed venation backbone (`venationLinks`). The last level stays as in `depths`.
  */
 export declare function venationLevels(input: LevelInput, options: Readonly<VenationOptions>): Level[];
+/** The growth of the width of a stroke with the number of its edges. */
+export type WidthScale = "linear" | "sqrt" | "log";
+/** The values of `WidthScale`. */
+export declare const WIDTH_SCALES: readonly WidthScale[];
+/** The options of the level strategy `detail`: the options of `depths`, and the limits of the collapse. */
+export interface DetailOptions extends DepthLevelOptions {
+  /** Two parallel legs closer than this number of pixels on the screen become one stroke, from 0.5 to 4. The default is 3. */
+  readonly pxMin: number;
+  /** A stroke holds this number of edges or more, from 2 to 5. The default is 2. */
+  readonly minCount: number;
+  /** The width of a stroke of one edge, in pixels, from 1 to 4. The default is 1.5. A renderer reads it with `detailWidth`. */
+  readonly w0: number;
+  /** The growth of the width of a stroke with its count. The default is `log`. */
+  readonly widthScale: WidthScale;
+}
+/** The default options of the level strategy `detail`. */
+export declare const DETAIL_DEFAULTS: Readonly<DetailOptions>;
+/**
+ * This function gives the width of a stroke of `count` edges, in pixels (WILD-016). With `log`, it is `w0 × (1 + log2(count))`.
+ * With `sqrt`, it is `w0 × sqrt(count)`. With `linear`, it is `w0 × count`.
+ */
+export declare function detailWidth(count: number, o?: Pick<DetailOptions, "w0" | "widthScale">): number;
+/**
+ * This function collapses the legs of the links of one level that are closer than `tol` (WILD-016, EDA-038).
+ * The legs of each axis go in clusters along the axis across it. The leg with the largest count of a cluster is its stroke, and each other leg moves onto it.
+ * A cluster needs two legs whose projections overlap, and a count of `minCount` or more. A move that puts a leg through the box of an item does not happen.
+ */
+export declare function collapseLinks(items: readonly LevelItem[], links: readonly LevelLink[], tol: number, minCount: number): LevelLink[];
+/**
+ * This function gives the zoom levels of the level strategy `detail` (WILD-016 with EDA-038). The levels and their items are the levels of `depths`.
+ * A level with groups first shows at the scale `itemAt / size`, with `size` its median item (`pickLevel`). At that scale, `pxMin` pixels are `pxMin × size / itemAt` units.
+ * The links of the level collapse their legs that are closer than that length (`collapseLinks`). The last level stays as in `depths`.
+ */
+export declare function detailLevels(input: LevelInput, options: Readonly<DetailOptions>): Level[];
 /** One setting of the portfolio: a name and the options of the pipeline. */
 export interface PortfolioSetting {
   readonly name: string;
@@ -2444,6 +2723,226 @@ export declare function rankShares(values: readonly number[], lowerIsBetter: boo
  * The measures are the crossings (R1), the median detour (R5) and the ink saved (B1). The least score wins, and a tie goes to the earlier setting.
  */
 export declare function boardPortfolio(graph: Graph, list: readonly PortfolioSetting[], o: Readonly<BoardPortfolioOptions>, now?: () => number): BoardPortfolioRun;
+/** One rule of the curriculum: the crossings (R1), the lane separation (R12) or the crossing angle (R2). */
+export type CurriculumRule = "R1" | "R12" | "R2";
+/** The order in which the curriculum adds its rules. */
+export type CurriculumOrder = "R1-R12-R2" | "R12-R1-R2" | "R1-R2-R12";
+/** The values of `CurriculumOrder`. */
+export declare const CURRICULUM_ORDERS: readonly CurriculumOrder[];
+/** The options of the whole strategy `curriculum` (RULE-048). */
+export interface CurriculumOptions {
+  /** The order in which the stages add the rules. The default is `R1-R12-R2`. */
+  readonly order: CurriculumOrder;
+  /** The number of passes over the edges in each stage, from 1 to 3. The default is 1. */
+  readonly passes: number;
+  /** The number of settings in the pool of routes, from the start of its list, from 2 to 3. The default is 3. */
+  readonly settings: number;
+  /** A new route has a detour of at most this value, or of its old route, from 1.5 to 4. The default is 2. */
+  readonly detour: number;
+}
+/** The default options of the strategy `curriculum`. */
+export declare const CURRICULUM_DEFAULTS: Readonly<CurriculumOptions>;
+/**
+ * This function gives the arc sine of `x` in radians, from -1 to 1. It is the algorithm of fdlibm, with only `+`, `*`, `/` and `Math.sqrt`.
+ * These operations are exact to the last bit on each platform, so the result does not depend on the engine.
+ */
+export declare function arcsin(x: number): number;
+/**
+ * This function gives the costs of the rules between two routes. R1 is the number of crossings.
+ * R2 is the sum of `1 - θ / 90` over the crossings. θ is the crossing angle in degrees.
+ * R12 is the overlap of the legs of `a` and `b` that are within 5 degrees of parallel. The two legs are nearer than 4 units.
+ */
+export declare function pairCosts(a: readonly Point[], b: readonly Point[]): Record<CurriculumRule, number>;
+/**
+ * This function runs the whole strategy `curriculum` (RULE-048, after curriculum learning, Bengio 2009). The record has no energy solver yet (RULE-019).
+ * Thus a pool of routes of fixed settings takes its place. Each edge can take its route from any setting of the pool.
+ * The first answer is the first setting. Each stage adds one rule, in the order `order`. A pass of a stage visits the edges, the worst first.
+ * An edge takes the route of the pool with the least cost of the new rule. That cost is lower, and the earlier rules do not get worse.
+ * A route with a break of a hard rule is not in the pool. The output has the routes alone, with no runs, bundles or levels.
+ */
+export declare function curriculum(graph: Graph, list: readonly PortfolioSetting[], options?: Partial<CurriculumOptions>): WholeOutput;
+/** The features of one route, in order: crossings (R1), angle cost (R2), lane overlap (R12) over 20, detour minus 1 (R5), and bends over 2. */
+export declare const PREFERENCE_FEATURES: readonly string[];
+/**
+ * The weights of the made-up panel that labels the made-up pairs, in the order of `PREFERENCE_FEATURES`.
+ * The order comes from the studies of the readers of graphs: the crossings count most, then the bends and the length, then the angle (Purchase 1997, Ware, Purchase, Colpoys and McGill 2002).
+ * The numbers are made up. They do not come from the screen or from a board.
+ */
+export declare const PREFERENCE_PANEL: readonly number[];
+/** The options of the fit of the preferences. */
+export interface PreferenceFit {
+  /** The weight of the L2 term of the fit, from 0 to 1. The default is 0.01. */
+  readonly l2: number;
+  /** The seed of the made-up pairs. The default is 1. */
+  readonly seed: number;
+  /** The number of made-up pairs, from 50 to 1000. The default is 200. */
+  readonly pairs: number;
+}
+/** The options of the whole strategy `preferences` (RULE-038). */
+export interface PreferenceOptions {
+  /** The weight of the L2 term of the fit, from 0 to 1. The default is 0.01. */
+  readonly l2: number;
+  /** The number of passes over the edges, from 1 to 3. The default is 1. */
+  readonly passes: number;
+  /** The number of settings in the pool of routes, from the start of its list, from 2 to 3. The default is 3. */
+  readonly settings: number;
+  /** A new route has a detour of at most this value, or of its old route, from 1.5 to 4. The default is 2. */
+  readonly detour: number;
+}
+/** The default options of the strategy `preferences`. */
+export declare const PREFERENCE_DEFAULTS: Readonly<PreferenceOptions>;
+/** One made-up pair: the features of two routes, and 1 when the panel prefers the first one. */
+export interface PreferencePair {
+  readonly a: readonly number[];
+  readonly b: readonly number[];
+  readonly first: 0 | 1;
+}
+/** The result of the fit: the weights, the agreement with held-out pairs, and the source of the pairs. */
+export interface PreferenceModel {
+  readonly weights: readonly number[];
+  /** The share of 50 held-out made-up pairs where the weights agree with the panel. */
+  readonly agreement: number;
+  readonly source: string;
+}
+/**
+ * This function gives a smooth step from 0 to 1, a stand-in for the logistic function with only `+`, `*`, `/` and `Math.abs`.
+ * It is `0.5 + 0.5 z / (1 + |z|)`. These operations are exact to the last bit on each platform.
+ */
+export declare function softStep(z: number): number;
+/**
+ * This function gives `count` made-up pairs, with the labels of the made-up panel `PREFERENCE_PANEL` and a noise.
+ * The pairs come from the seed alone. They do not come from a board.
+ */
+export declare function madeUpPairs(count: number, seed: number): PreferencePair[];
+/** This function gives the share of the pairs where the weights `w` prefer the same route as the panel. */
+export declare function agreementOf(w: readonly number[], pairs: readonly PreferencePair[]): number;
+/**
+ * This function fits the weights of the rules to made-up pairs (RULE-038, a Bradley-Terry model, after Bradley and Terry 1952).
+ * The probability that a reader prefers `a` to `b` is `softStep(u(a) - u(b))`, with `u(x) = -w · f(x)`. The fit takes 400 steps of the gradient of the score.
+ * An L2 term `l2 × |w|²` keeps the weights small. A weight below 0 becomes 0. The weights are scaled so that their sum is the number of features.
+ * The held-out pairs come from the seed plus 7919. The pairs do not come from the screen or from a board.
+ */
+export declare function fitPreferences(options?: Partial<PreferenceFit>): PreferenceModel;
+/**
+ * This function runs the whole strategy `preferences` (RULE-038). It fits the weights of the rules to made-up pairs (`fitPreferences`).
+ * Each edge can take its route from any setting of the pool. The first answer is the first setting.
+ * A pass visits the edges in order. An edge takes the route of the pool with the least weighted cost, when that cost is lower than the cost of its route.
+ * The cost is the weighted sum of the features of the route against the routes of the other edges. A route with a break of a hard rule is not in the pool.
+ * The output has the routes alone, with no runs, bundles or levels.
+ */
+export declare function preferences(graph: Graph, list: readonly PortfolioSetting[], options?: Partial<PreferenceOptions>): WholeOutput;
+/** The search of the whole strategy `fireflies`: the firefly algorithm, or the artificial bee colony. */
+export type SwarmSearch = "firefly" | "bees";
+/** The values of `SwarmSearch`. */
+export declare const SWARM_SEARCHES: readonly SwarmSearch[];
+/** The options of the whole strategy `fireflies` (NAT-047). */
+export interface FireflyOptions {
+  /** The search. The default is `firefly`. */
+  readonly search: SwarmSearch;
+  /** The budget: the largest number of different settings that the search routes, from 4 to 40. The default is 12. */
+  readonly budget: number;
+  /** The number of fireflies or food sources, from 4 to 20. The default is 6. */
+  readonly colony: number;
+  /** The absorption `gamma` of the light of a firefly, from 0.01 to 10. The default is 1. */
+  readonly gamma: number;
+  /** The size `alpha` of the random step of a firefly, as a share of the range, from 0.01 to 0.5. The default is 0.2. */
+  readonly alpha: number;
+  /** The number of tries with no gain, after which a scout bee leaves a food source, from 10 to 100. The default is 10. */
+  readonly limit: number;
+  /** The seed of the search, a whole number from 0. The same seed gives the same routes. The default is 1. */
+  readonly seed: number;
+}
+/** The default options of the strategy `fireflies`. */
+export declare const FIREFLY_DEFAULTS: Readonly<FireflyOptions>;
+/**
+ * This function gives the attraction of a firefly at the distance `r`: `BETA0 / (1 + u + u² / 2)` with `u = gamma × r²`.
+ * It is a rational stand-in for `BETA0 × exp(-u)`, with only `+`, `*` and `/`, so it is exact to the last bit on each platform.
+ */
+export declare function attraction(gamma: number, r2: number): number;
+/** One setting of the router `shared`: the option `discount` and the option `margin`. */
+export interface SwarmSetting {
+  readonly discount: number;
+  readonly margin: number;
+}
+/** This function gives the setting of a point of the unit square, on the grid of the search. */
+export declare function settingAt(x: number, y: number): SwarmSetting;
+/** One setting that the search routed: its score and its output. A setting with a break of a hard rule has the score `Infinity`. */
+export interface SwarmEntry {
+  readonly setting: SwarmSetting;
+  readonly score: number;
+  readonly output: WholeOutput;
+}
+/** The result of `fireflies`: the output, the best setting and each setting that the search routed, in order. */
+export interface SwarmRun {
+  readonly output: WholeOutput;
+  readonly best: SwarmSetting;
+  readonly entries: readonly SwarmEntry[];
+}
+/**
+ * This function gives the score of an output on its board. A lower score is better.
+ * The score is `crossings / edges + (median detour - 1) - ink saved`. A break of a hard rule gives `Infinity`.
+ */
+export declare function swarmScore(output: WholeOutput): number;
+/**
+ * This function runs the whole strategy `fireflies` (NAT-047, after the firefly algorithm of Yang 2008 and the bee colony of Karaboga 2005).
+ * It searches the options `discount` and `margin` of the router `router` on the board, on a grid of 20 × 8 settings.
+ * The first firefly or food source is the default setting, so the score of the output is not worse than the score of the default.
+ * A firefly moves toward each brighter one by `attraction(gamma, r²)` of the distance, plus a seeded step of size `alpha`.
+ * A bee tries `v = x + phi (x - x_k)` in one dimension, and a scout takes a new seeded place after `limit` tries with no gain.
+ * The search stops after `budget` different settings, or after 60 rounds. It reads only the board and the outputs of its own settings.
+ */
+export declare function fireflies(graph: Graph, router: Strategy<"router">, options?: Partial<FireflyOptions>): SwarmRun;
+/** The value of the loads of the edges of a board that the pick reads: the median, the quantile 0.95 or the mean. */
+export type TracingQuantile = "q50" | "q95" | "mean";
+/** The values of `TracingQuantile`. */
+export declare const TRACING_QUANTILES: readonly TracingQuantile[];
+/** The weights of the places to choose on the way of one edge (WILD-057). */
+export interface TracingWeights {
+  /** The weight of a crossing, from 0 to 4. The default is 1. */
+  readonly crossing: number;
+  /** The weight of a merge or a split where the edge is not an outer lane, from 0 to 4. The default is 2. */
+  readonly merge: number;
+  /** The weight of a bend, from 0 to 4. The default is 0.5. */
+  readonly bend: number;
+}
+/** The default weights of the tracing load, as the record gives them. */
+export declare const TRACING_WEIGHTS: Readonly<TracingWeights>;
+/** The options of the whole strategy `tracing` (WILD-057). */
+export interface TracingOptions extends TracingWeights {
+  /** The number of settings that the strategy tries, from the start of its list, from 1 to 12. The default is 4. */
+  readonly settings: number;
+  /** The value of the loads that the pick reads. The default is `q95`. */
+  readonly quantile: TracingQuantile;
+}
+/** The default options of the strategy `tracing`. */
+export declare const TRACING_DEFAULTS: Readonly<TracingOptions>;
+/**
+ * This function gives the tracing load of each edge of a result (WILD-057, after the tracing tasks of Ware, Purchase, Colpoys and McGill 2002).
+ * The load is `T(e) = crossing × crossings + merge × (merges and splits where e is not an outer lane) + bend × bends`.
+ * A shared run where the edge is not an outer lane gives one merge and one split. Such a bundle gives one split.
+ * A bend is a turn of more than 1 degree. The measure is W4 of MEAS3.
+ */
+export declare function tracingLoads(result: Result, weights?: Partial<TracingWeights>): Map<string, number>;
+/** This function gives a value of a list of loads: the median, the quantile 0.95 by the nearest rank, or the mean. An empty list gives 0. */
+export declare function tracingValue(loads: Iterable<number>, quantile: TracingQuantile): number;
+/** The tracing loads of one setting on the board: the value that the pick reads, and the median for a tie. */
+export interface TracingEntry {
+  readonly name: string;
+  readonly value: number;
+  readonly median: number;
+}
+/** The result of `tracing`: the output, the name of the pick and the loads of each setting with no break of a hard rule. */
+export interface TracingRun {
+  readonly output: WholeOutput;
+  readonly pick: string;
+  readonly entries: readonly TracingEntry[];
+}
+/**
+ * This function runs the whole strategy `tracing` (WILD-057). It runs the first `settings` settings of `list` on the board.
+ * A setting with a break of a hard rule, or above its node limit, does not count. The setting with the least tracing load wins.
+ * A tie goes to the least median load, then to the earlier setting. It reads only the board and the outputs of its own settings.
+ */
+export declare function tracing(graph: Graph, list: readonly PortfolioSetting[], options?: Partial<TracingOptions>): TracingRun;
 /** A broken hard rule. A correct router has none. */
 export interface Violation {
   readonly rule: "complete" | "ends-at-plugs" | "fixed-plugs" | "no-pass-through" | "counts-sum" | "link-ends" | "bundle-trunk" | "run-shared";
@@ -5517,6 +6016,58 @@ export declare function kneeOf(trees: readonly Pick<KneeTree, "ink" | "paths">[]
  * The stretches of the tree that two edges or more share become highways.
  */
 export declare function kneePlan(input: HighwayInput, o: Readonly<KneeOptions>): HighwayPlan;
+/** The end of a ride that the price moves: the exit, the entry, or both by half. */
+type BalanceEnd = "exit" | "entry" | "both";
+/** The values of `BalanceEnd`. */
+export declare const BALANCE_ENDS: readonly BalanceEnd[];
+/** The options of the highway strategy `balance` (EDA-017). */
+interface BalanceOptions {
+  /** The target of the stretch of an edge: its route on the plan over its route alone, from 1.1 to 2. The default is 1.2. */
+  readonly tau: number;
+  /** The number of updates of the prices, from 5 to 30. The default is 5. */
+  readonly iterations: number;
+  /** The end of a ride that the price moves. The default is `exit`. */
+  readonly end: BalanceEnd;
+  /** The plan that the strategy balances. The default is `shared-ways`. */
+  readonly from: HighwayBase;
+}
+/** The default options of the strategy `balance`. */
+export declare const BALANCE_DEFAULTS: Readonly<BalanceOptions>;
+/**
+ * This function gives the plan of the highway strategy `balance` (EDA-017, after the Lagrange relaxation of the stretch).
+ * The stretch of an edge is its route on the plan over its route alone, as the gate `stretch` measures it.
+ * At each update, an edge with a stretch above `tau` adds `stretch - tau` to its price. Each of its rides keeps the share `1 - price` of its first length.
+ * A ride shorter than the margin leaves the plan. The updates stop when no edge is above `tau`.
+ */
+export declare function balancePlan(input: HighwayInput, options?: Partial<BalanceOptions>): HighwayPlan;
+/** This function balances the plan `first` of the graph, as `balancePlan` does. It reads all the options except `from`. */
+export declare function balanceOf(graph: Graph, first: HighwayPlan, options?: Partial<BalanceOptions>): HighwayPlan;
+/** The place of the header in the gap before the row: near the row, or near the feed node. */
+type ManifoldSide = "near" | "far";
+/** The values of `ManifoldSide`. */
+export declare const MANIFOLD_SIDES: readonly ManifoldSide[];
+/** The options of the highway strategy `manifolds` (WILD-036). */
+interface ManifoldOptions {
+  /** A manifold has this number of taps or more, from 3 to 8. The default is 3. */
+  readonly kMin: number;
+  /** The nodes of one row have centers in a band of this many median box heights, from 0.5 to 2. The default is 1. */
+  readonly band: number;
+  /** The place of the header in the gap before the row. The default is `near`. */
+  readonly side: ManifoldSide;
+  /** A tap stays on the manifold only when its way is this many times the direct line or less, from 1 to 3. The default is 1.5. */
+  readonly detour: number;
+  /** The plan of the edges that are not on a manifold. The default is `shared-ways`. */
+  readonly from: HighwayBase;
+}
+/** The default options of the strategy `manifolds`. */
+export declare const MANIFOLD_DEFAULTS: Readonly<ManifoldOptions>;
+/**
+ * This function gives the plan of the highway strategy `manifolds` (WILD-036, after the headers of pipes and of bus bars).
+ * A fan of `kMin` edges or more from one node to a row of nodes gets a straight header in the gap before the row.
+ * Each edge of the fan joins the header at the feed point, in line with the center of the node. It leaves the header at its tap, in line with the center of its far node.
+ * A tap whose way is more than `detour` times the direct line leaves the manifold. Each edge is on one manifold at most. The other edges keep the plan `from`.
+ */
+export declare function manifoldPlan(input: HighwayInput, options?: Partial<ManifoldOptions>): HighwayPlan;
 /** The rule that splits the targets of a tip in two: by count, by weight, or at the widest gap of the angles. */
 type BronchialSplit = "count" | "weight" | "gap";
 /** The values of `BronchialSplit`. */
@@ -6310,6 +6861,53 @@ interface SidePlugOptions {
   /** The largest number of places that the search tries on each side. The default is 16. */
   readonly most?: number;
 }
+/** The edges that can join a trunk: only the edges with the key of the trunk, or each edge. */
+type SlotKeys = "same" | "any";
+/** The values of `SlotKeys`. */
+export declare const SLOT_KEYS: readonly SlotKeys[];
+/** The options of the highway strategy `slots` (RULE-047). */
+interface SlotOptions {
+  /** The weight `k` of the pull, from 0.25 to 8. The default is 2. The name is not `k`, because `follow` reads `k` as an option of its ways. */
+  readonly pull: number;
+  /** The reach `r` of the pull, in units, from 8 to 64. A route point farther than this distance from a trunk gets no pull. The default is 24. */
+  readonly reach: number;
+  /** The distance between two lanes of a trunk, in units, from 2 to 8. The default is 4. */
+  readonly laneSpacing: number;
+  /** The largest stretch of a route after it joins a trunk: its new length over its first length, from 1.05 to 2. The default is 1.25. */
+  readonly maxStretch: number;
+  /** The edges that can join a trunk. The default is `same`. */
+  readonly keys: SlotKeys;
+  /** The plan that gives the trunks. The default is `shared-ways`. */
+  readonly from: HighwayBase;
+}
+/** The default options of the strategy `slots`. */
+export declare const SLOT_DEFAULTS: Readonly<SlotOptions>;
+/** One possible join of an edge to a trunk: the trunk, the places on its spine, the pull and the detour. */
+interface SlotJoin {
+  readonly highway: number;
+  readonly on: number;
+  readonly off: number;
+  /** The pull energy that the join removes: `k × Σ w(d) × (d - slot)² × step / r²`, in units of length. */
+  readonly pull: number;
+  /** The length that the join adds to the route, as an estimate. */
+  readonly detour: number;
+}
+/**
+ * This function gives the best join of one route to the trunk `h`, or `undefined`.
+ * The longest row of samples nearer than `reach` to the spine is the part of the route that the trunk pulls.
+ * The slot of the new lane is at `laneSpacing × (lanes + 1) / 2` from the spine. The weight is `w(d) = max(0, 1 - d / r)`.
+ */
+export declare function slotJoin(route: readonly Point[], h: Highway, index: number, o: Readonly<SlotOptions>): SlotJoin | undefined;
+/**
+ * This function gives the plan of the highway strategy `slots` (RULE-047, after the pull of force-directed edge bundling, Holten and van Wijk 2009).
+ * The trunks are the highways of the plan `from`. Each edge outside the plan gets a pull toward the slot of a new lane of a trunk near its first route.
+ * The energy of the pull is `E = k Σ w(d_i) ‖x_i - slot_i‖²` over the samples of the route, with `w(d) = max(0, 1 - d / r)`.
+ * The edge joins the trunk when the pull is larger than the length that the join adds, and the stretch stays under `maxStretch`.
+ * The edge takes the trunk with the largest gain, on the outer lane. An edge that does not fit stays off the trunks.
+ */
+export declare function slotPlan(input: HighwayInput, options?: Partial<SlotOptions>): HighwayPlan;
+/** This function adds the joins of `slotPlan` to the plan `first` of the graph. It reads all the options except `from`. A join that breaks a hard rule after `follow` leaves the plan. */
+export declare function slotsOf(graph: Graph, first: HighwayPlan, routes: ReadonlyMap<string, readonly Point[]>, options?: Partial<SlotOptions>): HighwayPlan;
 /** The options of a router strategy: the options of its router, without the name and the limit of the benchmark. */
 export type RouterPreset<O> = Omit<O, "name" | "maxNodes">;
 /** The built-in router strategies, in the order of the benchmark. They route as the routers of `ROUTERS`. */
@@ -6456,6 +7054,9 @@ export declare const highwayStrategies: {
   readonly interchanges: Strategy<"highway", InterchangeOptions>;
   readonly knee: Strategy<"highway", KneeOptions>;
   readonly bronchial: Strategy<"highway", BronchialOptions>;
+  readonly balance: Strategy<"highway", BalanceOptions>;
+  readonly manifolds: Strategy<"highway", ManifoldOptions>;
+  readonly slots: Strategy<"highway", SlotOptions>;
   readonly "corridors+breakeven": Strategy<"highway", CorridorOptions & BreakEvenOptions>;
   readonly "corridors+stretch": Strategy<"highway", CorridorOptions & StretchOptions>;
   readonly "corridors+ambiguity": Strategy<"highway", CorridorOptions & AmbiguityGuardOptions>;
@@ -6468,17 +7069,25 @@ export declare const plugStrategies: {
   readonly side: Strategy<"plugs", SidePlugOptions>;
   readonly justify: Strategy<"plugs", JustifyOptions>;
   readonly spread: Strategy<"plugs", SpreadOptions>;
+  readonly leaders: Strategy<"plugs", LeaderOptions>;
+  readonly assign: Strategy<"plugs", AssignOptions>;
 };
 /** The built-in level rules: the strategies of the step `levels`. The router `sections` makes its zoom levels with its option `level`. */
 export declare const levelStrategies: {
   readonly depths: Strategy<"levels", DepthLevelOptions>;
   readonly venation: Strategy<"levels", VenationOptions>;
+  readonly detail: Strategy<"levels", DetailOptions>;
 };
 /**
  * The fixed list of settings of the whole strategy `board-portfolio` (WILD-045), in order. The option `settings` takes the first ones.
  * The list holds routers and highway strategies with their defaults. It comes from the catalog of the strategies, not from a fit to the screen.
  */
 export declare const BOARD_PORTFOLIO_SETTINGS: readonly PortfolioSetting[];
+/**
+ * The pool of routes of the whole strategy `curriculum` (RULE-048), in order: the routers of the base of the screen. The first one gives the first answer.
+ * The option `settings` takes the first ones.
+ */
+export declare const CURRICULUM_POOL: readonly PortfolioSetting[];
 /**
  * The built-in whole strategies: the strategies of the step `whole`. The strategy `pipeline` runs one strategy of each step, as the demo of the site does.
  * Without options, it routes the graph with the router `corners`.
@@ -6486,6 +7095,10 @@ export declare const BOARD_PORTFOLIO_SETTINGS: readonly PortfolioSetting[];
 export declare const wholeStrategies: {
   readonly pipeline: Strategy<"whole", PipelineOptions>;
   readonly "board-portfolio": Strategy<"whole", BoardPortfolioOptions>;
+  readonly curriculum: Strategy<"whole", CurriculumOptions>;
+  readonly preferences: Strategy<"whole", PreferenceOptions>;
+  readonly fireflies: Strategy<"whole", FireflyOptions>;
+  readonly tracing: Strategy<"whole", TracingOptions>;
 };
 /** The built-in strategies of each step, in order. A consumer adds its own: `createRegistry([...BUILT_IN_STRATEGIES, mine])`. */
 export declare const BUILT_IN_STRATEGIES: readonly AnyStrategy[];
@@ -8053,5 +8666,5 @@ export declare const PORTFOLIO_SETS: Readonly<Record<`${PortfolioRule}|${Portfol
  * The default stretch order is `sifting`, the best order of the screen. The option `stretchOrder` selects `consensus` or `periphery`.
  */
 export declare const sharedStretchStrategy: Strategy<"router", RouterPreset<SharedOptions>>;
-export { type AdvectionSettings, type AmbiguityGuardOptions, type AnnealingOptions, type ArcOptions, type ArcSource, type AreaOptions, type AreaWidth, type AttractionOptions, type Biclique, type BreakEvenOptions, type BronchialOptions, type BronchialSplit, type BundleLine, type BundleOrder, type CandidateSource, type CellStep, type ClothoidOptions, type ConfluentOptions, type ConsensusLinkage, type ConsensusOptions, type CornersOptions, type CorpusDimension, type CorpusFamily, type CorridorOptions, type Crossbar, type CrossbarOptions, type CubuOptions, type CurveSpace, type CutObjective, type CutOptions, DEFAULT_RNG, type DensityGrid, type DensityImage, type DensityKernel, type DensitySource, type DiffusionOptions, type DimensionValues, type DividedOptions, type EdgeDistance, type EdgeEnds, type EdgeGroup, type EdgeLengths, type EdgePathOptions, type EdgePlugs, type ExerciseEvidence, type FamilyRegistry, type FdebOptions, type FieldEnd, type FlowClusterOptions, type FlowFieldOptions, type FollowOptions, type FrameOptions, type FrechetBundle, type FrechetOptions, type FreeLine, type GapOptions, type Gate, type GenerateContext, type GroupScope, type GroupSpine, type GroupedOptions, type GrowthOptions, type GrowthOrder, type GutterEdge, type GutterOptions, type HashOptions, type HdbscanOptions, type HierarchyGroups, type HierarchyOptions, type Highway, type HighwayBase, type HighwayInput, type HighwayMember, type HighwayOptions, type HighwayPlan, type HoughOptions, type HoughPeak, type HubAllocation, type HubArcOptions, type HubCandidates, type HysteresisOptions, type InnerMode, type Interchange, type InterchangeBase, type InterchangeOptions, type JogStyle, type KdAxis, type KdLine, type KdOptions, type KdeebOptions, type KeyOptions, type KeyedWay, type KeysOptions, type KneeOptions, type KneeRule, type KneeTree, type LaneCurve, type LanesOptions, type LevelHighwayOptions, type LinkCommunityOptions, type LinkEdge, type Linkage, type MeetOptions, type Member, type MemberStatus, type MemberTrace, type MeshOptions, type MingleOptions, type MlsFit, type MlsebOptions, type ModuleRule, type NestedOptions, type NodeKey, type NodeLinks, type OdCellOptions, type OutputGroup, type Outside, type PHubOptions, type ParamValue, type PathStep, type PickSpec, type Portfolio, type PortfolioKey, type PortfolioLevel, type PortfolioOptions, type PortfolioPick, type PortfolioTrace, type PowerOptions, type QuickBundlesOptions, RECORD_EPS, type ResistanceOptions, type Ridge, type RidgeOptions, type RidgeSource, type RoadClassOptions, type RoomBends, type RoundedOptions, type RouteCrossing, type RouteSegment, type SbebOptions, type ScaleCluster, type ScaleSpaceOptions, type SearchMove, type SearchOptions, type SectionsOptions, type SelectCandidate, type SelectLevel, type SelectOptions, type Selection, type ShapeSkeleton, type ShareCost, type ShareMerge, type ShareOrder, type SharedHooks, type SharedNegotiation, type SharedOptions, type SharedSearch, type SharedStretchOptions, type SharedWaysOptions, type SkeletonGroups, type SkeletonTarget, type SmoothOptions, type SnapLine, type SnapMember, type SnapOptions, type SoftKeyOptions, type SpectralOptions, type SpiralNode, type SpiralOptions, type SplineOptions, type SplitCell, type StableIdOptions, type SteinerGroup, type SteinerMethod, type SteinerMetric, type SteinerOptions, type StreetEdge, type StreetOptions, type StreetRide, type StreetSource, type StretchOptions, type StubEnds, type StubOptions, type TerritoryOptions, type TerritoryPoints, type TightFirst, type TightOptions, type TightTies, type TraceOptions, type TraclusOptions, type TrafficRule, type TrunkFan, type TrunkSplit, type TrunksOptions, type WeiszfeldOptions, type WspdOptions, type Zip, type ZipLimits, type ZipperOptions, canonicalJson, compareMeasure, createFamilyRegistry, dimensionAt, dimensionUnit, exercised, familyKind, levelsOf, minEffectOf, outputGroups, outputHash, paramProblem, pickMoves, portfolio, randomInt, selectBest, sha256Hex };
+export { type AdamOptions, type AdvectionSettings, type AmbiguityGuardOptions, type AnnealingOptions, type ArcOptions, type ArcSource, type AreaOptions, type AreaWidth, type AttractionOptions, type BalanceEnd, type BalanceOptions, type Biclique, type BreakEvenOptions, type BronchialOptions, type BronchialSplit, type BundleLine, type BundleOrder, type CanalHub, type CanalOptions, type CandidateSource, type CellStep, type ClothoidOptions, type ConfluentOptions, type ConsensusLinkage, type ConsensusOptions, type CornersOptions, type CorpusDimension, type CorpusFamily, type CorridorOptions, type Crossbar, type CrossbarOptions, type CubuOptions, type CurveSpace, type CutObjective, type CutOptions, DEFAULT_RNG, type DensityGrid, type DensityImage, type DensityKernel, type DensitySource, type DiffusionOptions, type DimensionValues, type DividedOptions, type EdgeDistance, type EdgeEnds, type EdgeGroup, type EdgeLengths, type EdgePathOptions, type EdgePlugs, type ExerciseEvidence, type FamilyRegistry, type FdebOptions, type FieldEnd, type FlowClusterOptions, type FlowFieldOptions, type FollowOptions, type FrameOptions, type FrechetBundle, type FrechetOptions, type FreeLine, type GapOptions, type Gate, type GenerateContext, type GroupScope, type GroupSpine, type GroupedOptions, type GrowthOptions, type GrowthOrder, type GutterEdge, type GutterOptions, type HashOptions, type HdbscanOptions, type HierarchyGroups, type HierarchyOptions, type Highway, type HighwayBase, type HighwayInput, type HighwayMember, type HighwayOptions, type HighwayPlan, type HoughOptions, type HoughPeak, type HubAllocation, type HubArcOptions, type HubCandidates, type HysteresisOptions, type InnerMode, type Interchange, type InterchangeBase, type InterchangeOptions, type JogStyle, type KdAxis, type KdLine, type KdOptions, type KdeebOptions, type KeyOptions, type KeyedWay, type KeysOptions, type KneeOptions, type KneeRule, type KneeTree, type LaneCurve, type LanesOptions, type LevelHighwayOptions, type LinkCommunityOptions, type LinkEdge, type Linkage, type ManifoldOptions, type ManifoldSide, type MeetOptions, type Member, type MemberStatus, type MemberTrace, type MeshOptions, type MingleOptions, type MlsFit, type MlsebOptions, type ModuleRule, type NestedOptions, type NodeKey, type NodeLinks, type OdCellOptions, type OutputGroup, type Outside, type PHubOptions, type ParamValue, type PathStep, type PickSpec, type Portfolio, type PortfolioKey, type PortfolioLevel, type PortfolioOptions, type PortfolioPick, type PortfolioTrace, type PowerOptions, type QuickBundlesOptions, RECORD_EPS, type RerouteOptions, type ResistanceOptions, type Ridge, type RidgeOptions, type RidgeSource, type RoadClassOptions, type RoomBends, type RoundedOptions, type RouteCrossing, type RouteSegment, type SbebOptions, type ScaleCluster, type ScaleSpaceOptions, type SearchMove, type SearchOptions, type SectionsOptions, type SelectCandidate, type SelectLevel, type SelectOptions, type Selection, type ShapeSkeleton, type ShareCost, type ShareMerge, type ShareOrder, type SharedHooks, type SharedNegotiation, type SharedOptions, type SharedSearch, type SharedStretchOptions, type SharedWaysOptions, type SkeletonGroups, type SkeletonTarget, type SlotJoin, type SlotKeys, type SlotOptions, type SmoothOptions, type SnapLine, type SnapMember, type SnapOptions, type SoftKeyOptions, type SpectralOptions, type SpiralNode, type SpiralOptions, type SplineOptions, type SplitCell, type StableIdOptions, type SteinerGroup, type SteinerMethod, type SteinerMetric, type SteinerOptions, type StreetEdge, type StreetOptions, type StreetRide, type StreetSource, type StretchOptions, type StubEnds, type StubOptions, type TerritoryOptions, type TerritoryPoints, type TightFirst, type TightOptions, type TightTies, type TraceOptions, type TraclusOptions, type TrafficRule, type TrunkFan, type TrunkSplit, type TrunksOptions, type WeiszfeldOptions, type WspdOptions, type Zip, type ZipLimits, type ZipperOptions, canonicalJson, compareMeasure, createFamilyRegistry, dimensionAt, dimensionUnit, exercised, familyKind, levelsOf, minEffectOf, outputGroups, outputHash, paramProblem, pickMoves, portfolio, randomInt, selectBest, sha256Hex };
 //# sourceMappingURL=index.d.ts.map