@travisennis/acai 0.0.3 → 0.0.5

package/dist/terminal/ansi-styles.js

@@ -0,0 +1,215 @@
+// Converted from ansi-styles/index.js to modern TypeScript
+// Original source: chalk-main/source/vendor/ansi-styles/index.js
+import { objectEntries } from "@travisennis/stdlib/object";
+const ANSI_BACKGROUND_OFFSET = 10;
+const wrapAnsi16 = (offset = 0) => (code) => `\u001B[${code + offset}m`;
+const wrapAnsi256 = (offset = 0) => (code) => `\u001B[${38 + offset};5;${code}m`;
+const wrapAnsi16m = (offset = 0) => (red, green, blue) => `\u001B[${38 + offset};2;${red};${green};${blue}m`;
+const styles = {
+    modifier: {
+        reset: [0, 0],
+        // 21 isn't widely supported and 22 does the same thing
+        bold: [1, 22],
+        dim: [2, 22],
+        italic: [3, 23],
+        underline: [4, 24],
+        overline: [53, 55],
+        inverse: [7, 27],
+        hidden: [8, 28],
+        strikethrough: [9, 29],
+    },
+    color: {
+        black: [30, 39],
+        red: [31, 39],
+        green: [32, 39],
+        yellow: [33, 39],
+        blue: [34, 39],
+        magenta: [35, 39],
+        cyan: [36, 39],
+        white: [37, 39],
+        // Bright color
+        blackBright: [90, 39],
+        gray: [90, 39], // Alias of `blackBright`
+        grey: [90, 39], // Alias of `blackBright`
+        redBright: [91, 39],
+        greenBright: [92, 39],
+        yellowBright: [93, 39],
+        blueBright: [94, 39],
+        magentaBright: [95, 39],
+        cyanBright: [96, 39],
+        whiteBright: [97, 39],
+    },
+    bgColor: {
+        bgBlack: [40, 49],
+        bgRed: [41, 49],
+        bgGreen: [42, 49],
+        bgYellow: [43, 49],
+        bgBlue: [44, 49],
+        bgMagenta: [45, 49],
+        bgCyan: [46, 49],
+        bgWhite: [47, 49],
+        // Bright color
+        bgBlackBright: [100, 49],
+        bgGray: [100, 49], // Alias of `bgBlackBright`
+        bgGrey: [100, 49], // Alias of `bgBlackBright`
+        bgRedBright: [101, 49],
+        bgGreenBright: [102, 49],
+        bgYellowBright: [103, 49],
+        bgBlueBright: [104, 49],
+        bgMagentaBright: [105, 49],
+        bgCyanBright: [106, 49],
+        bgWhiteBright: [107, 49],
+    },
+};
+/**
+ * Assembles the styles object with open/close ANSI sequences.
+ * @returns The fully assembled styles object.
+ */
+function assembleStyles() {
+    const codes = new Map();
+    for (const [groupName, group] of objectEntries(styles)) {
+        for (const [styleName, styleCodes] of objectEntries(group)) {
+            const style = {
+                open: `\u001B[${styleCodes[0]}m`,
+                close: `\u001B[${styleCodes[1]}m`,
+            };
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic property assignment needed for chalk compatibility
+            styles[styleName] = style;
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic property assignment needed for chalk compatibility
+            group[styleName] = style;
+            codes.set(styleCodes[0], styleCodes[1]);
+        }
+        Object.defineProperty(styles, groupName, {
+            value: group,
+            enumerable: false,
+        });
+    }
+    Object.defineProperty(styles, "codes", {
+        value: codes,
+        enumerable: false,
+    });
+    // biome-ignore lint/suspicious/noExplicitAny: Dynamic property assignment needed for chalk compatibility
+    styles.color.close = "\u001B[39m";
+    // biome-ignore lint/suspicious/noExplicitAny: Dynamic property assignment needed for chalk compatibility
+    styles.bgColor.close = "\u001B[49m";
+    // biome-ignore lint/suspicious/noExplicitAny: Dynamic property assignment needed for chalk compatibility
+    styles.color.ansi = wrapAnsi16();
+    // biome-ignore lint/suspicious/noExplicitAny: Dynamic property assignment needed for chalk compatibility
+    styles.color.ansi256 = wrapAnsi256();
+    // biome-ignore lint/suspicious/noExplicitAny: Dynamic property assignment needed for chalk compatibility
+    styles.color.ansi16m = wrapAnsi16m();
+    // biome-ignore lint/suspicious/noExplicitAny: Dynamic property assignment needed for chalk compatibility
+    styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+    // biome-ignore lint/suspicious/noExplicitAny: Dynamic property assignment needed for chalk compatibility
+    styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+    // biome-ignore lint/suspicious/noExplicitAny: Dynamic property assignment needed for chalk compatibility
+    styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+    // Color conversion functions (from original source)
+    Object.defineProperties(styles, {
+        rgbToAnsi256: {
+            value(red, green, blue) {
+                // We use the extended greyscale palette here, with the exception of
+                // black and white. normal palette only has 4 greyscale shades.
+                if (red === green && green === blue) {
+                    if (red < 8) {
+                        return 16;
+                    }
+                    if (red > 248) {
+                        return 231;
+                    }
+                    return Math.round(((red - 8) / 247) * 24) + 232;
+                }
+                return (16 +
+                    36 * Math.round((red / 255) * 5) +
+                    6 * Math.round((green / 255) * 5) +
+                    Math.round((blue / 255) * 5));
+            },
+            enumerable: false,
+        },
+        hexToRgb: {
+            value(hex) {
+                const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex);
+                if (!matches) {
+                    return [0, 0, 0];
+                }
+                let [colorString] = matches;
+                if (colorString.length === 3) {
+                    colorString = [...colorString]
+                        .map((character) => character + character)
+                        .join("");
+                }
+                const integer = Number.parseInt(colorString, 16);
+                return [
+                    /* eslint-disable no-bitwise */
+                    (integer >> 16) & 0xff,
+                    (integer >> 8) & 0xff,
+                    integer & 0xff,
+                    /* eslint-enable no-bitwise */
+                ];
+            },
+            enumerable: false,
+        },
+        hexToAnsi256: {
+            value: (hex) => 
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic method access needed for chalk compatibility
+            styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+            enumerable: false,
+        },
+        ansi256ToAnsi: {
+            value(codeParam) {
+                const code = codeParam;
+                if (code < 8) {
+                    return 30 + code;
+                }
+                if (code < 16) {
+                    return 90 + (code - 8);
+                }
+                let red;
+                let green;
+                let blue;
+                if (code >= 232) {
+                    red = ((code - 232) * 10 + 8) / 255;
+                    green = red;
+                    blue = red;
+                }
+                else {
+                    const adjustedCode = code - 16;
+                    const remainder = adjustedCode % 36;
+                    red = Math.floor(adjustedCode / 36) / 5;
+                    green = Math.floor(remainder / 6) / 5;
+                    blue = (remainder % 6) / 5;
+                }
+                const value = Math.max(red, green, blue) * 2;
+                if (value === 0) {
+                    return 30;
+                }
+                // eslint-disable-next-line no-bitwise
+                let result = 30 +
+                    ((Math.round(blue) << 2) |
+                        (Math.round(green) << 1) |
+                        Math.round(red));
+                if (value === 2) {
+                    result += 60;
+                }
+                return result;
+            },
+            enumerable: false,
+        },
+        rgbToAnsi: {
+            value: (red, green, blue) => 
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic method access needed for chalk compatibility
+            styles.ansi256ToAnsi(
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic method access needed for chalk compatibility
+            styles.rgbToAnsi256(red, green, blue)),
+            enumerable: false,
+        },
+        hexToAnsi: {
+            value: (hex) => 
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic method access needed for chalk compatibility
+            styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+            enumerable: false,
+        },
+    });
+    return styles;
+}
+export const ansiStyles = assembleStyles();

