mepcli 0.6.1 → 1.0.0-beta.2

package/dist/ansi.d.ts

@@ -15,6 +15,14 @@ export declare const ANSI: {
     FG_RED: string;
     FG_GRAY: string;
     FG_WHITE: string;
+    FG_BLUE: string;
+    FG_MAGENTA: string;
+    FG_BLACK: string;
+    BG_YELLOW: string;
+    BG_BLUE: string;
+    BG_CYAN: string;
+    BG_GREEN: string;
+    BG_RED: string;
     ERASE_LINE: string;
     ERASE_DOWN: string;
     CURSOR_LEFT: string;

package/dist/ansi.js

@@ -19,6 +19,14 @@ exports.ANSI = {
     FG_RED: '\x1b[31m',
     FG_GRAY: '\x1b[90m',
     FG_WHITE: '\x1b[37m',
+    FG_BLUE: '\x1b[34m',
+    FG_MAGENTA: '\x1b[35m',
+    FG_BLACK: '\x1b[30m',
+    BG_YELLOW: '\x1b[43m',
+    BG_BLUE: '\x1b[44m',
+    BG_CYAN: '\x1b[46m',
+    BG_GREEN: '\x1b[42m',
+    BG_RED: '\x1b[41m',
     // Cursor & Erasing
     ERASE_LINE: '\x1b[2K', // Clear current line
     ERASE_DOWN: '\x1b[J', // Clear from cursor to end of screen

package/dist/base.d.ts

@@ -14,17 +14,38 @@ export declare abstract class Prompt<T, O> {
     private _inputParser;
     private _onKeyHandler?;
     private _onDataHandler?;
+    private static warnedComponents;
     protected lastRenderLines: string[];
     protected lastRenderHeight: number;
     protected capabilities: ReturnType<typeof detectCapabilities>;
     constructor(options: O);
+    /**
+     * Checks if running on Windows and logs a warning message once per component type.
+     * Call this in the constructor of problematic prompts.
+     */
+    protected checkWindowsAttention(): void;
+    /**
+     * Warn about experimental prompts.
+     * Call this in the constructor of experimental prompts.
+     */
+    protected warnExperimental(): void;
     protected abstract render(firstRender: boolean): void;
     protected abstract handleInput(char: string, key: Buffer): void;
     protected handleMouse(_event: MouseEvent): void;
     protected print(text: string): void;
     run(): Promise<T>;
+    /**
+     * Pauses the input stream and removes listeners.
+     * Useful for yielding control to child processes.
+     */
+    protected pauseInput(): void;
+    /**
+     * Resumes the input stream and re-attaches listeners.
+     */
+    protected resumeInput(): void;
     protected cleanup(): void;
     protected submit(result: T): void;
+    protected cancel(reason: any): void;
     /**
      * Renders the frame using a linear scan diffing algorithm.
      * Prevents flicker and handles height changes (expand/collapse) robustly.

package/dist/base.js

@@ -18,6 +18,31 @@ class Prompt {
         this._inputParser = new input_1.InputParser();
         this.capabilities = (0, utils_1.detectCapabilities)();
     }
+    /**
+     * Checks if running on Windows and logs a warning message once per component type.
+     * Call this in the constructor of problematic prompts.
+     */
+    checkWindowsAttention() {
+        const componentName = this.constructor.name;
+        // Check platform and if already warned
+        if (process.platform === 'win32' && !Prompt.warnedComponents.has(componentName)) {
+            console.warn(`${ansi_1.ANSI.FG_YELLOW}Warning:${ansi_1.ANSI.RESET} ${componentName} may hang on Windows TTY after multiple cycles. ` +
+                `Press 'Enter' if unresponsive.`);
+            Prompt.warnedComponents.add(componentName);
+        }
+    }
+    /**
+     * Warn about experimental prompts.
+     * Call this in the constructor of experimental prompts.
+     */
+    warnExperimental() {
+        const componentName = this.constructor.name;
+        if (!Prompt.warnedComponents.has(componentName)) {
+            console.warn(`${ansi_1.ANSI.FG_YELLOW}Warning:${ansi_1.ANSI.RESET} ${componentName} is an experimental prompt and may have bugs or unexpected behavior. ` +
+                `Use with caution.`);
+            Prompt.warnedComponents.add(componentName);
+        }
+    }
     handleMouse(_event) { }
     print(text) {
         this.stdout.write(text);
@@ -58,6 +83,31 @@ class Prompt {
             this.stdin.on('data', this._onDataHandler);
         });
     }
+    /**
+     * Pauses the input stream and removes listeners.
+     * Useful for yielding control to child processes.
+     */
+    pauseInput() {
+        if (this._onDataHandler) {
+            this.stdin.removeListener('data', this._onDataHandler);
+        }
+        if (typeof this.stdin.setRawMode === 'function') {
+            this.stdin.setRawMode(false);
+        }
+        this.stdin.pause();
+    }
+    /**
+     * Resumes the input stream and re-attaches listeners.
+     */
+    resumeInput() {
+        if (typeof this.stdin.setRawMode === 'function') {
+            this.stdin.setRawMode(true);
+        }
+        this.stdin.resume();
+        if (this._onDataHandler) {
+            this.stdin.on('data', this._onDataHandler);
+        }
+    }
     cleanup() {
         if (this._onDataHandler) {
             this.stdin.removeListener('data', this._onDataHandler);
@@ -78,6 +128,12 @@ class Prompt {
         if (this._resolve)
             this._resolve(result);
     }
+    cancel(reason) {
+        this.cleanup();
+        this.print('\n');
+        if (this._reject)
+            this._reject(reason);
+    }
     /**
      * Renders the frame using a linear scan diffing algorithm.
      * Prevents flicker and handles height changes (expand/collapse) robustly.
@@ -187,3 +243,4 @@ class Prompt {
     }
 }
 exports.Prompt = Prompt;
+Prompt.warnedComponents = new Set();

package/dist/core.d.ts

@@ -1,5 +1,8 @@
-import { TextOptions, SelectOptions, ConfirmOptions, CheckboxOptions, ThemeConfig, NumberOptions, ToggleOptions, ListOptions, SliderOptions, DateOptions, FileOptions, MultiSelectOptions, RatingOptions, AutocompleteOptions, SortOptions, TableOptions, EditorOptions, TreeOptions, KeypressOptions, FormOptions, SnippetOptions, SpamOptions, WaitOptions, CodeOptions, TreeSelectOptions, RangeOptions, TransferOptions, CronOptions, ColorOptions, GridOptions, CalendarOptions } from './types';
+import { TextOptions, SelectOptions, ConfirmOptions, CheckboxOptions, ThemeConfig, NumberOptions, ToggleOptions, ListOptions, SliderOptions, DateOptions, FileOptions, MultiSelectOptions, RatingOptions, AutocompleteOptions, SortOptions, TableOptions, EditorOptions, TreeOptions, KeypressOptions, FormOptions, SnippetOptions, SpamOptions, WaitOptions, CodeOptions, TreeSelectOptions, RangeOptions, TransferOptions, CronOptions, ColorOptions, GridOptions, CalendarOptions, MapOptions, SemVerOptions, IPOptions, OTPOptions, QuizSelectOptions, QuizTextOptions, KanbanOptions, KanbanItem, TimeOptions, HeatmapOptions, ByteOptions, PatternOptions, RegionOptions, SpreadsheetOptions, SelectRangeOptions, SortGridOptions } from './types';
+import { SlotOptions, GaugeOptions, CalculatorOptions, EmojiOptions, MatchOptions, DiffOptions, DialOptions, DrawOptions, MultiColumnSelectOptions, FuzzySelectOptions, MillerOptions, ScrollOptions, BreadcrumbOptions, ScheduleOptions, ScheduleTask, DataInspectorOptions, ExecOptions, ShortcutOptions, ShortcutResult, SeatOptions, DependencyOptions, LicenseOptions, RegexOptions, BoxOptions } from './types';
 import { Spinner } from './spinner';
+import { ConnectionStringOptions, ConnectionStringResult } from './prompts/connection-string';
+import { CurlOptions, CurlResult } from './prompts/curl';
 /**
  * Public Facade for MepCLI
  */
@@ -50,4 +53,48 @@ export declare class MepCLI {
     static color(options: ColorOptions): Promise<string>;
     static grid(options: GridOptions): Promise<boolean[][]>;
     static calendar(options: CalendarOptions): Promise<Date | [Date, Date]>;
+    static map(options: MapOptions): Promise<Record<string, string>>;
+    static semver(options: SemVerOptions): Promise<string>;
+    static ip(options: IPOptions): Promise<string>;
+    static otp(options: OTPOptions): Promise<string>;
+    static quizSelect<const V>(options: QuizSelectOptions<V>): Promise<V>;
+    static quizText(options: QuizTextOptions): Promise<string>;
+    static kanban<V extends KanbanItem>(options: KanbanOptions<V>): Promise<Record<string, V[]>>;
+    static time(options: TimeOptions): Promise<string>;
+    static heatmap(options: HeatmapOptions): Promise<number[][]>;
+    static byte(options: ByteOptions): Promise<number>;
+    static slot(options: SlotOptions): Promise<string>;
+    static gauge(options: GaugeOptions): Promise<string>;
+    static calculator(options: CalculatorOptions): Promise<number>;
+    static emoji(options: EmojiOptions): Promise<string>;
+    static match(options: MatchOptions): Promise<Record<string, any[]>>;
+    static diff(options: DiffOptions): Promise<string>;
+    static dial(options: DialOptions): Promise<number>;
+    static draw(options: DrawOptions): Promise<string | boolean[][]>;
+    static multiColumnSelect<V>(options: MultiColumnSelectOptions<V>): Promise<V>;
+    static fuzzySelect<V>(options: FuzzySelectOptions<V>): Promise<V>;
+    static miller<V>(options: MillerOptions<V>): Promise<V[]>;
+    static pattern(options: PatternOptions): Promise<number[]>;
+    static region(options: RegionOptions): Promise<string>;
+    static spreadsheet(options: SpreadsheetOptions): Promise<Record<string, any>[]>;
+    static scroll(options: ScrollOptions): Promise<boolean>;
+    static breadcrumb(options: BreadcrumbOptions): Promise<string>;
+    static schedule(options: ScheduleOptions): Promise<ScheduleTask[]>;
+    static inspector(options: DataInspectorOptions): Promise<any>;
+    static exec(options: ExecOptions): Promise<void>;
+    static shortcut(options: ShortcutOptions): Promise<ShortcutResult>;
+    static seat(options: SeatOptions): Promise<string[]>;
+    static selectRange<const V>(options: SelectRangeOptions<V>): Promise<V[]>;
+    static sortGrid(options: SortGridOptions): Promise<string[][]>;
+    static dependency<V>(options: DependencyOptions<V>): Promise<V[]>;
+    static license(options: LicenseOptions): Promise<string>;
+    static regex(options: RegexOptions): Promise<RegExp>;
+    static box(options: BoxOptions): Promise<{
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    }>;
+    static connectionString(options: ConnectionStringOptions): Promise<ConnectionStringResult>;
+    static curl(options: CurlOptions): Promise<CurlResult>;
 }

package/dist/core.js

@@ -33,6 +33,45 @@ const tree_select_1 = require("./prompts/tree-select");
 const color_1 = require("./prompts/color");
 const grid_1 = require("./prompts/grid");
 const calendar_1 = require("./prompts/calendar");
+const map_1 = require("./prompts/map");
+const semver_1 = require("./prompts/semver");
+const ip_1 = require("./prompts/ip");
+const otp_1 = require("./prompts/otp");
+const quiz_select_1 = require("./prompts/quiz-select");
+const quiz_text_1 = require("./prompts/quiz-text");
+const kanban_1 = require("./prompts/kanban");
+const time_1 = require("./prompts/time");
+const heatmap_1 = require("./prompts/heatmap");
+const byte_1 = require("./prompts/byte");
+const slot_1 = require("./prompts/slot");
+const gauge_1 = require("./prompts/gauge");
+const calculator_1 = require("./prompts/calculator");
+const emoji_1 = require("./prompts/emoji");
+const match_1 = require("./prompts/match");
+const diff_1 = require("./prompts/diff");
+const dial_1 = require("./prompts/dial");
+const draw_1 = require("./prompts/draw");
+const multi_column_select_1 = require("./prompts/multi-column-select");
+const fuzzy_1 = require("./prompts/fuzzy");
+const miller_1 = require("./prompts/miller");
+const pattern_1 = require("./prompts/pattern");
+const region_1 = require("./prompts/region");
+const spreadsheet_1 = require("./prompts/spreadsheet");
+const scroll_1 = require("./prompts/scroll");
+const breadcrumb_1 = require("./prompts/breadcrumb");
+const schedule_1 = require("./prompts/schedule");
+const data_inspector_1 = require("./prompts/data-inspector");
+const exec_1 = require("./prompts/exec");
+const shortcut_1 = require("./prompts/shortcut");
+const seat_1 = require("./prompts/seat");
+const select_range_1 = require("./prompts/select-range");
+const sort_grid_1 = require("./prompts/sort-grid");
+const dependency_1 = require("./prompts/dependency");
+const license_1 = require("./prompts/license");
+const regex_1 = require("./prompts/regex");
+const box_1 = require("./prompts/box");
+const connection_string_1 = require("./prompts/connection-string");
+const curl_1 = require("./prompts/curl");
 /**
  * Public Facade for MepCLI
  */
@@ -148,6 +187,123 @@ class MepCLI {
     static calendar(options) {
         return new calendar_1.CalendarPrompt(options).run();
     }
+    static map(options) {
+        return new map_1.MapPrompt(options).run();
+    }
+    static semver(options) {
+        return new semver_1.SemVerPrompt(options).run();
+    }
+    static ip(options) {
+        return new ip_1.IPPrompt(options).run();
+    }
+    static otp(options) {
+        return new otp_1.OTPPrompt(options).run();
+    }
+    static quizSelect(options) {
+        return new quiz_select_1.QuizSelectPrompt(options).run();
+    }
+    static quizText(options) {
+        return new quiz_text_1.QuizTextPrompt(options).run();
+    }
+    static kanban(options) {
+        return new kanban_1.KanbanPrompt(options).run();
+    }
+    static time(options) {
+        return new time_1.TimePrompt(options).run();
+    }
+    static heatmap(options) {
+        return new heatmap_1.HeatmapPrompt(options).run();
+    }
+    static byte(options) {
+        return new byte_1.BytePrompt(options).run();
+    }
+    static slot(options) {
+        return new slot_1.SlotPrompt(options).run();
+    }
+    static gauge(options) {
+        return new gauge_1.GaugePrompt(options).run();
+    }
+    static calculator(options) {
+        return new calculator_1.CalculatorPrompt(options).run();
+    }
+    static emoji(options) {
+        return new emoji_1.EmojiPrompt(options).run();
+    }
+    static match(options) {
+        return new match_1.MatchPrompt(options).run();
+    }
+    static diff(options) {
+        return new diff_1.DiffPrompt(options).run();
+    }
+    static dial(options) {
+        return new dial_1.DialPrompt(options).run();
+    }
+    static draw(options) {
+        return new draw_1.DrawPrompt(options).run();
+    }
+    static multiColumnSelect(options) {
+        return new multi_column_select_1.MultiColumnSelectPrompt(options).run();
+    }
+    static fuzzySelect(options) {
+        return new fuzzy_1.FuzzySelectPrompt(options).run();
+    }
+    static miller(options) {
+        return new miller_1.MillerPrompt(options).run();
+    }
+    static pattern(options) {
+        return new pattern_1.PatternPrompt(options).run();
+    }
+    static region(options) {
+        return new region_1.RegionPrompt(options).run();
+    }
+    static spreadsheet(options) {
+        return new spreadsheet_1.SpreadsheetPrompt(options).run();
+    }
+    static scroll(options) {
+        return new scroll_1.ScrollPrompt(options).run();
+    }
+    static breadcrumb(options) {
+        return new breadcrumb_1.BreadcrumbPrompt(options).run();
+    }
+    static schedule(options) {
+        return new schedule_1.SchedulePrompt(options).run();
+    }
+    static inspector(options) {
+        return new data_inspector_1.DataInspectorPrompt(options).run();
+    }
+    static exec(options) {
+        return new exec_1.ExecPrompt(options).run();
+    }
+    static shortcut(options) {
+        return new shortcut_1.ShortcutPrompt(options).run();
+    }
+    static seat(options) {
+        return new seat_1.SeatPrompt(options).run();
+    }
+    static selectRange(options) {
+        return new select_range_1.SelectRangePrompt(options).run();
+    }
+    static sortGrid(options) {
+        return new sort_grid_1.SortGridPrompt(options).run();
+    }
+    static dependency(options) {
+        return new dependency_1.DependencyPrompt(options).run();
+    }
+    static license(options) {
+        return new license_1.LicensePrompt(options).run();
+    }
+    static regex(options) {
+        return new regex_1.RegexPrompt(options).run();
+    }
+    static box(options) {
+        return new box_1.BoxPrompt(options).run();
+    }
+    static connectionString(options) {
+        return (0, connection_string_1.connectionString)(options);
+    }
+    static curl(options) {
+        return new curl_1.CurlPrompt(options).run();
+    }
 }
 exports.MepCLI = MepCLI;
 MepCLI.theme = theme_1.theme;

package/dist/data/licenses.d.ts

@@ -0,0 +1,2 @@
+import { License } from '../types';
+export declare const POPULAR_LICENSES: License[];

package/dist/data/licenses.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POPULAR_LICENSES = void 0;
+exports.POPULAR_LICENSES = [
+    {
+        id: 'MIT',
+        name: 'MIT License',
+        description: 'A short and simple permissive license with conditions only requiring preservation of copyright and license notices. Licensed works, modifications, and larger works may be distributed under different terms and without source code.',
+        permissions: ['Commercial use', 'Modification', 'Distribution', 'Private use'],
+        conditions: ['License and copyright notice'],
+        limitations: ['Liability', 'Warranty']
+    },
+    {
+        id: 'Apache-2.0',
+        name: 'Apache License 2.0',
+        description: 'A permissive license whose main conditions require preservation of copyright and license notices. Contributors provide an express grant of patent rights. Licensed works, modifications, and larger works may be distributed under different terms.',
+        permissions: ['Commercial use', 'Modification', 'Distribution', 'Patent use', 'Private use'],
+        conditions: ['License and copyright notice', 'State changes'],
+        limitations: ['Liability', 'Warranty', 'Trademark use']
+    },
+    {
+        id: 'GPL-3.0',
+        name: 'GNU General Public License v3.0',
+        description: 'Permissions of this strong copyleft license are conditioned on making available complete source code of licensed works and modifications, which include larger works using a licensed work, under the same license. Copyright and license notices must be preserved.',
+        permissions: ['Commercial use', 'Modification', 'Distribution', 'Patent use', 'Private use'],
+        conditions: ['Disclose source', 'License and copyright notice', 'Same license', 'State changes'],
+        limitations: ['Liability', 'Warranty']
+    },
+    {
+        id: 'BSD-3-Clause',
+        name: 'BSD 3-Clause "New" or "Revised" License',
+        description: 'A permissive license similar to the BSD 2-Clause License, but with a 3rd clause that prohibits others from using the name of the project or its contributors to promote derived products without written consent.',
+        permissions: ['Commercial use', 'Modification', 'Distribution', 'Private use'],
+        conditions: ['License and copyright notice'],
+        limitations: ['Liability', 'Warranty']
+    },
+    {
+        id: 'ISC',
+        name: 'ISC License',
+        description: 'A permissive license that is functionally equivalent to the BSD 2-Clause and MIT licenses, but removing some language that is no longer necessary.',
+        permissions: ['Commercial use', 'Modification', 'Distribution', 'Private use'],
+        conditions: ['License and copyright notice'],
+        limitations: ['Liability', 'Warranty']
+    },
+    {
+        id: 'Unlicense',
+        name: 'The Unlicense',
+        description: 'A license with no conditions whatsoever which dedicates works to the public domain. Unlicensed works, modifications, and larger works may be distributed under different terms and without source code.',
+        permissions: ['Commercial use', 'Modification', 'Distribution', 'Private use'],
+        conditions: [],
+        limitations: ['Liability', 'Warranty']
+    },
+    {
+        id: 'BSD-2-Clause',
+        name: 'BSD 2-Clause "Simplified" License',
+        description: 'A permissive license that is similar to the MIT License, with conditions requiring preservation of copyright and license notices.',
+        permissions: ['Commercial use', 'Modification', 'Distribution', 'Private use'],
+        conditions: ['License and copyright notice'],
+        limitations: ['Liability', 'Warranty']
+    },
+    {
+        id: 'LGPL-3.0',
+        name: 'GNU Lesser General Public License v3.0',
+        description: 'A weak copyleft license permitting proprietary use. Requires preservation of copyright and license notices. Modifications of the library under the same license must be provided under the LGPL, but applications built on top may be licensed proprietary.',
+        permissions: ['Commercial use', 'Modification', 'Distribution', 'Patent use', 'Private use'],
+        conditions: ['Disclose source', 'License and copyright notice', 'Same license', 'State changes'],
+        limitations: ['Liability', 'Warranty']
+    },
+    {
+        id: 'AGPL-3.0',
+        name: 'GNU Affero General Public License v3.0',
+        description: 'A strong copyleft license that requires releasing source code when distributing the software over a network. Includes all conditions of GPL-3.0 plus a network use clause.',
+        permissions: ['Commercial use', 'Modification', 'Distribution', 'Patent use', 'Private use'],
+        conditions: ['Disclose source', 'License and copyright notice', 'Network use disclosure', 'Same license', 'State changes'],
+        limitations: ['Liability', 'Warranty']
+    },
+    {
+        id: 'MPL-2.0',
+        name: 'Mozilla Public License 2.0',
+        description: 'A copyleft license that is easy to comply with. You must make the source code for any of your modifications available under MPL-2.0, but you can combine the software with code under other licenses.',
+        permissions: ['Commercial use', 'Modification', 'Distribution', 'Patent use', 'Private use'],
+        conditions: ['Disclose source', 'License and copyright notice', 'Same license'],
+        limitations: ['Liability', 'Warranty', 'Trademark use']
+    },
+    {
+        id: 'EPL-2.0',
+        name: 'Eclipse Public License 2.0',
+        description: 'A copyleft license based on the Mozilla Public License, designed for programs and libraries. Modified code under the same license must be provided.',
+        permissions: ['Commercial use', 'Modification', 'Distribution', 'Patent use', 'Private use'],
+        conditions: ['Disclose source', 'License and copyright notice', 'Same license'],
+        limitations: ['Liability', 'Warranty']
+    },
+    {
+        id: 'CC0-1.0',
+        name: 'Creative Commons Zero v1.0 Universal',
+        description: 'A public domain dedication waiver that places works in the public domain. A work released under CC0 incurs no obligations and anyone may use the work in any way.',
+        permissions: ['Commercial use', 'Modification', 'Distribution', 'Private use'],
+        conditions: [],
+        limitations: ['Liability', 'Warranty']
+    },
+    {
+        id: 'WTFPL',
+        name: 'Do What The F* You Want To Public License',
+        description: 'An extremely permissive license that allows anyone to do whatever they want with the work with no restrictions whatsoever.',
+        permissions: ['Commercial use', 'Modification', 'Distribution', 'Private use'],
+        conditions: [],
+        limitations: ['Liability', 'Warranty']
+    }
+];

package/dist/highlight.js

@@ -2,39 +2,71 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.highlightJson = highlightJson;
 const ansi_1 = require("./ansi");
+const theme_1 = require("./theme");
 function highlightJson(json) {
     if (!json)
         return '';
-    // Regex for JSON tokens
-    // Captures:
-    // 1. Strings (potentially keys if followed by :)
+    // Updated Regex for better partial matching and separation
+    // 1. Strings (keys or values), allowing unclosed quotes for partial typing
     // 2. Numbers
     // 3. Booleans/Null
-    // 4. Punctuation
-    const tokenRegex = /("(\\u[a-zA-Z0-9]{4}|\\[^u]|[^\\"])*"(\s*:)?)|(-?\d+(?:\.\d*)?(?:[eE][+-]?\d+)?)|(true|false|null)|([{}[\],:])/g;
-    return json.replace(tokenRegex, (match) => {
-        // String
-        if (match.startsWith('"')) {
-            // Check if it's a key (ends with :)
-            if (match.trim().endsWith(':')) {
-                const colonIndex = match.lastIndexOf(':');
-                const keyPart = match.substring(0, colonIndex);
-                const colonPart = match.substring(colonIndex);
-                // Key in Cyan
-                return `${ansi_1.ANSI.FG_CYAN}${keyPart}${ansi_1.ANSI.RESET}${colonPart}`;
+    // 4. Punctuation (separated colon from keys logic)
+    // Regex explanation:
+    // ("(\\u[a-zA-Z0-9]{4}|\\[^u]|[^\\"])*"?) -> Captures strings, optionally unclosed at the end
+    // (-?\d+(?:\.\d*)?(?:[eE][+-]?\d+)?)       -> Captures numbers
+    // (true|false|null)                        -> Captures keywords
+    // ([{}[\],:])                              -> Captures punctuation
+    const tokenRegex = /("(\\u[a-zA-Z0-9]{4}|\\[^u]|[^\\"])*"?)|(-?\d+(?:\.\d*)?(?:[eE][+-]?\d+)?)|(true|false|null)|([{}[\],:])/g;
+    let result = '';
+    let lastIndex = 0;
+    let match;
+    while ((match = tokenRegex.exec(json)) !== null) {
+        // Add any non-matching text (whitespace/invalid) as-is
+        if (match.index > lastIndex) {
+            result += json.substring(lastIndex, match.index);
+        }
+        const token = match[0];
+        // 1. Strings (Key or Value determination is context-based, but here we do simple check)
+        // Note: In strict JSON, keys are strings followed by :, but since we separated colon,
+        // we can't easily distinguish keys just by regex lookahead safely without lookbehind support.
+        // However, for visual highlighting, colouring all strings consistently is often acceptable 
+        // or we can try to peek ahead.
+        if (token.startsWith('"')) {
+            // Simple heuristic: If the NEXT non-whitespace char is ':', treat as key
+            const remaining = json.substring(tokenRegex.lastIndex);
+            if (/^\s*:/.test(remaining)) {
+                result += `${theme_1.theme.syntax.key}${token}${ansi_1.ANSI.RESET}`;
+            }
+            else {
+                result += `${theme_1.theme.syntax.string}${token}${ansi_1.ANSI.RESET}`;
+            }
+        }
+        // 2. Numbers
+        else if (/^-?\d/.test(token)) {
+            result += `${theme_1.theme.syntax.number}${token}${ansi_1.ANSI.RESET}`;
+        }
+        // 3. Booleans/Null
+        else if (/^(true|false|null)$/.test(token)) {
+            if (token === 'null') {
+                result += `${theme_1.theme.syntax.null}${token}${ansi_1.ANSI.RESET}`;
+            }
+            else {
+                result += `${theme_1.theme.syntax.boolean}${token}${ansi_1.ANSI.RESET}`;
             }
-            // String value in Green
-            return `${ansi_1.ANSI.FG_GREEN}${match}${ansi_1.ANSI.RESET}`;
         }
-        // Number in Yellow
-        if (/^-?\d/.test(match)) {
-            return `${ansi_1.ANSI.FG_YELLOW}${match}${ansi_1.ANSI.RESET}`;
+        // 4. Punctuation
+        else if (/^[{}[\],:]$/.test(token)) {
+            result += `${theme_1.theme.syntax.punctuation}${token}${ansi_1.ANSI.RESET}`;
         }
-        // Boolean/Null in Red (or Magenta if available, using Red for now)
-        if (/^(true|false|null)$/.test(match)) {
-            return `${ansi_1.ANSI.FG_RED}${match}${ansi_1.ANSI.RESET}`;
+        // Fallback
+        else {
+            result += token;
         }
-        // Punctuation in White (or default)
-        return `${ansi_1.ANSI.FG_WHITE}${match}${ansi_1.ANSI.RESET}`;
-    });
+        lastIndex = tokenRegex.lastIndex;
+    }
+    // Append remaining text
+    if (lastIndex < json.length) {
+        result += json.substring(lastIndex);
+    }
+    return result;
 }

package/dist/index.d.ts

@@ -4,3 +4,39 @@
  */
 export * from './types';
 export * from './core';
+export * from './prompts/map';
+export * from './prompts/semver';
+export * from './prompts/ip';
+export * from './prompts/kanban';
+export * from './prompts/time';
+export * from './prompts/heatmap';
+export * from './prompts/byte';
+export * from './prompts/slot';
+export * from './prompts/gauge';
+export * from './prompts/calculator';
+export * from './prompts/emoji';
+export * from './prompts/match';
+export * from './prompts/diff';
+export * from './prompts/dial';
+export * from './prompts/draw';
+export * from './prompts/multi-column-select';
+export * from './prompts/fuzzy';
+export * from './prompts/miller';
+export * from './prompts/pattern';
+export * from './prompts/region';
+export * from './prompts/spreadsheet';
+export * from './prompts/scroll';
+export * from './prompts/breadcrumb';
+export * from './prompts/schedule';
+export * from './prompts/data-inspector';
+export * from './prompts/exec';
+export * from './prompts/shortcut';
+export * from './prompts/seat';
+export * from './prompts/select-range';
+export * from './prompts/sort-grid';
+export * from './prompts/dependency';
+export * from './prompts/license';
+export * from './prompts/regex';
+export * from './prompts/box';
+export * from './prompts/connection-string';
+export * from './prompts/curl';