duckdb-terminal 0.1.0

package/dist/duckdb-terminal.js

@@ -0,0 +1,3407 @@
+var st = Object.defineProperty;
+var rt = (i, t, e) => t in i ? st(i, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : i[t] = e;
+var a = (i, t, e) => rt(i, typeof t != "symbol" ? t + "" : t, e);
+import { Ghostty as nt, Terminal as ot, FitAddon as at } from "ghostty-web";
+import * as R from "@duckdb/duckdb-wasm";
+const lt = "https://cdn.jsdelivr.net/npm/ghostty-web", ht = () => `${lt}@0.3.0/dist/ghostty-vt.wasm`;
+class ct {
+  constructor() {
+    a(this, "terminal");
+    a(this, "fitAddon");
+    a(this, "ghostty");
+    a(this, "dataHandler");
+    a(this, "resizeHandler");
+    a(this, "currentTheme", null);
+    a(this, "initialized", !1);
+    a(this, "container", null);
+    a(this, "options", {});
+    a(this, "resizeObserver", null);
+    a(this, "mobileInput", null);
+    /**
+     * Handles window resize events.
+     * @internal
+     */
+    a(this, "handleResize", () => {
+      this.fit();
+    });
+  }
+  /**
+   * Initializes the Ghostty terminal and mounts it to the container.
+   *
+   * This method:
+   * 1. Initializes the Ghostty WASM module
+   * 2. Creates the terminal with the specified options
+   * 3. Loads the FitAddon for auto-resizing
+   * 4. Mounts the terminal to the container
+   * 5. Sets up resize observers
+   *
+   * @param container - The HTML element to mount the terminal into
+   * @param options - Configuration options for the terminal
+   * @returns A promise that resolves when initialization is complete
+   *
+   * @example
+   * ```typescript
+   * const adapter = new TerminalAdapter();
+   * await adapter.init(document.getElementById('terminal'), {
+   *   fontSize: 14,
+   *   fontFamily: 'JetBrains Mono',
+   *   theme: darkTheme,
+   * });
+   * ```
+   */
+  async init(t, e = {}) {
+    this.initialized || (this.container = t, this.options = e, this.currentTheme = e.theme ?? null, this.ghostty = await nt.load(ht()), this.createTerminal(), this.initialized = !0, this.focus());
+  }
+  /**
+   * Creates or recreates the terminal instance.
+   * @internal
+   */
+  createTerminal() {
+    this.container && (this.terminal = new ot({
+      ghostty: this.ghostty,
+      cursorBlink: !0,
+      fontSize: this.options.fontSize ?? 14,
+      fontFamily: this.options.fontFamily ?? '"Fira Code", "Cascadia Code", "JetBrains Mono", Consolas, monospace',
+      theme: this.currentTheme ? this.themeToGhostty(this.currentTheme) : void 0,
+      // Scrollback is in bytes, not lines. 10MB is a reasonable default.
+      scrollback: this.options.scrollback ?? 10 * 1024 * 1024
+    }), this.fitAddon = new at(), this.terminal.loadAddon(this.fitAddon), this.container.innerHTML = "", this.terminal.open(this.container), this.fit(), window.addEventListener("resize", this.handleResize), typeof ResizeObserver < "u" && (this.resizeObserver?.disconnect(), this.resizeObserver = new ResizeObserver(() => {
+      this.fit();
+    }), this.resizeObserver.observe(this.container)), this.terminal.onData((t) => {
+      this.dataHandler?.(t);
+    }), this.terminal.onResize(({ cols: t, rows: e }) => {
+      this.resizeHandler?.(t, e);
+    }), this.setupMobileInput());
+  }
+  /**
+   * Sets up mobile-specific functionality: touch scrolling and keyboard input.
+   * @internal
+   */
+  setupMobileInput() {
+    this.container && this.isTouchDevice() && (this.setupTouchScrolling(), this.setupMobileKeyboard());
+  }
+  /**
+   * Creates a hidden textarea for mobile keyboard input.
+   * Appended to document.body to avoid interfering with terminal touch events.
+   * @internal
+   */
+  setupMobileKeyboard() {
+    this.mobileInput?.remove();
+    const t = document.createElement("textarea");
+    t.className = "mobile-keyboard-input", t.setAttribute("autocapitalize", "off"), t.setAttribute("autocomplete", "off"), t.setAttribute("autocorrect", "off"), t.setAttribute("spellcheck", "false"), t.setAttribute("enterkeyhint", "send"), t.setAttribute("aria-label", "Terminal input"), t.style.cssText = `
+      position: fixed;
+      bottom: 0;
+      left: 50%;
+      transform: translateX(-50%);
+      width: 1px;
+      height: 1px;
+      opacity: 0;
+      font-size: 16px;
+      border: none;
+      outline: none;
+      resize: none;
+      background: transparent;
+      color: transparent;
+      z-index: -1;
+    `, t.addEventListener("input", () => {
+      const e = t.value;
+      e && this.dataHandler && this.dataHandler(e), t.value = "";
+    }), t.addEventListener("keydown", (e) => {
+      e.key.length === 1 && !e.ctrlKey && !e.altKey && !e.metaKey || (e.key === "Enter" ? (e.preventDefault(), this.dataHandler?.("\r"), t.value = "", t.blur()) : e.key === "Backspace" ? (e.preventDefault(), this.dataHandler?.("")) : e.key === "Tab" ? (e.preventDefault(), this.dataHandler?.("	")) : e.key === "ArrowUp" ? (e.preventDefault(), this.dataHandler?.("\x1B[A")) : e.key === "ArrowDown" ? (e.preventDefault(), this.dataHandler?.("\x1B[B")) : e.key === "ArrowLeft" ? (e.preventDefault(), this.dataHandler?.("\x1B[D")) : e.key === "ArrowRight" && (e.preventDefault(), this.dataHandler?.("\x1B[C")));
+    }), document.body.appendChild(t), this.mobileInput = t;
+  }
+  /**
+   * Sets up touch-based scrolling for the terminal.
+   * Translates touch gestures into scroll commands.
+   * @internal
+   */
+  setupTouchScrolling() {
+    if (!this.container) return;
+    let t = 0, e = 0, s = !1;
+    const n = (l) => {
+      l.touches.length === 1 && (t = l.touches[0].clientY, e = t, s = !1);
+    }, r = (l) => {
+      if (l.touches.length !== 1) return;
+      const h = l.touches[0].clientY, d = e - h;
+      if (!s && Math.abs(h - t) > 10 && (s = !0), s) {
+        l.preventDefault();
+        const f = Math.round(d / 20);
+        f !== 0 && this.terminal && this.terminal.scrollLines?.(f), e = h;
+      }
+    }, o = () => {
+      s = !1;
+    };
+    this.container.addEventListener("touchstart", n, { passive: !0 }), this.container.addEventListener("touchmove", r, { passive: !1 }), this.container.addEventListener("touchend", o, { passive: !0 });
+  }
+  /**
+   * Converts a Theme object to Ghostty's theme format.
+   *
+   * @internal
+   * @param theme - The theme to convert
+   * @returns The theme in Ghostty's expected format
+   */
+  themeToGhostty(t) {
+    return {
+      background: t.colors.background,
+      foreground: t.colors.foreground,
+      cursor: t.colors.cursor,
+      black: t.colors.black,
+      red: t.colors.red,
+      green: t.colors.green,
+      yellow: t.colors.yellow,
+      blue: t.colors.blue,
+      magenta: t.colors.magenta,
+      cyan: t.colors.cyan,
+      white: t.colors.white,
+      brightBlack: t.colors.brightBlack,
+      brightRed: t.colors.brightRed,
+      brightGreen: t.colors.brightGreen,
+      brightYellow: t.colors.brightYellow,
+      brightBlue: t.colors.brightBlue,
+      brightMagenta: t.colors.brightMagenta,
+      brightCyan: t.colors.brightCyan,
+      brightWhite: t.colors.brightWhite
+    };
+  }
+  /**
+   * Fits the terminal to its container dimensions.
+   *
+   * This method should be called when the container size changes.
+   * It's automatically called on window resize, but you may need
+   * to call it manually after dynamic layout changes.
+   *
+   * @example
+   * ```typescript
+   * // After changing container size
+   * container.style.height = '500px';
+   * adapter.fit();
+   * ```
+   */
+  fit() {
+    this.fitAddon && this.fitAddon.fit();
+  }
+  /**
+   * Writes text to the terminal without a trailing newline.
+   *
+   * @param text - The text to write
+   *
+   * @example
+   * ```typescript
+   * adapter.write('Hello');
+   * adapter.write(' World');
+   * ```
+   */
+  write(t) {
+    this.terminal?.write(t);
+  }
+  /**
+   * Writes text to the terminal followed by a newline.
+   *
+   * @param text - The text to write
+   *
+   * @example
+   * ```typescript
+   * adapter.writeln('First line');
+   * adapter.writeln('Second line');
+   * ```
+   */
+  writeln(t) {
+    this.terminal?.writeln(t);
+  }
+  /**
+   * Clears the terminal screen and moves cursor to top-left.
+   *
+   * @example
+   * ```typescript
+   * adapter.clear();
+   * adapter.writeln('Fresh start!');
+   * ```
+   */
+  clear() {
+    this.terminal?.write("\x1B[2J\x1B[H");
+  }
+  /**
+   * Gives keyboard focus to the terminal.
+   * On mobile devices, focuses the hidden input to trigger the virtual keyboard.
+   *
+   * @example
+   * ```typescript
+   * adapter.focus();
+   * ```
+   */
+  focus() {
+    this.mobileInput && this.isTouchDevice() ? this.mobileInput.focus() : this.terminal?.focus();
+  }
+  /**
+   * Checks if the current device supports touch input.
+   * @internal
+   */
+  isTouchDevice() {
+    return "ontouchstart" in window || navigator.maxTouchPoints > 0;
+  }
+  /**
+   * Registers a callback to receive user input data.
+   *
+   * The callback is invoked whenever the user types in the terminal.
+   * This includes regular characters, control sequences, and escape codes.
+   *
+   * @param handler - The callback function to handle input data
+   *
+   * @example
+   * ```typescript
+   * adapter.onData((data) => {
+   *   if (data === '\r') {
+   *     console.log('User pressed Enter');
+   *   } else {
+   *     console.log('User typed:', data);
+   *   }
+   * });
+   * ```
+   */
+  onData(t) {
+    this.dataHandler = t;
+  }
+  /**
+   * Registers a callback to receive terminal resize events.
+   *
+   * @param handler - The callback function receiving new dimensions
+   *
+   * @example
+   * ```typescript
+   * adapter.onResize((cols, rows) => {
+   *   console.log(`Terminal resized to ${cols}x${rows}`);
+   * });
+   * ```
+   */
+  onResize(t) {
+    this.resizeHandler = t;
+  }
+  /**
+   * The number of columns (characters per line) in the terminal.
+   *
+   * @returns The current column count, or 80 if not initialized
+   */
+  get cols() {
+    return this.terminal?.cols ?? 80;
+  }
+  /**
+   * The number of rows (lines) in the terminal.
+   *
+   * @returns The current row count, or 24 if not initialized
+   */
+  get rows() {
+    return this.terminal?.rows ?? 24;
+  }
+  /**
+   * Sets the terminal color theme.
+   *
+   * Since Ghostty-web doesn't fully support runtime theme changes,
+   * this method recreates the terminal with the new theme.
+   *
+   * @param theme - The theme to apply
+   *
+   * @example
+   * ```typescript
+   * adapter.setTheme({
+   *   name: 'dark',
+   *   colors: {
+   *     background: '#1e1e1e',
+   *     foreground: '#d4d4d4',
+   *     // ... other colors
+   *   },
+   * });
+   * ```
+   */
+  setTheme(t) {
+    this.currentTheme = t, !(!this.initialized || !this.container) && (window.removeEventListener("resize", this.handleResize), this.terminal?.dispose(), this.createTerminal(), this.focus());
+  }
+  /**
+   * Gets the current terminal theme.
+   *
+   * @returns The current theme, or null if no theme is set
+   */
+  getTheme() {
+    return this.currentTheme;
+  }
+  /**
+   * Disposes of the terminal and cleans up resources.
+   *
+   * After calling this method, the adapter cannot be used again.
+   * Create a new instance if you need another terminal.
+   *
+   * @example
+   * ```typescript
+   * adapter.dispose();
+   * // adapter is no longer usable
+   * ```
+   */
+  dispose() {
+    window.removeEventListener("resize", this.handleResize), this.resizeObserver?.disconnect(), this.resizeObserver = null, this.mobileInput?.remove(), this.mobileInput = null, this.terminal?.dispose(), this.initialized = !1, this.container = null;
+  }
+}
+class ut {
+  constructor(t = {}) {
+    a(this, "db", null);
+    a(this, "conn", null);
+    a(this, "worker", null);
+    a(this, "initialized", !1);
+    a(this, "options");
+    this.options = {
+      storage: "memory",
+      databasePath: ":memory:",
+      ...t
+    };
+  }
+  /**
+   * Initializes the DuckDB database.
+   *
+   * This method performs the following setup:
+   * 1. Downloads the appropriate DuckDB WASM bundle
+   * 2. Creates a Web Worker for database operations
+   * 3. Instantiates the DuckDB instance
+   * 4. Opens the database (in-memory or OPFS-backed)
+   * 5. Creates a connection for query execution
+   *
+   * @returns A promise that resolves when initialization is complete
+   *
+   * @throws Error if initialization fails (network issues, WASM loading, etc.)
+   *
+   * @example
+   * ```typescript
+   * const db = new Database();
+   * await db.init();
+   * console.log('Database ready:', db.isReady());
+   * ```
+   */
+  async init() {
+    if (this.initialized)
+      return;
+    const t = R.getJsDelivrBundles(), e = await R.selectBundle(t), s = URL.createObjectURL(
+      new Blob([`importScripts("${e.mainWorker}");`], {
+        type: "text/javascript"
+      })
+    );
+    this.worker = new Worker(s);
+    const n = new R.ConsoleLogger();
+    this.db = new R.AsyncDuckDB(n, this.worker), await this.db.instantiate(e.mainModule, e.pthreadWorker), URL.revokeObjectURL(s);
+    const r = {
+      castDecimalToDouble: !0
+    };
+    this.options.storage === "opfs" && this.options.databasePath ? await this.db.open({
+      path: this.options.databasePath,
+      accessMode: R.DuckDBAccessMode.READ_WRITE,
+      query: r
+    }) : await this.db.open({
+      path: ":memory:",
+      query: r
+    }), this.conn = await this.db.connect(), this.initialized = !0;
+  }
+  /**
+   * Executes a SQL query and returns the results.
+   *
+   * @param sql - The SQL statement to execute
+   * @returns A promise that resolves to the query result containing columns, rows, row count, and duration
+   *
+   * @throws Error if the database is not initialized
+   * @throws Error if the SQL query is invalid or fails
+   *
+   * @example SELECT query
+   * ```typescript
+   * const result = await db.executeQuery('SELECT * FROM users WHERE age > 18;');
+   * console.log('Columns:', result.columns); // ['id', 'name', 'age']
+   * console.log('Rows:', result.rows);       // [[1, 'Alice', 25], [2, 'Bob', 30]]
+   * console.log('Duration:', result.duration); // 5.23 (milliseconds)
+   * ```
+   *
+   * @example DDL statement
+   * ```typescript
+   * await db.executeQuery('CREATE TABLE products (id INTEGER, name VARCHAR);');
+   * ```
+   */
+  async executeQuery(t) {
+    if (!this.conn)
+      throw new Error("Database not initialized");
+    const e = performance.now(), s = await this.conn.query(t), n = performance.now() - e, r = s.schema.fields.map((h) => h.name), o = [];
+    for (let h = 0; h < s.numRows; h++) {
+      const d = [];
+      for (let f = 0; f < r.length; f++) {
+        const m = s.getChildAt(f);
+        d.push(m?.get(h));
+      }
+      o.push(d);
+    }
+    const l = typeof s.numRows == "bigint" ? Number(s.numRows) : s.numRows;
+    return {
+      columns: r,
+      rows: o,
+      rowCount: l,
+      duration: n
+    };
+  }
+  /**
+   * Gets auto-completion suggestions for the current input.
+   *
+   * Provides suggestions for:
+   * - SQL keywords (SELECT, FROM, WHERE, etc.)
+   * - Table names from the current database
+   * - Common SQL functions
+   *
+   * @param text - The current input text
+   * @param cursorPosition - The cursor position within the text
+   * @returns A promise that resolves to an array of completion suggestions
+   *
+   * @example
+   * ```typescript
+   * const suggestions = await db.getCompletions('SEL', 3);
+   * console.log(suggestions);
+   * // [{ value: 'SELECT', type: 'keyword' }]
+   * ```
+   */
+  async getCompletions(t, e) {
+    if (!this.db)
+      return [];
+    try {
+      const n = t.substring(0, e).match(/[\w.]*$/), r = n ? n[0].toLowerCase() : "";
+      if (!r)
+        return [];
+      const o = [], l = [
+        "SELECT",
+        "FROM",
+        "WHERE",
+        "AND",
+        "OR",
+        "NOT",
+        "INSERT",
+        "INTO",
+        "VALUES",
+        "UPDATE",
+        "SET",
+        "DELETE",
+        "CREATE",
+        "TABLE",
+        "DROP",
+        "ALTER",
+        "INDEX",
+        "VIEW",
+        "JOIN",
+        "LEFT",
+        "RIGHT",
+        "INNER",
+        "OUTER",
+        "ON",
+        "GROUP",
+        "BY",
+        "ORDER",
+        "HAVING",
+        "LIMIT",
+        "OFFSET",
+        "UNION",
+        "EXCEPT",
+        "INTERSECT",
+        "AS",
+        "DISTINCT",
+        "ALL",
+        "NULL",
+        "TRUE",
+        "FALSE",
+        "CASE",
+        "WHEN",
+        "THEN",
+        "ELSE",
+        "END",
+        "IS",
+        "IN",
+        "BETWEEN",
+        "LIKE",
+        "EXISTS",
+        "COUNT",
+        "SUM",
+        "AVG",
+        "MIN",
+        "MAX",
+        "CAST",
+        "COALESCE",
+        "NULLIF"
+      ];
+      for (const d of l)
+        d.toLowerCase().startsWith(r) && o.push({ value: d, type: "keyword" });
+      try {
+        const d = await this.executeQuery(
+          "SELECT table_name FROM information_schema.tables WHERE table_schema = 'main'"
+        );
+        for (const f of d.rows) {
+          const m = String(f[0]);
+          m.toLowerCase().startsWith(r) && o.push({ value: m, type: "table" });
+        }
+      } catch {
+      }
+      const h = [
+        "abs",
+        "ceil",
+        "floor",
+        "round",
+        "sqrt",
+        "log",
+        "exp",
+        "power",
+        "length",
+        "lower",
+        "upper",
+        "trim",
+        "ltrim",
+        "rtrim",
+        "replace",
+        "substring",
+        "concat",
+        "now",
+        "current_date",
+        "current_time",
+        "current_timestamp",
+        "date_part",
+        "date_trunc",
+        "extract",
+        "array_agg",
+        "string_agg",
+        "list_agg",
+        "first",
+        "last",
+        "any_value"
+      ];
+      for (const d of h)
+        d.toLowerCase().startsWith(r) && o.push({ value: d, type: "function" });
+      return o.sort((d, f) => {
+        const m = d.value.toLowerCase() === r, P = f.value.toLowerCase() === r;
+        return m && !P ? -1 : !m && P ? 1 : d.value.localeCompare(f.value);
+      }), o.slice(0, 20);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Gets a list of all tables in the database.
+   *
+   * Queries the information_schema to retrieve table names from the 'main' schema.
+   *
+   * @returns A promise that resolves to an array of table names
+   *
+   * @example
+   * ```typescript
+   * const tables = await db.getTables();
+   * console.log('Tables:', tables); // ['users', 'products', 'orders']
+   * ```
+   */
+  async getTables() {
+    if (!this.conn)
+      return [];
+    try {
+      return (await this.executeQuery(
+        "SELECT table_name FROM information_schema.tables WHERE table_schema = 'main' ORDER BY table_name"
+      )).rows.map((e) => String(e[0]));
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Gets the schema (column definitions) for a specific table.
+   *
+   * @param tableName - The name of the table to get the schema for
+   * @returns A promise that resolves to an array of column definitions
+   *
+   * @example
+   * ```typescript
+   * const schema = await db.getTableSchema('users');
+   * console.log(schema);
+   * // [
+   * //   { name: 'id', type: 'INTEGER' },
+   * //   { name: 'name', type: 'VARCHAR' },
+   * //   { name: 'email', type: 'VARCHAR' }
+   * // ]
+   * ```
+   */
+  async getTableSchema(t) {
+    if (!this.conn)
+      return [];
+    try {
+      const e = t.replace(/'/g, "''");
+      return (await this.executeQuery(
+        `SELECT column_name, data_type FROM information_schema.columns WHERE table_name = '${e}' ORDER BY ordinal_position`
+      )).rows.map((n) => ({
+        name: String(n[0]),
+        type: String(n[1])
+      }));
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Registers a file in DuckDB's virtual filesystem.
+   *
+   * This allows you to load external files (CSV, Parquet, JSON) into DuckDB
+   * and query them using functions like `read_csv()`, `read_parquet()`, etc.
+   *
+   * @param filename - The virtual filename to register (e.g., 'data.csv')
+   * @param data - The file contents as a Uint8Array
+   *
+   * @throws Error if the database is not initialized
+   *
+   * @example
+   * ```typescript
+   * // Load a CSV file
+   * const response = await fetch('https://example.com/data.csv');
+   * const data = new Uint8Array(await response.arrayBuffer());
+   * await db.registerFile('data.csv', data);
+   *
+   * // Query the file
+   * const result = await db.executeQuery("SELECT * FROM read_csv('data.csv');");
+   * ```
+   */
+  async registerFile(t, e) {
+    if (!this.db)
+      throw new Error("Database not initialized");
+    await this.db.registerFileBuffer(t, e);
+  }
+  /**
+   * Removes a file from DuckDB's virtual filesystem.
+   *
+   * @param filename - The filename to remove
+   *
+   * @throws Error if the database is not initialized
+   *
+   * @example
+   * ```typescript
+   * await db.dropFile('data.csv');
+   * ```
+   */
+  async dropFile(t) {
+    if (!this.db)
+      throw new Error("Database not initialized");
+    await this.db.dropFile(t);
+  }
+  /**
+   * Checks if the database is initialized and ready for queries.
+   *
+   * @returns True if the database is ready, false otherwise
+   *
+   * @example
+   * ```typescript
+   * if (db.isReady()) {
+   *   const result = await db.executeQuery('SELECT 1;');
+   * }
+   * ```
+   */
+  isReady() {
+    return this.initialized && this.conn !== null;
+  }
+  /**
+   * Closes the database connection and releases resources.
+   *
+   * This method:
+   * 1. Closes the database connection
+   * 2. Terminates the DuckDB instance
+   * 3. Terminates the Web Worker
+   *
+   * After calling this method, {@link init} must be called again before
+   * executing any queries.
+   *
+   * @returns A promise that resolves when cleanup is complete
+   *
+   * @example
+   * ```typescript
+   * await db.close();
+   * console.log('Database closed:', !db.isReady());
+   * ```
+   */
+  async close() {
+    this.conn && (await this.conn.close(), this.conn = null), this.db && (await this.db.terminate(), this.db = null), this.worker && (this.worker.terminate(), this.worker = null), this.initialized = !1;
+  }
+}
+const v = "\x1B[0m", dt = "\x1B[1m", ft = "\x1B[2m", mt = "\x1B[30m", g = "\x1B[31m", b = "\x1B[32m", N = "\x1B[33m", U = "\x1B[34m", j = "\x1B[35m", S = "\x1B[36m", F = "\x1B[37m", w = "\x1B[90m", gt = "\x1B[91m", pt = "\x1B[92m", wt = "\x1B[93m", bt = "\x1B[94m", Tt = "\x1B[95m", Et = "\x1B[96m", yt = "\x1B[97m", St = "\x1B[C", x = "\x1B[D", C = "\x1B[K";
+function Lt(i) {
+  return `\x1B[${i}C`;
+}
+function T(i) {
+  return `\x1B[${i}D`;
+}
+const Rt = {
+  black: mt,
+  red: g,
+  green: b,
+  yellow: N,
+  blue: U,
+  magenta: j,
+  cyan: S,
+  white: F,
+  brightBlack: w,
+  brightRed: gt,
+  brightGreen: pt,
+  brightYellow: wt,
+  brightBlue: bt,
+  brightMagenta: Tt,
+  brightCyan: Et,
+  brightWhite: yt
+};
+function c(i, t) {
+  return `${Rt[t] || t}${i}${v}`;
+}
+function y(i) {
+  return `${dt}${i}${v}`;
+}
+function u(i) {
+  return `${ft}${i}${v}`;
+}
+const At = 64 * 1024;
+class Ct {
+  constructor() {
+    a(this, "buffer", "");
+    a(this, "cursorPos", 0);
+    a(this, "maxSize", At);
+  }
+  /**
+   * Set the prompt length for cursor calculations (reserved for future use)
+   */
+  setPromptLength(t) {
+  }
+  /**
+   * Sets the maximum buffer size.
+   *
+   * @param size - Maximum size in bytes (defaults to MAX_BUFFER_SIZE)
+   */
+  setMaxSize(t) {
+    this.maxSize = t;
+  }
+  /**
+   * Returns the maximum buffer size.
+   *
+   * @returns The maximum size in bytes
+   */
+  getMaxSize() {
+    return this.maxSize;
+  }
+  /**
+   * Returns the current buffer content.
+   *
+   * @returns The full text content of the buffer
+   */
+  getContent() {
+    return this.buffer;
+  }
+  /**
+   * Returns the current cursor position within the buffer.
+   *
+   * @returns The zero-based cursor position
+   */
+  getCursorPos() {
+    return this.cursorPos;
+  }
+  /**
+   * Clears the buffer and resets cursor to position 0.
+   */
+  clear() {
+    this.buffer = "", this.cursorPos = 0;
+  }
+  /**
+   * Sets the buffer content and moves cursor to end.
+   *
+   * Used for history navigation when replacing the current line with a previous command.
+   *
+   * @param content - The new buffer content
+   */
+  setContent(t) {
+    t.length > this.maxSize && (t = t.substring(0, this.maxSize)), this.buffer = t, this.cursorPos = t.length;
+  }
+  /**
+   * Inserts text at the cursor position.
+   *
+   * @param char - The character(s) to insert
+   * @returns VT100 escape sequences to update the terminal display
+   */
+  insert(t) {
+    if (this.buffer.length + t.length > this.maxSize) {
+      const n = this.maxSize - this.buffer.length;
+      if (n <= 0)
+        return "";
+      t = t.substring(0, n);
+    }
+    const e = this.buffer.substring(0, this.cursorPos), s = this.buffer.substring(this.cursorPos);
+    return this.buffer = e + t + s, this.cursorPos += t.length, s.length === 0 ? t : t + s + T(s.length);
+  }
+  /**
+   * Deletes the character before the cursor (backspace operation).
+   *
+   * @returns VT100 escape sequences to update the terminal display, or empty string if at start
+   */
+  backspace() {
+    if (this.cursorPos === 0)
+      return "";
+    const t = this.buffer.substring(0, this.cursorPos - 1), e = this.buffer.substring(this.cursorPos);
+    return this.buffer = t + e, this.cursorPos--, e.length === 0 ? "\b \b" : x + e + " " + T(e.length + 1);
+  }
+  /**
+   * Deletes the character at the cursor position (delete key operation).
+   *
+   * @returns VT100 escape sequences to update the terminal display, or empty string if at end
+   */
+  delete() {
+    if (this.cursorPos >= this.buffer.length)
+      return "";
+    const t = this.buffer.substring(0, this.cursorPos), e = this.buffer.substring(this.cursorPos + 1);
+    return this.buffer = t + e, e + " " + T(e.length + 1);
+  }
+  /**
+   * Moves the cursor one position to the left.
+   *
+   * @returns VT100 escape sequence, or empty string if already at start
+   */
+  moveLeft() {
+    return this.cursorPos > 0 ? (this.cursorPos--, x) : "";
+  }
+  /**
+   * Moves the cursor one position to the right.
+   *
+   * @returns VT100 escape sequence, or empty string if already at end
+   */
+  moveRight() {
+    return this.cursorPos < this.buffer.length ? (this.cursorPos++, St) : "";
+  }
+  /**
+   * Moves the cursor to the start of the line (Home key / Ctrl+A).
+   *
+   * @returns VT100 escape sequence, or empty string if already at start
+   */
+  moveToStart() {
+    if (this.cursorPos === 0)
+      return "";
+    const t = this.cursorPos;
+    return this.cursorPos = 0, T(t);
+  }
+  /**
+   * Moves the cursor to the end of the line (End key / Ctrl+E).
+   *
+   * @returns VT100 escape sequence, or empty string if already at end
+   */
+  moveToEnd() {
+    if (this.cursorPos === this.buffer.length)
+      return "";
+    const t = this.buffer.length - this.cursorPos;
+    return this.cursorPos = this.buffer.length, Lt(t);
+  }
+  /**
+   * Clears from cursor position to end of line (Ctrl+K).
+   *
+   * @returns VT100 escape sequence to clear the terminal
+   */
+  clearToEnd() {
+    return this.buffer = this.buffer.substring(0, this.cursorPos), C;
+  }
+  /**
+   * Clears the entire line and resets buffer (Ctrl+U).
+   *
+   * @returns VT100 escape sequences to clear the terminal line
+   */
+  clearLine() {
+    const t = this.moveToStart() + C;
+    return this.buffer = "", this.cursorPos = 0, t;
+  }
+  /**
+   * Returns the word immediately before the cursor for auto-completion.
+   *
+   * A word is defined as a sequence of word characters (`\w`) and dots.
+   *
+   * @returns The word before cursor, or empty string if none
+   */
+  getWordBeforeCursor() {
+    const e = this.buffer.substring(0, this.cursorPos).match(/[\w.]*$/);
+    return e ? e[0] : "";
+  }
+  /**
+   * Replaces the word before the cursor with a completion string.
+   *
+   * @param completion - The completion string to insert
+   * @returns VT100 escape sequences to update the terminal display
+   */
+  replaceWordBeforeCursor(t) {
+    const e = this.getWordBeforeCursor(), s = this.cursorPos - e.length, n = this.buffer.substring(0, s), r = this.buffer.substring(this.cursorPos);
+    this.buffer = n + t + r, this.cursorPos = s + t.length;
+    let o = "";
+    return e.length > 0 && (o += T(e.length)), o += C, o += t + r, r.length > 0 && (o += T(r.length)), o;
+  }
+  /**
+   * Checks if the buffer is empty.
+   *
+   * @returns True if buffer has no content
+   */
+  isEmpty() {
+    return this.buffer.length === 0;
+  }
+  /**
+   * Checks if the buffer contains only whitespace.
+   *
+   * @returns True if buffer is empty or contains only whitespace
+   */
+  isBlank() {
+    return this.buffer.trim().length === 0;
+  }
+}
+const It = "duckdb-terminal", p = "history", A = 1e3;
+class Pt {
+  constructor() {
+    a(this, "db", null);
+    a(this, "history", []);
+    a(this, "cursor", -1);
+    a(this, "currentInput", "");
+    a(this, "initialized", !1);
+  }
+  /**
+   * Initializes the history store by opening IndexedDB and loading existing history.
+   *
+   * This method must be called before using other methods. It loads any
+   * previously stored commands from IndexedDB. If IndexedDB is unavailable
+   * (e.g., in private browsing), the store falls back to in-memory storage.
+   *
+   * @returns A promise that resolves when initialization is complete
+   *
+   * @example
+   * ```typescript
+   * const history = new HistoryStore();
+   * await history.init();
+   * // Now ready to use
+   * ```
+   */
+  async init() {
+    if (!this.initialized)
+      try {
+        this.db = await this.openDatabase(), this.history = await this.loadHistory(), this.history.length > A && (this.history = this.history.slice(-A), this.db && await this.trimHistory()), this.cursor = this.history.length, this.initialized = !0;
+      } catch (t) {
+        console.warn("IndexedDB not available, using in-memory history:", t), this.initialized = !0;
+      }
+  }
+  /**
+   * Open IndexedDB database
+   */
+  openDatabase() {
+    return new Promise((t, e) => {
+      const s = indexedDB.open(It, 1);
+      s.onerror = () => e(s.error), s.onsuccess = () => t(s.result), s.onupgradeneeded = (n) => {
+        const r = n.target.result;
+        r.objectStoreNames.contains(p) || r.createObjectStore(p, {
+          keyPath: "id",
+          autoIncrement: !0
+        });
+      };
+    });
+  }
+  /**
+   * Load history from IndexedDB
+   */
+  loadHistory() {
+    return new Promise((t, e) => {
+      if (!this.db) {
+        t([]);
+        return;
+      }
+      const r = this.db.transaction(p, "readonly").objectStore(p).getAll();
+      r.onerror = () => e(r.error), r.onsuccess = () => {
+        const o = r.result;
+        o.sort((l, h) => l.id - h.id), t(o.map((l) => l.command));
+      };
+    });
+  }
+  /**
+   * Adds a command to the history.
+   *
+   * The command is stored both in memory and persisted to IndexedDB.
+   * Empty commands and consecutive duplicates are ignored.
+   *
+   * @param command - The command to add to history
+   * @returns A promise that resolves when the command has been persisted
+   *
+   * @example
+   * ```typescript
+   * await history.add('SELECT * FROM users;');
+   * await history.add('SELECT * FROM users;'); // Ignored (duplicate)
+   * await history.add(''); // Ignored (empty)
+   * ```
+   */
+  async add(t) {
+    const e = t.trim();
+    if (e) {
+      if (this.history.length > 0 && this.history[this.history.length - 1] === e) {
+        this.reset();
+        return;
+      }
+      for (this.history.push(e); this.history.length > A; )
+        this.history.shift();
+      if (this.db)
+        try {
+          await this.saveCommand(e), await this.trimHistory();
+        } catch (s) {
+          console.warn("Failed to save history:", s);
+        }
+      this.reset();
+    }
+  }
+  /**
+   * Save command to IndexedDB
+   */
+  saveCommand(t) {
+    return new Promise((e, s) => {
+      if (!this.db) {
+        e();
+        return;
+      }
+      const o = this.db.transaction(p, "readwrite").objectStore(p).add({ command: t });
+      o.onerror = () => s(o.error), o.onsuccess = () => e();
+    });
+  }
+  /**
+   * Trim history in IndexedDB to max size.
+   *
+   * Uses a single transaction for all deletions for better performance.
+   */
+  trimHistory() {
+    return new Promise((t, e) => {
+      if (!this.db) {
+        t();
+        return;
+      }
+      const s = this.db.transaction(p, "readwrite"), n = s.objectStore(p), r = n.count();
+      r.onsuccess = () => {
+        const o = r.result;
+        if (o <= A) {
+          t();
+          return;
+        }
+        const l = o - A, h = n.getAllKeys();
+        h.onsuccess = () => {
+          const f = h.result.slice(0, l);
+          if (f.length === 0) {
+            t();
+            return;
+          }
+          s.oncomplete = () => t(), s.onerror = () => e(s.error);
+          for (const m of f)
+            n.delete(m);
+        }, h.onerror = () => e(h.error);
+      }, r.onerror = () => e(r.error);
+    });
+  }
+  /**
+   * Navigates to the previous command in history.
+   *
+   * When called from the end of history (most recent position), this method
+   * saves the current input so it can be restored when navigating forward.
+   *
+   * @param currentInput - The current input buffer content to preserve
+   * @returns The previous command, or null if at the beginning of history
+   *
+   * @example
+   * ```typescript
+   * // Assuming history has ['SELECT 1;', 'SELECT 2;']
+   * const cmd1 = history.previous('SELECT 3'); // Returns 'SELECT 2;'
+   * const cmd2 = history.previous('');         // Returns 'SELECT 1;'
+   * const cmd3 = history.previous('');         // Returns null (at beginning)
+   * ```
+   */
+  previous(t) {
+    return this.history.length === 0 ? null : (this.cursor === this.history.length && (this.currentInput = t), this.cursor > 0 ? (this.cursor--, this.history[this.cursor]) : null);
+  }
+  /**
+   * Navigates to the next command in history.
+   *
+   * When reaching the end of history, returns the previously saved current input.
+   *
+   * @returns The next command, the saved current input if at the end, or null if beyond
+   *
+   * @example
+   * ```typescript
+   * // After navigating backward with previous()
+   * const cmd1 = history.next(); // Returns next newer command
+   * const cmd2 = history.next(); // Returns original input when at end
+   * ```
+   */
+  next() {
+    return this.cursor < this.history.length - 1 ? (this.cursor++, this.history[this.cursor]) : this.cursor === this.history.length - 1 ? (this.cursor++, this.currentInput) : null;
+  }
+  /**
+   * Resets the history cursor to the end and clears the saved current input.
+   *
+   * This should be called after a command is executed to prepare for new navigation.
+   */
+  reset() {
+    this.cursor = this.history.length, this.currentInput = "";
+  }
+  /**
+   * Returns a copy of all commands in history.
+   *
+   * @returns An array of all stored commands, oldest first
+   */
+  getAll() {
+    return [...this.history];
+  }
+  /**
+   * Clears all history from both memory and IndexedDB.
+   *
+   * @returns A promise that resolves when the history has been cleared
+   */
+  async clear() {
+    if (this.history = [], this.cursor = 0, this.currentInput = "", this.db)
+      return new Promise((t, e) => {
+        const r = this.db.transaction(p, "readwrite").objectStore(p).clear();
+        r.onerror = () => e(r.error), r.onsuccess = () => t();
+      });
+  }
+}
+const Nt = 50;
+function B(i) {
+  let t = 0;
+  for (const e of i) {
+    const s = e.charCodeAt(0);
+    s >= 4352 && s <= 4447 || s >= 11904 && s <= 42191 || s >= 44032 && s <= 55203 || s >= 63744 && s <= 64255 || s >= 65040 && s <= 65055 || s >= 65072 && s <= 65135 || s >= 65280 && s <= 65376 || s >= 65504 && s <= 65510 ? t += 2 : t += 1;
+  }
+  return t;
+}
+function _(i, t) {
+  const e = B(i), s = t - e;
+  return s <= 0 ? i : i + " ".repeat(s);
+}
+function z(i, t) {
+  if (B(i) <= t) return i;
+  let e = "", s = 0;
+  for (const n of i) {
+    const r = n.charCodeAt(0) >= 4352 && n.charCodeAt(0) <= 65535 ? 2 : 1;
+    if (s + r + 1 > t) break;
+    e += n, s += r;
+  }
+  return e + "…";
+}
+function Y(i) {
+  return i >= Number.MIN_SAFE_INTEGER && i <= Number.MAX_SAFE_INTEGER ? Number(i) : i.toString();
+}
+function Bt(i) {
+  const t = [];
+  if (i.months) {
+    const e = Math.floor(i.months / 12), s = i.months % 12;
+    e && t.push(`${e} year${e !== 1 ? "s" : ""}`), s && t.push(`${s} month${s !== 1 ? "s" : ""}`);
+  }
+  if (i.days && t.push(`${i.days} day${i.days !== 1 ? "s" : ""}`), i.micros) {
+    const e = typeof i.micros == "bigint" ? Number(i.micros) : i.micros, s = Math.floor(e / 36e8), n = Math.floor(e % 36e8 / 6e7), r = e % 6e7 / 1e6;
+    (s || n || r) && t.push(`${String(s).padStart(2, "0")}:${String(n).padStart(2, "0")}:${r.toFixed(6).padStart(9, "0")}`);
+  }
+  return t.length ? t.join(" ") : "00:00:00";
+}
+function vt(i) {
+  if (typeof i != "object" || i === null) return !1;
+  const t = i;
+  return "months" in t || "days" in t || "micros" in t;
+}
+function V(i, t) {
+  return typeof t == "bigint" ? Y(t) : t instanceof Date ? t.toISOString() : t instanceof Map ? Object.fromEntries(t) : t instanceof Uint8Array ? "\\x" + Array.from(t).map((e) => e.toString(16).padStart(2, "0")).join("") : t;
+}
+function L(i, t) {
+  return i == null ? t : typeof i == "string" ? i : typeof i == "boolean" ? i ? "true" : "false" : typeof i == "bigint" ? String(Y(i)) : i instanceof Date ? i.toISOString() : i instanceof Map ? "{" + Array.from(i.entries()).map(
+    ([s, n]) => `${L(s, t)}: ${L(n, t)}`
+  ).join(", ") + "}" : i instanceof Uint8Array ? "\\x" + Array.from(i).map((e) => e.toString(16).padStart(2, "0")).join("") : Array.isArray(i) ? "[" + i.map((e) => L(e, t)).join(", ") + "]" : vt(i) ? Bt(i) : typeof i == "object" ? JSON.stringify(i, V) : String(i);
+}
+function k(i, t, e = {}) {
+  const { maxColumnWidth: s = Nt, nullValue: n = "NULL" } = e;
+  if (i.length === 0)
+    return "";
+  const r = t.map(
+    (h) => h.map((d) => {
+      const f = L(d, n);
+      return s ? z(f, s) : f;
+    })
+  ), o = i.map((h, d) => {
+    const f = B(h), m = r.reduce((P, et) => {
+      const it = B(et[d] ?? "");
+      return Math.max(P, it);
+    }, 0);
+    return Math.min(Math.max(f, m), s);
+  }), l = [];
+  l.push("┌" + o.map((h) => "─".repeat(h + 2)).join("┬") + "┐"), l.push(
+    "│" + i.map((h, d) => " " + _(z(h, o[d]), o[d]) + " ").join("│") + "│"
+  ), l.push("├" + o.map((h) => "─".repeat(h + 2)).join("┼") + "┤");
+  for (const h of r)
+    l.push(
+      "│" + h.map((d, f) => " " + _(d, o[f]) + " ").join("│") + "│"
+    );
+  return l.push("└" + o.map((h) => "─".repeat(h + 2)).join("┴") + "┘"), l.join(`
+`);
+}
+function O(i, t) {
+  const e = (n) => {
+    const r = L(n, "");
+    return r.includes(",") || r.includes('"') || r.includes(`
+`) ? '"' + r.replace(/"/g, '""') + '"' : r;
+  }, s = [];
+  s.push(i.map(e).join(","));
+  for (const n of t)
+    s.push(n.map(e).join(","));
+  return s.join(`
+`);
+}
+function $(i, t) {
+  const e = (n) => L(n, "").replace(/\t/g, " ").replace(/\n/g, " "), s = [];
+  s.push(i.map(e).join("	"));
+  for (const n of t)
+    s.push(n.map(e).join("	"));
+  return s.join(`
+`);
+}
+function D(i, t) {
+  const e = t.map((s) => {
+    const n = {};
+    return i.forEach((r, o) => {
+      n[r] = s[o] ?? null;
+    }), n;
+  });
+  return JSON.stringify(e, V, 2);
+}
+const M = 100 * 1024 * 1024;
+class kt extends Error {
+  constructor(t, e, s = M) {
+    super(
+      `File "${t}" (${I(e)}) exceeds maximum size of ${I(s)}`
+    ), this.filename = t, this.size = e, this.maxSize = s, this.name = "FileSizeError";
+  }
+}
+function Ot(i, t = M) {
+  if (i.size > t)
+    throw new kt(i.name, i.size, t);
+}
+async function K(i) {
+  return new Promise((t) => {
+    const e = document.createElement("input");
+    e.type = "file", e.multiple = i?.multiple ?? !0, e.accept = i?.accept ?? ".csv,.parquet,.json,.db,.duckdb", e.onchange = () => {
+      const s = Array.from(e.files ?? []);
+      t(s);
+    }, e.oncancel = () => {
+      t([]);
+    }, e.click();
+  });
+}
+async function $t(i, t = M) {
+  return Ot(i, t), new Promise((e, s) => {
+    const n = new FileReader();
+    n.onload = () => {
+      e(new Uint8Array(n.result));
+    }, n.onerror = () => s(n.error), n.readAsArrayBuffer(i);
+  });
+}
+function I(i) {
+  if (i === 0) return "0 B";
+  const t = 1024, e = ["B", "KB", "MB", "GB"], s = Math.floor(Math.log(i) / Math.log(t));
+  return parseFloat((i / Math.pow(t, s)).toFixed(2)) + " " + e[s];
+}
+function X(i) {
+  const t = i.lastIndexOf(".");
+  return t === -1 ? "" : i.substring(t + 1).toLowerCase();
+}
+function Dt(i) {
+  return {
+    name: i.name,
+    size: i.size,
+    type: i.type || X(i.name),
+    lastModified: new Date(i.lastModified)
+  };
+}
+function Ut(i, t) {
+  const e = (r) => {
+    r.preventDefault(), r.stopPropagation(), i.classList.add("drag-over");
+  }, s = (r) => {
+    r.preventDefault(), r.stopPropagation(), i.classList.remove("drag-over");
+  }, n = (r) => {
+    r.preventDefault(), r.stopPropagation(), i.classList.remove("drag-over");
+    const o = Array.from(r.dataTransfer?.files ?? []);
+    o.length > 0 && t(o);
+  };
+  return i.addEventListener("dragover", e), i.addEventListener("dragleave", s), i.addEventListener("drop", n), () => {
+    i.removeEventListener("dragover", e), i.removeEventListener("dragleave", s), i.removeEventListener("drop", n);
+  };
+}
+async function J(i) {
+  try {
+    if (navigator.clipboard && navigator.clipboard.writeText)
+      return await navigator.clipboard.writeText(i), !0;
+    const t = document.createElement("textarea");
+    t.value = i, t.style.position = "fixed", t.style.left = "-9999px", t.style.top = "-9999px", document.body.appendChild(t), t.select();
+    try {
+      return document.execCommand("copy"), !0;
+    } finally {
+      document.body.removeChild(t);
+    }
+  } catch {
+    return !1;
+  }
+}
+async function Ft() {
+  try {
+    return navigator.clipboard && navigator.clipboard.readText ? await navigator.clipboard.readText() : null;
+  } catch {
+    return null;
+  }
+}
+function ye() {
+  return !!(navigator.clipboard && navigator.clipboard.writeText);
+}
+const Mt = /* @__PURE__ */ new Set([
+  "SELECT",
+  "FROM",
+  "WHERE",
+  "AND",
+  "OR",
+  "NOT",
+  "IN",
+  "IS",
+  "NULL",
+  "INSERT",
+  "INTO",
+  "VALUES",
+  "UPDATE",
+  "SET",
+  "DELETE",
+  "CREATE",
+  "TABLE",
+  "DROP",
+  "ALTER",
+  "INDEX",
+  "VIEW",
+  "DATABASE",
+  "SCHEMA",
+  "JOIN",
+  "LEFT",
+  "RIGHT",
+  "INNER",
+  "OUTER",
+  "FULL",
+  "CROSS",
+  "ON",
+  "USING",
+  "GROUP",
+  "BY",
+  "ORDER",
+  "HAVING",
+  "LIMIT",
+  "OFFSET",
+  "UNION",
+  "EXCEPT",
+  "INTERSECT",
+  "ALL",
+  "DISTINCT",
+  "AS",
+  "CASE",
+  "WHEN",
+  "THEN",
+  "ELSE",
+  "END",
+  "BETWEEN",
+  "LIKE",
+  "ILIKE",
+  "EXISTS",
+  "ANY",
+  "SOME",
+  "TRUE",
+  "FALSE",
+  "ASC",
+  "DESC",
+  "NULLS",
+  "FIRST",
+  "LAST",
+  "WITH",
+  "RECURSIVE",
+  "OVER",
+  "PARTITION",
+  "WINDOW",
+  "CAST",
+  "COALESCE",
+  "NULLIF",
+  "EXTRACT",
+  "INTERVAL",
+  "PRIMARY",
+  "KEY",
+  "FOREIGN",
+  "REFERENCES",
+  "UNIQUE",
+  "CHECK",
+  "DEFAULT",
+  "CONSTRAINT",
+  "CASCADE",
+  "RESTRICT",
+  "NO",
+  "ACTION",
+  "BEGIN",
+  "COMMIT",
+  "ROLLBACK",
+  "TRANSACTION",
+  "SAVEPOINT",
+  "GRANT",
+  "REVOKE",
+  "PRIVILEGES",
+  "TO",
+  "PUBLIC",
+  "IF",
+  "REPLACE",
+  "TEMPORARY",
+  "TEMP",
+  "VIRTUAL",
+  "MATERIALIZED"
+]), xt = /* @__PURE__ */ new Set([
+  "INTEGER",
+  "INT",
+  "BIGINT",
+  "SMALLINT",
+  "TINYINT",
+  "HUGEINT",
+  "FLOAT",
+  "DOUBLE",
+  "REAL",
+  "DECIMAL",
+  "NUMERIC",
+  "VARCHAR",
+  "CHAR",
+  "TEXT",
+  "STRING",
+  "BLOB",
+  "BYTEA",
+  "BOOLEAN",
+  "BOOL",
+  "BIT",
+  "DATE",
+  "TIME",
+  "TIMESTAMP",
+  "DATETIME",
+  "TIMESTAMPTZ",
+  "UUID",
+  "JSON",
+  "ARRAY",
+  "LIST",
+  "MAP",
+  "STRUCT"
+]), _t = /* @__PURE__ */ new Set([
+  "COUNT",
+  "SUM",
+  "AVG",
+  "MIN",
+  "MAX",
+  "TOTAL",
+  "ABS",
+  "CEIL",
+  "CEILING",
+  "FLOOR",
+  "ROUND",
+  "TRUNC",
+  "TRUNCATE",
+  "SQRT",
+  "POWER",
+  "POW",
+  "EXP",
+  "LOG",
+  "LOG10",
+  "LOG2",
+  "LN",
+  "SIN",
+  "COS",
+  "TAN",
+  "ASIN",
+  "ACOS",
+  "ATAN",
+  "ATAN2",
+  "LENGTH",
+  "CHAR_LENGTH",
+  "OCTET_LENGTH",
+  "BIT_LENGTH",
+  "UPPER",
+  "LOWER",
+  "INITCAP",
+  "TRIM",
+  "LTRIM",
+  "RTRIM",
+  "SUBSTR",
+  "SUBSTRING",
+  "LEFT",
+  "RIGHT",
+  "LPAD",
+  "RPAD",
+  "CONCAT",
+  "CONCAT_WS",
+  "REPLACE",
+  "REVERSE",
+  "REPEAT",
+  "POSITION",
+  "STRPOS",
+  "INSTR",
+  "LOCATE",
+  "SPLIT_PART",
+  "STRING_SPLIT",
+  "STRING_AGG",
+  "LISTAGG",
+  "ARRAY_AGG",
+  "NOW",
+  "CURRENT_DATE",
+  "CURRENT_TIME",
+  "CURRENT_TIMESTAMP",
+  "DATE_PART",
+  "DATE_TRUNC",
+  "DATE_DIFF",
+  "DATE_ADD",
+  "DATE_SUB",
+  "YEAR",
+  "MONTH",
+  "DAY",
+  "HOUR",
+  "MINUTE",
+  "SECOND",
+  "COALESCE",
+  "NULLIF",
+  "IFNULL",
+  "NVL",
+  "IIF",
+  "GREATEST",
+  "LEAST",
+  "RANDOM",
+  "SETSEED",
+  "ROW_NUMBER",
+  "RANK",
+  "DENSE_RANK",
+  "NTILE",
+  "LAG",
+  "LEAD",
+  "FIRST_VALUE",
+  "LAST_VALUE",
+  "NTH_VALUE",
+  "TYPEOF",
+  "TRY_CAST",
+  "UNNEST",
+  "GENERATE_SERIES",
+  "RANGE",
+  "READ_CSV",
+  "READ_PARQUET",
+  "READ_JSON"
+]);
+function Z(i) {
+  const t = [];
+  let e = 0;
+  for (; e < i.length; ) {
+    const s = i[e];
+    if (/\s/.test(s)) {
+      const r = e;
+      for (; e < i.length && /\s/.test(i[e]); )
+        e++;
+      t.push({ type: "whitespace", value: i.slice(r, e), start: r, end: e });
+      continue;
+    }
+    if (i.slice(e, e + 2) === "--") {
+      const r = e;
+      for (; e < i.length && i[e] !== `
+`; )
+        e++;
+      t.push({ type: "comment", value: i.slice(r, e), start: r, end: e });
+      continue;
+    }
+    if (i.slice(e, e + 2) === "/*") {
+      const r = e;
+      for (e += 2; e < i.length - 1 && i.slice(e, e + 2) !== "*/"; )
+        e++;
+      e += 2, t.push({ type: "comment", value: i.slice(r, e), start: r, end: e });
+      continue;
+    }
+    if (s === "'") {
+      const r = e;
+      for (e++; e < i.length; )
+        if (i[e] === "'" && i[e + 1] === "'")
+          e += 2;
+        else if (i[e] === "'") {
+          e++;
+          break;
+        } else
+          e++;
+      t.push({ type: "string", value: i.slice(r, e), start: r, end: e });
+      continue;
+    }
+    if (s === '"') {
+      const r = e;
+      for (e++; e < i.length && i[e] !== '"'; )
+        e++;
+      e++, t.push({ type: "identifier", value: i.slice(r, e), start: r, end: e });
+      continue;
+    }
+    if (/[0-9]/.test(s) || s === "." && /[0-9]/.test(i[e + 1] || "")) {
+      const r = e;
+      for (; e < i.length && /[0-9]/.test(i[e]); )
+        e++;
+      if (i[e] === "." && /[0-9]/.test(i[e + 1] || ""))
+        for (e++; e < i.length && /[0-9]/.test(i[e]); )
+          e++;
+      if (i[e] === "e" || i[e] === "E")
+        for (e++, (i[e] === "+" || i[e] === "-") && e++; e < i.length && /[0-9]/.test(i[e]); )
+          e++;
+      t.push({ type: "number", value: i.slice(r, e), start: r, end: e });
+      continue;
+    }
+    if (/[a-zA-Z_]/.test(s)) {
+      const r = e;
+      for (; e < i.length && /[a-zA-Z0-9_]/.test(i[e]); )
+        e++;
+      const o = i.slice(r, e), l = o.toUpperCase();
+      let h = "identifier";
+      Mt.has(l) ? h = "keyword" : xt.has(l) ? h = "type" : _t.has(l) && (h = "function"), t.push({ type: h, value: o, start: r, end: e });
+      continue;
+    }
+    const n = e;
+    e++, t.push({ type: "operator", value: i.slice(n, e), start: n, end: e });
+  }
+  return t;
+}
+function zt(i) {
+  switch (i) {
+    case "keyword":
+      return U;
+    case "type":
+      return S;
+    case "function":
+      return N;
+    case "string":
+      return b;
+    case "number":
+      return j;
+    case "comment":
+      return w;
+    case "operator":
+      return F;
+    case "identifier":
+    case "whitespace":
+    default:
+      return "";
+  }
+}
+function H(i) {
+  const t = Z(i);
+  let e = "";
+  for (const s of t) {
+    const n = zt(s.type);
+    n ? e += n + s.value + v : e += s.value;
+  }
+  return e;
+}
+function Se(i) {
+  const t = i.trim();
+  return t ? [...Z(t)].reverse().find((n) => n.type !== "whitespace")?.value === ";" : !1;
+}
+function Ht(i, t) {
+  let e = null;
+  const s = function(...n) {
+    e !== null && clearTimeout(e), e = setTimeout(() => {
+      i.apply(this, n), e = null;
+    }, t);
+  };
+  return s.cancel = () => {
+    e !== null && (clearTimeout(e), e = null);
+  }, s;
+}
+function Gt(i) {
+  const t = [];
+  let e = "", s = null, n = !1, r = !1;
+  for (let o = 0; o < i.length; o++) {
+    const l = i[o];
+    if (n) {
+      switch (l) {
+        case "n":
+          e += `
+`;
+          break;
+        case "t":
+          e += "	";
+          break;
+        case "r":
+          e += "\r";
+          break;
+        case "\\":
+          e += "\\";
+          break;
+        case '"':
+          e += '"';
+          break;
+        case "'":
+          e += "'";
+          break;
+        case " ":
+          e += " ";
+          break;
+        default:
+          e += "\\" + l;
+      }
+      n = !1;
+      continue;
+    }
+    if (l === "\\" && s !== "'") {
+      n = !0;
+      continue;
+    }
+    if ((l === '"' || l === "'") && !s) {
+      s = l, r = !0;
+      continue;
+    }
+    if (l === s) {
+      s = null;
+      continue;
+    }
+    if (l === " " && !s) {
+      (e || r) && (t.push(e), e = "", r = !1);
+      continue;
+    }
+    e += l;
+  }
+  return (e || r) && t.push(e), t;
+}
+function Qt(i) {
+  const t = Gt(i), e = t[0]?.toLowerCase() ?? "", s = t.slice(1);
+  return { command: e, args: s, allArgs: t };
+}
+const E = /https?:\/\/[^\s<>"\])\[}{'|^`\\]+/gi, Wt = "\x1B]8;;", jt = "\x07", Yt = "\x1B]8;;\x07";
+function Le(i) {
+  return E.lastIndex = 0, E.test(i);
+}
+function Re(i) {
+  return E.lastIndex = 0, i.match(E) || [];
+}
+function q(i, t) {
+  return `${Wt}${i}${jt}${t ?? i}${Yt}`;
+}
+function Vt(i) {
+  return E.lastIndex = 0, i.replace(E, (t) => q(t));
+}
+function Ae(i) {
+  try {
+    return new URL(i), !0;
+  } catch {
+    return !1;
+  }
+}
+function Kt(i, t = 60) {
+  if (i.length <= t)
+    return i;
+  try {
+    const e = new URL(i), s = e.host, n = e.pathname + e.search + e.hash, r = s.length, o = t - r - 8;
+    if (o < 10)
+      return i.substring(0, t - 3) + "...";
+    const l = n.substring(0, Math.floor(o / 2)), h = n.substring(n.length - Math.floor(o / 2));
+    return `${e.protocol}//${s}${l}...${h}`;
+  } catch {
+    return i.substring(0, t - 3) + "...";
+  }
+}
+class Xt {
+  constructor() {
+    a(this, "enabled", !0);
+    a(this, "maxURLLength", 80);
+  }
+  /**
+   * Enable or disable URL linking
+   */
+  setEnabled(t) {
+    this.enabled = t;
+  }
+  /**
+   * Check if URL linking is enabled
+   */
+  isEnabled() {
+    return this.enabled;
+  }
+  /**
+   * Set maximum URL display length
+   */
+  setMaxURLLength(t) {
+    this.maxURLLength = t;
+  }
+  /**
+   * Process text and add hyperlinks to URLs
+   */
+  process(t) {
+    return this.enabled ? Vt(t) : t;
+  }
+  /**
+   * Process text with truncated URL display
+   */
+  processWithTruncation(t) {
+    return this.enabled ? (E.lastIndex = 0, t.replace(E, (e) => {
+      const s = Kt(e, this.maxURLLength);
+      return q(e, s);
+    })) : t;
+  }
+}
+const Jt = {
+  background: "#1e1e1e",
+  foreground: "#d4d4d4",
+  cursor: "#d4d4d4",
+  selection: "#264f78",
+  black: "#000000",
+  red: "#cd3131",
+  green: "#0dbc79",
+  yellow: "#e5e510",
+  blue: "#2472c8",
+  magenta: "#bc3fbc",
+  cyan: "#11a8cd",
+  white: "#e5e5e5",
+  brightBlack: "#666666",
+  brightRed: "#f14c4c",
+  brightGreen: "#23d18b",
+  brightYellow: "#f5f543",
+  brightBlue: "#3b8eea",
+  brightMagenta: "#d670d6",
+  brightCyan: "#29b8db",
+  brightWhite: "#ffffff"
+}, Zt = {
+  background: "#ffffff",
+  foreground: "#1e1e1e",
+  cursor: "#1e1e1e",
+  selection: "#add6ff",
+  black: "#000000",
+  red: "#cd3131",
+  green: "#008000",
+  yellow: "#795e00",
+  blue: "#0451a5",
+  magenta: "#bc05bc",
+  cyan: "#0598bc",
+  white: "#e5e5e5",
+  brightBlack: "#666666",
+  brightRed: "#cd3131",
+  brightGreen: "#14ce14",
+  brightYellow: "#b5ba00",
+  brightBlue: "#0451a5",
+  brightMagenta: "#bc05bc",
+  brightCyan: "#0598bc",
+  brightWhite: "#a5a5a5"
+}, qt = {
+  name: "dark",
+  colors: Jt
+}, te = {
+  name: "light",
+  colors: Zt
+};
+function G(i) {
+  return i === "light" ? te : qt;
+}
+function ee() {
+  try {
+    const i = localStorage.getItem("duckdb-terminal-theme");
+    if (i === "light" || i === "dark")
+      return i;
+  } catch {
+  }
+  return "dark";
+}
+function ie(i) {
+  try {
+    localStorage.setItem("duckdb-terminal-theme", i);
+  } catch {
+  }
+}
+const Q = "🦆 ", W = "  > ";
+class se {
+  constructor(t) {
+    a(this, "terminalAdapter");
+    a(this, "database");
+    a(this, "inputBuffer");
+    a(this, "history");
+    a(this, "state", "idle");
+    a(this, "collectedSQL", []);
+    a(this, "commands", /* @__PURE__ */ new Map());
+    a(this, "showTimer", !1);
+    a(this, "outputMode", "table");
+    a(this, "currentThemeName");
+    a(this, "customTheme", null);
+    a(this, "config");
+    a(this, "loadedFiles", /* @__PURE__ */ new Map());
+    a(this, "syntaxHighlighting", !0);
+    a(this, "lastQueryResult", null);
+    a(this, "linkProvider");
+    // Event emitter
+    a(this, "eventListeners", /* @__PURE__ */ new Map());
+    // Pagination state (0 = disabled by default)
+    a(this, "pageSize", 0);
+    a(this, "paginationQuery", null);
+    a(this, "currentPage", 0);
+    a(this, "totalRows", 0);
+    // Prompt customization
+    a(this, "prompt");
+    a(this, "continuationPrompt");
+    // Debounced syntax highlighting (150ms delay to avoid excessive redraws)
+    a(this, "debouncedHighlight", Ht(() => this.redrawLineHighlighted(), 150));
+    // Query queue to prevent race conditions
+    a(this, "queryQueue", Promise.resolve(null));
+    // Cleanup function for drag-and-drop
+    a(this, "dragDropCleanup", null);
+    this.config = t, this.terminalAdapter = new ct(), this.database = new ut({
+      storage: t.storage ?? "memory",
+      databasePath: t.databasePath
+    }), this.inputBuffer = new Ct(), this.history = new Pt(), this.linkProvider = new Xt(), t.linkDetection === !1 && this.linkProvider.setEnabled(!1), this.prompt = t.prompt ?? Q, this.continuationPrompt = t.continuationPrompt ?? W, typeof t.theme == "object" ? (this.customTheme = t.theme, this.currentThemeName = "custom") : this.currentThemeName = t.theme ?? ee(), this.registerCommands();
+  }
+  // ==================== Event Emitter ====================
+  /**
+   * Subscribes to a terminal event.
+   *
+   * The terminal emits various events during its lifecycle that you can
+   * subscribe to for monitoring, logging, or integrating with your application.
+   *
+   * @typeParam K - The event type key from {@link TerminalEvents}
+   * @param event - The event name to subscribe to
+   * @param listener - The callback function to invoke when the event occurs
+   * @returns An unsubscribe function that removes the listener when called
+   *
+   * @example Subscribe to query events
+   * ```typescript
+   * const unsubscribe = terminal.on('queryEnd', ({ sql, result, duration }) => {
+   *   console.log(`Query completed in ${duration}ms`);
+   * });
+   *
+   * // Later, to stop listening:
+   * unsubscribe();
+   * ```
+   *
+   * @example Monitor state changes
+   * ```typescript
+   * terminal.on('stateChange', ({ state, previous }) => {
+   *   console.log(`Terminal state: ${previous} -> ${state}`);
+   * });
+   * ```
+   */
+  on(t, e) {
+    return this.eventListeners.has(t) || this.eventListeners.set(t, /* @__PURE__ */ new Set()), this.eventListeners.get(t).add(e), () => this.off(t, e);
+  }
+  /**
+   * Unsubscribes a listener from a terminal event.
+   *
+   * This is an alternative to using the unsubscribe function returned by {@link on}.
+   *
+   * @typeParam K - The event type key from {@link TerminalEvents}
+   * @param event - The event name to unsubscribe from
+   * @param listener - The callback function to remove
+   *
+   * @example
+   * ```typescript
+   * const handler = ({ sql }) => console.log(sql);
+   * terminal.on('queryStart', handler);
+   *
+   * // Later:
+   * terminal.off('queryStart', handler);
+   * ```
+   */
+  off(t, e) {
+    this.eventListeners.get(t)?.delete(e);
+  }
+  /**
+   * Emits an event to all registered listeners.
+   *
+   * @internal
+   * @typeParam K - The event type key from {@link TerminalEvents}
+   * @param event - The event name to emit
+   * @param payload - The event payload to pass to listeners
+   */
+  emit(t, e) {
+    this.eventListeners.get(t)?.forEach((s) => {
+      try {
+        s(e);
+      } catch (n) {
+        console.error(`Error in ${t} event listener:`, n);
+      }
+    });
+  }
+  /**
+   * Sets the terminal state and emits a stateChange event.
+   *
+   * @internal
+   * @param newState - The new terminal state
+   */
+  setState(t) {
+    const e = this.state;
+    e !== t && (this.state = t, this.emit("stateChange", { state: t, previous: e }));
+  }
+  // ==================== Syntax Highlighting ====================
+  /**
+   * Returns SQL with syntax highlighting applied.
+   *
+   * @param sql - The SQL string to highlight
+   * @returns The SQL with VT100 color codes applied, or the original SQL if highlighting is disabled
+   */
+  getHighlightedSQL(t) {
+    return this.syntaxHighlighting ? H(t) : t;
+  }
+  /**
+   * Redraws the current input line with syntax highlighting applied.
+   *
+   * This method clears the current line content and rewrites it with
+   * color codes for SQL keywords, strings, numbers, etc. Called on
+   * delimiter characters (space, semicolon, parentheses, comma) via debouncing.
+   */
+  redrawLineHighlighted() {
+    if (!this.syntaxHighlighting)
+      return;
+    const t = this.inputBuffer.getContent();
+    if (t.length === 0)
+      return;
+    const e = this.inputBuffer.getCursorPos(), s = H(t);
+    e > 0 && this.write(T(e)), this.write(C), this.write(s);
+    const n = t.length - e;
+    n > 0 && this.write(T(n));
+  }
+  /**
+   * Returns the current theme object for terminal styling.
+   *
+   * @returns The custom theme if set, otherwise the built-in theme ('dark' or 'light')
+   */
+  getCurrentThemeObject() {
+    return this.customTheme ? this.customTheme : G(this.currentThemeName);
+  }
+  /**
+   * Initializes and starts the terminal.
+   *
+   * This method performs the following initialization steps:
+   * 1. Resolves the container element
+   * 2. Initializes the terminal adapter (Ghostty), database (DuckDB), and history store in parallel
+   * 3. Sets up input handling and drag-and-drop file loading
+   * 4. Displays the welcome message (if enabled)
+   * 5. Shows the command prompt
+   * 6. Emits the 'ready' event
+   *
+   * @returns A promise that resolves when the terminal is fully initialized
+   *
+   * @throws Error if the container element cannot be found
+   * @throws Error if DuckDB WASM initialization fails
+   *
+   * @example
+   * ```typescript
+   * const terminal = new DuckDBTerminal({ container: '#terminal' });
+   * await terminal.start();
+   * console.log('Terminal is ready!');
+   * ```
+   *
+   * @fires ready - Emitted when initialization is complete
+   */
+  async start() {
+    const t = this.resolveContainer();
+    await this.terminalAdapter.init(t, {
+      fontFamily: this.config.fontFamily,
+      fontSize: this.config.fontSize,
+      theme: this.getCurrentThemeObject(),
+      scrollback: this.config.scrollback
+    }), this.config.welcomeMessage !== !1 && (this.writeln(y("DuckDB Terminal") + " v0.1.0"), this.write(u("Loading DuckDB WASM..."))), await Promise.all([
+      this.database.init(),
+      this.history.init()
+    ]), this.config.welcomeMessage !== !1 && (this.write("\r" + C), this.writeln(u("Powered by DuckDB WASM and Ghostty")), this.writeln(""), this.writeln("Type " + c(".help", S) + " for available commands"), this.writeln("Enter SQL statements ending with " + c(";", N)), this.writeln("")), this.terminalAdapter.onData(this.handleInput.bind(this)), this.dragDropCleanup = Ut(t, (e) => {
+      this.handleDroppedFiles(e);
+    }), this.showPrompt(), this.emit("ready", {});
+  }
+  /**
+   * Cleans up resources and event listeners.
+   *
+   * Call this method when disposing of the terminal to prevent memory leaks.
+   * This removes drag-and-drop handlers and clears internal state.
+   */
+  destroy() {
+    this.dragDropCleanup && (this.dragDropCleanup(), this.dragDropCleanup = null), this.eventListeners.clear(), this.debouncedHighlight.cancel();
+  }
+  /**
+   * Processes files dropped onto the terminal via drag-and-drop.
+   *
+   * Uses Promise.allSettled to ensure all files are attempted even if some fail.
+   *
+   * @param files - Array of File objects to load into DuckDB
+   */
+  async handleDroppedFiles(t) {
+    const e = await Promise.allSettled(
+      t.map((r) => this.loadFile(r))
+    ), s = e.filter((r) => r.status === "fulfilled" && r.value).length, n = e.length - s;
+    n > 0 && s > 0 && this.writeln(
+      u(`Loaded ${s} of ${e.length} files (${n} failed)`)
+    ), this.showPrompt();
+  }
+  /**
+   * Loads a file into DuckDB's virtual filesystem.
+   *
+   * Registers the file and displays usage hints for supported file types
+   * (CSV, Parquet, JSON). Emits a 'fileLoaded' event on success.
+   *
+   * @param file - The file to load
+   * @returns True if the file was loaded successfully, false otherwise
+   */
+  async loadFile(t) {
+    const e = X(t.name), s = Dt(t);
+    try {
+      const n = await $t(t);
+      await this.database.registerFile(t.name, n), this.loadedFiles.set(t.name, s), this.emit("fileLoaded", {
+        filename: t.name,
+        size: t.size,
+        type: e
+      }), this.writeln(""), this.writeln(
+        c(`Loaded: ${t.name}`, b) + ` (${I(t.size)})`
+      );
+      const r = t.name.replace(/'/g, "''");
+      if (e === "csv") {
+        const o = t.name.replace(/\.[^.]+$/, "").replace(/[^a-zA-Z0-9_]/g, "_");
+        this.writeln(
+          u(`Hint: SELECT * FROM read_csv('${r}');`)
+        ), this.writeln(
+          u(`  or: CREATE TABLE ${o} AS SELECT * FROM read_csv('${r}');`)
+        );
+      } else e === "parquet" ? this.writeln(
+        u(`Hint: SELECT * FROM read_parquet('${r}');`)
+      ) : e === "json" && this.writeln(
+        u(`Hint: SELECT * FROM read_json('${r}');`)
+      );
+      return !0;
+    } catch (n) {
+      const r = n instanceof Error ? n.message : String(n);
+      return this.writeln(c(`Error loading ${t.name}: ${r}`, g)), !1;
+    }
+  }
+  /**
+   * Resolves the container element from the configuration.
+   *
+   * @returns The resolved HTML element to attach the terminal to
+   * @throws Error if the container selector doesn't match any element
+   */
+  resolveContainer() {
+    if (typeof this.config.container == "string") {
+      const t = document.querySelector(this.config.container);
+      if (!t)
+        throw new Error(`Container not found: ${this.config.container}`);
+      return t;
+    }
+    return this.config.container;
+  }
+  /**
+   * Registers all built-in dot commands (.help, .tables, .schema, etc.).
+   *
+   * Called during construction to populate the commands map with handlers
+   * for terminal commands.
+   */
+  registerCommands() {
+    this.commands.set(".help", {
+      name: ".help",
+      description: "Show available commands",
+      handler: () => this.cmdHelp()
+    }), this.commands.set(".clear", {
+      name: ".clear",
+      description: "Clear the terminal",
+      handler: () => this.clear()
+    }), this.commands.set(".tables", {
+      name: ".tables",
+      description: "List all tables",
+      handler: () => this.cmdTables()
+    }), this.commands.set(".schema", {
+      name: ".schema",
+      description: "Show table schema",
+      usage: ".schema <table_name>",
+      handler: (t) => this.cmdSchema(t)
+    }), this.commands.set(".timer", {
+      name: ".timer",
+      description: "Toggle query timing",
+      usage: ".timer on|off",
+      handler: (t) => this.cmdTimer(t)
+    }), this.commands.set(".mode", {
+      name: ".mode",
+      description: "Set output mode",
+      usage: ".mode table|csv|tsv|json",
+      handler: (t) => this.cmdMode(t)
+    }), this.commands.set(".theme", {
+      name: ".theme",
+      description: "Set color theme (clears screen)",
+      usage: ".theme dark|light",
+      handler: (t) => this.cmdTheme(t)
+    }), this.commands.set(".examples", {
+      name: ".examples",
+      description: "Show example queries",
+      handler: () => this.cmdExamples()
+    }), this.commands.set(".files", {
+      name: ".files",
+      description: "Manage loaded files",
+      usage: ".files [list|add|remove <name|index>]",
+      handler: (t) => this.cmdFiles(t)
+    }), this.commands.set(".open", {
+      name: ".open",
+      description: "Open a file picker to load files",
+      handler: () => this.cmdOpen()
+    }), this.commands.set(".copy", {
+      name: ".copy",
+      description: "Copy last result to clipboard",
+      handler: async () => {
+        await this.copyLastResult();
+      }
+    }), this.commands.set(".highlight", {
+      name: ".highlight",
+      description: "Toggle syntax highlighting",
+      usage: ".highlight on|off",
+      handler: (t) => this.cmdHighlight(t)
+    }), this.commands.set(".links", {
+      name: ".links",
+      description: "Toggle clickable URL detection",
+      usage: ".links on|off",
+      handler: (t) => this.cmdLinks(t)
+    }), this.commands.set(".pagesize", {
+      name: ".pagesize",
+      description: "Enable pagination for large results (default: off)",
+      usage: ".pagesize <number> (0 = disabled)",
+      handler: (t) => this.cmdPageSize(t)
+    }), this.commands.set(".reset", {
+      name: ".reset",
+      description: "Reset database and all settings to defaults",
+      handler: () => this.cmdReset()
+    }), this.commands.set(".prompt", {
+      name: ".prompt",
+      description: "Get or set the command prompt",
+      usage: ".prompt [primary [continuation]]",
+      handler: (t) => this.cmdPrompt(t)
+    });
+  }
+  /**
+   * Displays the command prompt (primary or continuation based on state).
+   *
+   * Sets terminal state to 'idle' if not currently collecting multi-line SQL.
+   */
+  showPrompt() {
+    const t = this.state === "collecting" ? this.continuationPrompt : this.prompt;
+    this.inputBuffer.setPromptLength(t.length), this.write(c(t, b)), this.state !== "collecting" && this.setState("idle");
+  }
+  /**
+   * Handles raw terminal input data.
+   *
+   * Routes input to the appropriate handler based on terminal state
+   * (executing, paginating, or normal input mode). Processes escape
+   * sequences separately from regular character input.
+   *
+   * @param data - The raw input data from the terminal
+   */
+  handleInput(t) {
+    if (this.state !== "executing") {
+      if (this.state === "paginating") {
+        this.handlePaginationInput(t);
+        return;
+      }
+      if (t.startsWith("\x1B[")) {
+        this.handleEscapeSequence(t);
+        return;
+      }
+      for (const e of t)
+        this.handleChar(e);
+    }
+  }
+  /**
+   * Handles input during pagination mode.
+   *
+   * Supports: [n]ext page, [p]revious page, [q]uit, page number entry,
+   * and arrow keys for navigation.
+   *
+   * @param data - The input character or escape sequence
+   */
+  async handlePaginationInput(t) {
+    const e = Math.ceil(this.totalRows / this.pageSize), s = t.toLowerCase();
+    if (s === "n" || t === "\x1B[B") {
+      this.currentPage < e - 1 ? (this.currentPage++, await this.executePaginatedQuery()) : this.writeln(u("Already on last page"));
+      return;
+    }
+    if (s === "p" || t === "\x1B[A") {
+      this.currentPage > 0 ? (this.currentPage--, await this.executePaginatedQuery()) : this.writeln(u("Already on first page"));
+      return;
+    }
+    if (s === "q" || s === "\x1B" || s === "") {
+      this.writeln(""), this.exitPagination(), this.writeln(""), this.showPrompt();
+      return;
+    }
+    if (s === "\r" || s === `
+`) {
+      const n = this.inputBuffer.getContent().trim();
+      if (n) {
+        const r = parseInt(n, 10);
+        !isNaN(r) && r >= 1 && r <= e ? (this.currentPage = r - 1, this.inputBuffer.clear(), await this.executePaginatedQuery()) : (this.writeln(c(`Invalid page number. Enter 1-${e}`, g)), this.inputBuffer.clear());
+      }
+      return;
+    }
+    if (/^\d$/.test(s)) {
+      this.write(this.inputBuffer.insert(s));
+      return;
+    }
+    if (s === "" || s === "\b") {
+      this.write(this.inputBuffer.backspace());
+      return;
+    }
+  }
+  /**
+   * Processes a single character of user input.
+   *
+   * Handles special characters (Enter, Backspace, Tab, Ctrl sequences)
+   * and regular printable characters including Unicode.
+   *
+   * @param char - The single character to process
+   */
+  handleChar(t) {
+    const e = t.charCodeAt(0);
+    switch (t) {
+      case "\r":
+      // Enter
+      case `
+`:
+        this.handleEnter();
+        return;
+      case "":
+      // Backspace
+      case "\b":
+        this.write(this.inputBuffer.backspace());
+        return;
+      case "\x1B":
+        return;
+      // Will be handled by escape sequence
+      case "	":
+        this.handleTab();
+        return;
+      case "":
+        this.handleCtrlC();
+        return;
+      case "":
+        this.handlePaste();
+        return;
+      case "
":
+        this.write(this.inputBuffer.moveToStart());
+        return;
+      case "":
+        this.write(this.inputBuffer.moveToEnd());
+        return;
+      case "\v":
+        this.write(this.inputBuffer.clearToEnd());
+        return;
+      case "":
+        this.write(this.inputBuffer.clearLine());
+        return;
+    }
+    t !== "\x1B" && (e >= 32 && e < 127 ? (this.write(this.inputBuffer.insert(t)), this.isHighlightTrigger(t) && this.debouncedHighlight()) : e >= 128 && this.write(this.inputBuffer.insert(t)));
+  }
+  /**
+   * Checks if a character should trigger syntax highlighting redraw.
+   *
+   * @param char - The character to check
+   * @returns True if the character is a highlighting trigger (space, semicolon, parentheses, comma)
+   */
+  isHighlightTrigger(t) {
+    return t === " " || t === ";" || t === "(" || t === ")" || t === ",";
+  }
+  /**
+   * Processes VT100 escape sequences for special keys.
+   *
+   * Handles arrow keys (up/down for history, left/right for cursor),
+   * Home, End, and Delete keys.
+   *
+   * @param seq - The escape sequence string (e.g., '\x1b[A' for Arrow Up)
+   */
+  handleEscapeSequence(t) {
+    switch (t) {
+      case "\x1B[A":
+        this.handleArrowUp();
+        break;
+      case "\x1B[B":
+        this.handleArrowDown();
+        break;
+      case "\x1B[C":
+        this.write(this.inputBuffer.moveRight());
+        break;
+      case "\x1B[D":
+        this.write(this.inputBuffer.moveLeft());
+        break;
+      case "\x1B[H":
+        this.write(this.inputBuffer.moveToStart());
+        break;
+      case "\x1B[F":
+        this.write(this.inputBuffer.moveToEnd());
+        break;
+      case "\x1B[3~":
+        this.write(this.inputBuffer.delete());
+        break;
+    }
+  }
+  /**
+   * Handles the Enter key press.
+   *
+   * For dot commands, executes immediately. For SQL, collects lines until
+   * a semicolon terminates the statement, then executes.
+   */
+  async handleEnter() {
+    const t = this.inputBuffer.getContent();
+    if (this.writeln(""), t.trim() === "" && this.state !== "collecting") {
+      this.showPrompt();
+      return;
+    }
+    if (t.trim().startsWith(".") && this.state !== "collecting") {
+      this.writeln(""), await this.history.add(t.trim()), await this.executeCommand(t.trim()), this.inputBuffer.clear(), this.writeln(""), this.showPrompt();
+      return;
+    }
+    this.collectedSQL.push(t);
+    const e = this.collectedSQL.join(`
+`).trim();
+    e.endsWith(";") ? (this.writeln(""), await this.executeSQL(e), this.collectedSQL = [], this.state !== "paginating" && this.setState("idle")) : this.setState("collecting"), this.inputBuffer.clear(), this.state !== "paginating" && (e.endsWith(";") && this.writeln(""), this.showPrompt());
+  }
+  /**
+   * Navigates to the previous command in history (Arrow Up).
+   */
+  handleArrowUp() {
+    const t = this.history.previous(this.inputBuffer.getContent());
+    t !== null && (this.write(this.inputBuffer.clearLine()), this.inputBuffer.setContent(t), this.write(this.getHighlightedSQL(t)));
+  }
+  /**
+   * Navigates to the next command in history (Arrow Down).
+   */
+  handleArrowDown() {
+    const t = this.history.next();
+    t !== null && (this.write(this.inputBuffer.clearLine()), this.inputBuffer.setContent(t), this.write(this.getHighlightedSQL(t)));
+  }
+  /**
+   * Handles Tab key for auto-completion.
+   *
+   * Provides suggestions for SQL keywords, table names, and functions.
+   * Single match is applied directly; multiple matches are displayed.
+   */
+  async handleTab() {
+    const t = this.inputBuffer.getContent(), e = this.inputBuffer.getCursorPos(), s = await this.database.getCompletions(t, e);
+    if (s.length !== 0)
+      if (s.length === 1)
+        this.write(this.inputBuffer.replaceWordBeforeCursor(s[0].value)), this.redrawLineHighlighted();
+      else {
+        this.writeln("");
+        const n = s.map((h) => {
+          const d = h.type === "keyword" ? U : h.type === "table" ? b : h.type === "function" ? N : F;
+          return c(h.value, d);
+        }).join("  ");
+        this.writeln(n);
+        const r = this.findCommonPrefix(s.map((h) => h.value)), o = this.inputBuffer.getWordBeforeCursor();
+        r.length > o.length && this.write(this.inputBuffer.replaceWordBeforeCursor(r));
+        const l = this.state === "collecting" ? this.continuationPrompt : this.prompt;
+        this.write(c(l, b)), this.write(this.getHighlightedSQL(this.inputBuffer.getContent()));
+      }
+  }
+  /**
+   * Finds the longest common prefix among an array of strings.
+   *
+   * Used for auto-completion to expand to the longest unambiguous prefix.
+   *
+   * @param strings - Array of strings to find common prefix for
+   * @returns The longest common prefix (case-insensitive comparison)
+   */
+  findCommonPrefix(t) {
+    if (t.length === 0) return "";
+    if (t.length === 1) return t[0];
+    let e = t[0];
+    for (let s = 1; s < t.length; s++)
+      for (; !t[s].toLowerCase().startsWith(e.toLowerCase()); )
+        if (e = e.slice(0, -1), e === "") return "";
+    return e;
+  }
+  /**
+   * Handles Ctrl+C to cancel current input or multi-line collection.
+   */
+  handleCtrlC() {
+    this.writeln("^C"), this.inputBuffer.clear(), this.collectedSQL = [], this.setState("idle"), this.showPrompt();
+  }
+  /**
+   * Handles Ctrl+V to paste content from clipboard.
+   *
+   * Inserts text character-by-character, skipping newlines.
+   */
+  async handlePaste() {
+    const t = await Ft();
+    if (t)
+      for (const e of t)
+        e === `
+` || e === "\r" || this.write(this.inputBuffer.insert(e));
+  }
+  /**
+   * Copy last query result to clipboard
+   */
+  async copyLastResult() {
+    if (!this.lastQueryResult)
+      return this.writeln(u("No query result to copy")), !1;
+    let t;
+    switch (this.outputMode) {
+      case "csv":
+        t = O(this.lastQueryResult.columns, this.lastQueryResult.rows);
+        break;
+      case "tsv":
+        t = $(this.lastQueryResult.columns, this.lastQueryResult.rows);
+        break;
+      case "json":
+        t = D(this.lastQueryResult.columns, this.lastQueryResult.rows);
+        break;
+      default:
+        t = k(this.lastQueryResult.columns, this.lastQueryResult.rows);
+    }
+    const e = await J(t);
+    return e ? this.writeln(c("Result copied to clipboard", b)) : this.writeln(c("Failed to copy to clipboard", g)), e;
+  }
+  /**
+   * Executes a dot command (e.g., .help, .tables, .schema).
+   *
+   * Parses the command and arguments, looks up the handler, and executes it.
+   * Emits 'commandExecute' event on execution and 'error' on failure.
+   *
+   * @param input - The full command string including arguments
+   */
+  async executeCommand(t) {
+    const { command: e, args: s } = Qt(t), n = this.commands.get(e);
+    if (!n) {
+      this.writeln(c(`Unknown command: ${e}`, g)), this.writeln("Type .help for available commands"), this.emit("error", { message: `Unknown command: ${e}`, source: "command" });
+      return;
+    }
+    this.emit("commandExecute", { command: e, args: s });
+    try {
+      await n.handler(s, this);
+    } catch (r) {
+      const o = r instanceof Error ? r.message : String(r);
+      this.writeln(c(`Error: ${o}`, g)), this.emit("error", { message: o, source: "command" });
+    }
+  }
+  /**
+   * Executes a SQL query and displays the results.
+   *
+   * This method executes the provided SQL statement against the DuckDB database,
+   * displays the results in the configured output format (table, CSV, or JSON),
+   * and adds the query to the command history.
+   *
+   * For large result sets (when pagination is enabled via `.pagesize`), the method
+   * will automatically paginate the results and enter pagination mode.
+   *
+   * @param sql - The SQL statement to execute (should end with a semicolon)
+   * @returns A promise that resolves to the query result, or null if an error occurred
+   *
+   * @fires queryStart - Emitted before query execution begins
+   * @fires queryEnd - Emitted after query execution completes (success or failure)
+   * @fires error - Emitted if the query fails
+   *
+   * @example Execute a SELECT query
+   * ```typescript
+   * const result = await terminal.executeSQL('SELECT * FROM users;');
+   * if (result) {
+   *   console.log(`Retrieved ${result.rowCount} rows in ${result.duration}ms`);
+   *   console.log('Columns:', result.columns);
+   *   console.log('First row:', result.rows[0]);
+   * }
+   * ```
+   *
+   * @example Execute DDL statements
+   * ```typescript
+   * await terminal.executeSQL('CREATE TABLE products (id INTEGER, name VARCHAR);');
+   * await terminal.executeSQL("INSERT INTO products VALUES (1, 'Widget');");
+   * ```
+   */
+  async executeSQL(t) {
+    const e = this.queryQueue.then(() => this.executeSQLInternal(t));
+    return this.queryQueue = e.catch(() => null), e;
+  }
+  /**
+   * Internal SQL execution logic.
+   *
+   * @internal
+   * @param sql - The SQL statement to execute
+   * @returns The query result, or null on error
+   */
+  async executeSQLInternal(t) {
+    this.setState("executing");
+    const e = performance.now();
+    this.emit("queryStart", { sql: t });
+    try {
+      await this.history.add(t);
+      const s = t.trim().replace(/;+$/, ""), n = /^\s*SELECT\s/i.test(s), r = /\b(LIMIT|OFFSET)\b/i.test(s);
+      if (this.pageSize > 0 && n && !r) {
+        const h = `SELECT COUNT(*) as cnt FROM (${s}) AS _count_subquery`, f = (await this.database.executeQuery(h)).rows[0]?.[0], m = typeof f == "bigint" ? Number(f) : f ?? 0;
+        if (m > this.pageSize)
+          return this.paginationQuery = s, this.totalRows = m, this.currentPage = 0, await this.executePaginatedQuery();
+      }
+      const o = await this.database.executeQuery(t), l = performance.now() - e;
+      return this.lastQueryResult = o, o.columns.length > 0 && this.displayResult(o), this.showTimer && this.writeln(
+        u(`Time: ${o.duration.toFixed(2)}ms`)
+      ), this.emit("queryEnd", { sql: t, result: o, duration: l }), o;
+    } catch (s) {
+      const n = s instanceof Error ? s.message : String(s), r = performance.now() - e;
+      if (this.writeln(c(`Error: ${n}`, g)), t.includes(`
+`) || t.length > 80) {
+        const o = t.length > 200 ? t.substring(0, 200) + "..." : t;
+        this.writeln(u(`  Query: ${o.replace(/\n/g, " ")}`));
+      }
+      return this.emit("queryEnd", { sql: t, result: null, error: n, duration: r }), this.emit("error", { message: n, source: "query" }), null;
+    } finally {
+      this.state !== "paginating" && this.setState("idle");
+    }
+  }
+  /**
+   * Executes the current paginated query for the current page.
+   *
+   * Adds LIMIT/OFFSET to the stored query and displays results with
+   * pagination controls.
+   *
+   * @returns The query result for the current page, or null on error
+   */
+  async executePaginatedQuery() {
+    if (!this.paginationQuery) return null;
+    const t = this.currentPage * this.pageSize, e = `${this.paginationQuery} LIMIT ${this.pageSize} OFFSET ${t}`;
+    try {
+      const s = await this.database.executeQuery(e);
+      this.lastQueryResult = s, s.columns.length > 0 && this.displayResult(s);
+      const n = Math.ceil(this.totalRows / this.pageSize), r = t + 1, o = Math.min(t + this.pageSize, this.totalRows);
+      return this.writeln(""), this.writeln(
+        u(`Showing rows ${r}-${o} of ${this.totalRows} (page ${this.currentPage + 1}/${n})`)
+      ), this.writeln(
+        c("  [n]ext  [p]rev  [q]uit  or enter page number", S)
+      ), this.setState("paginating"), s;
+    } catch (s) {
+      const n = s instanceof Error ? s.message : String(s);
+      if (this.writeln(c(`Error: ${n}`, g)), e.length > 80) {
+        const r = e.length > 200 ? e.substring(0, 200) + "..." : e;
+        this.writeln(u(`  Query: ${r.replace(/\n/g, " ")}`));
+      }
+      return this.exitPagination(), null;
+    }
+  }
+  /**
+   * Exits pagination mode and resets pagination state.
+   */
+  exitPagination() {
+    this.paginationQuery = null, this.currentPage = 0, this.totalRows = 0, this.setState("idle");
+  }
+  /**
+   * Displays a query result in the current output mode.
+   *
+   * Formats and writes the result as table, CSV, TSV, or JSON based on
+   * the current outputMode setting.
+   *
+   * @param result - The query result to display
+   */
+  displayResult(t) {
+    switch (this.outputMode) {
+      case "csv":
+        this.writeln(O(t.columns, t.rows));
+        break;
+      case "tsv":
+        this.writeln($(t.columns, t.rows));
+        break;
+      case "json":
+        this.writeln(D(t.columns, t.rows));
+        break;
+      case "table":
+      default:
+        this.writeln(k(t.columns, t.rows));
+        break;
+    }
+    this.writeln(
+      u(
+        `${t.rowCount} row${t.rowCount !== 1 ? "s" : ""}`
+      )
+    );
+  }
+  // Command handlers
+  cmdHelp() {
+    this.writeln(y("Available commands:")), this.writeln("");
+    for (const t of this.commands.values()) {
+      const e = t.usage ? `  ${u(t.usage)}` : "";
+      this.writeln(`  ${c(t.name, S)}  ${t.description}${e}`);
+    }
+    this.writeln(""), this.writeln("SQL statements must end with a semicolon (;)");
+  }
+  async cmdTables() {
+    const t = await this.database.getTables();
+    if (t.length === 0) {
+      this.writeln(u("No tables found"));
+      return;
+    }
+    for (const e of t)
+      this.writeln(e);
+  }
+  async cmdSchema(t) {
+    if (t.length === 0) {
+      this.writeln("Usage: .schema <table_name>");
+      return;
+    }
+    const e = await this.database.getTableSchema(t[0]);
+    if (e.length === 0) {
+      this.writeln(u(`Table not found: ${t[0]}`));
+      return;
+    }
+    for (const s of e)
+      this.writeln(`  ${s.name} ${u(s.type)}`);
+  }
+  cmdTimer(t) {
+    if (t.length === 0) {
+      this.writeln(`Timer is ${this.showTimer ? "on" : "off"}`);
+      return;
+    }
+    const e = t[0].toLowerCase();
+    e === "on" ? (this.showTimer = !0, this.writeln("Timer is now on")) : e === "off" ? (this.showTimer = !1, this.writeln("Timer is now off")) : this.writeln("Usage: .timer on|off");
+  }
+  cmdMode(t) {
+    if (t.length === 0) {
+      this.writeln(`Output mode: ${this.outputMode}`);
+      return;
+    }
+    const e = t[0].toLowerCase();
+    e === "table" || e === "csv" || e === "tsv" || e === "json" ? (this.outputMode = e, this.writeln(`Output mode set to ${e}`)) : this.writeln("Usage: .mode table|csv|tsv|json");
+  }
+  cmdTheme(t) {
+    if (t.length === 0) {
+      const s = this.customTheme ? this.customTheme.name : this.currentThemeName;
+      this.writeln(`Theme: ${s}`);
+      return;
+    }
+    const e = t[0].toLowerCase();
+    e === "dark" || e === "light" ? this.setTheme(e) : this.writeln("Usage: .theme dark|light");
+  }
+  cmdExamples() {
+    this.writeln(y("Example queries:")), this.writeln(""), this.writeln(c("  -- Create a table", w)), this.writeln("  " + this.getHighlightedSQL("CREATE TABLE users (id INTEGER, name VARCHAR);")), this.writeln(""), this.writeln(c("  -- Insert data", w)), this.writeln("  " + this.getHighlightedSQL("INSERT INTO users VALUES (1, 'Alice'), (2, 'Bob');")), this.writeln(""), this.writeln(c("  -- Query data", w)), this.writeln("  " + this.getHighlightedSQL("SELECT * FROM users WHERE name LIKE 'A%';")), this.writeln(""), this.writeln(c("  -- Use built-in functions", w)), this.writeln("  " + this.getHighlightedSQL("SELECT range(10), current_timestamp;"));
+  }
+  async cmdFiles(t) {
+    const e = t[0]?.toLowerCase() ?? "list";
+    if (e === "list") {
+      if (this.loadedFiles.size === 0) {
+        this.writeln(u("No files loaded")), this.writeln(u("Use .open or drag-and-drop to add files"));
+        return;
+      }
+      this.writeln(y("Loaded files:"));
+      let s = 1;
+      for (const [n, r] of this.loadedFiles)
+        this.writeln(`  ${u(`${s}.`)} ${n} ${u(`(${I(r.size)})`)}`), s++;
+    } else if (e === "add")
+      await this.cmdOpen();
+    else if (e === "remove" || e === "rm") {
+      const s = t.slice(1).join(" ");
+      if (!s) {
+        this.writeln("Usage: .files remove <filename|index>");
+        return;
+      }
+      const n = parseInt(s, 10);
+      let r = null;
+      if (!isNaN(n) && n >= 1) {
+        const o = Array.from(this.loadedFiles.keys());
+        if (n <= o.length)
+          r = o[n - 1];
+        else {
+          this.writeln(c(`Invalid index: ${n}. Use .files list to see available files.`, "red"));
+          return;
+        }
+      } else if (this.loadedFiles.has(s))
+        r = s;
+      else {
+        this.writeln(c(`File not found: ${s}`, "red"));
+        return;
+      }
+      if (r)
+        try {
+          await this.database.dropFile(r), this.loadedFiles.delete(r), this.writeln(c(`Removed: ${r}`, "green"));
+        } catch (o) {
+          this.writeln(c(`Error removing file: ${o}`, "red"));
+        }
+    } else
+      this.writeln("Usage: .files [list|add|remove <name|index>]");
+  }
+  async cmdOpen() {
+    this.writeln(u("Opening file picker..."));
+    const t = await K({
+      multiple: !0,
+      accept: ".csv,.parquet,.json,.db,.duckdb"
+    });
+    if (t.length === 0) {
+      this.writeln(u("No files selected"));
+      return;
+    }
+    for (const e of t)
+      await this.loadFile(e);
+  }
+  cmdHighlight(t) {
+    if (t.length === 0) {
+      this.writeln(`Syntax highlighting is ${this.syntaxHighlighting ? "on" : "off"}`);
+      return;
+    }
+    const e = t[0].toLowerCase();
+    e === "on" ? (this.syntaxHighlighting = !0, this.writeln("Syntax highlighting is now on")) : e === "off" ? (this.syntaxHighlighting = !1, this.writeln("Syntax highlighting is now off")) : this.writeln("Usage: .highlight on|off");
+  }
+  cmdLinks(t) {
+    if (t.length === 0) {
+      this.writeln(`URL link detection is ${this.linkProvider.isEnabled() ? "on" : "off"}`);
+      return;
+    }
+    const e = t[0].toLowerCase();
+    e === "on" ? (this.linkProvider.setEnabled(!0), this.writeln("URL link detection is now on")) : e === "off" ? (this.linkProvider.setEnabled(!1), this.writeln("URL link detection is now off")) : this.writeln("Usage: .links on|off");
+  }
+  cmdPageSize(t) {
+    if (t.length === 0) {
+      this.pageSize === 0 ? this.writeln("Pagination is disabled (showing all rows)") : this.writeln(`Page size: ${this.pageSize} rows`);
+      return;
+    }
+    const e = parseInt(t[0], 10);
+    if (isNaN(e) || e < 0) {
+      this.writeln("Usage: .pagesize <number> (0 = no pagination)");
+      return;
+    }
+    this.pageSize = e, e === 0 ? this.writeln("Pagination disabled (will show all rows)") : this.writeln(`Page size set to ${e} rows`);
+  }
+  async cmdReset() {
+    try {
+      const t = await this.database.getTables(), e = t.length;
+      for (const n of t)
+        await this.database.executeQuery(`DROP TABLE IF EXISTS "${n}";`);
+      const s = this.loadedFiles.size;
+      for (const n of this.loadedFiles.keys())
+        try {
+          await this.database.dropFile(n);
+        } catch {
+        }
+      this.loadedFiles.clear(), this.lastQueryResult = null, this.history.reset(), this.showTimer = !1, this.outputMode = "table", this.syntaxHighlighting = !0, this.pageSize = 0, this.linkProvider.setEnabled(!0), this.prompt = Q, this.continuationPrompt = W, this.paginationQuery = null, this.currentPage = 0, this.totalRows = 0, this.writeln(
+        c(
+          `Reset complete: dropped ${e} table${e !== 1 ? "s" : ""}, cleared ${s} file${s !== 1 ? "s" : ""}, settings restored to defaults`,
+          b
+        )
+      );
+    } catch (t) {
+      const e = t instanceof Error ? t.message : String(t);
+      this.writeln(c(`Error during reset: ${e}`, g));
+    }
+  }
+  cmdPrompt(t) {
+    if (t.length === 0) {
+      this.writeln(`Primary prompt: "${this.prompt}"`), this.writeln(`Continuation prompt: "${this.continuationPrompt}"`);
+      return;
+    }
+    const e = t[0];
+    this.prompt = e, t.length >= 2 ? (this.continuationPrompt = t[1], this.writeln(`Prompts set to "${this.prompt}" and "${this.continuationPrompt}"`)) : this.writeln(`Primary prompt set to "${this.prompt}"`);
+  }
+  // ==================== TerminalInterface Implementation ====================
+  /**
+   * Writes text to the terminal without a trailing newline.
+   *
+   * Use this method for inline output where you don't want to start a new line.
+   * The text is written directly to the terminal without any processing.
+   *
+   * @param text - The text to write to the terminal
+   *
+   * @example
+   * ```typescript
+   * terminal.write('Loading');
+   * terminal.write('...');
+   * terminal.write(' Done!\n');
+   * ```
+   */
+  write(t) {
+    this.terminalAdapter.write(t);
+  }
+  /**
+   * Writes text to the terminal followed by a newline.
+   *
+   * The text is processed for clickable URLs (if link detection is enabled)
+   * and newlines are normalized to CRLF for proper terminal display.
+   *
+   * @param text - The text to write to the terminal
+   *
+   * @example
+   * ```typescript
+   * terminal.writeln('Query completed successfully!');
+   * terminal.writeln('Visit https://duckdb.org for documentation');
+   * ```
+   */
+  writeln(t) {
+    const s = this.linkProvider.process(t).replace(/\r?\n/g, `\r
+`);
+    this.terminalAdapter.writeln(s);
+  }
+  /**
+   * Clears the terminal screen.
+   *
+   * This removes all content from the terminal display and moves the cursor
+   * to the top-left corner.
+   *
+   * @example
+   * ```typescript
+   * terminal.clear();
+   * terminal.writeln('Screen cleared!');
+   * ```
+   */
+  clear() {
+    this.terminalAdapter.clear();
+  }
+  /**
+   * Sets the terminal color theme.
+   *
+   * You can set a built-in theme ('dark' or 'light') or provide a custom
+   * theme object with your own colors. Built-in theme preferences are
+   * persisted to localStorage.
+   *
+   * @param theme - The theme to apply: 'dark', 'light', or a custom Theme object
+   *
+   * @fires themeChange - Emitted after the theme is changed
+   *
+   * @example Set a built-in theme
+   * ```typescript
+   * terminal.setTheme('light');
+   * ```
+   *
+   * @example Set a custom theme
+   * ```typescript
+   * terminal.setTheme({
+   *   name: 'my-theme',
+   *   colors: {
+   *     background: '#1a1b26',
+   *     foreground: '#a9b1d6',
+   *     cursor: '#c0caf5',
+   *     // ... other color properties
+   *   },
+   * });
+   * ```
+   */
+  setTheme(t) {
+    const e = this.getCurrentThemeObject();
+    typeof t == "object" ? (this.customTheme = t, this.currentThemeName = "custom", this.terminalAdapter.setTheme(t), this.writeln(`Theme set to ${t.name}`)) : (this.customTheme = null, this.currentThemeName = t, this.terminalAdapter.setTheme(G(t)), ie(t), this.writeln(`Theme set to ${t}`));
+    const s = this.getCurrentThemeObject();
+    this.emit("themeChange", { theme: s, previous: e });
+    const n = this.currentThemeName === "light" || this.customTheme?.name === "light";
+    document.body.classList.toggle("light", n), document.body.classList.toggle("dark", !n);
+  }
+  /**
+   * Gets the current theme mode.
+   *
+   * Returns 'dark' or 'light' based on the current theme. For custom themes,
+   * this returns 'light' if the theme name is 'light', otherwise 'dark'.
+   *
+   * @returns The current theme mode: 'dark' or 'light'
+   *
+   * @example
+   * ```typescript
+   * const mode = terminal.getTheme();
+   * console.log(`Current theme mode: ${mode}`);
+   * ```
+   */
+  getTheme() {
+    return this.currentThemeName === "custom" && this.customTheme ? this.customTheme.name === "light" ? "light" : "dark" : this.currentThemeName;
+  }
+}
+function Ce(i) {
+  const t = /* @__PURE__ */ new Map();
+  return t.set(".help", {
+    name: ".help",
+    description: "Show available commands",
+    handler: () => re(t, i)
+  }), t.set(".clear", {
+    name: ".clear",
+    description: "Clear the terminal",
+    handler: () => i.clear()
+  }), t.set(".tables", {
+    name: ".tables",
+    description: "List all tables",
+    handler: () => ne(i)
+  }), t.set(".schema", {
+    name: ".schema",
+    description: "Show table schema",
+    usage: ".schema <table_name>",
+    handler: (e) => oe(e, i)
+  }), t.set(".timer", {
+    name: ".timer",
+    description: "Toggle query timing",
+    usage: ".timer on|off",
+    handler: (e) => ae(e, i)
+  }), t.set(".mode", {
+    name: ".mode",
+    description: "Set output mode",
+    usage: ".mode table|csv|tsv|json",
+    handler: (e) => le(e, i)
+  }), t.set(".theme", {
+    name: ".theme",
+    description: "Set color theme (clears screen)",
+    usage: ".theme dark|light",
+    handler: (e) => he(e, i)
+  }), t.set(".examples", {
+    name: ".examples",
+    description: "Show example queries",
+    handler: () => ce(i)
+  }), t.set(".files", {
+    name: ".files",
+    description: "Manage loaded files",
+    usage: ".files [list|add|remove <name|index>]",
+    handler: (e) => ue(e, i)
+  }), t.set(".open", {
+    name: ".open",
+    description: "Open a file picker to load files",
+    handler: () => tt(i)
+  }), t.set(".copy", {
+    name: ".copy",
+    description: "Copy last result to clipboard",
+    handler: () => we(i)
+  }), t.set(".highlight", {
+    name: ".highlight",
+    description: "Toggle syntax highlighting",
+    usage: ".highlight on|off",
+    handler: (e) => de(e, i)
+  }), t.set(".links", {
+    name: ".links",
+    description: "Toggle clickable URL detection",
+    usage: ".links on|off",
+    handler: (e) => fe(e, i)
+  }), t.set(".pagesize", {
+    name: ".pagesize",
+    description: "Enable pagination for large results (default: off)",
+    usage: ".pagesize <number> (0 = disabled)",
+    handler: (e) => me(e, i)
+  }), t.set(".reset", {
+    name: ".reset",
+    description: "Reset database and all settings to defaults",
+    handler: () => ge(i)
+  }), t.set(".prompt", {
+    name: ".prompt",
+    description: "Get or set the command prompt",
+    usage: ".prompt [primary [continuation]]",
+    handler: (e) => pe(e, i)
+  }), t;
+}
+function re(i, t) {
+  t.writeln(y("Available commands:")), t.writeln("");
+  for (const e of i.values()) {
+    const s = e.usage ? `  ${u(e.usage)}` : "";
+    t.writeln(`  ${c(e.name, S)}  ${e.description}${s}`);
+  }
+  t.writeln(""), t.writeln("SQL statements must end with a semicolon (;)");
+}
+async function ne(i) {
+  const t = await i.getDatabase().getTables();
+  if (t.length === 0) {
+    i.writeln(u("No tables found"));
+    return;
+  }
+  for (const e of t)
+    i.writeln(e);
+}
+async function oe(i, t) {
+  if (i.length === 0) {
+    t.writeln("Usage: .schema <table_name>");
+    return;
+  }
+  const e = await t.getDatabase().getTableSchema(i[0]);
+  if (e.length === 0) {
+    t.writeln(u(`Table not found: ${i[0]}`));
+    return;
+  }
+  for (const s of e)
+    t.writeln(`  ${s.name} ${u(s.type)}`);
+}
+function ae(i, t) {
+  if (i.length === 0) {
+    t.writeln(`Timer is ${t.getShowTimer() ? "on" : "off"}`);
+    return;
+  }
+  const e = i[0].toLowerCase();
+  e === "on" ? (t.setShowTimer(!0), t.writeln("Timer is now on")) : e === "off" ? (t.setShowTimer(!1), t.writeln("Timer is now off")) : t.writeln("Usage: .timer on|off");
+}
+function le(i, t) {
+  if (i.length === 0) {
+    t.writeln(`Output mode: ${t.getOutputMode()}`);
+    return;
+  }
+  const e = i[0].toLowerCase();
+  e === "table" || e === "csv" || e === "tsv" || e === "json" ? (t.setOutputMode(e), t.writeln(`Output mode set to ${e}`)) : t.writeln("Usage: .mode table|csv|tsv|json");
+}
+function he(i, t) {
+  if (i.length === 0) {
+    t.writeln(`Theme: ${t.getThemeName()}`);
+    return;
+  }
+  const e = i[0].toLowerCase();
+  e === "dark" || e === "light" ? t.setTheme(e) : t.writeln("Usage: .theme dark|light");
+}
+function ce(i) {
+  i.writeln(y("Example queries:")), i.writeln(""), i.writeln(c("  -- Create a table", w)), i.writeln("  " + i.getHighlightedSQL("CREATE TABLE users (id INTEGER, name VARCHAR);")), i.writeln(""), i.writeln(c("  -- Insert data", w)), i.writeln("  " + i.getHighlightedSQL("INSERT INTO users VALUES (1, 'Alice'), (2, 'Bob');")), i.writeln(""), i.writeln(c("  -- Query data", w)), i.writeln("  " + i.getHighlightedSQL("SELECT * FROM users WHERE name LIKE 'A%';")), i.writeln(""), i.writeln(c("  -- Use built-in functions", w)), i.writeln("  " + i.getHighlightedSQL("SELECT range(10), current_timestamp;"));
+}
+async function ue(i, t) {
+  const e = i[0]?.toLowerCase() ?? "list", s = t.getLoadedFiles();
+  if (e === "list") {
+    if (s.size === 0) {
+      t.writeln(u("No files loaded")), t.writeln(u("Use .open or drag-and-drop to add files"));
+      return;
+    }
+    t.writeln(y("Loaded files:"));
+    let n = 1;
+    for (const [r, o] of s)
+      t.writeln(`  ${u(`${n}.`)} ${r} ${u(`(${I(o.size)})`)}`), n++;
+  } else if (e === "add")
+    await tt(t);
+  else if (e === "remove" || e === "rm") {
+    const n = i.slice(1).join(" ");
+    if (!n) {
+      t.writeln("Usage: .files remove <filename|index>");
+      return;
+    }
+    const r = parseInt(n, 10);
+    let o = null;
+    if (!isNaN(r) && r >= 1) {
+      const l = Array.from(s.keys());
+      if (r <= l.length)
+        o = l[r - 1];
+      else {
+        t.writeln(c(`Invalid index: ${r}. Use .files list to see available files.`, "red"));
+        return;
+      }
+    } else if (s.has(n))
+      o = n;
+    else {
+      t.writeln(c(`File not found: ${n}`, "red"));
+      return;
+    }
+    if (o)
+      try {
+        await t.removeFile(o), t.writeln(c(`Removed: ${o}`, "green"));
+      } catch (l) {
+        t.writeln(c(`Error removing file: ${l}`, "red"));
+      }
+  } else
+    t.writeln("Usage: .files [list|add|remove <name|index>]");
+}
+async function tt(i) {
+  i.writeln(u("Opening file picker..."));
+  const t = await K({
+    multiple: !0,
+    accept: ".csv,.parquet,.json,.db,.duckdb"
+  });
+  if (t.length === 0) {
+    i.writeln(u("No files selected"));
+    return;
+  }
+  for (const e of t)
+    await i.loadFile(e);
+}
+function de(i, t) {
+  if (i.length === 0) {
+    t.writeln(`Syntax highlighting is ${t.getSyntaxHighlighting() ? "on" : "off"}`);
+    return;
+  }
+  const e = i[0].toLowerCase();
+  e === "on" ? (t.setSyntaxHighlighting(!0), t.writeln("Syntax highlighting is now on")) : e === "off" ? (t.setSyntaxHighlighting(!1), t.writeln("Syntax highlighting is now off")) : t.writeln("Usage: .highlight on|off");
+}
+function fe(i, t) {
+  const e = t.getLinkProvider();
+  if (i.length === 0) {
+    t.writeln(`URL link detection is ${e.isEnabled() ? "on" : "off"}`);
+    return;
+  }
+  const s = i[0].toLowerCase();
+  s === "on" ? (e.setEnabled(!0), t.writeln("URL link detection is now on")) : s === "off" ? (e.setEnabled(!1), t.writeln("URL link detection is now off")) : t.writeln("Usage: .links on|off");
+}
+function me(i, t) {
+  if (i.length === 0) {
+    const s = t.getPageSize();
+    s === 0 ? t.writeln("Pagination is disabled (showing all rows)") : t.writeln(`Page size: ${s} rows`);
+    return;
+  }
+  const e = parseInt(i[0], 10);
+  if (isNaN(e) || e < 0) {
+    t.writeln("Usage: .pagesize <number> (0 = no pagination)");
+    return;
+  }
+  t.setPageSize(e), e === 0 ? t.writeln("Pagination disabled (will show all rows)") : t.writeln(`Page size set to ${e} rows`);
+}
+async function ge(i) {
+  await i.resetState();
+}
+function pe(i, t) {
+  if (i.length === 0) {
+    t.writeln(`Primary prompt: "${t.getPrompt()}"`), t.writeln(`Continuation prompt: "${t.getContinuationPrompt()}"`);
+    return;
+  }
+  const e = i[0];
+  i.length >= 2 ? (t.setPrompts(e, i[1]), t.writeln(`Prompts set to "${e}" and "${i[1]}"`)) : (t.setPrompts(e), t.writeln(`Primary prompt set to "${e}"`));
+}
+async function we(i) {
+  const t = i.getLastQueryResult();
+  if (!t) {
+    i.writeln(u("No query result to copy"));
+    return;
+  }
+  const e = i.getOutputMode();
+  let s;
+  switch (e) {
+    case "csv":
+      s = O(t.columns, t.rows);
+      break;
+    case "tsv":
+      s = $(t.columns, t.rows);
+      break;
+    case "json":
+      s = D(t.columns, t.rows);
+      break;
+    default:
+      s = k(t.columns, t.rows);
+  }
+  await J(s) ? i.writeln(c(`Copied ${t.rowCount} rows to clipboard (${e} format)`, b)) : i.writeln(c("Failed to copy to clipboard", g));
+}
+class Ie {
+  constructor(t) {
+    a(this, "state", {
+      query: null,
+      currentPage: 0,
+      totalRows: 0,
+      pageSize: 0,
+      isActive: !1
+    });
+    a(this, "ctx");
+    this.ctx = t;
+  }
+  /**
+   * Initialize pagination for a query
+   */
+  start(t, e, s) {
+    this.state = {
+      query: t,
+      currentPage: 0,
+      totalRows: e,
+      pageSize: s,
+      isActive: !0
+    };
+  }
+  /**
+   * Exit pagination mode
+   */
+  exit() {
+    this.state = {
+      query: null,
+      currentPage: 0,
+      totalRows: 0,
+      pageSize: 0,
+      isActive: !1
+    };
+  }
+  /**
+   * Check if pagination is currently active
+   */
+  isActive() {
+    return this.state.isActive;
+  }
+  /**
+   * Get current state
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Get the total number of pages
+   */
+  getTotalPages() {
+    return this.state.pageSize === 0 ? 0 : Math.ceil(this.state.totalRows / this.state.pageSize);
+  }
+  /**
+   * Get current page (1-indexed for display)
+   */
+  getCurrentPageDisplay() {
+    return this.state.currentPage + 1;
+  }
+  /**
+   * Execute the paginated query for the current page
+   */
+  async executeCurrentPage() {
+    if (!this.state.query) return;
+    const t = this.state.currentPage * this.state.pageSize, e = `${this.state.query} LIMIT ${this.state.pageSize} OFFSET ${t}`;
+    try {
+      const s = await this.ctx.getDatabase().executeQuery(e);
+      this.ctx.displayResult(s, !1), this.showNavigationHint();
+    } catch (s) {
+      const n = s instanceof Error ? s.message : String(s);
+      this.ctx.writeln(c(`Error: ${n}`, g));
+    }
+  }
+  /**
+   * Show navigation hint
+   */
+  showNavigationHint() {
+    const t = this.getTotalPages();
+    this.ctx.writeln(""), this.ctx.writeln(
+      u(
+        `Page ${this.getCurrentPageDisplay()}/${t} (${this.state.totalRows} rows) - n:next p:prev 1-${t}:goto q:quit`
+      )
+    );
+  }
+  /**
+   * Handle user input during pagination
+   * @returns true if the input was handled, false otherwise
+   */
+  async handleInput(t) {
+    if (!this.state.isActive) return !1;
+    const e = this.getTotalPages(), s = t.toLowerCase();
+    if (s === "n" || t === "\x1B[B")
+      return this.state.currentPage < e - 1 ? (this.state.currentPage++, await this.executeCurrentPage()) : this.ctx.writeln(u("Already on last page")), !0;
+    if (s === "p" || t === "\x1B[A")
+      return this.state.currentPage > 0 ? (this.state.currentPage--, await this.executeCurrentPage()) : this.ctx.writeln(u("Already on first page")), !0;
+    if (s === "q" || s === "\x1B" || s === "")
+      return this.ctx.writeln(""), this.exit(), !0;
+    if (s === "\r" || s === `
+`) {
+      const n = this.ctx.getInputContent().trim();
+      if (n) {
+        const r = parseInt(n, 10);
+        !isNaN(r) && r >= 1 && r <= e ? (this.state.currentPage = r - 1, this.ctx.clearInput(), await this.executeCurrentPage()) : (this.ctx.writeln(c(`Invalid page number. Enter 1-${e}`, g)), this.ctx.clearInput());
+      }
+      return !0;
+    }
+    return /^\d$/.test(s) ? (this.ctx.write(this.ctx.insertChar(s)), !0) : s === "" || s === "\b" ? (this.ctx.write(this.ctx.backspace()), !0) : !1;
+  }
+  /**
+   * Check if a query should use pagination
+   * @param sql The SQL query
+   * @param rowCount The total row count
+   * @param pageSize The configured page size (0 = disabled)
+   * @returns Whether pagination should be enabled
+   */
+  static shouldPaginate(t, e, s) {
+    return !(s === 0 || e <= s || !t.trim().toUpperCase().startsWith("SELECT") || /\b(LIMIT|OFFSET)\b/i.test(t));
+  }
+  /**
+   * Strip trailing semicolon from SQL for pagination
+   */
+  static prepareQuery(t) {
+    return t.replace(/;\s*$/, "");
+  }
+}
+async function be(i) {
+  const t = new se(i);
+  return await t.start(), t;
+}
+async function Pe(i) {
+  return be(i);
+}
+export {
+  dt as BOLD,
+  ft as DIM,
+  ut as Database,
+  se as DuckDBTerminal,
+  U as FG_BLUE,
+  S as FG_CYAN,
+  b as FG_GREEN,
+  g as FG_RED,
+  F as FG_WHITE,
+  N as FG_YELLOW,
+  Pt as HistoryStore,
+  Ct as InputBuffer,
+  Xt as LinkProvider,
+  Ie as PaginationHandler,
+  v as RESET,
+  ct as TerminalAdapter,
+  y as bold,
+  c as colorize,
+  Le as containsURL,
+  J as copyToClipboard,
+  Ce as createCommands,
+  be as createTerminal,
+  qt as darkTheme,
+  u as dim,
+  Pe as embed,
+  Re as extractURLs,
+  O as formatCSV,
+  D as formatJSON,
+  $ as formatTSV,
+  k as formatTable,
+  ee as getSavedTheme,
+  G as getTheme,
+  H as highlightSQL,
+  ye as isClipboardAvailable,
+  Se as isSQLComplete,
+  Ae as isValidURL,
+  te as lightTheme,
+  Vt as linkifyText,
+  Ft as readFromClipboard,
+  ie as saveTheme,
+  Z as tokenize
+};