package/dist/terminal/checkbox-prompt.d.ts

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+/**
+ * Standalone checkbox prompt (inquirer-like)
+ * - TypeScript version
+ */
+interface TerminalIo {
+    stdin: NodeJS.ReadStream;
+    stdout: NodeJS.WriteStream;
+}
+interface ChoiceObject<T = unknown> {
+    name: string;
+    value: T;
+    disabled?: boolean;
+    checked?: boolean;
+}
+export type Choice<T = unknown> = string | ChoiceObject<T>;
+export interface CheckboxOptions<T = unknown> {
+    message?: string;
+    choices: Choice<T>[];
+    initial?: number;
+    pageSize?: number;
+    loop?: boolean;
+    required?: boolean;
+    signal?: AbortSignal;
+    terminal?: TerminalIo;
+}
+/**
+ * Interactive checkbox prompt for selecting multiple options
+ * @param options Configuration options for the checkbox prompt
+ * @returns Promise resolving to array of selected values
+ * @throws {PromptCancelError} When user cancels with Ctrl+C
+ * @throws {PromptAbortError} When signal is aborted
+ */
+export declare function checkbox<T = unknown>({ message, choices, initial, pageSize, required, signal, terminal, }: CheckboxOptions<T>): Promise<T[]>;
+export {};
+//# sourceMappingURL=checkbox-prompt.d.ts.map

