mixdog 0.7.18 → 0.8.1

package/vendor/ink/build/render-to-string.d.ts

@@ -0,0 +1,38 @@
+import type { ReactNode } from 'react';
+export type RenderToStringOptions = {
+    /**
+    Width of the virtual terminal in columns.
+
+    @default 80
+    */
+    columns?: number;
+};
+/**
+Render a React element to a string synchronously. Unlike `render()`, this function does not write to stdout, does not set up any terminal event listeners, and returns the rendered output as a string.
+
+Useful for generating documentation, writing output to files, testing, or any scenario where you need the rendered output as a string without starting a persistent terminal application.
+
+**Notes:**
+
+- Terminal-specific hooks (`useInput`, `useStdin`, `useStdout`, `useStderr`, `useApp`, `useFocus`, `useFocusManager`) return default no-op values since there is no terminal session. They will not throw, but they will not function as in a live terminal.
+- `useEffect` callbacks will execute during rendering (due to synchronous rendering mode), but state updates they trigger will not affect the returned output, which reflects the initial render.
+- `useLayoutEffect` callbacks fire synchronously during commit, so state updates they trigger **will** be reflected in the output.
+- The `<Static>` component is supported — its output is prepended to the dynamic output.
+- If a component throws during rendering, the error is propagated to the caller after cleanup.
+
+@example
+```
+import {renderToString, Text, Box} from 'ink';
+
+const output = renderToString(
+    <Box padding={1}>
+        <Text color="green">Hello World</Text>
+    </Box>,
+    {columns: 40}
+);
+
+console.log(output);
+```
+*/
+declare const renderToString: (node: ReactNode, options?: RenderToStringOptions) => string;
+export default renderToString;

package/vendor/ink/build/render-to-string.js

