@askdkc/dsh-cli 0.11.3

package/lib/types/ink/input-suppression.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Input suppression window for terminal handoffs (issue #123): when stdin is
+ * handed to an external TUI (full-screen editor) and back, the tty can
+ * deliver a burst of bytes that are NOT user keystrokes — the editor's
+ * rmcup/mode-restore replies, CPR/DECRPM query responses, mouse-event
+ * fragments, or keystrokes typed into the canonical line buffer while raw
+ * mode was off. Parsed as input they are destructive: a stray ESC reads as
+ * the escape key (which CLEARS a non-empty prompt) and the rest lands as
+ * text garbage.
+ *
+ * resumeStdin() drains what is already buffered; this module covers what
+ * arrives LATE (terminal replies are async). use-input checks the window at
+ * the single choke point every component's input flows through, so no
+ * listener (Chat's ctrl+c/esc handling included) sees the burst.
+ */
+/** Suppress all parsed input for `ms` from now (monotonic extension). */
+export declare function suppressInputFor(ms: number): void;
+/** True while the post-handoff suppression window is open. */
+export declare function isInputSuppressed(): boolean;
+//# sourceMappingURL=input-suppression.d.ts.map

package/lib/types/ink/input-suppression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-suppression.d.ts","sourceRoot":"","sources":["../../../src/ink/input-suppression.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,yEAAyE;AACzE,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAGjD;AAED,8DAA8D;AAC9D,wBAAgB,iBAAiB,IAAI,OAAO,CAE3C"}

package/lib/types/ink/input-suppression.js

@@ -0,0 +1,26 @@
+/**
+ * Input suppression window for terminal handoffs (issue #123): when stdin is
+ * handed to an external TUI (full-screen editor) and back, the tty can
+ * deliver a burst of bytes that are NOT user keystrokes — the editor's
+ * rmcup/mode-restore replies, CPR/DECRPM query responses, mouse-event
+ * fragments, or keystrokes typed into the canonical line buffer while raw
+ * mode was off. Parsed as input they are destructive: a stray ESC reads as
+ * the escape key (which CLEARS a non-empty prompt) and the rest lands as
+ * text garbage.
+ *
+ * resumeStdin() drains what is already buffered; this module covers what
+ * arrives LATE (terminal replies are async). use-input checks the window at
+ * the single choke point every component's input flows through, so no
+ * listener (Chat's ctrl+c/esc handling included) sees the burst.
+ */
+let suppressedUntil = 0;
+/** Suppress all parsed input for `ms` from now (monotonic extension). */
+export function suppressInputFor(ms) {
+    const until = Date.now() + ms;
+    if (until > suppressedUntil)
+        suppressedUntil = until;
+}
+/** True while the post-handoff suppression window is open. */
+export function isInputSuppressed() {
+    return Date.now() < suppressedUntil;
+}

package/lib/types/ink/instances.d.ts

@@ -0,0 +1,10 @@
+import type Ink from './ink.js';
+/**
+ * Live Ink instances keyed by their output stream, so consecutive render()
+ * calls reuse the instance for a stream instead of creating a new one.
+ * Lives in its own module: render.js creates instances while instance.js
+ * deletes its own entry on unmount.
+ */
+declare const instances: Map<NodeJS.WriteStream, Ink>;
+export default instances;
+//# sourceMappingURL=instances.d.ts.map

package/lib/types/ink/instances.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instances.d.ts","sourceRoot":"","sources":["../../../src/ink/instances.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,GAAG,MAAM,UAAU,CAAA;AAE/B;;;;;GAKG;AACH,QAAA,MAAM,SAAS,8BAAqC,CAAA;AACpD,eAAe,SAAS,CAAA"}

package/lib/types/ink/instances.js

@@ -0,0 +1,13 @@
+// Store all instances of Ink (instance.js) to ensure that consecutive render() calls
+// use the same instance of Ink and don't create a new one
+//
+// This map has to be stored in a separate file, because render.js creates instances,
+// but instance.js should delete itself from the map on unmount
+/**
+ * Live Ink instances keyed by their output stream, so consecutive render()
+ * calls reuse the instance for a stream instead of creating a new one.
+ * Lives in its own module: render.js creates instances while instance.js
+ * deletes its own entry on unmount.
+ */
+const instances = new Map();
+export default instances;

package/lib/types/ink/kitty-graphics.d.ts

@@ -0,0 +1,41 @@
+import { type TerminalCellSize, type TerminalImagePlacement, type TerminalImageSource } from './terminal-image.js';
+export interface KittyGraphicsManagerOptions {
+    /** Deterministic seed used by protocol tests; production chooses a random range. */
+    readonly firstImageId?: number;
+    /** Physical pixels per cell; defaults to a conventional 8×16 cell. */
+    readonly cellSize?: TerminalCellSize;
+}
+/**
+ * Reconcile renderer image requests with Kitty image/placement state.
+ *
+ * Pixel content owns an image id while each DOM node owns a placement id.
+ * Equal immutable RGBA content is uploaded once and can back several nodes;
+ * geometry changes replace only that node's placement without flicker.
+ */
+export declare class KittyGraphicsManager {
+    private readonly images;
+    private readonly placements;
+    private readonly contentHashes;
+    private nextImageId;
+    private nextPlacementId;
+    private cellSize;
+    constructor(options?: KittyGraphicsManagerOptions);
+    /** Update the physical cell ratio used by future image variants. */
+    setCellSize(cellSize: TerminalCellSize): boolean;
+    reconcile(placements: readonly TerminalImagePlacement[]): string;
+    /** A clear/screen swap invalidated terminal-side data; resend next frame. */
+    invalidateAll(): void;
+    /** Delete every image owned by this renderer and forget their ids. */
+    deleteAll(): string;
+    private imageFor;
+    private contentHash;
+    private allocateImageId;
+    private allocatePlacementId;
+}
+/** Zlib-compressed direct RGBA split into protocol-compliant base64 chunks. */
+export declare function transmitKittyRgba(imageId: number, source: TerminalImageSource): string;
+export declare function kittyPlacement(imageId: number, placementId: number, x: number, y: number, columns: number, rows: number, zIndex?: number): string;
+export declare function deleteKittyPlacement(imageId: number, placementId: number): string;
+export declare function deleteKittyImage(imageId: number): string;
+export declare function kittyCommand(control: string, payload?: string): string;
+//# sourceMappingURL=kitty-graphics.d.ts.map

package/lib/types/ink/kitty-graphics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kitty-graphics.d.ts","sourceRoot":"","sources":["../../../src/ink/kitty-graphics.ts"],"names":[],"mappings":"AAGA,OAAO,EAIL,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,EAC3B,KAAK,mBAAmB,EACzB,MAAM,qBAAqB,CAAA;AAkC5B,MAAM,WAAW,2BAA2B;IAC1C,oFAAoF;IACpF,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAA;IAC9B,sEAAsE;IACtE,QAAQ,CAAC,QAAQ,CAAC,EAAE,gBAAgB,CAAA;CACrC;AAED;;;;;;GAMG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgC;IACvD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAwC;IACnE,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAoC;IAClE,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,eAAe,CAAI;IAC3B,OAAO,CAAC,QAAQ,CAAkB;gBAEtB,OAAO,GAAE,2BAAgC;IASrD,oEAAoE;IACpE,WAAW,CAAC,QAAQ,EAAE,gBAAgB,GAAG,OAAO;IAYhD,SAAS,CAAC,UAAU,EAAE,SAAS,sBAAsB,EAAE,GAAG,MAAM;IA0GhE,6EAA6E;IAC7E,aAAa,IAAI,IAAI;IAOrB,sEAAsE;IACtE,SAAS,IAAI,MAAM;IASnB,OAAO,CAAC,QAAQ;IA+BhB,OAAO,CAAC,WAAW;IAQnB,OAAO,CAAC,eAAe;IAOvB,OAAO,CAAC,mBAAmB;CAQ5B;AAED,+EAA+E;AAC/E,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,mBAAmB,GAC1B,MAAM,CAER;AAoCD,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EACnB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,MAAM,SAAgB,GACrB,MAAM,CAOR;AAED,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,GAClB,MAAM,CAER;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,SAAK,GAAG,MAAM,CAElE"}

package/lib/types/ink/kitty-graphics.js

@@ -0,0 +1,229 @@
+import { createHash, randomInt } from 'node:crypto';
+import { deflateSync } from 'node:zlib';
+import { DEFAULT_TERMINAL_CELL_SIZE, fitTerminalImageSource, normalizeTerminalCellSize, } from './terminal-image.js';
+const APC = '\u001b_G';
+const ST = '\u001b\\';
+const BASE64_CHUNK_CELLS = 4096;
+const ID_MIN = 0x40000000;
+const ID_MAX_EXCLUSIVE = 0x7fffffff;
+const PLACEMENT_ID_MAX_EXCLUSIVE = 0x40000000;
+// Keep raster content behind terminal text and explicit panel backgrounds.
+const IMAGE_Z_INDEX = -0x80000000;
+/**
+ * Reconcile renderer image requests with Kitty image/placement state.
+ *
+ * Pixel content owns an image id while each DOM node owns a placement id.
+ * Equal immutable RGBA content is uploaded once and can back several nodes;
+ * geometry changes replace only that node's placement without flicker.
+ */
+export class KittyGraphicsManager {
+    images = new Map();
+    placements = new Map();
+    contentHashes = new WeakMap();
+    nextImageId;
+    nextPlacementId = 1;
+    cellSize;
+    constructor(options = {}) {
+        this.nextImageId = normalizeFirstId(options.firstImageId ?? randomInt(ID_MIN, ID_MAX_EXCLUSIVE));
+        this.cellSize = normalizeTerminalCellSize(options.cellSize ?? DEFAULT_TERMINAL_CELL_SIZE);
+    }
+    /** Update the physical cell ratio used by future image variants. */
+    setCellSize(cellSize) {
+        const normalized = normalizeTerminalCellSize(cellSize);
+        if (normalized.width === this.cellSize.width &&
+            normalized.height === this.cellSize.height) {
+            return false;
+        }
+        this.cellSize = normalized;
+        return true;
+    }
+    reconcile(placements) {
+        const desiredNodes = new Set();
+        const desiredImages = new Set();
+        const desired = [];
+        const output = [];
+        for (const placement of placements) {
+            if (desiredNodes.has(placement.node))
+                continue;
+            desiredNodes.add(placement.node);
+            const image = this.imageFor(placement);
+            desiredImages.add(image);
+            desired.push({ placement, image });
+        }
+        const obsoletePlacements = [];
+        for (const { placement, image } of desired) {
+            let state = this.placements.get(placement.node);
+            if (state === undefined) {
+                const placementId = this.allocatePlacementId();
+                state = {
+                    image,
+                    placementId,
+                    zIndex: IMAGE_Z_INDEX + placementId - 1,
+                    placed: false,
+                    x: -1,
+                    y: -1,
+                    columns: 0,
+                    rows: 0,
+                };
+                this.placements.set(placement.node, state);
+            }
+            if (state.image !== image) {
+                obsoletePlacements.push({
+                    image: state.image,
+                    placementId: state.placementId,
+                });
+                state.image = image;
+                state.placed = false;
+            }
+            if (!image.uploaded) {
+                output.push(transmitPreparedKittyRgba(image.imageId, image.payload));
+                image.uploaded = true;
+            }
+            const moved = state.x !== placement.x ||
+                state.y !== placement.y ||
+                state.columns !== placement.columns ||
+                state.rows !== placement.rows;
+            if (!state.placed || moved) {
+                output.push(kittyPlacement(image.imageId, state.placementId, placement.x, placement.y, placement.columns, placement.rows, state.zIndex));
+                state.x = placement.x;
+                state.y = placement.y;
+                state.columns = placement.columns;
+                state.rows = placement.rows;
+                state.placed = true;
+            }
+        }
+        for (const [node, state] of this.placements) {
+            if (desiredNodes.has(node))
+                continue;
+            obsoletePlacements.push({
+                image: state.image,
+                placementId: state.placementId,
+            });
+            this.placements.delete(node);
+        }
+        for (const obsolete of obsoletePlacements) {
+            if (!desiredImages.has(obsolete.image))
+                continue;
+            output.push(deleteKittyPlacement(obsolete.image.imageId, obsolete.placementId));
+        }
+        for (const [key, image] of this.images) {
+            if (desiredImages.has(image))
+                continue;
+            output.push(deleteKittyImage(image.imageId));
+            this.images.delete(key);
+        }
+        return output.join('');
+    }
+    /** A clear/screen swap invalidated terminal-side data; resend next frame. */
+    invalidateAll() {
+        for (const image of this.images.values())
+            image.uploaded = false;
+        for (const state of this.placements.values()) {
+            state.placed = false;
+        }
+    }
+    /** Delete every image owned by this renderer and forget their ids. */
+    deleteAll() {
+        const output = [...this.images.values()]
+            .map(image => deleteKittyImage(image.imageId))
+            .join('');
+        this.images.clear();
+        this.placements.clear();
+        return output;
+    }
+    imageFor(placement) {
+        const digest = this.contentHash(placement.source.data);
+        const key = [
+            digest,
+            placement.source.width,
+            placement.source.height,
+            placement.columns,
+            placement.rows,
+            this.cellSize.width,
+            this.cellSize.height,
+            placement.presentation,
+        ].join(':');
+        const existing = this.images.get(key);
+        if (existing !== undefined)
+            return existing;
+        const fitted = fitTerminalImageSource(placement.source, placement.columns, placement.rows, this.cellSize, placement.presentation);
+        const image = {
+            imageId: this.allocateImageId(),
+            payload: prepareKittyRgba(fitted),
+            uploaded: false,
+        };
+        this.images.set(key, image);
+        return image;
+    }
+    contentHash(data) {
+        const existing = this.contentHashes.get(data);
+        if (existing !== undefined)
+            return existing;
+        const digest = createHash('sha256').update(data).digest('base64url');
+        this.contentHashes.set(data, digest);
+        return digest;
+    }
+    allocateImageId() {
+        const id = this.nextImageId;
+        this.nextImageId += 1;
+        if (this.nextImageId >= ID_MAX_EXCLUSIVE)
+            this.nextImageId = ID_MIN;
+        return id;
+    }
+    allocatePlacementId() {
+        const id = this.nextPlacementId;
+        this.nextPlacementId += 1;
+        if (this.nextPlacementId >= PLACEMENT_ID_MAX_EXCLUSIVE) {
+            this.nextPlacementId = 1;
+        }
+        return id;
+    }
+}
+/** Zlib-compressed direct RGBA split into protocol-compliant base64 chunks. */
+export function transmitKittyRgba(imageId, source) {
+    return transmitPreparedKittyRgba(imageId, prepareKittyRgba(source));
+}
+function prepareKittyRgba(source) {
+    return {
+        data: deflateSync(source.data, { level: 1 }),
+        width: source.width,
+        height: source.height,
+    };
+}
+function transmitPreparedKittyRgba(imageId, payload) {
+    const encoded = Buffer.from(payload.data.buffer, payload.data.byteOffset, payload.data.byteLength).toString('base64');
+    const chunks = [];
+    for (let offset = 0; offset < encoded.length; offset += BASE64_CHUNK_CELLS) {
+        chunks.push(encoded.slice(offset, offset + BASE64_CHUNK_CELLS));
+    }
+    if (chunks.length === 0)
+        chunks.push('');
+    return chunks
+        .map((chunk, index) => {
+        const more = index + 1 < chunks.length ? 1 : 0;
+        const control = index === 0
+            ? `a=t,t=d,f=32,s=${payload.width},v=${payload.height},i=${imageId},o=z,q=2,m=${more}`
+            : `m=${more},q=2`;
+        return kittyCommand(control, chunk);
+    })
+        .join('');
+}
+export function kittyPlacement(imageId, placementId, x, y, columns, rows, zIndex = IMAGE_Z_INDEX) {
+    return (`\u001b[${y + 1};${x + 1}H` +
+        kittyCommand(`a=p,i=${imageId},p=${placementId},c=${columns},r=${rows},z=${zIndex},C=1,q=2`));
+}
+export function deleteKittyPlacement(imageId, placementId) {
+    return kittyCommand(`a=d,d=i,i=${imageId},p=${placementId},q=2`);
+}
+export function deleteKittyImage(imageId) {
+    return kittyCommand(`a=d,d=I,i=${imageId},q=2`);
+}
+export function kittyCommand(control, payload = '') {
+    return `${APC}${control};${payload}${ST}`;
+}
+function normalizeFirstId(value) {
+    if (!Number.isSafeInteger(value) || value <= 0 || value >= 0xffffffff) {
+        return ID_MIN;
+    }
+    return value;
+}

package/lib/types/ink/layout/engine.d.ts

@@ -0,0 +1,7 @@
+import type { LayoutNode } from './node.js';
+/**
+ * Create a new layout node backed by the Yoga adapter.
+ * @returns an empty layout node with no children, styles, or measure function.
+ */
+export declare function createLayoutNode(): LayoutNode;
+//# sourceMappingURL=engine.d.ts.map

package/lib/types/ink/layout/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../../../src/ink/layout/engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAG3C;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,UAAU,CAE7C"}

package/lib/types/ink/layout/engine.js

@@ -0,0 +1,8 @@
+import { createYogaLayoutNode } from './yoga.js';
+/**
+ * Create a new layout node backed by the Yoga adapter.
+ * @returns an empty layout node with no children, styles, or measure function.
+ */
+export function createLayoutNode() {
+    return createYogaLayoutNode();
+}

package/lib/types/ink/layout/geometry.d.ts

@@ -0,0 +1,86 @@
+/** A 2D point in grid coordinates. */
+export type Point = {
+    x: number;
+    y: number;
+};
+/** A width and height in terminal cells. */
+export type Size = {
+    width: number;
+    height: number;
+};
+/** A rectangle: an origin point plus a size. */
+export type Rectangle = Point & Size;
+/** Edge insets (padding, margin, border) */
+export type Edges = {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+/**
+ * Create uniform edges with the same value on every side.
+ * @param all - the value applied to all four sides.
+ * @returns edges with every side set to `all`.
+ */
+export declare function edges(all: number): Edges;
+/**
+ * Create edges from vertical and horizontal values.
+ * @param vertical - the value for the top and bottom sides.
+ * @param horizontal - the value for the left and right sides.
+ * @returns edges with the vertical value on top/bottom and the horizontal value on left/right.
+ */
+export declare function edges(vertical: number, horizontal: number): Edges;
+/**
+ * Create edges from four individual side values.
+ * @param top - the value for the top side.
+ * @param right - the value for the right side.
+ * @param bottom - the value for the bottom side.
+ * @param left - the value for the left side.
+ * @returns edges with each side set to its own value.
+ */
+export declare function edges(top: number, right: number, bottom: number, left: number): Edges;
+/**
+ * Add two edge values side by side.
+ * @param a - the first edges.
+ * @param b - the second edges.
+ * @returns edges whose each side is the sum of the corresponding sides of `a` and `b`.
+ */
+export declare function addEdges(a: Edges, b: Edges): Edges;
+/** Zero edges constant */
+export declare const ZERO_EDGES: Edges;
+/**
+ * Convert partial edges to full edges with defaults.
+ * @param partial - edges with optional sides; omitted sides default to zero.
+ * @returns full edges where every missing side is zero.
+ */
+export declare function resolveEdges(partial?: Partial<Edges>): Edges;
+/**
+ * Compute the smallest rectangle containing both input rectangles.
+ * @param a - the first rectangle.
+ * @param b - the second rectangle.
+ * @returns the union of `a` and `b`.
+ */
+export declare function unionRect(a: Rectangle, b: Rectangle): Rectangle;
+/**
+ * Clamp a rectangle into a size's bounds, keeping it inside the grid.
+ * @param rect - the rectangle to clamp.
+ * @param size - the bounding grid size.
+ * @returns the intersection of `rect` with the grid; empty when they do not overlap.
+ */
+export declare function clampRect(rect: Rectangle, size: Size): Rectangle;
+/**
+ * Test whether a point lies inside a size's bounds.
+ * @param size - the grid size.
+ * @param point - the point to test.
+ * @returns true when `point` is inside `size` (edges exclusive).
+ */
+export declare function withinBounds(size: Size, point: Point): boolean;
+/**
+ * Clamp a value to an optional range.
+ * @param value - the value to clamp.
+ * @param min - the lower bound, or undefined for none.
+ * @param max - the upper bound, or undefined for none.
+ * @returns `value` clamped to [`min`, `max`].
+ */
+export declare function clamp(value: number, min?: number, max?: number): number;
+//# sourceMappingURL=geometry.d.ts.map

package/lib/types/ink/layout/geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../../../src/ink/layout/geometry.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC,MAAM,MAAM,KAAK,GAAG;IAClB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV,CAAA;AAED,4CAA4C;AAC5C,MAAM,MAAM,IAAI,GAAG;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,gDAAgD;AAChD,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,IAAI,CAAA;AAEpC,4CAA4C;AAC5C,MAAM,MAAM,KAAK,GAAG;IAClB,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAA;AACzC;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,KAAK,CAAA;AAClE;;;;;;;GAOG;AACH,wBAAgB,KAAK,CACnB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,GACX,KAAK,CAAA;AAWR;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK,CAOlD;AAED,0BAA0B;AAC1B,eAAO,MAAM,UAAU,EAAE,KAAgD,CAAA;AAEzE;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,GAAG,KAAK,CAO5D;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,SAAS,CAM/D;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,GAAG,SAAS,CAWhE;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAO9D;AAED;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAIvE"}

package/lib/types/ink/layout/geometry.js

@@ -0,0 +1,95 @@
+export function edges(a, b, c, d) {
+    if (b === undefined) {
+        return { top: a, right: a, bottom: a, left: a };
+    }
+    if (c === undefined) {
+        return { top: a, right: b, bottom: a, left: b };
+    }
+    return { top: a, right: b, bottom: c, left: d };
+}
+/**
+ * Add two edge values side by side.
+ * @param a - the first edges.
+ * @param b - the second edges.
+ * @returns edges whose each side is the sum of the corresponding sides of `a` and `b`.
+ */
+export function addEdges(a, b) {
+    return {
+        top: a.top + b.top,
+        right: a.right + b.right,
+        bottom: a.bottom + b.bottom,
+        left: a.left + b.left,
+    };
+}
+/** Zero edges constant */
+export const ZERO_EDGES = { top: 0, right: 0, bottom: 0, left: 0 };
+/**
+ * Convert partial edges to full edges with defaults.
+ * @param partial - edges with optional sides; omitted sides default to zero.
+ * @returns full edges where every missing side is zero.
+ */
+export function resolveEdges(partial) {
+    return {
+        top: partial?.top ?? 0,
+        right: partial?.right ?? 0,
+        bottom: partial?.bottom ?? 0,
+        left: partial?.left ?? 0,
+    };
+}
+/**
+ * Compute the smallest rectangle containing both input rectangles.
+ * @param a - the first rectangle.
+ * @param b - the second rectangle.
+ * @returns the union of `a` and `b`.
+ */
+export function unionRect(a, b) {
+    const minX = Math.min(a.x, b.x);
+    const minY = Math.min(a.y, b.y);
+    const maxX = Math.max(a.x + a.width, b.x + b.width);
+    const maxY = Math.max(a.y + a.height, b.y + b.height);
+    return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+/**
+ * Clamp a rectangle into a size's bounds, keeping it inside the grid.
+ * @param rect - the rectangle to clamp.
+ * @param size - the bounding grid size.
+ * @returns the intersection of `rect` with the grid; empty when they do not overlap.
+ */
+export function clampRect(rect, size) {
+    const minX = Math.max(0, rect.x);
+    const minY = Math.max(0, rect.y);
+    const maxX = Math.min(size.width - 1, rect.x + rect.width - 1);
+    const maxY = Math.min(size.height - 1, rect.y + rect.height - 1);
+    return {
+        x: minX,
+        y: minY,
+        width: Math.max(0, maxX - minX + 1),
+        height: Math.max(0, maxY - minY + 1),
+    };
+}
+/**
+ * Test whether a point lies inside a size's bounds.
+ * @param size - the grid size.
+ * @param point - the point to test.
+ * @returns true when `point` is inside `size` (edges exclusive).
+ */
+export function withinBounds(size, point) {
+    return (point.x >= 0 &&
+        point.y >= 0 &&
+        point.x < size.width &&
+        point.y < size.height);
+}
+/**
+ * Clamp a value to an optional range.
+ * @param value - the value to clamp.
+ * @param min - the lower bound, or undefined for none.
+ * @param max - the upper bound, or undefined for none.
+ * @returns `value` clamped to [`min`, `max`].
+ */
+export function clamp(value, min, max) {
+    if (min !== undefined && value < min)
+        return min;
+    if (max !== undefined && value > max)
+        return max;
+    return value;
+}