package/dist/terminal/checkbox-prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkbox-prompt.d.ts","sourceRoot":"","sources":["../../source/terminal/checkbox-prompt.ts"],"names":[],"mappings":";AACA;;;GAGG;AAoCH,UAAU,UAAU;IAClB,KAAK,EAAE,MAAM,CAAC,UAAU,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC,WAAW,CAAC;CAC5B;AAED,UAAU,YAAY,CAAC,CAAC,GAAG,OAAO;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,CAAC,CAAC;IACT,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AACD,MAAM,MAAM,MAAM,CAAC,CAAC,GAAG,OAAO,IAAI,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;AAS3D,MAAM,WAAW,eAAe,CAAC,CAAC,GAAG,OAAO;IAC1C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,QAAQ,CAAC,EAAE,UAAU,CAAC;CACvB;AA4GD;;;;;;GAMG;AACH,wBAAsB,QAAQ,CAAC,CAAC,GAAG,OAAO,EAAE,EAC1C,OAAkB,EAClB,OAAO,EACP,OAAW,EACX,QAAY,EACZ,QAAgB,EAChB,MAAM,EACN,QAA2D,GAC5D,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,CAyPnC"}

package/dist/terminal/checkbox-prompt.js

@@ -0,0 +1,362 @@
+#!/usr/bin/env node
+/**
+ * Standalone checkbox prompt (inquirer-like)
+ * - TypeScript version
+ */
+import { isAbortError, isCancelError, PromptAbortError, PromptCancelError, } from "./errors.js";
+const Keys = {
+    up: "\x1b[A",
+    down: "\x1b[B",
+    home: "\x1b[H",
+    homeAlt: "\x1b[1~",
+    end: "\x1b[F",
+    endAlt: "\x1b[4~",
+    ctrlC: "\u0003",
+    enter: "\r",
+    newline: "\n",
+    backspace: "\x7f",
+    backspaceAlt: "\b",
+};
+const ANSI = {
+    hideCursor: "\x1b[?25l",
+    showCursor: "\x1b[?25h",
+    clearLine: "\x1b[2K",
+    carriageReturn: "\r",
+    moveToStart: "\x1b[0G",
+    clearFromCursor: "\x1b[0J",
+    moveUp: "\x1b[1A",
+    cyan: "\x1b[36m",
+    dim: "\x1b[2m",
+    reset: "\x1b[0m",
+};
+function normalizeChoice(choice) {
+    if (typeof choice === "string") {
+        return {
+            name: choice,
+            value: choice,
+            disabled: false,
+            checked: false,
+        };
+    }
+    const { name, value, disabled = false, checked = false } = choice;
+    return { name, value, disabled, checked };
+}
+function updatePageStart(pointerIndex, pageSize, totalItems) {
+    const currentPage = Math.floor(pointerIndex / pageSize);
+    const pageStart = currentPage * pageSize;
+    return Math.max(0, Math.min(pageStart, Math.max(0, totalItems - pageSize)));
+}
+function findNextEnabledIndex(choices, startIndex, direction) {
+    const len = choices.length;
+    let index = startIndex;
+    for (let i = 0; i < len; i++) {
+        index = (index + direction + len) % len;
+        if (!choices[index].disabled) {
+            return index;
+        }
+    }
+    return startIndex;
+}
+function findFirstEnabledIndex(choices) {
+    for (let i = 0; i < choices.length; i++) {
+        if (!choices[i].disabled) {
+            return i;
+        }
+    }
+    return 0;
+}
+function findLastEnabledIndex(choices) {
+    for (let i = choices.length - 1; i >= 0; i--) {
+        if (!choices[i].disabled) {
+            return i;
+        }
+    }
+    return choices.length - 1;
+}
+function render(choices, pointerIndex, pageStart, pageSize, prompt, typed, requiredError = false) {
+    const visible = choices.slice(pageStart, pageStart + pageSize);
+    const lines = [];
+    lines.push(`${prompt}${typed ? ` (search: ${typed})` : ""}`);
+    if (requiredError) {
+        lines.push(`${ANSI.dim}At least one option must be selected${ANSI.reset}`);
+    }
+    for (let i = 0; i < visible.length; i++) {
+        const actualIndex = pageStart + i;
+        const ch = visible[i];
+        const prefix = actualIndex === pointerIndex ? "›" : " ";
+        const checkbox = ch.checked ? "[x]" : "[ ]";
+        if (ch.disabled) {
+            lines.push(` ${prefix} ${checkbox} ${ch.name} (disabled)`);
+        }
+        else if (actualIndex === pointerIndex) {
+            lines.push(`${ANSI.cyan} ${prefix} ${checkbox} ${ch.name}${ANSI.reset}`);
+        }
+        else {
+            lines.push(` ${prefix} ${checkbox} ${ch.name}`);
+        }
+    }
+    if (choices.length > pageSize) {
+        const pageCount = Math.ceil(choices.length / pageSize);
+        const currentPage = Math.ceil(pageStart / pageSize) + 1;
+        lines.push(`${ANSI.dim}Page ${currentPage}/${pageCount}${ANSI.reset}`);
+    }
+    // Add keyboard shortcuts help
+    lines.push("");
+    lines.push(`${ANSI.dim}Controls: ↑↓ move, space toggle, a select all, i invert, enter confirm, ctrl+c cancel${ANSI.reset}`);
+    return lines.join("\n");
+}
+/**
+ * Interactive checkbox prompt for selecting multiple options
+ * @param options Configuration options for the checkbox prompt
+ * @returns Promise resolving to array of selected values
+ * @throws {PromptCancelError} When user cancels with Ctrl+C
+ * @throws {PromptAbortError} When signal is aborted
+ */
+export async function checkbox({ message = "Select", choices, initial = 0, pageSize = 7, required = false, signal, terminal = { stdin: process.stdin, stdout: process.stdout }, }) {
+    if (!Array.isArray(choices) || choices.length === 0) {
+        throw new Error("choices must be a non-empty array");
+    }
+    const normalized = choices.map(normalizeChoice);
+    const hasEnabledChoice = normalized.some((ch) => !ch.disabled);
+    if (!hasEnabledChoice) {
+        throw new Error("At least one choice must be enabled");
+    }
+    let pointer = Math.max(0, Math.min(Math.floor(initial ?? 0), normalized.length - 1));
+    if (normalized[pointer].disabled) {
+        pointer = findNextEnabledIndex(normalized, pointer, 1);
+    }
+    let pageStart = updatePageStart(pointer, pageSize, normalized.length);
+    const { stdin, stdout } = terminal;
+    if (!stdin.isTTY) {
+        throw new Error("TTY required");
+    }
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    let searchBuffer = "";
+    let searchTimer = null;
+    let requiredError = false;
+    const resetSearchBuffer = () => {
+        if (searchTimer)
+            clearTimeout(searchTimer);
+        searchTimer = setTimeout(() => {
+            searchBuffer = "";
+        }, 800);
+    };
+    let previousOutputLines = 0;
+    function renderToScreen() {
+        stdout.write(ANSI.clearLine);
+        stdout.write(ANSI.moveToStart);
+        stdout.write(ANSI.clearFromCursor);
+        // Clear previous output by moving up and clearing lines
+        for (let i = 0; i < previousOutputLines; i++) {
+            stdout.write(ANSI.moveUp);
+            stdout.write(ANSI.clearLine);
+        }
+        const out = render(normalized, pointer, pageStart, pageSize, message, searchBuffer, requiredError);
+        // Count lines in current output
+        previousOutputLines = out.split("\n").length;
+        stdout.write(`${out}\n`);
+    }
+    function move(delta) {
+        pointer = findNextEnabledIndex(normalized, pointer, delta);
+        pageStart = updatePageStart(pointer, pageSize, normalized.length);
+        renderToScreen();
+    }
+    function jumpToIndexStartingWith(prefix) {
+        const start = (pointer + 1) % normalized.length;
+        const lowerPref = prefix.toLowerCase();
+        for (let i = 0; i < normalized.length; i++) {
+            const idx = (start + i) % normalized.length;
+            if (normalized[idx].disabled)
+                continue;
+            if (normalized[idx].name.toLowerCase().startsWith(lowerPref)) {
+                pointer = idx;
+                pageStart = updatePageStart(pointer, pageSize, normalized.length);
+                renderToScreen();
+                return true;
+            }
+        }
+        return false;
+    }
+    function toggleCurrent() {
+        if (!normalized[pointer].disabled) {
+            normalized[pointer].checked = !normalized[pointer].checked;
+            renderToScreen();
+        }
+    }
+    function toggleAll() {
+        const allChecked = normalized.every((ch) => ch.disabled || ch.checked);
+        normalized.forEach((ch) => {
+            if (!ch.disabled) {
+                ch.checked = !allChecked;
+            }
+        });
+        renderToScreen();
+    }
+    function invertSelection() {
+        normalized.forEach((ch) => {
+            if (!ch.disabled) {
+                ch.checked = !ch.checked;
+            }
+        });
+        renderToScreen();
+    }
+    return new Promise((resolve, reject) => {
+        let resolved = false;
+        let cleanupCalled = false;
+        function cleanup() {
+            if (cleanupCalled)
+                return;
+            cleanupCalled = true;
+            stdin.setRawMode(false);
+            stdin.pause();
+            stdin.removeListener("data", onData);
+            if (searchTimer)
+                clearTimeout(searchTimer);
+            if (signal && abortHandler) {
+                signal.removeEventListener("abort", abortHandler);
+            }
+            stdout.write(ANSI.showCursor);
+        }
+        const abortHandler = signal
+            ? () => {
+                cleanup();
+                reject(new PromptAbortError());
+            }
+            : null;
+        if (signal && abortHandler) {
+            signal.addEventListener("abort", abortHandler);
+        }
+        function onData(key) {
+            if (key === Keys.ctrlC) {
+                cleanup();
+                stdout.write("\n");
+                reject(new PromptCancelError());
+                return;
+            }
+            if (key === Keys.enter || key === Keys.newline) {
+                const selected = normalized.filter((ch) => ch.checked && !ch.disabled);
+                if (required && selected.length === 0) {
+                    // Show error but don't exit
+                    requiredError = true;
+                    renderToScreen();
+                    return;
+                }
+                requiredError = false;
+                resolved = true;
+                cleanup();
+                stdout.write("\n");
+                resolve(selected.map((ch) => ch.value));
+                return;
+            }
+            if (key === Keys.up) {
+                move(-1);
+                return;
+            }
+            if (key === Keys.down) {
+                move(1);
+                return;
+            }
+            if (key === Keys.home || key === Keys.homeAlt) {
+                pointer = findFirstEnabledIndex(normalized);
+                pageStart = updatePageStart(pointer, pageSize, normalized.length);
+                renderToScreen();
+                return;
+            }
+            if (key === Keys.end || key === Keys.endAlt) {
+                pointer = findLastEnabledIndex(normalized);
+                pageStart = updatePageStart(pointer, pageSize, normalized.length);
+                renderToScreen();
+                return;
+            }
+            if (key === Keys.backspace || key === Keys.backspaceAlt) {
+                if (searchBuffer.length > 0) {
+                    searchBuffer = searchBuffer.slice(0, -1);
+                    if (searchBuffer.length === 0)
+                        resetSearchBuffer();
+                    renderToScreen();
+                }
+                return;
+            }
+            if (key === " ") {
+                toggleCurrent();
+                return;
+            }
+            if (key === "a") {
+                toggleAll();
+                return;
+            }
+            if (key === "i") {
+                invertSelection();
+                return;
+            }
+            if (key && key >= " " && key <= "~") {
+                searchBuffer += key;
+                resetSearchBuffer();
+                const found = jumpToIndexStartingWith(searchBuffer);
+                if (!found) {
+                    searchBuffer = key;
+                    resetSearchBuffer();
+                    jumpToIndexStartingWith(searchBuffer);
+                }
+                renderToScreen();
+                return;
+            }
+        }
+        try {
+            stdout.write(ANSI.hideCursor);
+            renderToScreen();
+            stdin.on("data", onData);
+            const exitHandler = () => {
+                if (!resolved) {
+                    cleanup();
+                    stdout.write("\n");
+                }
+            };
+            process.on("exit", exitHandler);
+        }
+        catch (error) {
+            cleanup();
+            throw error;
+        }
+    });
+}
+// Quick test when run directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    (async () => {
+        try {
+            const res = await checkbox({
+                message: "Pick fruits",
+                choices: [
+                    "Apple",
+                    "Banana",
+                    { name: "Date", value: "date", checked: true },
+                    "Elderberry",
+                    { name: "Fig", value: "fig", disabled: true },
+                    "Grapes",
+                    "Honeydew",
+                    "Orange",
+                ],
+                pageSize: 3,
+                initial: 0,
+            });
+            console.info("You picked:", res);
+            process.exit(0);
+        }
+        catch (err) {
+            if (isCancelError(err)) {
+                console.error("Cancelled");
+                process.exit(2);
+            }
+            else if (isAbortError(err)) {
+                console.error("Aborted");
+                process.exit(3);
+            }
+            else {
+                console.error(err);
+                process.exit(1);
+            }
+        }
+    })();
+}

package/dist/terminal/default-theme.d.ts

@@ -0,0 +1,6 @@
+import type { Theme } from "./highlight/theme.ts";
+/**
+ * The default theme. It is possible to override just individual keys.
+ */
+export declare const DEFAULT_THEME: Theme;
+//# sourceMappingURL=default-theme.d.ts.map

package/dist/terminal/default-theme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-theme.d.ts","sourceRoot":"","sources":["../../source/terminal/default-theme.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AASlD;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,KAqN3B,CAAC"}