@@ -0,0 +1,116 @@
+import Yoga from 'yoga-layout';
+import { LegacyRoot } from 'react-reconciler/constants.js';
+import reconciler from './reconciler.js';
+import renderer from './renderer.js';
+import { createNode } from './dom.js';
+/**
+Render a React element to a string synchronously. Unlike `render()`, this function does not write to stdout, does not set up any terminal event listeners, and returns the rendered output as a string.
+
+Useful for generating documentation, writing output to files, testing, or any scenario where you need the rendered output as a string without starting a persistent terminal application.
+
+**Notes:**
+
+- Terminal-specific hooks (`useInput`, `useStdin`, `useStdout`, `useStderr`, `useApp`, `useFocus`, `useFocusManager`) return default no-op values since there is no terminal session. They will not throw, but they will not function as in a live terminal.
+- `useEffect` callbacks will execute during rendering (due to synchronous rendering mode), but state updates they trigger will not affect the returned output, which reflects the initial render.
+- `useLayoutEffect` callbacks fire synchronously during commit, so state updates they trigger **will** be reflected in the output.
+- The `<Static>` component is supported — its output is prepended to the dynamic output.
+- If a component throws during rendering, the error is propagated to the caller after cleanup.
+
+@example
+```
+import {renderToString, Text, Box} from 'ink';
+
+const output = renderToString(
+    <Box padding={1}>
+        <Text color="green">Hello World</Text>
+    </Box>,
+    {columns: 40}
+);
+
+console.log(output);
+```
+*/
+const renderToString = (node, options) => {
+    const columns = options?.columns ?? 80;
+    // Create a standalone root node — no stdout, stdin, or terminal bindings
+    const rootNode = createNode('ink-root');
+    // Capture static output from intermediate renders.
+    // The <Static> component uses useLayoutEffect to clear its children after
+    // the first commit. The reconciler's resetAfterCommit calls onImmediateRender
+    // when static content is dirty (and returns early, skipping the normal
+    // onRender callback), giving us a chance to capture it before it's cleared
+    // by the subsequent re-render.
+    let capturedStaticOutput = '';
+    rootNode.onComputeLayout = () => {
+        rootNode.yogaNode.setWidth(columns);
+        rootNode.yogaNode.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
+    };
+    rootNode.onImmediateRender = () => {
+        const { staticOutput } = renderer(rootNode, false);
+        if (staticOutput && staticOutput !== '\n') {
+            capturedStaticOutput += staticOutput;
+        }
+    };
+    // Capture the first uncaught error so we can re-throw it after cleanup.
+    // React's reconciler catches component errors internally and reports them
+    // via onUncaughtError rather than letting them propagate. For a synchronous
+    // utility like renderToString, callers expect errors to throw.
+    let uncaughtError;
+    // Create a reconciler container in legacy (synchronous) mode.
+    // The four trailing callbacks are: onUncaughtError, onCaughtError,
+    // onRecoverableError, and onHostTransitionComplete.
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const container = reconciler.createContainer(rootNode, LegacyRoot, null, false, null, 'render-to-string', (error) => {
+        uncaughtError ??= error;
+    }, () => { }, () => { }, () => { });
+    let teardownSucceeded = false;
+    try {
+        // Synchronously render the React tree into the container
+        reconciler.updateContainerSync(node, container, null, () => { });
+        reconciler.flushSyncWork();
+        // Yoga layout has already been calculated by onComputeLayout during commit.
+        // Render the DOM tree to a string — this captures the dynamic (non-static) output.
+        const { output } = renderer(rootNode, false);
+        // Tear down: unmount the tree so the reconciler cleans up child nodes
+        // and runs effect cleanup functions. Child Yoga nodes are freed by the
+        // reconciler's removeChildFromContainer → cleanupYogaNode → freeRecursive.
+        reconciler.updateContainerSync(null, container, null, () => { });
+        reconciler.flushSyncWork();
+        teardownSucceeded = true;
+        // Free the root yoga node itself (children already freed by reconciler)
+        rootNode.yogaNode.free();
+        // Re-throw after full cleanup so callers see the original error.
+        if (uncaughtError !== undefined) {
+            throw uncaughtError instanceof Error
+                ? uncaughtError
+                : // eslint-disable-next-line @typescript-eslint/no-base-to-string
+                    new Error(String(uncaughtError));
+        }
+        // The renderer appends a trailing newline to static output for terminal
+        // rendering (so dynamic output starts on a fresh line). Strip it here
+        // so renderToString returns clean output.
+        const normalizedStaticOutput = capturedStaticOutput.endsWith('\n')
+            ? capturedStaticOutput.slice(0, -1)
+            : capturedStaticOutput;
+        if (normalizedStaticOutput && output) {
+            return normalizedStaticOutput + '\n' + output;
+        }
+        return normalizedStaticOutput || output;
+    }
+    finally {
+        // Ensure native Yoga memory is freed even if rendering or teardown threw.
+        // Yoga nodes are WASM-backed and not garbage collected.
+        if (!teardownSucceeded && rootNode.yogaNode) {
+            try {
+                // If reconciler teardown failed, some child nodes may not have been
+                // freed. Use freeRecursive to clean up the entire tree as best-effort.
+                rootNode.yogaNode.freeRecursive();
+            }
+            catch {
+                // Best-effort: node may already be partially freed
+            }
+        }
+    }
+};
+export default renderToString;
+//# sourceMappingURL=render-to-string.js.map

package/vendor/ink/build/render-to-string.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-to-string.js","sourceRoot":"","sources":["../src/render-to-string.ts"],"names":[],"mappings":"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"}

package/vendor/ink/build/render.d.ts

