@mark1russell7/packing 0.2.5 → 0.2.7

package/README.md

@@ -60,6 +60,28 @@ pack(rects, outer, { strategy: "maxrects", rule: "cp" });
 - The move of each rule other than `bl` counts a box when the rule chooses a place that `bl` does not choose.
 - A shape that is not a rectangle gets bands. The option `bandHeight` sets their largest height. The default is the height divided by `MAXRECTS_BANDS`.
 
+Since 0.2.6, `packPortfolio` packs an input with each member and keeps the best output. It is opt-in, and no default uses it.
+
+```ts
+const { output, winner } = packPortfolio(["skyline", "shelf"]).pick(input);
+```
+
+- The pick is `selectBest` of `@mark1russell7/layout-contract` on `PORTFOLIO_LEVELS`: the hard breaks, then `pack.overflow.excessArea`, then `pack.fill`.
+- The trace of the output gets the stage `portfolio` with the measure `move.pick`.
+- `outputHash` gives the hash of the placements of an output, as the bench records have it.
+
+Since 0.2.7, the strategy `portfolio` packs an input with the set of its cell. It is opt-in, and no default uses it.
+
+```ts
+const output = packWith("portfolio", input); // the default member count of the cell
+const cell = portfolioCell(input); // { shape: "rect", count: "100", spread: "uniform" }
+```
+
+- `portfolioCell` gives the container shape, the band of the item count and the band of the size spread.
+- `PORTFOLIO_SETS` gives the sets of 1, 2 and 3 members of each cell. The bench records of one run gave them.
+- Without options, the default member count of the cell runs. The output is a function of the input only.
+- The option `k` (2 or 3) runs each member of the set of `k`. The option `budgetMs` is an opt-in time limit.
+
 Both functions also work alone, in an outer rectangle with a width that you set. They do not change the width.
 
 A `locked` rectangle keeps its position. `packSkyline` and `packShelf` put the other rectangles around it. `packRows` only keeps its position.

package/build/index.d.ts

