@pilates/core 1.0.0-rc.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 pilates contributors
+
+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

@@ -0,0 +1,97 @@
+# @pilates/core
+
+> Headless flex layout engine for terminal UIs. Imperative `Node` API, integer cell
+> coordinates, terminal-correct text measurement. **Pure TypeScript, zero runtime
+> dependencies.**
+
+`@pilates/core` is what you get when you take Yoga's flex algorithm, rebuild it for
+the terminal (integer cells, CJK / emoji / wide-char awareness, ANSI escape
+passthrough), and *unbundle* it from any UI framework. Use it directly, or wrap it
+in React, Vue, Svelte, or anything else.
+
+## Install
+
+```bash
+npm install @pilates/core
+```
+
+## Quick start
+
+```ts
+import { Node, Edge } from '@pilates/core';
+
+const root = Node.create();
+root.setFlexDirection('row');
+root.setWidth(80);
+root.setHeight(24);
+root.setPadding(Edge.All, 1);
+
+const main = Node.create();
+main.setFlex(1);
+const sidebar = Node.create();
+sidebar.setWidth(20);
+
+root.insertChild(main, 0);
+root.insertChild(sidebar, 1);
+
+root.calculateLayout();
+
+main.getComputedLayout();    // { left:1, top:1, width:57, height:22 }
+sidebar.getComputedLayout(); // { left:58, top:1, width:20, height:22 }
+```
+
+## Style API
+
+Setters mirror Yoga / CSS Flexbox semantics. All values are in terminal cells.
+
+| Category | Setters |
+|---|---|
+| Direction | `setFlexDirection`, `setFlexWrap` |
+| Sizing | `setWidth`, `setHeight`, `setMinWidth`, `setMinHeight`, `setMaxWidth`, `setMaxHeight` |
+| Flex | `setFlex` (shorthand), `setFlexGrow`, `setFlexShrink`, `setFlexBasis` |
+| Spacing | `setPadding(edge, n)`, `setMargin(edge, n)`, `setGap('row' \| 'column', n)` |
+| Alignment | `setJustifyContent`, `setAlignItems`, `setAlignSelf`, `setAlignContent` |
+| Position | `setPositionType('relative' \| 'absolute')`, `setPosition(edge, n)` |
+| Visibility | `setDisplay('flex' \| 'none')` |
+
+`Edge` is `Top` / `Right` / `Bottom` / `Left` / `Horizontal` / `Vertical` / `All`.
+
+## Text measurement
+
+```ts
+import { stringWidth, cellWidth, graphemes, stripAnsi } from '@pilates/core';
+
+stringWidth('hello');      // 5
+stringWidth('你好');        // 4 (each CJK char is 2 cells)
+stringWidth('🔥');         // 2
+stringWidth('👨‍👩‍👧');     // 2 (ZWJ family is one grapheme)
+stringWidth('🇯🇵');        // 2 (regional indicator pair = flag)
+stringWidth('\x1b[31mred\x1b[0m'); // 3 (ANSI stripped)
+```
+
+Driven by the latest Unicode UCD data: East Asian Width, Emoji Presentation,
+Grapheme Break Property, Default Ignorable. No runtime fetch — tables are
+generated at build time and shipped with the package.
+
+## Custom text measurement (measure functions)
+
+```ts
+import { Node, MeasureMode } from '@pilates/core';
+
+const text = Node.create();
+text.setMeasureFunc((width, widthMode, height, heightMode) => {
+  // Compute the natural width / height of the leaf's content.
+  return { width: stringWidth('Hello'), height: 1 };
+});
+```
+
+## Status
+
+Release candidate (`1.0.0-rc.1`). The full v1 surface is implemented and
+verified cell-for-cell against `yoga-layout` (Meta's reference WASM build).
+
+**Out of v1:** `aspectRatio`, RTL/LTR direction inheritance, baseline alignment.
+
+## License
+
+MIT

package/dist/algorithm/axis.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Axis helpers — translate between flex semantics ("main", "cross", "start",
+ * "end") and concrete tuple/property accessors. Keeping this in one place lets
+ * the layout pass be written once and work for both row and column directions
+ * without endless if-else.
+ *
+ * Padding and margin tuples are stored as [top, right, bottom, left] in
+ * `Style`. Position tuples use the same convention.
+ *
+ * Gap is split into row-gap and column-gap (per CSS spec):
+ *   - In `flex-direction: row`, items are laid out horizontally; the gap
+ *     between them along the main axis is `column-gap`.
+ *   - In `flex-direction: column`, items are stacked vertically; the gap
+ *     between them along the main axis is `row-gap`.
+ */
+import type { FlexDirection, Style } from '../style.js';
+export type Axis = 'row' | 'column';
+export declare function mainAxis(d: FlexDirection): Axis;
+export declare function crossAxis(d: FlexDirection): Axis;
+export declare function isReverse(d: FlexDirection): boolean;
+/** Edge index for the start side of a given axis. */
+export declare function startEdge(axis: Axis): number;
+/** Edge index for the end side of a given axis. */
+export declare function endEdge(axis: Axis): number;
+/** Read the start side of a [top, right, bottom, left] tuple. */
+export declare function readStart(box: readonly number[], axis: Axis): number;
+/** Read the end side of a [top, right, bottom, left] tuple. */
+export declare function readEnd(box: readonly number[], axis: Axis): number;
+/**
+ * The CSS gap that separates flex items along the given axis.
+ *   - main axis is row → use column-gap
+ *   - main axis is column → use row-gap
+ */
+export declare function gapAlong(style: Style, axis: Axis): number;
+/** The style's preferred size along an axis (`width` for row, `height` for column). */
+export declare function preferredSize(style: Style, axis: Axis): number | 'auto';
+export declare function minSize(style: Style, axis: Axis): number;
+export declare function maxSize(style: Style, axis: Axis): number | undefined;
+/** Clamp a candidate size to the [minSize, maxSize] range for the given axis. */
+export declare function clampSize(style: Style, axis: Axis, value: number): number;
+//# sourceMappingURL=axis.d.ts.map

package/dist/algorithm/axis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"axis.d.ts","sourceRoot":"","sources":["../../src/algorithm/axis.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAExD,MAAM,MAAM,IAAI,GAAG,KAAK,GAAG,QAAQ,CAAC;AAOpC,wBAAgB,QAAQ,CAAC,CAAC,EAAE,aAAa,GAAG,IAAI,CAE/C;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,aAAa,GAAG,IAAI,CAEhD;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,aAAa,GAAG,OAAO,CAEnD;AAED,qDAAqD;AACrD,wBAAgB,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAE5C;AAED,mDAAmD;AACnD,wBAAgB,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAE1C;AAED,iEAAiE;AACjE,wBAAgB,SAAS,CAAC,GAAG,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,EAAE,IAAI,GAAG,MAAM,CAEpE;AAED,+DAA+D;AAC/D,wBAAgB,OAAO,CAAC,GAAG,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,EAAE,IAAI,GAAG,MAAM,CAElE;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,GAAG,MAAM,CAEzD;AAED,uFAAuF;AACvF,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,CAEvE;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,GAAG,MAAM,CAExD;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,GAAG,MAAM,GAAG,SAAS,CAEpE;AAED,iFAAiF;AACjF,wBAAgB,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAMzE"}

package/dist/algorithm/axis.js

@@ -0,0 +1,72 @@
+/**
+ * Axis helpers — translate between flex semantics ("main", "cross", "start",
+ * "end") and concrete tuple/property accessors. Keeping this in one place lets
+ * the layout pass be written once and work for both row and column directions
+ * without endless if-else.
+ *
+ * Padding and margin tuples are stored as [top, right, bottom, left] in
+ * `Style`. Position tuples use the same convention.
+ *
+ * Gap is split into row-gap and column-gap (per CSS spec):
+ *   - In `flex-direction: row`, items are laid out horizontally; the gap
+ *     between them along the main axis is `column-gap`.
+ *   - In `flex-direction: column`, items are stacked vertically; the gap
+ *     between them along the main axis is `row-gap`.
+ */
+const TOP = 0;
+const RIGHT = 1;
+const BOTTOM = 2;
+const LEFT = 3;
+export function mainAxis(d) {
+    return d === 'row' || d === 'row-reverse' ? 'row' : 'column';
+}
+export function crossAxis(d) {
+    return mainAxis(d) === 'row' ? 'column' : 'row';
+}
+export function isReverse(d) {
+    return d === 'row-reverse' || d === 'column-reverse';
+}
+/** Edge index for the start side of a given axis. */
+export function startEdge(axis) {
+    return axis === 'row' ? LEFT : TOP;
+}
+/** Edge index for the end side of a given axis. */
+export function endEdge(axis) {
+    return axis === 'row' ? RIGHT : BOTTOM;
+}
+/** Read the start side of a [top, right, bottom, left] tuple. */
+export function readStart(box, axis) {
+    return box[startEdge(axis)] ?? 0;
+}
+/** Read the end side of a [top, right, bottom, left] tuple. */
+export function readEnd(box, axis) {
+    return box[endEdge(axis)] ?? 0;
+}
+/**
+ * The CSS gap that separates flex items along the given axis.
+ *   - main axis is row → use column-gap
+ *   - main axis is column → use row-gap
+ */
+export function gapAlong(style, axis) {
+    return axis === 'row' ? style.gapColumn : style.gapRow;
+}
+/** The style's preferred size along an axis (`width` for row, `height` for column). */
+export function preferredSize(style, axis) {
+    return axis === 'row' ? style.width : style.height;
+}
+export function minSize(style, axis) {
+    return axis === 'row' ? style.minWidth : style.minHeight;
+}
+export function maxSize(style, axis) {
+    return axis === 'row' ? style.maxWidth : style.maxHeight;
+}
+/** Clamp a candidate size to the [minSize, maxSize] range for the given axis. */
+export function clampSize(style, axis, value) {
+    const min = minSize(style, axis);
+    const max = maxSize(style, axis);
+    let v = value < min ? min : value;
+    if (max !== undefined && v > max)
+        v = max;
+    return v;
+}
+//# sourceMappingURL=axis.js.map

package/dist/algorithm/axis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"axis.js","sourceRoot":"","sources":["../../src/algorithm/axis.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAMH,MAAM,GAAG,GAAG,CAAC,CAAC;AACd,MAAM,KAAK,GAAG,CAAC,CAAC;AAChB,MAAM,MAAM,GAAG,CAAC,CAAC;AACjB,MAAM,IAAI,GAAG,CAAC,CAAC;AAEf,MAAM,UAAU,QAAQ,CAAC,CAAgB;IACvC,OAAO,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC;AAC/D,CAAC;AAED,MAAM,UAAU,SAAS,CAAC,CAAgB;IACxC,OAAO,QAAQ,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC;AAClD,CAAC;AAED,MAAM,UAAU,SAAS,CAAC,CAAgB;IACxC,OAAO,CAAC,KAAK,aAAa,IAAI,CAAC,KAAK,gBAAgB,CAAC;AACvD,CAAC;AAED,qDAAqD;AACrD,MAAM,UAAU,SAAS,CAAC,IAAU;IAClC,OAAO,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC;AACrC,CAAC;AAED,mDAAmD;AACnD,MAAM,UAAU,OAAO,CAAC,IAAU;IAChC,OAAO,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC;AACzC,CAAC;AAED,iEAAiE;AACjE,MAAM,UAAU,SAAS,CAAC,GAAsB,EAAE,IAAU;IAC1D,OAAO,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC;AACnC,CAAC;AAED,+DAA+D;AAC/D,MAAM,UAAU,OAAO,CAAC,GAAsB,EAAE,IAAU;IACxD,OAAO,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC;AACjC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,QAAQ,CAAC,KAAY,EAAE,IAAU;IAC/C,OAAO,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC;AACzD,CAAC;AAED,uFAAuF;AACvF,MAAM,UAAU,aAAa,CAAC,KAAY,EAAE,IAAU;IACpD,OAAO,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC;AACrD,CAAC;AAED,MAAM,UAAU,OAAO,CAAC,KAAY,EAAE,IAAU;IAC9C,OAAO,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC;AAC3D,CAAC;AAED,MAAM,UAAU,OAAO,CAAC,KAAY,EAAE,IAAU;IAC9C,OAAO,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC;AAC3D,CAAC;AAED,iFAAiF;AACjF,MAAM,UAAU,SAAS,CAAC,KAAY,EAAE,IAAU,EAAE,KAAa;IAC/D,MAAM,GAAG,GAAG,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IACjC,MAAM,GAAG,GAAG,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IACjC,IAAI,CAAC,GAAG,KAAK,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC;IAClC,IAAI,GAAG,KAAK,SAAS,IAAI,CAAC,GAAG,GAAG;QAAE,CAAC,GAAG,GAAG,CAAC;IAC1C,OAAO,CAAC,CAAC;AACX,CAAC"}

package/dist/algorithm/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Top-level entry: turn a tree of styled nodes into a tree of computed
+ * layouts. The flow is:
+ *
+ *   1. Resolve the root's own size from its style + caller availability.
+ *   2. Recursively lay out children in floating-point coordinates.
+ *   3. Round the whole tree to integer cells.
+ *   4. Mark every node clean.
+ */
+import type { Node } from '../node.js';
+export declare function calculateLayout(root: Node, availableWidth: number | undefined, availableHeight: number | undefined): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/algorithm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/algorithm/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAIvC,wBAAgB,eAAe,CAC7B,IAAI,EAAE,IAAI,EACV,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,eAAe,EAAE,MAAM,GAAG,SAAS,GAClC,IAAI,CASN"}

package/dist/algorithm/index.js

@@ -0,0 +1,26 @@
+/**
+ * Top-level entry: turn a tree of styled nodes into a tree of computed
+ * layouts. The flow is:
+ *
+ *   1. Resolve the root's own size from its style + caller availability.
+ *   2. Recursively lay out children in floating-point coordinates.
+ *   3. Round the whole tree to integer cells.
+ *   4. Mark every node clean.
+ */
+import { layoutChildren, resolveRootAxisSize } from './main-axis.js';
+import { roundLayout } from './round.js';
+export function calculateLayout(root, availableWidth, availableHeight) {
+    root.layout.left = 0;
+    root.layout.top = 0;
+    root.layout.width = resolveRootAxisSize(root, 'row', availableWidth);
+    root.layout.height = resolveRootAxisSize(root, 'column', availableHeight);
+    layoutChildren(root);
+    roundLayout(root);
+    markClean(root);
+}
+function markClean(node) {
+    node.clearDirty();
+    for (let i = 0; i < node.getChildCount(); i++)
+        markClean(node.getChild(i));
+}
+//# sourceMappingURL=index.js.map

package/dist/algorithm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/algorithm/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACrE,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC,MAAM,UAAU,eAAe,CAC7B,IAAU,EACV,cAAkC,EAClC,eAAmC;IAEnC,IAAI,CAAC,MAAM,CAAC,IAAI,GAAG,CAAC,CAAC;IACrB,IAAI,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,CAAC;IACpB,IAAI,CAAC,MAAM,CAAC,KAAK,GAAG,mBAAmB,CAAC,IAAI,EAAE,KAAK,EAAE,cAAc,CAAC,CAAC;IACrE,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,mBAAmB,CAAC,IAAI,EAAE,QAAQ,EAAE,eAAe,CAAC,CAAC;IAE1E,cAAc,CAAC,IAAI,CAAC,CAAC;IACrB,WAAW,CAAC,IAAI,CAAC,CAAC;IAClB,SAAS,CAAC,IAAI,CAAC,CAAC;AAClB,CAAC;AAED,SAAS,SAAS,CAAC,IAAU;IAC3B,IAAI,CAAC,UAAU,EAAE,CAAC;IAClB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,aAAa,EAAE,EAAE,CAAC,EAAE;QAAE,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAE,CAAC,CAAC;AAC9E,CAAC"}

package/dist/algorithm/main-axis.d.ts

@@ -0,0 +1,59 @@
+/**
+ * The flex layout algorithm — Milestones 4 + 5.
+ *
+ * Pipeline (one container at a time):
+ *
+ *   1. Build per-child `FlexItem` records: hypothetical main size (basis or
+ *      style or measure-func or 0), main and cross margins, "natural" cross
+ *      size (used when alignment is not stretch).
+ *   2. Pack items into `FlexLine`s. With `flex-wrap: nowrap` everything goes
+ *      on one line; with `wrap` items spill onto a new line whenever the
+ *      next addition would exceed the container's inner main size.
+ *   3. For each line, distribute slack via flex-grow / flex-shrink with the
+ *      CSS freeze loop (items hitting min/max are frozen, their slack is
+ *      redistributed among unfrozen siblings). M4 work, unchanged.
+ *   4. Compute each line's cross size: max of items' (natural cross +
+ *      cross-margins). Single-line containers just use the inner cross.
+ *   5. Stack lines along the cross axis with `align-content`. Multi-line
+ *      stacks distribute leftover space; single-line stacks just place the
+ *      one line at the start.
+ *   6. Inside each line, position items along the main axis with
+ *      `justify-content`. Leftover space is distributed via flex-start /
+ *      flex-end / center / space-between / space-around / space-evenly.
+ *   7. Inside each line, cross-align each item: alignSelf takes precedence,
+ *      falling back to the container's alignItems for items with
+ *      alignSelf: 'auto'. Stretch fills the line cross size.
+ *   8. Reverse-direction containers flip main positions; wrap-reverse
+ *      reverses the line stack on the cross axis.
+ *   9. Recurse into each visible child.
+ *
+ * Position rounding lives in `round.ts` and runs once at the very end so
+ * sibling boxes butt cleanly on integer cell boundaries.
+ */
+import type { Node } from '../node.js';
+import { type Axis } from './axis.js';
+/**
+ * Lay out a node's children. The container's own `layout.width` and
+ * `layout.height` must already be set when this is called.
+ *
+ * Two child populations are handled here:
+ *   - In-flow flex children (positionType !== 'absolute', display !== 'none'):
+ *     run through the 8-step flex pipeline.
+ *   - Out-of-flow absolute children (positionType === 'absolute',
+ *     display !== 'none'): positioned independently against the parent's
+ *     content box. They do not contribute to the flex pipeline.
+ *
+ * After both populations are positioned, the function recurses into every
+ * non-hidden child so their own descendants are laid out within the box
+ * we just assigned them.
+ */
+export declare function layoutChildren(node: Node): void;
+/**
+ * Resolve the root node's own size from style + caller-supplied availability.
+ *
+ *   - explicit number → use it (clamped to min/max).
+ *   - 'auto' + an `available` value → use available, clamped.
+ *   - 'auto' with neither → 0.
+ */
+export declare function resolveRootAxisSize(node: Node, axis: Axis, available: number | undefined): number;
+//# sourceMappingURL=main-axis.d.ts.map

package/dist/algorithm/main-axis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main-axis.d.ts","sourceRoot":"","sources":["../../src/algorithm/main-axis.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAGH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAEvC,OAAO,EACL,KAAK,IAAI,EAWV,MAAM,WAAW,CAAC;AAgCnB;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAyB/C;AAirBD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAcjG"}