@@ -0,0 +1,176 @@
+import type { ReactNode } from 'react';
+import Ink, { type RenderMetrics } from './ink.js';
+import { type KittyKeyboardOptions } from './kitty-keyboard.js';
+export type RenderOptions = {
+    /**
+    Output stream where the app will be rendered.
+
+    @default process.stdout
+    */
+    stdout?: NodeJS.WriteStream;
+    /**
+    Input stream where app will listen for input.
+
+    @default process.stdin
+    */
+    stdin?: NodeJS.ReadStream;
+    /**
+    Error stream.
+    @default process.stderr
+    */
+    stderr?: NodeJS.WriteStream;
+    /**
+    If true, each update will be rendered as separate output, without replacing the previous one.
+
+    @default false
+    */
+    debug?: boolean;
+    /**
+    Configure whether Ink should listen for Ctrl+C keyboard input and exit the app. This is needed in case `process.stdin` is in raw mode, because then Ctrl+C is ignored by default and the process is expected to handle it manually.
+
+    @default true
+    */
+    exitOnCtrlC?: boolean;
+    /**
+    Patch console methods to ensure console output doesn't mix with Ink's output.
+
+    Note: Once unmount starts, Ink restores the native console before React cleanup runs. Teardown-time `console.*` output then follows the normal console behavior instead of being rerouted through Ink.
+
+    @default true
+    */
+    patchConsole?: boolean;
+    /**
+    Runs the given callback after each render and re-render with render metrics.
+
+    Note: this callback runs after Ink commits a frame, but it does not wait for `stdout`/`stderr` stream callbacks.
+    To run code after output is flushed, use `waitUntilRenderFlush()`.
+    */
+    onRender?: (metrics: RenderMetrics) => void;
+    /**
+    Enable screen reader support. See https://github.com/vadimdemedes/ink/blob/master/readme.md#screen-reader-support
+
+    @default process.env['INK_SCREEN_READER'] === 'true'
+    */
+    isScreenReaderEnabled?: boolean;
+    /**
+    Maximum frames per second for render updates.
+    This controls how frequently the UI can update to prevent excessive re-rendering.
+    Higher values allow more frequent updates but may impact performance.
+
+    @default 30
+    */
+    maxFps?: number;
+    /**
+    Enable incremental rendering mode which only updates changed lines instead of redrawing the entire output.
+    This can reduce flickering and improve performance for frequently updating UIs.
+
+    @default false
+    */
+    incrementalRendering?: boolean;
+    /**
+    Enable React Concurrent Rendering mode.
+
+    When enabled:
+    - Suspense boundaries work correctly with async data
+    - `useTransition` and `useDeferredValue` are fully functional
+    - Updates can be interrupted for higher priority work
+
+    Note: Concurrent mode changes the timing of renders. Some tests may need to use `act()` to properly await updates. Reusing the same stdout across multiple `render()` calls without unmounting is unsupported. Call `unmount()` first if you need to change the rendering mode or create a fresh instance.
+
+    @default false
+    */
+    concurrent?: boolean;
+    /**
+    Configure kitty keyboard protocol support for enhanced keyboard input.
+    Enables additional modifiers (super, hyper, capsLock, numLock) and
+    disambiguated key events in terminals that support the protocol.
+
+    @see https://sw.kovidgoyal.net/kitty/keyboard-protocol/
+    */
+    kittyKeyboard?: KittyKeyboardOptions;
+    /**
+    Override automatic interactive mode detection.
+
+    By default, Ink detects whether the environment is interactive based on CI detection (via [`is-in-ci`](https://github.com/sindresorhus/is-in-ci)) and `stdout.isTTY`. Most users should not need to set this.
+
+    When non-interactive, Ink disables ANSI erase sequences, cursor manipulation, synchronized output, resize handling, and kitty keyboard auto-detection, writing only the final frame at unmount.
+
+    Set to `false` to force non-interactive mode or `true` to force interactive mode when the automatic detection doesn't suit your use case.
+
+    Note: Reusing the same stdout across multiple `render()` calls without unmounting is unsupported. Call `unmount()` first if you need to change this option or create a fresh instance.
+
+    @default true (false if in CI or `stdout.isTTY` is falsy)
+    */
+    interactive?: boolean;
+    /**
+    Render the app in the terminal's alternate screen buffer. When enabled, the app renders on a separate screen, and the original terminal content is restored when the app exits. This is the same mechanism used by programs like vim, htop, and less.
+
+    Note: The terminal's scrollback buffer is not available while in the alternate screen. This is standard terminal behavior; programs like vim use the alternate screen specifically to avoid polluting the user's scrollback history.
+
+    Note: Ink intentionally treats alternate-screen teardown output as disposable. It does not preserve or replay teardown-time frames, hook writes, or `console.*` output after restoring the primary screen.
+
+    Only works in interactive mode. Ignored when `interactive` is `false` or in a non-interactive environment (CI, piped stdout).
+
+    Note: Reusing the same stdout across multiple `render()` calls without unmounting is unsupported. Call `unmount()` first if you need to change this option or create a fresh instance.
+
+    @default false
+    */
+    alternateScreen?: boolean;
+};
+export type Instance = {
+    /**
+    Replace the previous root node with a new one or update props of the current root node.
+    */
+    rerender: Ink['render'];
+    /**
+    Manually unmount the whole Ink app.
+    */
+    unmount: Ink['unmount'];
+    /**
+    Returns a promise that settles when the app is unmounted.
+
+    It resolves with the value passed to `exit(value)` and rejects with the error passed to `exit(error)`.
+    When `unmount()` is called manually, it settles after unmount-related stdout writes complete.
+
+    @example
+    ```jsx
+    const {unmount, waitUntilExit} = render(<MyApp />);
+
+    setTimeout(unmount, 1000);
+
+    await waitUntilExit(); // resolves after `unmount()` is called
+    ```
+    */
+    waitUntilExit: Ink['waitUntilExit'];
+    /**
+    Returns a promise that settles after pending render output is flushed to stdout.
+
+    This can be used after `rerender()` when you need to run code only after the frame is written.
+
+    @example
+    ```jsx
+    const {rerender, waitUntilRenderFlush} = render(<MyApp step="loading" />);
+
+    rerender(<MyApp step="ready" />);
+    await waitUntilRenderFlush(); // output for "ready" is flushed
+
+    runNextCommand();
+    ```
+    */
+    waitUntilRenderFlush: Ink['waitUntilRenderFlush'];
+    /**
+    Unmount the current app and remove the internal Ink instance for this stdout.
+
+    This is mostly useful for advanced cases where you need `render()` to create a fresh instance for the same stream without leaving terminal state such as the alternate screen behind.
+    */
+    cleanup: () => void;
+    /**
+    Clear output.
+    */
+    clear: () => void;
+};
+/**
+Mount a component and render the output.
+*/
+declare const render: (node: ReactNode, options?: NodeJS.WriteStream | RenderOptions) => Instance;
+export default render;

