@opentui/core 0.0.0-20250930-6541ec7f → 0.0.0-20250930-a8fe63ce

package/{index-kvwmgj67.js → index-h87jjatk.js}

@@ -1763,7 +1763,7 @@ var BorderCharArrays = {
 };
 
 // src/lib/parse.keypress.ts
-import { Buffer } from "buffer";
+import { Buffer as Buffer2 } from "buffer";
 
 // src/lib/parse.keypress-kitty.ts
 var kittyKeyMap = {
@@ -2080,7 +2080,7 @@ var isCtrlKey = (code) => {
 };
 var parseKeypress = (s = "", options = {}) => {
   let parts;
-  if (Buffer.isBuffer(s)) {
+  if (Buffer2.isBuffer(s)) {
     if (s[0] > 127 && s[1] === undefined) {
       s[0] -= 128;
       s = "\x1B" + String(s);
@@ -4188,60 +4188,9 @@ function isStyledText(obj) {
 class StyledText {
   [BrandedStyledText] = true;
   chunks;
-  textRenderable;
   constructor(chunks) {
     this.chunks = chunks;
   }
-  mount(textRenderable) {
-    this.textRenderable = textRenderable;
-  }
-  insert(chunk, index) {
-    const originalLength = this.chunks.length;
-    if (this.textRenderable) {
-      this.textRenderable.insertChunk(chunk, index ?? originalLength);
-      let newChunks;
-      if (index === undefined || index === originalLength) {
-        newChunks = [...this.chunks, chunk];
-      } else {
-        newChunks = [...this.chunks.slice(0, index), chunk, ...this.chunks.slice(index)];
-      }
-      this.chunks = newChunks;
-    }
-    return this;
-  }
-  remove(chunk) {
-    if (this.textRenderable) {
-      this.textRenderable.removeChunk(chunk);
-      const originalLength = this.chunks.length;
-      const index = this.chunks.indexOf(chunk);
-      if (index === -1)
-        return this;
-      let newChunks;
-      if (index === originalLength - 1) {
-        newChunks = this.chunks.slice(0, -1);
-      } else {
-        newChunks = [...this.chunks.slice(0, index), ...this.chunks.slice(index + 1)];
-      }
-      this.chunks = newChunks;
-    }
-    return this;
-  }
-  replace(chunk, oldChunk) {
-    if (this.textRenderable) {
-      this.textRenderable.replaceChunk(chunk, oldChunk);
-      const index = this.chunks.indexOf(oldChunk);
-      if (index === -1)
-        return this;
-      let newChunks;
-      if (index === this.chunks.length - 1) {
-        newChunks = [...this.chunks.slice(0, -1), chunk];
-      } else {
-        newChunks = [...this.chunks.slice(0, index), chunk, ...this.chunks.slice(index + 1)];
-      }
-      this.chunks = newChunks;
-    }
-    return this;
-  }
 }
 function stringToStyledText(content) {
   const chunk = {
@@ -4337,7 +4286,36 @@ function t(strings, ...values) {
   return new StyledText(chunks);
 }
 
-// src/lib/hast-styled-text.ts
+// src/lib/syntax-style.ts
+function convertThemeToStyles(theme) {
+  const flatStyles = {};
+  for (const tokenStyle of theme) {
+    const styleDefinition = {};
+    if (tokenStyle.style.foreground) {
+      styleDefinition.fg = parseColor(tokenStyle.style.foreground);
+    }
+    if (tokenStyle.style.background) {
+      styleDefinition.bg = parseColor(tokenStyle.style.background);
+    }
+    if (tokenStyle.style.bold !== undefined) {
+      styleDefinition.bold = tokenStyle.style.bold;
+    }
+    if (tokenStyle.style.italic !== undefined) {
+      styleDefinition.italic = tokenStyle.style.italic;
+    }
+    if (tokenStyle.style.underline !== undefined) {
+      styleDefinition.underline = tokenStyle.style.underline;
+    }
+    if (tokenStyle.style.dim !== undefined) {
+      styleDefinition.dim = tokenStyle.style.dim;
+    }
+    for (const scope of tokenStyle.scope) {
+      flatStyles[scope] = styleDefinition;
+    }
+  }
+  return flatStyles;
+}
+
 class SyntaxStyle {
   styles;
   mergedStyleCache;
@@ -4345,6 +4323,10 @@ class SyntaxStyle {
     this.styles = styles;
     this.mergedStyleCache = new Map;
   }
+  static fromTheme(theme) {
+    const flatStyles = convertThemeToStyles(theme);
+    return new SyntaxStyle(flatStyles);
+  }
   mergeStyles(...styleNames) {
     const cacheKey = styleNames.join(":");
     const cached = this.mergedStyleCache.get(cacheKey);
@@ -4352,7 +4334,7 @@ class SyntaxStyle {
       return cached;
     const styleDefinition = {};
     for (const name of styleNames) {
-      const style = this.styles[name];
+      const style = this.getStyle(name);
       if (!style)
         continue;
       if (style.fg)
@@ -4382,6 +4364,18 @@ class SyntaxStyle {
     this.mergedStyleCache.set(cacheKey, merged);
     return merged;
   }
+  getStyle(name) {
+    if (Object.prototype.hasOwnProperty.call(this.styles, name)) {
+      return this.styles[name];
+    }
+    if (name.includes(".")) {
+      const baseName = name.split(".")[0];
+      if (Object.prototype.hasOwnProperty.call(this.styles, baseName)) {
+        return this.styles[baseName];
+      }
+    }
+    return;
+  }
   clearCache() {
     this.mergedStyleCache.clear();
   }
@@ -4389,6 +4383,8 @@ class SyntaxStyle {
     return this.mergedStyleCache.size;
   }
 }
+
+// src/lib/hast-styled-text.ts
 function hastToTextChunks(node, syntaxStyle, parentStyles = []) {
   const chunks = [];
   if (node.type === "text") {
@@ -4923,9 +4919,19 @@ function singleton(key, factory) {
   }
   return bag[key];
 }
+function destroySingleton(key) {
+  const bag = globalThis[singletonCacheSymbol];
+  if (bag && key in bag) {
+    delete bag[key];
+  }
+}
+function hasSingleton(key) {
+  const bag = globalThis[singletonCacheSymbol];
+  return bag && key in bag;
+}
 
 // src/lib/env.ts
-var envRegistry = {};
+var envRegistry = singleton("env-registry", () => ({}));
 function registerEnvVar(config) {
   const existing = envRegistry[config.name];
   if (existing) {
@@ -4983,8 +4989,14 @@ class EnvStore {
   has(key) {
     return key in envRegistry;
   }
+  clearCache() {
+    this.parsedValues.clear();
+  }
 }
 var envStore = singleton("env-store", () => new EnvStore);
+function clearEnvCache() {
+  envStore.clearCache();
+}
 function generateEnvMarkdown() {
   const configs = Object.values(envRegistry);
   if (configs.length === 0) {
@@ -5073,6 +5085,1030 @@ var env = new Proxy({}, {
     return;
   }
 });
+
+// src/lib/tree-sitter-styled-text.ts
+function treeSitterToTextChunks(content, highlights, syntaxStyle) {
+  const chunks = [];
+  const defaultStyle = syntaxStyle.getStyle("default");
+  let currentIndex = 0;
+  for (let i = 0;i < highlights.length; i++) {
+    const [startIndex, endIndex, group] = highlights[i];
+    if (startIndex < currentIndex)
+      continue;
+    if (currentIndex < startIndex) {
+      const text2 = content.slice(currentIndex, startIndex);
+      chunks.push({
+        __isChunk: true,
+        text: text2,
+        fg: defaultStyle?.fg,
+        bg: defaultStyle?.bg,
+        attributes: defaultStyle ? createTextAttributes({
+          bold: defaultStyle.bold,
+          italic: defaultStyle.italic,
+          underline: defaultStyle.underline,
+          dim: defaultStyle.dim
+        }) : 0
+      });
+      currentIndex = startIndex;
+    }
+    let resolvedStyle = syntaxStyle.getStyle(group);
+    let j = i + 1;
+    while (j < highlights.length && highlights[j][0] === startIndex) {
+      const [, , nextGroup] = highlights[j];
+      const nextStyle = syntaxStyle.getStyle(nextGroup);
+      if (nextStyle) {
+        resolvedStyle = nextStyle;
+      }
+      j++;
+    }
+    i = j - 1;
+    const text = content.slice(startIndex, endIndex);
+    const styleToUse = resolvedStyle || defaultStyle;
+    chunks.push({
+      __isChunk: true,
+      text,
+      fg: styleToUse?.fg,
+      bg: styleToUse?.bg,
+      attributes: styleToUse ? createTextAttributes({
+        bold: styleToUse.bold,
+        italic: styleToUse.italic,
+        underline: styleToUse.underline,
+        dim: styleToUse.dim
+      }) : 0
+    });
+    currentIndex = endIndex;
+  }
+  if (currentIndex < content.length) {
+    const text = content.slice(currentIndex);
+    chunks.push({
+      __isChunk: true,
+      text,
+      fg: defaultStyle?.fg,
+      bg: defaultStyle?.bg,
+      attributes: defaultStyle ? createTextAttributes({
+        bold: defaultStyle.bold,
+        italic: defaultStyle.italic,
+        underline: defaultStyle.underline,
+        dim: defaultStyle.dim
+      }) : 0
+    });
+  }
+  return chunks;
+}
+async function treeSitterToStyledText(content, filetype, syntaxStyle, client) {
+  const result = await client.highlightOnce(content, filetype);
+  if (result.highlights && result.highlights.length > 0) {
+    const chunks = treeSitterToTextChunks(content, result.highlights, syntaxStyle);
+    return new StyledText(chunks);
+  } else {
+    const defaultStyle = syntaxStyle.mergeStyles("default");
+    const chunks = [
+      {
+        __isChunk: true,
+        text: content,
+        fg: defaultStyle.fg,
+        bg: defaultStyle.bg,
+        attributes: defaultStyle.attributes
+      }
+    ];
+    return new StyledText(chunks);
+  }
+}
+
+// src/lib/tree-sitter/client.ts
+import { EventEmitter as EventEmitter2 } from "events";
+
+// src/lib/debounce.ts
+var TIMERS_MAP = new Map;
+
+class DebounceController {
+  scopeId;
+  constructor(scopeId) {
+    this.scopeId = scopeId;
+    if (!TIMERS_MAP.has(this.scopeId)) {
+      TIMERS_MAP.set(this.scopeId, new Map);
+    }
+  }
+  debounce(id, ms, fn) {
+    const scopeMap = TIMERS_MAP.get(this.scopeId);
+    return new Promise((resolve, reject) => {
+      if (scopeMap.has(id)) {
+        clearTimeout(scopeMap.get(id));
+      }
+      const timerId = setTimeout(() => {
+        try {
+          resolve(fn());
+        } catch (error) {
+          reject(error);
+        }
+        scopeMap.delete(id);
+      }, ms);
+      scopeMap.set(id, timerId);
+    });
+  }
+  clearDebounce(id) {
+    const scopeMap = TIMERS_MAP.get(this.scopeId);
+    if (scopeMap && scopeMap.has(id)) {
+      clearTimeout(scopeMap.get(id));
+      scopeMap.delete(id);
+    }
+  }
+  clear() {
+    const scopeMap = TIMERS_MAP.get(this.scopeId);
+    if (scopeMap) {
+      scopeMap.forEach((timerId) => clearTimeout(timerId));
+      scopeMap.clear();
+    }
+  }
+}
+function createDebounce(scopeId) {
+  return new DebounceController(scopeId);
+}
+function clearDebounceScope(scopeId) {
+  const scopeMap = TIMERS_MAP.get(scopeId);
+  if (scopeMap) {
+    scopeMap.forEach((timerId) => clearTimeout(timerId));
+    scopeMap.clear();
+  }
+}
+
+// src/lib/queue.ts
+class ProcessQueue {
+  processor;
+  queue = [];
+  processing = false;
+  autoProcess = true;
+  constructor(processor, autoProcess = true) {
+    this.processor = processor;
+    this.autoProcess = autoProcess;
+  }
+  enqueue(item) {
+    this.queue.push(item);
+    if (!this.processing && this.autoProcess) {
+      this.processQueue();
+    }
+  }
+  processQueue() {
+    if (this.queue.length === 0) {
+      return;
+    }
+    this.processing = true;
+    queueMicrotask(async () => {
+      if (this.queue.length === 0) {
+        this.processing = false;
+        return;
+      }
+      const item = this.queue.shift();
+      try {
+        await this.processor(item);
+      } catch (error) {
+        console.error("Error processing queue item:", error);
+      }
+      if (this.queue.length > 0) {
+        this.processQueue();
+      } else {
+        this.processing = false;
+      }
+    });
+  }
+  clear() {
+    this.queue = [];
+  }
+  isProcessing() {
+    return this.processing;
+  }
+  size() {
+    return this.queue.length;
+  }
+}
+
+// src/lib/tree-sitter/assets/javascript/highlights.scm
+var highlights_default = "./highlights-ghv9g403.scm";
+
+// src/lib/tree-sitter/assets/javascript/tree-sitter-javascript.wasm
+var tree_sitter_javascript_default = "./tree-sitter-javascript-nd0q4pe9.wasm";
+
+// src/lib/tree-sitter/assets/typescript/highlights.scm
+var highlights_default2 = "./highlights-eq9cgrbb.scm";
+
+// src/lib/tree-sitter/assets/typescript/tree-sitter-typescript.wasm
+var tree_sitter_typescript_default = "./tree-sitter-typescript-zxjzwt75.wasm";
+
+// src/lib/tree-sitter/default-parsers.ts
+var DEFAULT_PARSERS = [
+  {
+    filetype: "javascript",
+    queries: {
+      highlights: [highlights_default]
+    },
+    wasm: tree_sitter_javascript_default
+  },
+  {
+    filetype: "typescript",
+    queries: {
+      highlights: [highlights_default2]
+    },
+    wasm: tree_sitter_typescript_default
+  }
+];
+
+// src/lib/tree-sitter/client.ts
+var DEFAULT_PARSERS2 = DEFAULT_PARSERS;
+function addDefaultParsers(parsers) {
+  for (const parser of parsers) {
+    const existingIndex = DEFAULT_PARSERS2.findIndex((p) => p.filetype === parser.filetype);
+    if (existingIndex >= 0) {
+      DEFAULT_PARSERS2[existingIndex] = parser;
+    } else {
+      DEFAULT_PARSERS2.push(parser);
+    }
+  }
+}
+
+class TreeSitterClient extends EventEmitter2 {
+  initialized = false;
+  worker;
+  buffers = new Map;
+  initializePromise;
+  initializeResolvers;
+  messageCallbacks = new Map;
+  messageIdCounter = 0;
+  editQueues = new Map;
+  debouncer;
+  options;
+  constructor(options) {
+    super();
+    this.options = options;
+    this.debouncer = createDebounce("tree-sitter-client");
+    this.startWorker();
+  }
+  startWorker() {
+    if (this.worker) {
+      return;
+    }
+    const workerPath = this.options.workerPath || new URL("./parser.worker.ts", import.meta.url);
+    this.worker = new Worker(workerPath);
+    this.worker.onmessage = this.handleWorkerMessage.bind(this);
+  }
+  stopWorker() {
+    if (!this.worker) {
+      return;
+    }
+    this.worker.terminate();
+    this.worker = undefined;
+  }
+  handleReset() {
+    this.buffers.clear();
+    this.stopWorker();
+    this.startWorker();
+    this.initializePromise = undefined;
+    this.initializeResolvers = undefined;
+    return this.initialize();
+  }
+  async initialize() {
+    if (this.initializePromise) {
+      return this.initializePromise;
+    }
+    this.initializePromise = new Promise((resolve, reject) => {
+      const timeoutMs = this.options.initTimeout ?? 1e4;
+      const timeoutId = setTimeout(() => {
+        this.initializeResolvers = undefined;
+        reject(new Error("Worker initialization timed out"));
+      }, timeoutMs);
+      this.initializeResolvers = { resolve, reject, timeoutId };
+      this.worker?.postMessage({
+        type: "INIT",
+        dataPath: this.options.dataPath
+      });
+    });
+    await this.initializePromise;
+    await this.registerDefaultParsers();
+    return this.initializePromise;
+  }
+  async registerDefaultParsers() {
+    for (const parser of DEFAULT_PARSERS2) {
+      this.addFiletypeParser(parser);
+    }
+  }
+  addFiletypeParser(filetypeParser) {
+    this.worker?.postMessage({ type: "ADD_FILETYPE_PARSER", filetypeParser });
+  }
+  async getPerformance() {
+    const messageId = `performance_${this.messageIdCounter++}`;
+    return new Promise((resolve) => {
+      this.messageCallbacks.set(messageId, resolve);
+      this.worker?.postMessage({ type: "GET_PERFORMANCE", messageId });
+    });
+  }
+  async highlightOnce(content, filetype) {
+    if (!this.initialized) {
+      try {
+        await this.initialize();
+      } catch (error) {
+        return { error: "Could not highlight because of initialization error" };
+      }
+    }
+    const messageId = `oneshot_${this.messageIdCounter++}`;
+    return new Promise((resolve) => {
+      this.messageCallbacks.set(messageId, resolve);
+      this.worker?.postMessage({
+        type: "ONESHOT_HIGHLIGHT",
+        content,
+        filetype,
+        messageId
+      });
+    });
+  }
+  handleWorkerMessage(event) {
+    const { type, bufferId, error, highlights, warning, messageId, hasParser, performance: performance2, version } = event.data;
+    if (type === "HIGHLIGHT_RESPONSE") {
+      const buffer = this.buffers.get(bufferId);
+      if (!buffer || !buffer.hasParser)
+        return;
+      if (buffer.version !== version) {
+        this.resetBuffer(bufferId, buffer.version, buffer.content);
+        return;
+      }
+      this.emit("highlights:response", bufferId, version, highlights);
+    }
+    if (type === "INIT_RESPONSE") {
+      if (this.initializeResolvers) {
+        clearTimeout(this.initializeResolvers.timeoutId);
+        if (error) {
+          this.initializeResolvers.reject(new Error(error));
+        } else {
+          this.initialized = true;
+          this.initializeResolvers.resolve();
+        }
+        this.initializeResolvers = undefined;
+        return;
+      }
+    }
+    if (type === "PARSER_INIT_RESPONSE") {
+      const callback = this.messageCallbacks.get(messageId);
+      if (callback) {
+        this.messageCallbacks.delete(messageId);
+        callback({ hasParser, warning, error });
+      }
+      return;
+    }
+    if (type === "PRELOAD_PARSER_RESPONSE") {
+      const callback = this.messageCallbacks.get(messageId);
+      if (callback) {
+        this.messageCallbacks.delete(messageId);
+        callback({ hasParser });
+      }
+      return;
+    }
+    if (type === "BUFFER_DISPOSED") {
+      const callback = this.messageCallbacks.get(`dispose_${bufferId}`);
+      if (callback) {
+        this.messageCallbacks.delete(`dispose_${bufferId}`);
+        callback(true);
+      }
+      this.emit("buffer:disposed", bufferId);
+      return;
+    }
+    if (type === "PERFORMANCE_RESPONSE") {
+      const callback = this.messageCallbacks.get(messageId);
+      if (callback) {
+        this.messageCallbacks.delete(messageId);
+        callback(performance2);
+      }
+      return;
+    }
+    if (type === "ONESHOT_HIGHLIGHT_RESPONSE") {
+      const callback = this.messageCallbacks.get(messageId);
+      if (callback) {
+        this.messageCallbacks.delete(messageId);
+        callback({ highlights, warning, error });
+      }
+      return;
+    }
+    if (type === "UPDATE_DATA_PATH_RESPONSE") {
+      const callback = this.messageCallbacks.get(messageId);
+      if (callback) {
+        this.messageCallbacks.delete(messageId);
+        callback({ error });
+      }
+      return;
+    }
+    if (warning) {
+      this.emit("warning", warning, bufferId);
+      return;
+    }
+    if (error) {
+      this.emit("error", error, bufferId);
+      return;
+    }
+    if (type === "WORKER_LOG") {
+      const { logType, data } = event.data;
+      const message = data.join(" ");
+      this.emit("worker:log", logType, message);
+      if (logType === "log") {
+        console.log("Worker stdout:", ...data);
+      } else if (logType === "error") {
+        console.error("Worker stderr:", ...data);
+      }
+      return;
+    }
+  }
+  async preloadParser(filetype) {
+    const messageId = `has_parser_${this.messageIdCounter++}`;
+    const response = await new Promise((resolve) => {
+      this.messageCallbacks.set(messageId, resolve);
+      this.worker?.postMessage({
+        type: "PRELOAD_PARSER",
+        filetype,
+        messageId
+      });
+    });
+    return response.hasParser;
+  }
+  async createBuffer(id, content, filetype, version = 1, autoInitialize = true) {
+    if (!this.initialized) {
+      if (!autoInitialize) {
+        this.emit("error", "Could not create buffer because client is not initialized");
+        return false;
+      }
+      try {
+        await this.initialize();
+      } catch (error) {
+        this.emit("error", "Could not create buffer because of initialization error");
+        return false;
+      }
+    }
+    if (this.buffers.has(id)) {
+      throw new Error(`Buffer with id ${id} already exists`);
+    }
+    this.buffers.set(id, { id, content, filetype, version, hasParser: false });
+    const messageId = `init_${this.messageIdCounter++}`;
+    const response = await new Promise((resolve) => {
+      this.messageCallbacks.set(messageId, resolve);
+      this.worker?.postMessage({
+        type: "INITIALIZE_PARSER",
+        bufferId: id,
+        version,
+        content,
+        filetype,
+        messageId
+      });
+    });
+    if (!response.hasParser) {
+      this.emit("buffer:initialized", id, false);
+      if (filetype !== "plaintext") {
+        this.emit("warning", response.warning || response.error || "Buffer has no parser", id);
+      }
+      return false;
+    }
+    const bufferState = { id, content, filetype, version, hasParser: true };
+    this.buffers.set(id, bufferState);
+    this.emit("buffer:initialized", id, true);
+    return true;
+  }
+  async updateBuffer(id, edits, newContent, version) {
+    if (!this.initialized) {
+      return;
+    }
+    const buffer = this.buffers.get(id);
+    if (!buffer || !buffer.hasParser) {
+      return;
+    }
+    this.buffers.set(id, { ...buffer, content: newContent, version });
+    if (!this.editQueues.has(id)) {
+      this.editQueues.set(id, new ProcessQueue((item) => this.processEdit(id, item.edits, item.newContent, item.version, item.isReset)));
+    }
+    const bufferQueue = this.editQueues.get(id);
+    bufferQueue.enqueue({ edits, newContent, version });
+  }
+  async processEdit(bufferId, edits, newContent, version, isReset = false) {
+    this.worker?.postMessage({
+      type: isReset ? "RESET_BUFFER" : "HANDLE_EDITS",
+      bufferId,
+      version,
+      content: newContent,
+      edits
+    });
+  }
+  async removeBuffer(bufferId) {
+    if (!this.initialized) {
+      return;
+    }
+    this.buffers.delete(bufferId);
+    if (this.editQueues.has(bufferId)) {
+      this.editQueues.get(bufferId)?.clear();
+      this.editQueues.delete(bufferId);
+    }
+    if (this.worker) {
+      await new Promise((resolve) => {
+        const messageId = `dispose_${bufferId}`;
+        this.messageCallbacks.set(messageId, resolve);
+        try {
+          this.worker.postMessage({
+            type: "DISPOSE_BUFFER",
+            bufferId
+          });
+        } catch (error) {
+          console.error("Error disposing buffer", error);
+          resolve(false);
+        }
+        setTimeout(() => {
+          if (this.messageCallbacks.has(messageId)) {
+            this.messageCallbacks.delete(messageId);
+            console.warn({ bufferId }, "Timed out waiting for buffer to be disposed");
+            resolve(false);
+          }
+        }, 3000);
+      });
+    }
+    this.debouncer.clearDebounce(`reset-${bufferId}`);
+  }
+  async destroy() {
+    if (this.initializeResolvers) {
+      clearTimeout(this.initializeResolvers.timeoutId);
+      this.initializeResolvers = undefined;
+    }
+    clearDebounceScope("tree-sitter-client");
+    this.stopWorker();
+    this.buffers.clear();
+    this.editQueues.clear();
+    this.initialized = false;
+    this.initializePromise = undefined;
+  }
+  async resetBuffer(bufferId, version, content) {
+    if (!this.initialized) {
+      return;
+    }
+    const buffer = this.buffers.get(bufferId);
+    if (!buffer || !buffer.hasParser) {
+      this.emit("error", "Cannot reset buffer with no parser", bufferId);
+      return;
+    }
+    this.buffers.set(bufferId, { ...buffer, content, version });
+    this.debouncer.debounce(`reset-${bufferId}`, 10, () => this.processEdit(bufferId, [], content, version, true));
+  }
+  getBuffer(bufferId) {
+    return this.buffers.get(bufferId);
+  }
+  getAllBuffers() {
+    return Array.from(this.buffers.values());
+  }
+  isInitialized() {
+    return this.initialized;
+  }
+  async setDataPath(dataPath) {
+    if (this.options.dataPath === dataPath) {
+      return;
+    }
+    this.options.dataPath = dataPath;
+    if (this.initialized && this.worker) {
+      const messageId = `update_datapath_${this.messageIdCounter++}`;
+      return new Promise((resolve, reject) => {
+        this.messageCallbacks.set(messageId, (response) => {
+          if (response.error) {
+            reject(new Error(response.error));
+          } else {
+            resolve();
+          }
+        });
+        this.worker.postMessage({
+          type: "UPDATE_DATA_PATH",
+          dataPath,
+          messageId
+        });
+      });
+    }
+  }
+}
+
+// src/lib/data-paths.ts
+import os from "os";
+import path from "path";
+import { EventEmitter as EventEmitter3 } from "events";
+
+// src/lib/validate-dir-name.ts
+function isValidDirectoryName(name) {
+  if (!name || typeof name !== "string") {
+    return false;
+  }
+  if (name.trim().length === 0) {
+    return false;
+  }
+  const reservedNames = [
+    "CON",
+    "PRN",
+    "AUX",
+    "NUL",
+    "COM1",
+    "COM2",
+    "COM3",
+    "COM4",
+    "COM5",
+    "COM6",
+    "COM7",
+    "COM8",
+    "COM9",
+    "LPT1",
+    "LPT2",
+    "LPT3",
+    "LPT4",
+    "LPT5",
+    "LPT6",
+    "LPT7",
+    "LPT8",
+    "LPT9"
+  ];
+  if (reservedNames.includes(name.toUpperCase())) {
+    return false;
+  }
+  const invalidChars = /[<>:"|?*\/\\\x00-\x1f]/;
+  if (invalidChars.test(name)) {
+    return false;
+  }
+  if (name.endsWith(".") || name.endsWith(" ")) {
+    return false;
+  }
+  if (name === "." || name === "..") {
+    return false;
+  }
+  return true;
+}
+
+// src/lib/data-paths.ts
+registerEnvVar({
+  name: "XDG_CONFIG_HOME",
+  description: "Base directory for user-specific configuration files",
+  type: "string",
+  default: ""
+});
+registerEnvVar({
+  name: "XDG_DATA_HOME",
+  description: "Base directory for user-specific data files",
+  type: "string",
+  default: ""
+});
+
+class DataPathsManager extends EventEmitter3 {
+  _appName;
+  _globalConfigPath;
+  _globalConfigFile;
+  _localConfigFile;
+  _globalDataPath;
+  constructor() {
+    super();
+    this._appName = "opentui";
+  }
+  get appName() {
+    return this._appName;
+  }
+  set appName(value) {
+    if (!isValidDirectoryName(value)) {
+      throw new Error(`Invalid app name "${value}": must be a valid directory name`);
+    }
+    if (this._appName !== value) {
+      this._appName = value;
+      this._globalConfigPath = undefined;
+      this._globalConfigFile = undefined;
+      this._localConfigFile = undefined;
+      this._globalDataPath = undefined;
+      this.emit("paths:changed", this.toObject());
+    }
+  }
+  get globalConfigPath() {
+    if (this._globalConfigPath === undefined) {
+      const homeDir = os.homedir();
+      const xdgConfigHome = env.XDG_CONFIG_HOME;
+      const baseConfigDir = xdgConfigHome || path.join(homeDir, ".config");
+      this._globalConfigPath = path.join(baseConfigDir, this._appName);
+    }
+    return this._globalConfigPath;
+  }
+  get globalConfigFile() {
+    if (this._globalConfigFile === undefined) {
+      this._globalConfigFile = path.join(this.globalConfigPath, "init.ts");
+    }
+    return this._globalConfigFile;
+  }
+  get localConfigFile() {
+    if (this._localConfigFile === undefined) {
+      this._localConfigFile = path.join(process.cwd(), `.${this._appName}.ts`);
+    }
+    return this._localConfigFile;
+  }
+  get globalDataPath() {
+    if (this._globalDataPath === undefined) {
+      const homeDir = os.homedir();
+      const xdgDataHome = env.XDG_DATA_HOME;
+      const baseDataDir = xdgDataHome || path.join(homeDir, ".local/share");
+      this._globalDataPath = path.join(baseDataDir, this._appName);
+    }
+    return this._globalDataPath;
+  }
+  toObject() {
+    return {
+      globalConfigPath: this.globalConfigPath,
+      globalConfigFile: this.globalConfigFile,
+      localConfigFile: this.localConfigFile,
+      globalDataPath: this.globalDataPath
+    };
+  }
+}
+function getDataPaths() {
+  return singleton("data-paths-opentui", () => new DataPathsManager);
+}
+
+// src/lib/tree-sitter/resolve-ft.ts
+function extToFiletype(extension) {
+  const extensionToFiletype = new Map([
+    ["js", "javascript"],
+    ["jsx", "javascriptreact"],
+    ["ts", "typescript"],
+    ["tsx", "typescriptreact"],
+    ["md", "markdown"],
+    ["json", "json"],
+    ["py", "python"],
+    ["rb", "ruby"],
+    ["go", "go"],
+    ["rs", "rust"],
+    ["c", "c"],
+    ["cpp", "cpp"],
+    ["h", "c"],
+    ["hpp", "cpp"],
+    ["html", "html"],
+    ["css", "css"],
+    ["scss", "scss"],
+    ["less", "less"],
+    ["sh", "shell"],
+    ["bash", "shell"],
+    ["zsh", "shell"],
+    ["vim", "vim"],
+    ["yaml", "yaml"],
+    ["yml", "yaml"],
+    ["toml", "toml"],
+    ["xml", "xml"],
+    ["zig", "zig"]
+  ]);
+  return extensionToFiletype.get(extension);
+}
+function pathToFiletype(path2) {
+  if (typeof path2 !== "string")
+    return;
+  const lastDot = path2.lastIndexOf(".");
+  if (lastDot === -1 || lastDot === path2.length - 1) {
+    return;
+  }
+  const extension = path2.substring(lastDot + 1);
+  return extToFiletype(extension);
+}
+
+// src/lib/tree-sitter/assets/update.ts
+import { readFile, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import * as path3 from "path";
+
+// src/lib/tree-sitter/download-utils.ts
+import { mkdir, writeFile } from "fs/promises";
+import * as path2 from "path";
+
+class DownloadUtils {
+  static hashUrl(url) {
+    let hash = 0;
+    for (let i = 0;i < url.length; i++) {
+      const char = url.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return Math.abs(hash).toString(16);
+  }
+  static async downloadOrLoad(source, cacheDir, cacheSubdir, fileExtension, useHashForCache = true, filetype) {
+    const isUrl = source.startsWith("http://") || source.startsWith("https://");
+    if (isUrl) {
+      let cacheFileName;
+      if (useHashForCache) {
+        const hash = this.hashUrl(source);
+        cacheFileName = filetype ? `${filetype}-${hash}${fileExtension}` : `${hash}${fileExtension}`;
+      } else {
+        cacheFileName = path2.basename(source);
+      }
+      const cacheFile = path2.join(cacheDir, cacheSubdir, cacheFileName);
+      await mkdir(path2.dirname(cacheFile), { recursive: true });
+      try {
+        const cachedContent = await Bun.file(cacheFile).arrayBuffer();
+        if (cachedContent.byteLength > 0) {
+          console.log(`Loaded from cache: ${cacheFile} (${source})`);
+          return { content: cachedContent, filePath: cacheFile };
+        }
+      } catch (error) {}
+      try {
+        console.log(`Downloading from URL: ${source}`);
+        const response = await fetch(source);
+        if (!response.ok) {
+          return { error: `Failed to fetch from ${source}: ${response.statusText}` };
+        }
+        const content = await response.arrayBuffer();
+        try {
+          await writeFile(cacheFile, Buffer.from(content));
+          console.log(`Cached: ${source}`);
+        } catch (cacheError) {
+          console.warn(`Failed to cache: ${cacheError}`);
+        }
+        return { content, filePath: cacheFile };
+      } catch (error) {
+        return { error: `Error downloading from ${source}: ${error}` };
+      }
+    } else {
+      try {
+        console.log(`Loading from local path: ${source}`);
+        const content = await Bun.file(source).arrayBuffer();
+        return { content, filePath: source };
+      } catch (error) {
+        return { error: `Error loading from local path ${source}: ${error}` };
+      }
+    }
+  }
+  static async downloadToPath(source, targetPath) {
+    const isUrl = source.startsWith("http://") || source.startsWith("https://");
+    await mkdir(path2.dirname(targetPath), { recursive: true });
+    if (isUrl) {
+      try {
+        console.log(`Downloading from URL: ${source}`);
+        const response = await fetch(source);
+        if (!response.ok) {
+          return { error: `Failed to fetch from ${source}: ${response.statusText}` };
+        }
+        const content = await response.arrayBuffer();
+        await writeFile(targetPath, Buffer.from(content));
+        console.log(`Downloaded: ${source} -> ${targetPath}`);
+        return { content, filePath: targetPath };
+      } catch (error) {
+        return { error: `Error downloading from ${source}: ${error}` };
+      }
+    } else {
+      try {
+        console.log(`Copying from local path: ${source}`);
+        const content = await Bun.file(source).arrayBuffer();
+        await writeFile(targetPath, Buffer.from(content));
+        return { content, filePath: targetPath };
+      } catch (error) {
+        return { error: `Error copying from local path ${source}: ${error}` };
+      }
+    }
+  }
+  static async fetchHighlightQueries(sources, cacheDir, filetype) {
+    const queryPromises = sources.map((source) => this.fetchHighlightQuery(source, cacheDir, filetype));
+    const queryResults = await Promise.all(queryPromises);
+    const validQueries = queryResults.filter((query) => query.trim().length > 0);
+    return validQueries.join(`
+`);
+  }
+  static async fetchHighlightQuery(source, cacheDir, filetype) {
+    const result = await this.downloadOrLoad(source, cacheDir, "queries", ".scm", true, filetype);
+    if (result.error) {
+      console.error(`Error fetching highlight query from ${source}:`, result.error);
+      return "";
+    }
+    if (result.content) {
+      return new TextDecoder().decode(result.content);
+    }
+    return "";
+  }
+}
+
+// src/lib/tree-sitter/assets/update.ts
+var __dirname = "/Users/runner/work/opentui/opentui/packages/core/src/lib/tree-sitter/assets";
+function getDefaultOptions() {
+  return {
+    configPath: path3.resolve(__dirname, "../parsers-config.json"),
+    assetsDir: path3.resolve(__dirname),
+    outputPath: path3.resolve(__dirname, "../default-parsers.ts")
+  };
+}
+async function loadConfig(configPath) {
+  const configContent = await readFile(configPath, "utf-8");
+  return JSON.parse(configContent);
+}
+async function downloadLanguage(filetype, languageUrl, assetsDir, outputPath) {
+  const languageDir = path3.join(assetsDir, filetype);
+  const languageFilename = path3.basename(languageUrl);
+  const languagePath = path3.join(languageDir, languageFilename);
+  const result = await DownloadUtils.downloadToPath(languageUrl, languagePath);
+  if (result.error) {
+    throw new Error(`Failed to download language for ${filetype}: ${result.error}`);
+  }
+  return "./" + path3.relative(path3.dirname(outputPath), languagePath);
+}
+async function downloadAndCombineQueries(filetype, queryUrls, assetsDir, outputPath) {
+  const queriesDir = path3.join(assetsDir, filetype);
+  const highlightsPath = path3.join(queriesDir, "highlights.scm");
+  const queryContents = [];
+  for (let i = 0;i < queryUrls.length; i++) {
+    const queryUrl = queryUrls[i];
+    console.log(`    Downloading query ${i + 1}/${queryUrls.length}: ${queryUrl}`);
+    try {
+      const response = await fetch(queryUrl);
+      if (!response.ok) {
+        console.warn(`Failed to download query from ${queryUrl}: ${response.statusText}`);
+        continue;
+      }
+      const content = await response.text();
+      if (content.trim()) {
+        queryContents.push(`; Query from: ${queryUrl}
+${content}`);
+        console.log(`    \u2713 Downloaded ${content.split(`
+`).length} lines`);
+      }
+    } catch (error) {
+      console.warn(`Failed to download query from ${queryUrl}: ${error}`);
+      continue;
+    }
+  }
+  const combinedContent = queryContents.join(`
+
+`);
+  await writeFile2(highlightsPath, combinedContent, "utf-8");
+  console.log(`  Combined ${queryContents.length} queries into ${highlightsPath}`);
+  return "./" + path3.relative(path3.dirname(outputPath), highlightsPath);
+}
+async function generateDefaultParsersFile(parsers, outputPath) {
+  const imports = parsers.map((parser) => {
+    const safeFiletype = parser.filetype.replace(/[^a-zA-Z0-9]/g, "_");
+    return `import ${safeFiletype}_highlights from "${parser.highlightsPath}" with { type: "file" }
+import ${safeFiletype}_language from "${parser.languagePath}" with { type: "file" }`;
+  }).join(`
+`);
+  const parserDefinitions = parsers.map((parser) => {
+    const safeFiletype = parser.filetype.replace(/[^a-zA-Z0-9]/g, "_");
+    return `  {
+    filetype: "${parser.filetype}",
+    queries: {
+      highlights: [${safeFiletype}_highlights],
+    },
+    wasm: ${safeFiletype}_language,
+  }`;
+  }).join(`,
+`);
+  const fileContent = `// This file is generated by assets/update.ts - DO NOT EDIT MANUALLY
+// Run 'bun assets/update.ts' to regenerate this file
+// Last generated: ${new Date().toISOString()}
+
+import type { FiletypeParserOptions } from "./types"
+
+${imports}
+
+export const DEFAULT_PARSERS: FiletypeParserOptions[] = [
+${parserDefinitions},
+]
+`;
+  await mkdir2(path3.dirname(outputPath), { recursive: true });
+  await writeFile2(outputPath, fileContent, "utf-8");
+  console.log(`Generated ${path3.basename(outputPath)} with ${parsers.length} parsers`);
+}
+async function main(options) {
+  const opts = { ...getDefaultOptions(), ...options };
+  try {
+    console.log("Loading parsers configuration...");
+    console.log(`  Config: ${opts.configPath}`);
+    console.log(`  Assets Dir: ${opts.assetsDir}`);
+    console.log(`  Output: ${opts.outputPath}`);
+    const config = await loadConfig(opts.configPath);
+    console.log(`Found ${config.parsers.length} parsers to process`);
+    const generatedParsers = [];
+    for (const parser of config.parsers) {
+      console.log(`Processing ${parser.filetype}...`);
+      console.log(`  Downloading language...`);
+      const languagePath = await downloadLanguage(parser.filetype, parser.wasm, opts.assetsDir, opts.outputPath);
+      console.log(`  Downloading ${parser.queries.highlights.length} highlight queries...`);
+      const highlightsPath = await downloadAndCombineQueries(parser.filetype, parser.queries.highlights, opts.assetsDir, opts.outputPath);
+      generatedParsers.push({
+        filetype: parser.filetype,
+        languagePath,
+        highlightsPath
+      });
+      console.log(`  \u2713 Completed ${parser.filetype}`);
+    }
+    console.log("Generating output file...");
+    await generateDefaultParsersFile(generatedParsers, opts.outputPath);
+    console.log("\u2705 Update completed successfully!");
+  } catch (error) {
+    console.error("\u274C Update failed:", error);
+    process.exit(1);
+  }
+}
+if (false) {}
+
+// src/lib/tree-sitter/index.ts
+function getTreeSitterClient() {
+  const dataPathsManager = getDataPaths();
+  const defaultOptions = {
+    dataPath: dataPathsManager.globalDataPath
+  };
+  return singleton("tree-sitter-client", () => {
+    const client2 = new TreeSitterClient(defaultOptions);
+    dataPathsManager.on("paths:changed", (paths) => {
+      client2.setDataPath(paths.globalDataPath);
+    });
+    return client2;
+  });
+}
 // src/zig.ts
 import { dlopen, toArrayBuffer as toArrayBuffer2, JSCallback, ptr } from "bun:ffi";
 import { existsSync } from "fs";
@@ -6380,7 +7416,7 @@ class TextBuffer {
 }
 
 // src/Renderable.ts
-import { EventEmitter as EventEmitter2 } from "events";
+import { EventEmitter as EventEmitter4 } from "events";
 
 // src/lib/renderable.validations.ts
 function validateOptions(id, options) {
@@ -6473,7 +7509,7 @@ function isRenderable(obj) {
   return !!obj?.[BrandedRenderable];
 }
 
-class BaseRenderable extends EventEmitter2 {
+class BaseRenderable extends EventEmitter4 {
   [BrandedRenderable] = true;
   static renderableNumber = 1;
   _id;
@@ -7776,17 +8812,17 @@ function delegate(mapping, vnode) {
 }
 
 // src/console.ts
-import { EventEmitter as EventEmitter4 } from "events";
+import { EventEmitter as EventEmitter6 } from "events";
 import { Console } from "console";
 import fs from "fs";
-import path from "path";
+import path4 from "path";
 import util2 from "util";
 
 // src/lib/output.capture.ts
 import { Writable } from "stream";
-import { EventEmitter as EventEmitter3 } from "events";
+import { EventEmitter as EventEmitter5 } from "events";
 
-class Capture extends EventEmitter3 {
+class Capture extends EventEmitter5 {
   output = [];
   constructor() {
     super();
@@ -7862,7 +8898,7 @@ registerEnvVar({
   default: false
 });
 
-class TerminalConsoleCache extends EventEmitter4 {
+class TerminalConsoleCache extends EventEmitter6 {
   _cachedLogs = [];
   MAX_CACHE_SIZE = 1000;
   _collectCallerInfo = false;
@@ -7983,7 +9019,7 @@ var DEFAULT_CONSOLE_OPTIONS = {
 };
 var INDENT_WIDTH = 2;
 
-class TerminalConsole extends EventEmitter4 {
+class TerminalConsole extends EventEmitter6 {
   isVisible = false;
   isFocused = false;
   renderer;
@@ -8422,7 +9458,7 @@ class TerminalConsole extends EventEmitter4 {
     try {
       const timestamp = Date.now();
       const filename = `_console_${timestamp}.log`;
-      const filepath = path.join(process.cwd(), filename);
+      const filepath = path4.join(process.cwd(), filename);
       const allLogEntries = [...this._allLogEntries, ...terminalConsoleCache.cachedLogs];
       const logLines = [];
       for (const [date, level, args, callerInfo] of allLogEntries) {
@@ -8443,7 +9479,7 @@ class TerminalConsole extends EventEmitter4 {
 }
 
 // src/renderer.ts
-import { EventEmitter as EventEmitter5 } from "events";
+import { EventEmitter as EventEmitter7 } from "events";
 
 // src/lib/objects-in-viewport.ts
 function getObjectsInViewport(viewport, objects, direction = "column", padding = 10, minTriggerSize = 16) {
@@ -8595,13 +9631,17 @@ var rendererTracker = singleton("RendererTracker", () => {
       renderers.delete(renderer);
       if (renderers.size === 0) {
         process.stdin.pause();
+        if (hasSingleton("tree-sitter-client")) {
+          getTreeSitterClient().destroy();
+          destroySingleton("tree-sitter-client");
+        }
       }
     }
   };
 });
 async function createCliRenderer(config = {}) {
   if (process.argv.includes("--delay-start")) {
-    await new Promise((resolve) => setTimeout(resolve, 5000));
+    await new Promise((resolve2) => setTimeout(resolve2, 5000));
   }
   const stdin = config.stdin || process.stdin;
   const stdout = config.stdout || process.stdout;
@@ -8628,7 +9668,7 @@ var CliRenderEvents;
 ((CliRenderEvents2) => {
   CliRenderEvents2["DEBUG_OVERLAY_TOGGLE"] = "debugOverlay:toggle";
 })(CliRenderEvents ||= {});
-class CliRenderer extends EventEmitter5 {
+class CliRenderer extends EventEmitter7 {
   static animationFrameId = 0;
   lib;
   rendererPtr;
@@ -8720,9 +9760,9 @@ class CliRenderer extends EventEmitter5 {
   handleError = ((error) => {
     this.stop();
     this.destroy();
-    new Promise((resolve) => {
+    new Promise((resolve2) => {
       setTimeout(() => {
-        resolve(true);
+        resolve2(true);
       }, 100);
     }).then(() => {
       this.realStdoutWrite.call(this.stdout, `
@@ -9041,16 +10081,16 @@ Captured output:
     if (this._terminalIsSetup)
       return;
     this._terminalIsSetup = true;
-    await new Promise((resolve) => {
+    await new Promise((resolve2) => {
       const timeout = setTimeout(() => {
         this.stdin.off("data", capListener);
-        resolve(true);
+        resolve2(true);
       }, 100);
       const capListener = (str) => {
         clearTimeout(timeout);
         this.lib.processCapabilityResponse(this.rendererPtr, str);
         this.stdin.off("data", capListener);
-        resolve(true);
+        resolve2(true);
       };
       this.stdin.on("data", capListener);
       this.lib.setupTerminal(this.rendererPtr, this._useAlternateScreen);
@@ -9450,7 +10490,11 @@ Captured output:
     this._isRunning = false;
     this.waitingForPixelResolution = false;
     this.capturedRenderable = undefined;
-    this.root.destroyRecursively();
+    try {
+      this.root.destroyRecursively();
+    } catch (e) {
+      console.error("Error destroying root renderable:", e instanceof Error ? e.stack : String(e));
+    }
     this._keyHandler.destroy();
     this._console.deactivate();
     this.disableStdoutInterception();
@@ -9688,7 +10732,7 @@ Captured output:
   }
 }
 
-export { __toESM, __commonJS, __export, __require, Edge, Gutter, exports_src, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, nonAlphanumericKeys, parseKeypress, ANSI, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, DebugOverlayCorner, createTextAttributes, visualizeRenderableTree, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, t, SyntaxStyle, hastToStyledText, parseAlign, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, envRegistry, registerEnvVar, generateEnvMarkdown, generateEnvColored, env, TextBuffer, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, isValidPercentage, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, CliRenderer };
+export { __toESM, __commonJS, __export, __require, Edge, Gutter, exports_src, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, nonAlphanumericKeys, parseKeypress, ANSI, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, DebugOverlayCorner, createTextAttributes, visualizeRenderableTree, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, t, convertThemeToStyles, SyntaxStyle, hastToStyledText, parseAlign, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extToFiletype, pathToFiletype, main, getTreeSitterClient, TextBuffer, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, isValidPercentage, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, CliRenderer };
 
-//# debugId=B65C4E4D90FC9D3564756E2164756E21
-//# sourceMappingURL=index-kvwmgj67.js.map
+//# debugId=259CDC2839F0878D64756E2164756E21
+//# sourceMappingURL=index-h87jjatk.js.map