@@ -1,4 +1,4 @@
-import { ContainerTest, ContainerTest as ContainerTest$1, DEFAULT_TOLERANCE, Direction, Direction as Direction$1, EPS, Item, Item as Item$1, LayoutContainer, LayoutContainer as LayoutContainer$1, LayoutEdge, LayoutEdge as LayoutEdge$1, LayoutGenerator, LayoutInput, LayoutInput as LayoutInput$1, Margin, MeasureSpec as MeasureSpec$1, Obstacle, PackHard, PackHard as PackHard$1, PackInput, PackOutput, Placement, Port, RECORD_EPS, Region, Side, Sides, Sides as Sides$1, StageTrace, Tolerance, checkInput, turnPoint, turnPort, turnRegion } from "@mark1russell7/layout-contract";
+import { ContainerTest, ContainerTest as ContainerTest$1, DEFAULT_TOLERANCE, Direction, Direction as Direction$1, EPS, Item, Item as Item$1, LayoutContainer, LayoutContainer as LayoutContainer$1, LayoutEdge, LayoutEdge as LayoutEdge$1, LayoutGenerator, LayoutInput, LayoutInput as LayoutInput$1, Margin, MeasureSpec as MeasureSpec$1, MemberTrace, Obstacle, PackHard, PackHard as PackHard$1, PackInput, PackOutput, Placement, Port, Portfolio, Portfolio as Portfolio$1, PortfolioPick, PortfolioTrace, RECORD_EPS, Region, SelectLevel, SelectLevel as SelectLevel$1, Side, Sides, Sides as Sides$1, StageTrace, Tolerance, checkInput, turnPoint, turnPort, turnRegion } from "@mark1russell7/layout-contract";
 /** A mutable two-dimensional vector. */
 export declare class Vector {
   #private;
@@ -750,36 +750,66 @@ export declare function fromRects<T>(rects: readonly Rect<T>[], outer: Rect<T>):
  * each rectangle, and the free sides of the outer rectangle. It gives the outer rectangle.
  */
 export declare function toRects<T>(output: PackOutput, rects: Rect<T>[], outer: Rect<T>): Rect<T>;
-/** Each strategy of the package. The benchmark starts each one on each input of the corpus. */
+/** Each single strategy of the package. The benchmark starts each one on each input of the corpus. */
 export declare const strategies: readonly Strategy[];
-/** This function gives the strategy with an id. It throws a `RangeError` for an id that the registry does not have. */
+/**
+ * The composite strategies of the registry: each one packs an input with other strategies. They are not in `strategies`.
+ * Since 0.2.7, the list has `portfolio` of roadmap item k20.
+ */
+export declare const composites: readonly Strategy[];
+/** This function gives the strategy with an id, also a composite strategy. It throws a `RangeError` for an id that the registry does not have. */
 export declare function strategy(id: string): Strategy;
 /**
  * This function packs an input with the strategy of an id. The options go over the defaults of the strategy. The
  * context gets `mulberry32` with the seed. The default seed is 0.
  */
 export declare function packWith(id: string, input: PackInput, options?: unknown, seed?: number): PackOutput;
+/** A member of `packPortfolio`: a strategy of the registry with some options. The id names the member in the trace. */
+interface PortfolioEntry {
+  id: string;
+  /** The id of a strategy of the registry */
+  strategy: string;
+  /** The options of the member over the defaults of the strategy */
+  options?: unknown;
+}
+/** The options of `packPortfolio`. The time limit and the member limit are those of `portfolio` of the contract. */
+interface PackPortfolioOptions {
+  /** The id of the portfolio. The default is `portfolio`. */
+  id?: string;
+  /** The seed of each member. The default is 0, as for `packWith`. */
+  seed?: number;
+  /** The time limit in milliseconds. Without it, each member runs. A cut member makes the pick not deterministic. */
+  budgetMs?: number;
+  /** The largest count of members that run */
+  maxMembers?: number;
+  /** The clock in milliseconds. The default is `performance.now`. */
+  now?: () => number;
+}
+/** The id of the trace stage of `packPortfolio`. Its measure `move.pick` is 1 when the pick is not member 0. */
+export declare const PORTFOLIO_STAGE = "portfolio";
 /**
- * This function counts the breaks of the 4 hard rules of the packer for an output.
- *
- * - `no-overlap`: each pair of items with their margins, and each pair of an item and an obstacle, that overlap by more than `tolerance.overlap`.
- * - `in-container`: each item with its margin that goes out of a fixed side by more than `tolerance.overlap`. The inset of
- *   the container makes each fixed side smaller (decision 3 of `docs/PACKER.md`).
- * - `locked-kept`: each locked item that moved by more than `RECORD_EPS`, or that has no placement.
- * - `complete`: each item with no placement that is not in the overflow. A locked item breaks `locked-kept` in its place.
+ * The levels of the pick of `packPortfolio` and of the portfolio report of the benchmark, in order. Level 0 is `hard`.
  *
- * A locked item with no placement stays at its input position for `no-overlap` and `in-container`. A locked item with no
- * `x` or no `y` in the input is a bad input. The rules skip it, as `packHard` of the contract does. `checkInput` finds it.
- *
- * The test of an obstacle is exact: a circle, an ellipse and a polygon with holes count only their insides, as in `packHard`.
- * The rules read a shape of the container or of an item as its bounding box (decision 5). The bounding box of an item
- * shape is relative to the position of the item. The result has no tolerance in it.
+ * - `hard`: the count of hard breaks of `checkHard` with `exactContainer`. Lower is better, with the minimum effect 0.
+ * - `pack.overflow.excessArea`: the overflow area above its bound. Lower is better.
+ * - `pack.fill`: the fill of the hull. Higher is better.
+ */
+export declare const PORTFOLIO_LEVELS: readonly SelectLevel$1[];
+/** This function gives the count of the hard breaks of an output: the sum of `checkHard` with `exactContainer`. */
+export declare function hardBreaks(input: PackInput, output: PackOutput): number;
+/**
+ * This function makes an opt-in portfolio of strategies of the registry with `portfolio` of the contract.
+ * Its `pick(input)` packs the input with each member and gives the output of the winner, its id and the trace.
  *
- * With `options.exactContainer`, a shaped container with the size `fixed` also uses its true outline for `in-container`.
- * A box then counts when `rectInRegion` of the contract tells that it is not in the shape, as in `packHard`.
- * For that test, the box grows by the inset and becomes smaller by `tolerance.overlap` on each side. The default is `false`.
+ * - A member is a strategy id, or a `PortfolioEntry` with options. The members run in the given order.
+ * - `members` is a list, or a function of the input that gives the list. The strategy `portfolio` uses the function form.
+ * - The key is the hard breaks, then `pack.overflow.excessArea`, then `pack.fill`. `PORTFOLIO_LEVELS` gives the specs.
+ * - The hash of the key is `outputHash`. `selectBest` of the contract picks the winner.
+ * - The output of the winner gets the trace stage `portfolio` with `move.pick` of `pickMoves`.
+ * - The function throws a `RangeError` for an unknown strategy, an empty list and two members with the same id.
+ *   With the function form, `pick` throws this error for the list of an input.
  */
-export declare function checkHard(input: PackInput, output: PackOutput, tolerance?: Pick<Tolerance, "overlap">, options?: ContainerTest$1): PackHard$1;
+export declare function packPortfolio(members: readonly (string | PortfolioEntry)[] | ((input: PackInput) => readonly (string | PortfolioEntry)[]), options?: PackPortfolioOptions): Portfolio$1<PackInput, PackOutput>;
 /** The parameters of a generator: a name and a string or a number for each parameter. */
 type GeneratorParams = Record<string, string | number>;
 /**
@@ -833,6 +863,12 @@ export declare function round3(x: number): number;
 export declare function canonicalJson(value: unknown): string;
 /** This function gives the hash of an input file: the first 16 hex characters of the SHA-256 of its canonical form without `hash`. */
 export declare function hashInput(file: LayoutInput$1): string;
+/**
+ * This function gives the `outputHash` of an output. It is the first 16 hex characters of the SHA-256 of the canonical form of
+ * its placements, sorted by id. The canonical form rounds each number with `round3`. Thus the order of the list does not count.
+ * The records of the benchmark and the key of `packPortfolio` use it. It is not `outputHash` of the contract, which uses a grid.
+ */
+export declare function outputHash(output: Pick<PackOutput, "placements">): string;
 /** This function gives the scale of a count: the nearest of 1, 10, 100, 1000 and 10000 on a log scale. The count 0 gives `1`. */
 export declare function countCell(count: number): CountScale;
 /**
@@ -840,6 +876,167 @@ export declare function countCell(count: number): CountScale;
  * A file without a container gets `{ fixed: "none" }`, so the packer picks the size. It is `toPackInput` of the contract.
  */
 export declare function toPackInput(file: Pick<LayoutInput$1, "container" | "boxes" | "obstacles" | "gap">): PackInput;
+/** The band of the size spread of the items of an input. */
+type SpreadBand = "identical" | "uniform" | "heavyTail";
+/** The cell of an input for the per-cell portfolio: the container shape, the band of the item count and the band of the size spread. */
+interface PortfolioCell {
+  shape: DimensionValue<"containerShape">;
+  /** The band of the item count, as `countCell` gives it: `1`, `10`, `100`, `1k` or `10k`. */
+  count: CountScale;
+  spread: SpreadBand;
+}
+/**
+ * The thresholds of the spread bands. The statistic is the standard deviation of the natural log of the linear size
+ * `sqrt(w * h)` of each item.
+ *
+ * - Below `identical`, the band is `identical`.
+ * - Below `uniform`, the band is `uniform`.
+ * - At `uniform` or above, the band is `heavyTail`.
+ *
+ * On the seeds 1 to 7 of the generators of `pack-screen-v1`, the uniform sizes give 0.258 at most. The heavy-tail sizes give 0.278 at least.
+ */
+export declare const SPREAD_THRESHOLDS: Readonly<{
+  identical: number;
+  uniform: number;
+}>;
+/** A cell with fewer inputs than this count in the training records is thin. It uses the set of its container shape. */
+export declare const THIN_INPUTS = 12;
+/**
+ * The frame budget of the default member count, in milliseconds. The default count of a cell is the largest prefix of its
+ * set of 3 that fits this budget. The prefix fits when its median summed member time on the CI records is this value or less.
+ * The count is 1 or more at all times.
+ * The default output thus does not depend on the clock: a time limit is only the opt-in option `budgetMs`.
+ */
+export declare const PORTFOLIO_FRAME_MS = 50;
+/** This function gives the key of a cell: `<shape>/<count>/<spread>`, for example `rect/100/uniform`. */
+export declare function cellKey(cell: PortfolioCell): string;
+/**
+ * This function gives the spread statistic of an input: the standard deviation of the natural log of `sqrt(w * h)` of each item.
+ * An item with no area does not count. Fewer than 2 items with an area give 0.
+ */
+export declare function spreadOf(input: PackInput): number;
+/** This function gives the band of a spread statistic by `SPREAD_THRESHOLDS`. */
+export declare function spreadBand(spread: number): SpreadBand;
+/**
+ * This function gives the cell of an input for the per-cell portfolio. The function reads only the input, not a corpus id.
+ *
+ * - `shape` is the `containerShape` of `cellOf`.
+ * - `count` is `countCell` of the count of the items.
+ * - `spread` is `spreadBand` of `spreadOf`.
+ */
+export declare function portfolioCell(input: PackInput): PortfolioCell;
+/** The sizes of the sets of the table. */
+type PortfolioSize = 1 | 2 | 3;
+/** The score of a set on its training records. The regrets are means against the oracle of the pool. */
+interface PortfolioTrainScore {
+  inputs: number;
+  /** The mean of the hard breaks of the winner of the set less those of the oracle */
+  hardRegret: number;
+  /** The mean of `pack.overflow.excessArea` of the winner of the set less that of the oracle */
+  excessAreaRegret: number;
+  /** The mean of `pack.fill` of the oracle less that of the winner of the set */
+  fillRegret: number;
+  /** The inputs where the winner of the set is in the last kept list of the oracle */
+  wins: number;
+  winShare: number;
+  /** The mean of the summed times of the members on an input, in milliseconds */
+  msMean: number;
+}
+/** The sets of one cell of the table, by size, with their training scores. */
+interface PortfolioCellSets {
+  /** The inputs of the cell in the training records */
+  inputs: number;
+  /** The value `true` when `inputs` is less than `THIN_INPUTS`. A thin cell has no sets. It uses the sets of its shape. */
+  thin: boolean;
+  /** The ids of the members of each set, in the order of the pick. A thin cell has none. */
+  sets?: Readonly<Record<`${PortfolioSize}`, readonly string[]>>;
+  /** The training score of each set */
+  train?: Readonly<Record<`${PortfolioSize}`, PortfolioTrainScore>>;
+  /** The median over the inputs of the summed member times of each prefix of the set of 3, in milliseconds. A missing record counts 0. */
+  prefixMedianMs?: Readonly<Record<`${PortfolioSize}`, number>>;
+  /** The default member count: the largest prefix of the set of 3 with `prefixMedianMs` of `PORTFOLIO_FRAME_MS` or less, and 1 at least */
+  defaultMembers?: PortfolioSize;
+}
+/** The table of the per-cell portfolio. `bench/choose-sets.ts` generates it from the records of one run. */
+interface PortfolioSets {
+  /** The run of the records: the corpus, the commit of the code and the id of the run of `bench.yml`. It also has the frame budget of the default counts. */
+  source: Readonly<{
+    corpus: string;
+    run: string;
+    commit: string;
+    inputs: number;
+    frameMs: number;
+  }>;
+  /** The member of each id: a strategy of the registry with some options */
+  entries: Readonly<Record<string, PortfolioEntry>>;
+  /** The sets of all the inputs. They are the fixed default of an input of an unknown shape. */
+  all: PortfolioCellSets;
+  /** The sets of each container shape. They are the fallback of a thin cell and of an unknown cell. */
+  shapes: Readonly<Record<string, PortfolioCellSets>>;
+  /** The sets of each cell, by `cellKey` */
+  cells: Readonly<Record<string, PortfolioCellSets>>;
+}
+/** The source of the members of an input in the table. */
+type PortfolioSetSource = "cell" | "shape" | "default";
+/** This function gives the sets of an input from a table: the sets of its cell, or of its shape, or of all the inputs. */
+export declare function portfolioSetOf(input: PackInput, table?: PortfolioSets): {
+  key: string;
+  source: PortfolioSetSource;
+  sets: PortfolioCellSets;
+};
+/**
+ * This function gives the `k` members of an input for `packPortfolio`. The members are the set of the cell of the input.
+ * A thin cell or an unknown cell takes the set of its shape, or the set of all the inputs. The function throws a `RangeError` for a `k` other than 1, 2 or 3.
+ */
+export declare function portfolioMembers(input: PackInput, k: number, table?: PortfolioSets): PortfolioEntry[];
+/**
+ * This function gives the default member count of an input: `defaultMembers` of the sets of its cell, its shape or all the inputs.
+ * With a `k`, the count is not more than `k`. A table without the count gives `k`, or 3 without a `k`.
+ */
+export declare function portfolioDefaultMembers(input: PackInput, k?: number, table?: PortfolioSets): number;
+/** The table of the per-cell portfolio: the sets of 1, 2 and 3 members of each cell, with their training scores. The run 40652567756 gives it. */
+export declare const PORTFOLIO_SETS: PortfolioSets;
+/** The options of the strategy `portfolio`. Without options, the output is a function of the input only. */
+interface PortfolioStrategyOptions {
+  /** The size of the set of the cell: 2 or 3. With `k`, each of the `k` members runs. Without `k`, the strategy uses the set of 3. */
+  k?: 2 | 3;
+  /** The largest count of the members that run. Without `k` and `maxMembers`, the count is `defaultMembers` of the cell. */
+  maxMembers?: number;
+  /** The opt-in time limit of `portfolio` of the contract, in milliseconds. It has no default. A cut member makes the result not deterministic. */
+  budgetMs?: number;
+}
+/**
+ * The strategy `portfolio`: `packPortfolio` with the function form `(input) => portfolioMembers(input, k)`. The seed of the context
+ * goes to each member. Its supports are the union of the supports of the members.
+ *
+ * - Without `k` and `maxMembers`, the members are the set of 3 of the cell, and `maxMembers` is `defaultMembers` of the cell.
+ *   The default output thus does not depend on the clock.
+ * - A member that does not support the cell of an input throws, and it does not win. When each member throws, the strategy throws the first error.
+ * - The option `budgetMs` goes to `portfolio` of the contract. The first member always runs.
+ * - The strategy throws a `RangeError` for a `k` other than 2 or 3.
+ */
+export declare const portfolioStrategy: Strategy<PortfolioStrategyOptions>;
+/**
+ * This function counts the breaks of the 4 hard rules of the packer for an output.
+ *
+ * - `no-overlap`: each pair of items with their margins, and each pair of an item and an obstacle, that overlap by more than `tolerance.overlap`.
+ * - `in-container`: each item with its margin that goes out of a fixed side by more than `tolerance.overlap`. The inset of
+ *   the container makes each fixed side smaller (decision 3 of `docs/PACKER.md`).
+ * - `locked-kept`: each locked item that moved by more than `RECORD_EPS`, or that has no placement.
+ * - `complete`: each item with no placement that is not in the overflow. A locked item breaks `locked-kept` in its place.
+ *
+ * A locked item with no placement stays at its input position for `no-overlap` and `in-container`. A locked item with no
+ * `x` or no `y` in the input is a bad input. The rules skip it, as `packHard` of the contract does. `checkInput` finds it.
+ *
+ * The test of an obstacle is exact: a circle, an ellipse and a polygon with holes count only their insides, as in `packHard`.
+ * The rules read a shape of the container or of an item as its bounding box (decision 5). The bounding box of an item
+ * shape is relative to the position of the item. The result has no tolerance in it.
+ *
+ * With `options.exactContainer`, a shaped container with the size `fixed` also uses its true outline for `in-container`.
+ * A box then counts when `rectInRegion` of the contract tells that it is not in the shape, as in `packHard`.
+ * For that test, the box grows by the inset and becomes smaller by `tolerance.overlap` on each side. The default is `false`.
+ */
+export declare function checkHard(input: PackInput, output: PackOutput, tolerance?: Pick<Tolerance, "overlap">, options?: ContainerTest$1): PackHard$1;
 /** A seeded generator of `layout-input/1` files. The same version, parameters and seed give the same file, byte for byte. */
 interface CorpusGenerator<P extends GeneratorParams = GeneratorParams> {
   /** The name. The file writes it in `generator.name`. */
@@ -952,5 +1149,5 @@ interface Corpus {
  * `RangeError` for an unknown generator, a different version or 2 inputs with the same id.
  */
 export declare function corpus(name: string, specs: readonly CorpusSpec[]): Corpus;
-export { type Cell, type ChangeMeasures, type ContainerTest, type Corpus, type CorpusCell, type CorpusEntry, type CorpusGenerator, type CorpusManifest, type CorpusSpec, type CountScale, DEFAULT_TOLERANCE, type Dimension, type DimensionValue, type Direction, EPS, type EdgeCase, type EdgeCaseParams, type FreeSpace, type FreeSpan, type FreeWidthOptions, type FreeWidthResult, type FreeWidthTry, type GeneratedInput, type GeneratorParams, type GeneratorStamp, type Item, type LayoutContainer, type LayoutEdge, type LayoutInput, type LayoutMeasures, type LayoutStrategyOptions, type Margin, type MaxRectsOptions, type MaxRectsRule, type MaxRectsStrategyOptions, type MeasureFamily, type MeasureId, type MeasureOptions, type MeasureSpec, type MetricsOptions, type Obstacle, type ObstacleLayout, type PackContext, type PackHard, type PackInput, type PackLayoutOptions, type PackOptions, type PackOutput, type PackingMetrics, type Placement, type Port, type PushOptions, type PushStrategyOptions, RECORD_EPS, type RectGridParams, type RectScatteredParams, type Region, type ShelfFit, type ShelfOptions, type Side, type Sides, type SizeDistribution, type SizeSearch, type SkylineOptions, type SortOrder, type SpaceRect, type StageTrace, type Strategy, type Supports, type Tolerance, type UiParams, checkInput, turnPoint, turnPort, turnRegion };
+export { type Cell, type ChangeMeasures, type ContainerTest, type Corpus, type CorpusCell, type CorpusEntry, type CorpusGenerator, type CorpusManifest, type CorpusSpec, type CountScale, DEFAULT_TOLERANCE, type Dimension, type DimensionValue, type Direction, EPS, type EdgeCase, type EdgeCaseParams, type FreeSpace, type FreeSpan, type FreeWidthOptions, type FreeWidthResult, type FreeWidthTry, type GeneratedInput, type GeneratorParams, type GeneratorStamp, type Item, type LayoutContainer, type LayoutEdge, type LayoutInput, type LayoutMeasures, type LayoutStrategyOptions, type Margin, type MaxRectsOptions, type MaxRectsRule, type MaxRectsStrategyOptions, type MeasureFamily, type MeasureId, type MeasureOptions, type MeasureSpec, type MemberTrace, type MetricsOptions, type Obstacle, type ObstacleLayout, type PackContext, type PackHard, type PackInput, type PackLayoutOptions, type PackOptions, type PackOutput, type PackPortfolioOptions, type PackingMetrics, type Placement, type Port, type Portfolio, type PortfolioCell, type PortfolioCellSets, type PortfolioEntry, type PortfolioPick, type PortfolioSetSource, type PortfolioSets, type PortfolioSize, type PortfolioStrategyOptions, type PortfolioTrace, type PortfolioTrainScore, type PushOptions, type PushStrategyOptions, RECORD_EPS, type RectGridParams, type RectScatteredParams, type Region, type SelectLevel, type ShelfFit, type ShelfOptions, type Side, type Sides, type SizeDistribution, type SizeSearch, type SkylineOptions, type SortOrder, type SpaceRect, type SpreadBand, type StageTrace, type Strategy, type Supports, type Tolerance, type UiParams, checkInput, turnPoint, turnPort, turnRegion };
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["Item","Sides","ContractMeasureSpec","Direction","ContainerTest","PackHard","LayoutContainer","LayoutEdge","LayoutInput"],"sources":["../src/vector.ts","../src/rect.ts","../src/order.ts","../src/contract.ts","../src/space.ts","../src/maxrects.ts","../src/shelf.ts","../src/pack.ts","../src/skyline.ts","../src/free.ts","../src/push.ts","../src/metrics.ts","../src/measures.ts","../src/strategy.ts","../src/adapters.ts","../src/convert.ts","../src/registry.ts","../src/check.ts","../src/layout-input.ts","../src/generators.ts","../src/corpus.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":["Item","Sides","ContractMeasureSpec","Direction","SelectLevel","Portfolio","LayoutContainer","LayoutEdge","LayoutInput","ContainerTest","PackHard"],"sources":["../src/vector.ts","../src/rect.ts","../src/order.ts","../src/contract.ts","../src/space.ts","../src/maxrects.ts","../src/shelf.ts","../src/pack.ts","../src/skyline.ts","../src/free.ts","../src/push.ts","../src/metrics.ts","../src/measures.ts","../src/strategy.ts","../src/adapters.ts","../src/convert.ts","../src/registry.ts","../src/portfolio.ts","../src/layout-input.ts","../src/portfolio-cell.ts","../src/portfolio-sets.ts","../src/portfolio-strategy.ts","../src/check.ts","../src/generators.ts","../src/corpus.ts"],"mappings":"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"}