package/vendor/ink/build/render.js

@@ -0,0 +1,71 @@
+import { Stream } from 'node:stream';
+import process from 'node:process';
+import Ink from './ink.js';
+import instances from './instances.js';
+/**
+Mount a component and render the output.
+*/
+const render = (node, options) => {
+    const inkOptions = {
+        stdout: process.stdout,
+        stdin: process.stdin,
+        stderr: process.stderr,
+        debug: false,
+        exitOnCtrlC: true,
+        patchConsole: true,
+        maxFps: 30,
+        incrementalRendering: false,
+        concurrent: false,
+        alternateScreen: false,
+        ...getOptions(options),
+    };
+    const instance = getInstance(inkOptions.stdout, () => new Ink(inkOptions));
+    instance.render(node);
+    return {
+        rerender: instance.render,
+        unmount() {
+            instance.unmount();
+        },
+        waitUntilExit: instance.waitUntilExit,
+        waitUntilRenderFlush: instance.waitUntilRenderFlush,
+        cleanup() {
+            instance.unmount();
+        },
+        clear: instance.clear,
+        // [mixdog fork] expose the mouse drag-selection setter so the app entry
+        // (index.jsx) can wire it into the engine store; the App's mouse handler
+        // pushes selection rectangles through it to drive the inverse highlight.
+        setSelection: instance.setSelection,
+        // [mixdog fork] read the text under the current selection rect (the cells
+        // the highlight covers), used to copy to the clipboard on drag-release.
+        getSelectionText: () => instance.selectedText,
+        // [mixdog fork] resolve the word rect at a cell for double-click select.
+        getWordRectAt: (x, y) => instance.getWordRectAt(x, y),
+    };
+};
+export default render;
+const getOptions = (stdout = {}) => {
+    if (stdout instanceof Stream) {
+        return {
+            stdout,
+            stdin: process.stdin,
+        };
+    }
+    return stdout;
+};
+const getInstance = (stdout, createInstance) => {
+    const instance = instances.get(stdout);
+    if (instance === undefined) {
+        const newInstance = createInstance();
+        instances.set(stdout, newInstance);
+        return newInstance;
+    }
+    // Ink keeps one live renderer per stdout. Reusing the same stream without
+    // unmounting is unsupported, but return the existing instance so we don't
+    // create two renderers that compete for the same output. Write the warning
+    // directly to native stderr so an existing alternate-screen renderer cannot
+    // swallow it via patchConsole.
+    process.stderr.write('Warning: render() was called again for the same stdout before the previous Ink instance was unmounted. Reusing stdout across multiple render() calls is unsupported. Call unmount() first.\n');
+    return instance;
+};
+//# sourceMappingURL=render.js.map

