@opentui/core 0.0.0-20251029-27ffe014 → 0.0.0-20251031-fc297165

package/{index-xn9k0wzm.js → index-vr8t68wb.js}

@@ -5112,19 +5112,141 @@ var env = new Proxy({}, {
 });
 
 // src/lib/tree-sitter-styled-text.ts
-function treeSitterToTextChunks(content, highlights, syntaxStyle) {
+registerEnvVar({ name: "OTUI_TS_STYLE_WARN", default: false, description: "Enable warnings for missing syntax styles" });
+function getSpecificity(group) {
+  return group.split(".").length;
+}
+function shouldSuppressInInjection(group, meta) {
+  if (meta?.isInjection) {
+    return false;
+  }
+  return group === "markup.raw.block";
+}
+function treeSitterToTextChunks(content, highlights, syntaxStyle, options) {
   const chunks = [];
   const defaultStyle = syntaxStyle.getStyle("default");
-  let currentIndex = 0;
+  const concealEnabled = options?.enabled ?? true;
+  const injectionContainerRanges = [];
+  const boundaries = [];
   for (let i = 0;i < highlights.length; i++) {
-    const [startIndex, endIndex, group] = highlights[i];
-    if (startIndex < currentIndex)
+    const [start, end, , meta] = highlights[i];
+    if (start === end)
       continue;
-    if (currentIndex < startIndex) {
-      const text2 = content.slice(currentIndex, startIndex);
+    if (meta?.containsInjection) {
+      injectionContainerRanges.push({ start, end });
+    }
+    boundaries.push({ offset: start, type: "start", highlightIndex: i });
+    boundaries.push({ offset: end, type: "end", highlightIndex: i });
+  }
+  boundaries.sort((a, b) => {
+    if (a.offset !== b.offset)
+      return a.offset - b.offset;
+    if (a.type === "end" && b.type === "start")
+      return -1;
+    if (a.type === "start" && b.type === "end")
+      return 1;
+    return 0;
+  });
+  const activeHighlights = new Set;
+  let currentOffset = 0;
+  for (let i = 0;i < boundaries.length; i++) {
+    const boundary = boundaries[i];
+    if (currentOffset < boundary.offset && activeHighlights.size > 0) {
+      const segmentText = content.slice(currentOffset, boundary.offset);
+      const activeGroups = [];
+      for (const idx of activeHighlights) {
+        const [, , group, meta] = highlights[idx];
+        activeGroups.push({ group, meta, index: idx });
+      }
+      const concealHighlight = concealEnabled ? activeGroups.find((h) => h.meta?.conceal !== undefined || h.group === "conceal" || h.group.startsWith("conceal.")) : undefined;
+      if (concealHighlight) {
+        let replacementText = "";
+        if (concealHighlight.meta?.conceal !== undefined) {
+          replacementText = concealHighlight.meta.conceal;
+        } else if (concealHighlight.group === "conceal.with.space") {
+          replacementText = " ";
+        }
+        if (replacementText) {
+          chunks.push({
+            __isChunk: true,
+            text: replacementText,
+            fg: defaultStyle?.fg,
+            bg: defaultStyle?.bg,
+            attributes: defaultStyle ? createTextAttributes({
+              bold: defaultStyle.bold,
+              italic: defaultStyle.italic,
+              underline: defaultStyle.underline,
+              dim: defaultStyle.dim
+            }) : 0
+          });
+        }
+      } else {
+        const insideInjectionContainer = injectionContainerRanges.some((range) => currentOffset >= range.start && currentOffset < range.end);
+        const validGroups = activeGroups.filter((h) => {
+          if (insideInjectionContainer && shouldSuppressInInjection(h.group, h.meta)) {
+            return false;
+          }
+          return true;
+        });
+        const sortedGroups = validGroups.sort((a, b) => {
+          const aSpec = getSpecificity(a.group);
+          const bSpec = getSpecificity(b.group);
+          if (aSpec !== bSpec)
+            return aSpec - bSpec;
+          return a.index - b.index;
+        });
+        const mergedStyle = {};
+        for (const { group } of sortedGroups) {
+          let styleForGroup = syntaxStyle.getStyle(group);
+          if (!styleForGroup && group.includes(".")) {
+            const baseName = group.split(".")[0];
+            styleForGroup = syntaxStyle.getStyle(baseName);
+          }
+          if (styleForGroup) {
+            if (styleForGroup.fg !== undefined)
+              mergedStyle.fg = styleForGroup.fg;
+            if (styleForGroup.bg !== undefined)
+              mergedStyle.bg = styleForGroup.bg;
+            if (styleForGroup.bold !== undefined)
+              mergedStyle.bold = styleForGroup.bold;
+            if (styleForGroup.italic !== undefined)
+              mergedStyle.italic = styleForGroup.italic;
+            if (styleForGroup.underline !== undefined)
+              mergedStyle.underline = styleForGroup.underline;
+            if (styleForGroup.dim !== undefined)
+              mergedStyle.dim = styleForGroup.dim;
+          } else {
+            if (group.includes(".")) {
+              const baseName = group.split(".")[0];
+              if (env.OTUI_TS_STYLE_WARN) {
+                console.warn(`Syntax style not found for group "${group}" or base scope "${baseName}", using default style`);
+              }
+            } else {
+              if (env.OTUI_TS_STYLE_WARN) {
+                console.warn(`Syntax style not found for group "${group}", using default style`);
+              }
+            }
+          }
+        }
+        const finalStyle = Object.keys(mergedStyle).length > 0 ? mergedStyle : defaultStyle;
+        chunks.push({
+          __isChunk: true,
+          text: segmentText,
+          fg: finalStyle?.fg,
+          bg: finalStyle?.bg,
+          attributes: finalStyle ? createTextAttributes({
+            bold: finalStyle.bold,
+            italic: finalStyle.italic,
+            underline: finalStyle.underline,
+            dim: finalStyle.dim
+          }) : 0
+        });
+      }
+    } else if (currentOffset < boundary.offset) {
+      const text = content.slice(currentOffset, boundary.offset);
       chunks.push({
         __isChunk: true,
-        text: text2,
+        text,
         fg: defaultStyle?.fg,
         bg: defaultStyle?.bg,
         attributes: defaultStyle ? createTextAttributes({
@@ -5134,37 +5256,39 @@ function treeSitterToTextChunks(content, highlights, syntaxStyle) {
           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;
+    if (boundary.type === "start") {
+      activeHighlights.add(boundary.highlightIndex);
+    } else {
+      activeHighlights.delete(boundary.highlightIndex);
+      if (concealEnabled) {
+        const [, , group, meta] = highlights[boundary.highlightIndex];
+        if (meta?.concealLines !== undefined) {
+          if (boundary.offset < content.length && content[boundary.offset] === `
+`) {
+            currentOffset = boundary.offset + 1;
+            continue;
+          }
+        }
+        if (meta?.conceal !== undefined) {
+          if (meta.conceal === " ") {
+            if (boundary.offset < content.length && content[boundary.offset] === " ") {
+              currentOffset = boundary.offset + 1;
+              continue;
+            }
+          } else if (meta.conceal === "" && group === "conceal" && !meta.isInjection) {
+            if (boundary.offset < content.length && content[boundary.offset] === " ") {
+              currentOffset = boundary.offset + 1;
+              continue;
+            }
+          }
+        }
       }
-      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;
+    currentOffset = boundary.offset;
   }
-  if (currentIndex < content.length) {
-    const text = content.slice(currentIndex);
+  if (currentOffset < content.length) {
+    const text = content.slice(currentOffset);
     chunks.push({
       __isChunk: true,
       text,
@@ -5180,10 +5304,10 @@ function treeSitterToTextChunks(content, highlights, syntaxStyle) {
   }
   return chunks;
 }
-async function treeSitterToStyledText(content, filetype, syntaxStyle, client) {
+async function treeSitterToStyledText(content, filetype, syntaxStyle, client, options) {
   const result = await client.highlightOnce(content, filetype);
   if (result.highlights && result.highlights.length > 0) {
-    const chunks = treeSitterToTextChunks(content, result.highlights, syntaxStyle);
+    const chunks = treeSitterToTextChunks(content, result.highlights, syntaxStyle, options?.conceal);
     return new StyledText(chunks);
   } else {
     const defaultStyle = syntaxStyle.mergeStyles("default");
@@ -5314,6 +5438,11 @@ import javascript_highlights from "./assets/javascript/highlights.scm" with { ty
 import javascript_language from "./assets/javascript/tree-sitter-javascript.wasm" with { type: "file" };
 import typescript_highlights from "./assets/typescript/highlights.scm" with { type: "file" };
 import typescript_language from "./assets/typescript/tree-sitter-typescript.wasm" with { type: "file" };
+import markdown_highlights from "./assets/markdown/highlights.scm" with { type: "file" };
+import markdown_language from "./assets/markdown/tree-sitter-markdown.wasm" with { type: "file" };
+import markdown_injections from "./assets/markdown/injections.scm" with { type: "file" };
+import markdown_inline_highlights from "./assets/markdown_inline/highlights.scm" with { type: "file" };
+import markdown_inline_language from "./assets/markdown_inline/tree-sitter-markdown_inline.wasm" with { type: "file" };
 var _cachedParsers;
 function getParsers() {
   if (!_cachedParsers) {
@@ -5331,6 +5460,35 @@ function getParsers() {
           highlights: [resolve(dirname(fileURLToPath(import.meta.url)), typescript_highlights)]
         },
         wasm: resolve(dirname(fileURLToPath(import.meta.url)), typescript_language)
+      },
+      {
+        filetype: "markdown",
+        queries: {
+          highlights: [resolve(dirname(fileURLToPath(import.meta.url)), markdown_highlights)],
+          injections: [resolve(dirname(fileURLToPath(import.meta.url)), markdown_injections)]
+        },
+        wasm: resolve(dirname(fileURLToPath(import.meta.url)), markdown_language),
+        injectionMapping: {
+          nodeTypes: {
+            inline: "markdown_inline",
+            pipe_table_cell: "markdown_inline"
+          },
+          infoStringMap: {
+            javascript: "javascript",
+            js: "javascript",
+            typescript: "typescript",
+            ts: "typescript",
+            markdown: "markdown",
+            md: "markdown"
+          }
+        }
+      },
+      {
+        filetype: "markdown_inline",
+        queries: {
+          highlights: [resolve(dirname(fileURLToPath(import.meta.url)), markdown_inline_highlights)]
+        },
+        wasm: resolve(dirname(fileURLToPath(import.meta.url)), markdown_inline_language)
       }
     ];
   }
@@ -5475,7 +5633,8 @@ class TreeSitterClient extends EventEmitter2 {
       ...filetypeParser,
       wasm: this.resolvePath(filetypeParser.wasm),
       queries: {
-        highlights: filetypeParser.queries.highlights.map((path) => this.resolvePath(path))
+        highlights: filetypeParser.queries.highlights.map((path) => this.resolvePath(path)),
+        injections: filetypeParser.queries.injections?.map((path) => this.resolvePath(path))
       }
     };
     this.worker?.postMessage({ type: "ADD_FILETYPE_PARSER", filetypeParser: resolvedParser });
@@ -5581,6 +5740,14 @@ class TreeSitterClient extends EventEmitter2 {
       }
       return;
     }
+    if (type === "CLEAR_CACHE_RESPONSE") {
+      const callback = this.messageCallbacks.get(messageId);
+      if (callback) {
+        this.messageCallbacks.delete(messageId);
+        callback({ error });
+      }
+      return;
+    }
     if (warning) {
       this.emitWarning(warning, bufferId);
       return;
@@ -5594,9 +5761,11 @@ class TreeSitterClient extends EventEmitter2 {
       const message = data.join(" ");
       this.emit("worker:log", logType, message);
       if (logType === "log") {
-        console.log("Worker stdout:", ...data);
+        console.log("TSWorker:", ...data);
       } else if (logType === "error") {
-        console.error("Worker stderr:", ...data);
+        console.error("TSWorker:", ...data);
+      } else if (logType === "warn") {
+        console.warn("TSWorker:", ...data);
       }
       return;
     }
@@ -5776,6 +5945,25 @@ class TreeSitterClient extends EventEmitter2 {
       });
     }
   }
+  async clearCache() {
+    if (!this.initialized || !this.worker) {
+      throw new Error("Cannot clear cache: client is not initialized");
+    }
+    const messageId = `clear_cache_${this.messageIdCounter++}`;
+    return new Promise((resolve3, reject) => {
+      this.messageCallbacks.set(messageId, (response) => {
+        if (response.error) {
+          reject(new Error(response.error));
+        } else {
+          resolve3();
+        }
+      });
+      this.worker.postMessage({
+        type: "CLEAR_CACHE",
+        messageId
+      });
+    });
+  }
 }
 
 // src/lib/data-paths.ts
@@ -5929,6 +6117,24 @@ function extToFiletype(extension) {
     ["rs", "rust"],
     ["c", "c"],
     ["cpp", "cpp"],
+    ["c++", "cpp"],
+    ["cs", "csharp"],
+    ["java", "java"],
+    ["kt", "kotlin"],
+    ["swift", "swift"],
+    ["php", "php"],
+    ["sql", "sql"],
+    ["pl", "perl"],
+    ["lua", "lua"],
+    ["erl", "erlang"],
+    ["exs", "elixir"],
+    ["ex", "elixir"],
+    ["elm", "elm"],
+    ["fsharp", "fsharp"],
+    ["fs", "fsharp"],
+    ["fsx", "fsharp"],
+    ["fsscript", "fsharp"],
+    ["fsi", "fsharp"],
     ["h", "c"],
     ["hpp", "cpp"],
     ["html", "html"],
@@ -6071,17 +6277,35 @@ class DownloadUtils {
 }
 
 // src/lib/tree-sitter/assets/update.ts
+import { readdir } from "fs/promises";
 var __dirname = "/Users/runner/work/opentui/opentui/packages/core/src/lib/tree-sitter/assets";
 function getDefaultOptions() {
   return {
-    configPath: path3.resolve(__dirname, "../parsers-config.json"),
+    configPath: path3.resolve(__dirname, "../parsers-config"),
     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);
+  let ext = path3.extname(configPath);
+  let resolvedConfigPath = configPath;
+  if (ext === "") {
+    const files = await readdir(path3.dirname(configPath));
+    const file = files.find((file2) => file2.startsWith(path3.basename(configPath)) && (file2.endsWith(".json") || file2.endsWith(".ts") || file2.endsWith(".js")));
+    if (!file) {
+      throw new Error(`No config file found for ${configPath}`);
+    }
+    resolvedConfigPath = path3.join(path3.dirname(configPath), file);
+    ext = path3.extname(resolvedConfigPath);
+  }
+  if (ext === ".json") {
+    const configContent = await readFile(resolvedConfigPath, "utf-8");
+    return JSON.parse(configContent);
+  } else if (ext === ".ts" || ext === ".js") {
+    const { default: configContent } = await import(resolvedConfigPath);
+    return configContent;
+  }
+  throw new Error(`Unsupported config file extension: ${ext}`);
 }
 async function downloadLanguage(filetype, languageUrl, assetsDir, outputPath) {
   const languageDir = path3.join(assetsDir, filetype);
@@ -6093,53 +6317,85 @@ async function downloadLanguage(filetype, languageUrl, assetsDir, outputPath) {
   }
   return "./" + path3.relative(path3.dirname(outputPath), languagePath);
 }
-async function downloadAndCombineQueries(filetype, queryUrls, assetsDir, outputPath) {
+async function downloadAndCombineQueries(filetype, queryUrls, assetsDir, outputPath, queryType, configPath) {
   const queriesDir = path3.join(assetsDir, filetype);
-  const highlightsPath = path3.join(queriesDir, "highlights.scm");
+  const queryPath = path3.join(queriesDir, `${queryType}.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}`);
+    if (queryUrl.startsWith("./")) {
+      console.log(`    Using local query ${i + 1}/${queryUrls.length}: ${queryUrl}`);
+      try {
+        const localPath = path3.resolve(path3.dirname(configPath), queryUrl);
+        const content = await readFile(localPath, "utf-8");
+        if (content.trim()) {
+          queryContents.push(content);
+          console.log(`    \u2713 Loaded ${content.split(`
+`).length} lines from local file`);
+        }
+      } catch (error) {
+        console.warn(`Failed to read local query from ${queryUrl}: ${error}`);
         continue;
       }
-      const content = await response.text();
-      if (content.trim()) {
-        queryContents.push(`; Query from: ${queryUrl}
+    } else {
+      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(`
+          console.log(`    \u2713 Downloaded ${content.split(`
 `).length} lines`);
+        }
+      } catch (error) {
+        console.warn(`Failed to download query from ${queryUrl}: ${error}`);
+        continue;
       }
-    } 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);
+  await writeFile2(queryPath, combinedContent, "utf-8");
+  console.log(`  Combined ${queryContents.length} queries into ${queryPath}`);
+  return "./" + path3.relative(path3.dirname(outputPath), queryPath);
 }
 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" }`;
+    const lines = [
+      `import ${safeFiletype}_highlights from "${parser.highlightsPath}" with { type: "file" }`,
+      `import ${safeFiletype}_language from "${parser.languagePath}" with { type: "file" }`
+    ];
+    if (parser.injectionsPath) {
+      lines.push(`import ${safeFiletype}_injections from "${parser.injectionsPath}" with { type: "file" }`);
+    }
+    return lines.join(`
+`);
   }).join(`
 `);
   const parserDefinitions = parsers.map((parser) => {
     const safeFiletype = parser.filetype.replace(/[^a-zA-Z0-9]/g, "_");
+    const queriesLines = [
+      `          highlights: [resolve(dirname(fileURLToPath(import.meta.url)), ${safeFiletype}_highlights)],`
+    ];
+    if (parser.injectionsPath) {
+      queriesLines.push(`          injections: [resolve(dirname(fileURLToPath(import.meta.url)), ${safeFiletype}_injections)],`);
+    }
+    const injectionMappingLine = parser.injectionMapping ? `        injectionMapping: ${JSON.stringify(parser.injectionMapping, null, 10)},` : "";
     return `      {
         filetype: "${parser.filetype}",
         queries: {
-          highlights: [resolve(dirname(fileURLToPath(import.meta.url)), ${safeFiletype}_highlights)],
+${queriesLines.join(`
+`)}
         },
-        wasm: resolve(dirname(fileURLToPath(import.meta.url)), ${safeFiletype}_language),
+        wasm: resolve(dirname(fileURLToPath(import.meta.url)), ${safeFiletype}_language),${injectionMappingLine ? `
+` + injectionMappingLine : ""}
       }`;
   }).join(`,
 `);
@@ -6184,11 +6440,18 @@ async function main(options) {
       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);
+      const highlightsPath = await downloadAndCombineQueries(parser.filetype, parser.queries.highlights, opts.assetsDir, opts.outputPath, "highlights", opts.configPath);
+      let injectionsPath;
+      if (parser.queries.injections && parser.queries.injections.length > 0) {
+        console.log(`  Downloading ${parser.queries.injections.length} injection queries...`);
+        injectionsPath = await downloadAndCombineQueries(parser.filetype, parser.queries.injections, opts.assetsDir, opts.outputPath, "injections", opts.configPath);
+      }
       generatedParsers.push({
         filetype: parser.filetype,
         languagePath,
-        highlightsPath
+        highlightsPath,
+        injectionsPath,
+        injectionMapping: parser.injectionMapping
       });
       console.log(`  \u2713 Completed ${parser.filetype}`);
     }
@@ -8073,6 +8336,10 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "usize"],
       returns: "void"
     },
+    textBufferGetHighlightCount: {
+      args: ["ptr"],
+      returns: "u32"
+    },
     createTextBufferView: {
       args: ["ptr"],
       returns: "ptr"
@@ -9118,6 +9385,9 @@ class FFIRenderLib {
     this.opentui.symbols.textBufferFreeLineHighlights(nativePtr, count);
     return results;
   }
+  textBufferGetHighlightCount(buffer) {
+    return this.opentui.symbols.textBufferGetHighlightCount(buffer);
+  }
   getArenaAllocatedBytes() {
     const result = this.opentui.symbols.getArenaAllocatedBytes();
     return typeof result === "bigint" ? Number(result) : result;
@@ -9657,6 +9927,10 @@ class TextBuffer {
     this.guard();
     return this.lib.textBufferGetLineHighlights(this.bufferPtr, lineIdx);
   }
+  getHighlightCount() {
+    this.guard();
+    return this.lib.textBufferGetHighlightCount(this.bufferPtr);
+  }
   setSyntaxStyle(style) {
     this.guard();
     this._syntaxStyle = style ?? undefined;
@@ -13097,5 +13371,5 @@ 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, hastToStyledText, LinearScrollAccel, MacOSScrollAccel, 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, ExtmarksController, createExtmarksController, 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, RendererControlState, CliRenderer };
 
-//# debugId=33BCB77A44B43F2164756E2164756E21
-//# sourceMappingURL=index-xn9k0wzm.js.map
+//# debugId=3D6AC881EA3F1FB664756E2164756E21
+//# sourceMappingURL=index-vr8t68wb.js.map