package/vendor/ink/build/render.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.js","sourceRoot":"","sources":["../src/render.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AACnC,OAAO,OAAO,MAAM,cAAc,CAAC;AAEnC,OAAO,GAAqD,MAAM,UAAU,CAAC;AAC7E,OAAO,SAAS,MAAM,gBAAgB,CAAC;AA+LvC;;EAEE;AACF,MAAM,MAAM,GAAG,CACd,IAAe,EACf,OAA4C,EACjC,EAAE;IACb,MAAM,UAAU,GAAe;QAC9B,MAAM,EAAE,OAAO,CAAC,MAAM;QACtB,KAAK,EAAE,OAAO,CAAC,KAAK;QACpB,MAAM,EAAE,OAAO,CAAC,MAAM;QACtB,KAAK,EAAE,KAAK;QACZ,WAAW,EAAE,IAAI;QACjB,YAAY,EAAE,IAAI;QAClB,MAAM,EAAE,EAAE;QACV,oBAAoB,EAAE,KAAK;QAC3B,UAAU,EAAE,KAAK;QACjB,eAAe,EAAE,KAAK;QACtB,GAAG,UAAU,CAAC,OAAO,CAAC;KACtB,CAAC;IAEF,MAAM,QAAQ,GAAQ,WAAW,CAChC,UAAU,CAAC,MAAM,EACjB,GAAG,EAAE,CAAC,IAAI,GAAG,CAAC,UAAU,CAAC,CACzB,CAAC;IACF,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAEtB,OAAO;QACN,QAAQ,EAAE,QAAQ,CAAC,MAAM;QACzB,OAAO;YACN,QAAQ,CAAC,OAAO,EAAE,CAAC;QACpB,CAAC;QACD,aAAa,EAAE,QAAQ,CAAC,aAAa;QACrC,oBAAoB,EAAE,QAAQ,CAAC,oBAAoB;QACnD,OAAO;YACN,QAAQ,CAAC,OAAO,EAAE,CAAC;QACpB,CAAC;QACD,KAAK,EAAE,QAAQ,CAAC,KAAK;KACrB,CAAC;AACH,CAAC,CAAC;AAEF,eAAe,MAAM,CAAC;AAEtB,MAAM,UAAU,GAAG,CAClB,SAAyD,EAAE,EAC3C,EAAE;IAClB,IAAI,MAAM,YAAY,MAAM,EAAE,CAAC;QAC9B,OAAO;YACN,MAAM;YACN,KAAK,EAAE,OAAO,CAAC,KAAK;SACpB,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAC;AACf,CAAC,CAAC;AAEF,MAAM,WAAW,GAAG,CACnB,MAA0B,EAC1B,cAAyB,EACnB,EAAE;IACR,MAAM,QAAQ,GAAG,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAEvC,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC5B,MAAM,WAAW,GAAG,cAAc,EAAE,CAAC;QACrC,SAAS,CAAC,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;QACnC,OAAO,WAAW,CAAC;IACpB,CAAC;IAED,0EAA0E;IAC1E,0EAA0E;IAC1E,2EAA2E;IAC3E,4EAA4E;IAC5E,+BAA+B;IAC/B,OAAO,CAAC,MAAM,CAAC,KAAK,CACnB,8LAA8L,CAC9L,CAAC;IAEF,OAAO,QAAQ,CAAC;AACjB,CAAC,CAAC"}

package/vendor/ink/build/renderer.d.ts

@@ -0,0 +1,8 @@
+import { type DOMElement } from './dom.js';
+type Result = {
+    output: string;
+    outputHeight: number;
+    staticOutput: string;
+};
+declare const renderer: (node: DOMElement, isScreenReaderEnabled: boolean) => Result;
+export default renderer;

package/vendor/ink/build/renderer.js

@@ -0,0 +1,64 @@
+import renderNodeToOutput, { renderNodeToScreenReaderOutput, } from './render-node-to-output.js';
+import Output from './output.js';
+const renderer = (node, isScreenReaderEnabled, selection) => {
+    if (node.yogaNode) {
+        if (isScreenReaderEnabled) {
+            const output = renderNodeToScreenReaderOutput(node, {
+                skipStaticElements: true,
+            });
+            const outputHeight = output === '' ? 0 : output.split('\n').length;
+            let staticOutput = '';
+            if (node.staticNode) {
+                staticOutput = renderNodeToScreenReaderOutput(node.staticNode, {
+                    skipStaticElements: false,
+                });
+            }
+            return {
+                output,
+                outputHeight,
+                staticOutput: staticOutput ? `${staticOutput}\n` : '',
+            };
+        }
+        const output = new Output({
+            width: node.yogaNode.getComputedWidth(),
+            height: node.yogaNode.getComputedHeight(),
+        });
+        // [mixdog fork] hand the mouse drag-selection rectangle to the output so
+        // it can paint an inverse highlight over the selected cells at the
+        // serialization step. null when there is no active selection.
+        if (selection) {
+            output.setSelection(selection);
+        }
+        renderNodeToOutput(node, output, {
+            skipStaticElements: true,
+        });
+        let staticOutput;
+        if (node.staticNode?.yogaNode) {
+            staticOutput = new Output({
+                width: node.staticNode.yogaNode.getComputedWidth(),
+                height: node.staticNode.yogaNode.getComputedHeight(),
+            });
+            renderNodeToOutput(node.staticNode, staticOutput, {
+                skipStaticElements: false,
+            });
+        }
+        const { output: generatedOutput, height: outputHeight, cursor, selectedText, plainRows } = output.get();
+        return {
+            output: generatedOutput,
+            outputHeight,
+            cursor, // [mixdog fork] absolute cursor cell from the anchored input node, or null
+            selectedText, // [mixdog fork] text inside the drag-selection, or null
+            plainRows, // [mixdog fork] column-indexed cell values per row for word lookup
+            // Newline at the end is needed, because static output doesn't have one, so
+            // interactive output will override last line of static output
+            staticOutput: staticOutput ? `${staticOutput.get().output}\n` : '',
+        };
+    }
+    return {
+        output: '',
+        outputHeight: 0,
+        staticOutput: '',
+    };
+};
+export default renderer;
+//# sourceMappingURL=renderer.js.map

package/vendor/ink/build/renderer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.js","sourceRoot":"","sources":["../src/renderer.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,EAAE,EAC1B,8BAA8B,GAC9B,MAAM,4BAA4B,CAAC;AACpC,OAAO,MAAM,MAAM,aAAa,CAAC;AASjC,MAAM,QAAQ,GAAG,CAAC,IAAgB,EAAE,qBAA8B,EAAU,EAAE;IAC7E,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;QACnB,IAAI,qBAAqB,EAAE,CAAC;YAC3B,MAAM,MAAM,GAAG,8BAA8B,CAAC,IAAI,EAAE;gBACnD,kBAAkB,EAAE,IAAI;aACxB,CAAC,CAAC;YAEH,MAAM,YAAY,GAAG,MAAM,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC;YAEnE,IAAI,YAAY,GAAG,EAAE,CAAC;YAEtB,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;gBACrB,YAAY,GAAG,8BAA8B,CAAC,IAAI,CAAC,UAAU,EAAE;oBAC9D,kBAAkB,EAAE,KAAK;iBACzB,CAAC,CAAC;YACJ,CAAC;YAED,OAAO;gBACN,MAAM;gBACN,YAAY;gBACZ,YAAY,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,IAAI,CAAC,CAAC,CAAC,EAAE;aACrD,CAAC;QACH,CAAC;QAED,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC;YACzB,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,gBAAgB,EAAE;YACvC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,iBAAiB,EAAE;SACzC,CAAC,CAAC;QAEH,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE;YAChC,kBAAkB,EAAE,IAAI;SACxB,CAAC,CAAC;QAEH,IAAI,YAAY,CAAC;QAEjB,IAAI,IAAI,CAAC,UAAU,EAAE,QAAQ,EAAE,CAAC;YAC/B,YAAY,GAAG,IAAI,MAAM,CAAC;gBACzB,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,gBAAgB,EAAE;gBAClD,MAAM,EAAE,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,iBAAiB,EAAE;aACpD,CAAC,CAAC;YAEH,kBAAkB,CAAC,IAAI,CAAC,UAAU,EAAE,YAAY,EAAE;gBACjD,kBAAkB,EAAE,KAAK;aACzB,CAAC,CAAC;QACJ,CAAC;QAED,MAAM,EAAC,MAAM,EAAE,eAAe,EAAE,MAAM,EAAE,YAAY,EAAC,GAAG,MAAM,CAAC,GAAG,EAAE,CAAC;QAErE,OAAO;YACN,MAAM,EAAE,eAAe;YACvB,YAAY;YACZ,2EAA2E;YAC3E,8DAA8D;YAC9D,YAAY,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,GAAG,EAAE,CAAC,MAAM,IAAI,CAAC,CAAC,CAAC,EAAE;SAClE,CAAC;IACH,CAAC;IAED,OAAO;QACN,MAAM,EAAE,EAAE;QACV,YAAY,EAAE,CAAC;QACf,YAAY,EAAE,EAAE;KAChB,CAAC;AACH,CAAC,CAAC;AAEF,eAAe,QAAQ,CAAC"}

package/vendor/ink/build/sanitize-ansi.d.ts

@@ -0,0 +1,2 @@
+declare const sanitizeAnsi: (text: string) => string;
+export default sanitizeAnsi;

package/vendor/ink/build/sanitize-ansi.js

@@ -0,0 +1,27 @@
+import { hasAnsiControlCharacters, tokenizeAnsi } from './ansi-tokenizer.js';
+const sgrParametersRegex = /^[\d:;]*$/;
+// Strip ANSI escape sequences that would conflict with Ink's layout.
+// Preserved: SGR sequences (colors, bold, etc. - end with 'm') and
+// OSC sequences (hyperlinks, etc. - ESC ] or C1 OSC).
+// Stripped: cursor movement, screen clearing, and other control sequences.
+const sanitizeAnsi = (text) => {
+    if (!hasAnsiControlCharacters(text)) {
+        return text;
+    }
+    let output = '';
+    for (const token of tokenizeAnsi(text)) {
+        if (token.type === 'text' || token.type === 'osc') {
+            output += token.value;
+            continue;
+        }
+        if (token.type === 'csi' &&
+            token.finalCharacter === 'm' &&
+            token.intermediateString === '' &&
+            sgrParametersRegex.test(token.parameterString)) {
+            output += token.value;
+        }
+    }
+    return output;
+};
+export default sanitizeAnsi;
+//# sourceMappingURL=sanitize-ansi.js.map

package/vendor/ink/build/sanitize-ansi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize-ansi.js","sourceRoot":"","sources":["../src/sanitize-ansi.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,wBAAwB,EAAE,YAAY,EAAC,MAAM,qBAAqB,CAAC;AAE3E,MAAM,kBAAkB,GAAG,WAAW,CAAC;AAEvC,qEAAqE;AACrE,mEAAmE;AACnE,sDAAsD;AACtD,2EAA2E;AAC3E,MAAM,YAAY,GAAG,CAAC,IAAY,EAAU,EAAE;IAC7C,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,EAAE,CAAC;QACrC,OAAO,IAAI,CAAC;IACb,CAAC;IAED,IAAI,MAAM,GAAG,EAAE,CAAC;IAEhB,KAAK,MAAM,KAAK,IAAI,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC;QACxC,IAAI,KAAK,CAAC,IAAI,KAAK,MAAM,IAAI,KAAK,CAAC,IAAI,KAAK,KAAK,EAAE,CAAC;YACnD,MAAM,IAAI,KAAK,CAAC,KAAK,CAAC;YACtB,SAAS;QACV,CAAC;QAED,IACC,KAAK,CAAC,IAAI,KAAK,KAAK;YACpB,KAAK,CAAC,cAAc,KAAK,GAAG;YAC5B,KAAK,CAAC,kBAAkB,KAAK,EAAE;YAC/B,kBAAkB,CAAC,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,EAC7C,CAAC;YACF,MAAM,IAAI,KAAK,CAAC,KAAK,CAAC;QACvB,CAAC;IACF,CAAC;IAED,OAAO,MAAM,CAAC;AACf,CAAC,CAAC;AAEF,eAAe,YAAY,CAAC"}

package/vendor/ink/build/squash-text-nodes.d.ts

@@ -0,0 +1,3 @@
+import { type DOMElement } from './dom.js';
+declare const squashTextNodes: (node: DOMElement) => string;
+export default squashTextNodes;

package/vendor/ink/build/squash-text-nodes.js

@@ -0,0 +1,36 @@
+import sanitizeAnsi from './sanitize-ansi.js';
+// Squashing text nodes allows to combine multiple text nodes into one and write
+// to `Output` instance only once. For example, <Text>hello{' '}world</Text>
+// is actually 3 text nodes, which would result 3 writes to `Output`.
+//
+// Also, this is necessary for libraries like ink-link (https://github.com/sindresorhus/ink-link),
+// which need to wrap all children at once, instead of wrapping 3 text nodes separately.
+const squashTextNodes = (node) => {
+    let text = '';
+    for (let index = 0; index < node.childNodes.length; index++) {
+        const childNode = node.childNodes[index];
+        if (childNode === undefined) {
+            continue;
+        }
+        let nodeText = '';
+        if (childNode.nodeName === '#text') {
+            nodeText = childNode.nodeValue;
+        }
+        else {
+            if (childNode.nodeName === 'ink-text' ||
+                childNode.nodeName === 'ink-virtual-text') {
+                nodeText = squashTextNodes(childNode);
+            }
+            // Since these text nodes are being concatenated, `Output` instance won't be able to
+            // apply children transform, so we have to do it manually here for each text node
+            if (nodeText.length > 0 &&
+                typeof childNode.internal_transform === 'function') {
+                nodeText = childNode.internal_transform(nodeText, index);
+            }
+        }
+        text += nodeText;
+    }
+    return sanitizeAnsi(text);
+};
+export default squashTextNodes;
+//# sourceMappingURL=squash-text-nodes.js.map

package/vendor/ink/build/squash-text-nodes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"squash-text-nodes.js","sourceRoot":"","sources":["../src/squash-text-nodes.ts"],"names":[],"mappings":"AACA,OAAO,YAAY,MAAM,oBAAoB,CAAC;AAE9C,gFAAgF;AAChF,4EAA4E;AAC5E,qEAAqE;AACrE,EAAE;AACF,kGAAkG;AAClG,wFAAwF;AACxF,MAAM,eAAe,GAAG,CAAC,IAAgB,EAAU,EAAE;IACpD,IAAI,IAAI,GAAG,EAAE,CAAC;IAEd,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;QAC7D,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QAEzC,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;YAC7B,SAAS;QACV,CAAC;QAED,IAAI,QAAQ,GAAG,EAAE,CAAC;QAElB,IAAI,SAAS,CAAC,QAAQ,KAAK,OAAO,EAAE,CAAC;YACpC,QAAQ,GAAG,SAAS,CAAC,SAAS,CAAC;QAChC,CAAC;aAAM,CAAC;YACP,IACC,SAAS,CAAC,QAAQ,KAAK,UAAU;gBACjC,SAAS,CAAC,QAAQ,KAAK,kBAAkB,EACxC,CAAC;gBACF,QAAQ,GAAG,eAAe,CAAC,SAAS,CAAC,CAAC;YACvC,CAAC;YAED,oFAAoF;YACpF,iFAAiF;YACjF,IACC,QAAQ,CAAC,MAAM,GAAG,CAAC;gBACnB,OAAO,SAAS,CAAC,kBAAkB,KAAK,UAAU,EACjD,CAAC;gBACF,QAAQ,GAAG,SAAS,CAAC,kBAAkB,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;YAC1D,CAAC;QACF,CAAC;QAED,IAAI,IAAI,QAAQ,CAAC;IAClB,CAAC;IAED,OAAO,YAAY,CAAC,IAAI,CAAC,CAAC;AAC3B,CAAC,CAAC;AAEF,eAAe,eAAe,CAAC"}