@takara-ai/miru-code 1.2.1 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takara-ai/miru-code",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "Miru (見る) — hybrid code search for agents. Bun, TypeScript, Takara embeddings.",
   "type": "module",
   "license": "MIT",

package/src/benchmark/locate-compare.ts

@@ -8,6 +8,7 @@
  */
 
 import {
+  DEFAULT_LITERAL_MODE,
   formatLiteralLocate,
   type LiteralLocateOptions,
   type LiteralLocateResult,
@@ -37,11 +38,7 @@ export async function benchmarkLocateComparison(options: {
   index: MiruIndex;
   locate?: LiteralLocateOptions;
 }): Promise<LocateBenchmarkComparison> {
-  const locateOpts: LiteralLocateOptions = {
-    mode: options.locate?.mode ?? "lines",
-    ignore_case: options.locate?.ignore_case,
-    ...(options.locate?.limit != null ? { limit: options.locate.limit } : {}),
-  };
+  const locateOpts: LiteralLocateOptions = { mode: DEFAULT_LITERAL_MODE, ...options.locate };
 
   const miruStart = performance.now();
   const result = options.index.locateLiteral(options.literal, locateOpts);

package/src/cli.ts

@@ -27,7 +27,12 @@ import { getBenchmarkModeStatus, setBenchmarkMode } from "./installer/benchmark-
 import { runSearchGuardFromStdin } from "./installer/hooks/search-guard.ts";
 import { runInstaller } from "./installer/installer.ts";
 import { promptConfirm } from "./installer/prompt.ts";
-import { formatLiteralLocate, type LiteralMode } from "./literal.ts";
+import {
+  DEFAULT_LITERAL_MODE,
+  formatLiteralLocate,
+  type LiteralLocateOptions,
+  type LiteralMode,
+} from "./literal.ts";
 import { serveMcp } from "./mcp/serve.ts";
 import { MiruIndex } from "./miru-index.ts";
 import {
@@ -264,22 +269,15 @@ async function runLocate(
   literal: string,
   content: ContentType[],
   jsonFlag: boolean,
-  mode: LiteralMode,
-  limit: number | undefined,
-  ignoreCase: boolean,
+  options: LiteralLocateOptions,
 ): Promise<void> {
   await ensureCredentials({ interactive: true });
+  const mode = options.mode ?? DEFAULT_LITERAL_MODE;
 
   const payload = await withSpinner("Locating literal", async () => {
     const built = await MiruIndex.fromSource(path, content);
     await built.saveToCache(path);
-    return formatLiteralLocate(
-      built.locateLiteral(literal, {
-        mode,
-        ignore_case: ignoreCase,
-        ...(limit != null ? { limit } : {}),
-      }),
-    );
+    return formatLiteralLocate(built.locateLiteral(literal, options));
   });
 
   if (prefersJsonOutput(jsonFlag)) {
@@ -290,10 +288,18 @@ async function runLocate(
   const n = Number(payload.n ?? 0);
   const files = Number(payload.files ?? 0);
   writeStdout(`literal=${literal}  n=${n}  files=${files}  mode=${mode}`);
-  const hits = payload.hits as Array<{ f: string; l: number; t?: string }> | undefined;
+  const hits = payload.hits as
+    | Array<{ f: string; l: number; t?: string; ctx?: string[]; ctx_l?: number }>
+    | undefined;
   if (hits) {
     for (const hit of hits) {
-      if (hit.t !== undefined) {
+      if (hit.ctx !== undefined) {
+        writeStdout(`  ${hit.f}:${hit.l}:`);
+        const startLine = hit.ctx_l ?? hit.l;
+        hit.ctx.forEach((line, i) => {
+          writeStdout(`    ${startLine + i}: ${line}`);
+        });
+      } else if (hit.t !== undefined) {
         writeStdout(`  ${hit.f}:${hit.l}: ${hit.t}`);
       } else {
         writeStdout(`  ${hit.f}:${hit.l}`);
@@ -528,10 +534,20 @@ async function runCli(argv: string[]): Promise<void> {
       printCommandHelp("locate");
       process.exit(1);
     }
-    let mode: LiteralMode = "lines";
-    let limit: number | undefined;
-    let ignoreCase = false;
+    const options: LiteralLocateOptions = {};
+    const include: string[] = [];
+    const exclude: string[] = [];
     const pathArgs: string[] = [];
+    const positiveInt = (flag: string, raw: string | undefined, min: number): number => {
+      const n = Number(raw);
+      if (!Number.isFinite(n) || n < min) {
+        fail(
+          `locate ${flag} must be a${min === 0 ? " non-negative" : ""} integer${min > 0 ? ` ≥ ${min}` : ""}.`,
+        );
+        process.exit(1);
+      }
+      return Math.floor(n);
+    };
     for (let i = 1; i < sizedRest.length; i++) {
       const arg = sizedRest[i];
       if (arg === "--mode" && sizedRest[i + 1]) {
@@ -540,28 +556,45 @@ async function runCli(argv: string[]): Promise<void> {
           fail(`Unknown locate mode "${value}". Use count, locations, or lines.`);
           process.exit(1);
         }
-        mode = value;
+        options.mode = value as LiteralMode;
         continue;
       }
       if (arg === "--limit" && sizedRest[i + 1]) {
-        const raw = Number(sizedRest[++i]);
-        if (!Number.isFinite(raw) || raw < 1) {
-          fail("locate --limit must be a positive integer.");
-          process.exit(1);
-        }
-        limit = Math.floor(raw);
+        options.limit = positiveInt("--limit", sizedRest[++i], 1);
         continue;
       }
       if (arg === "--ignore-case") {
-        ignoreCase = true;
+        options.ignore_case = true;
+        continue;
+      }
+      if (arg === "--match-variants") {
+        options.match_variants = true;
+        continue;
+      }
+      if (arg === "--include" && sizedRest[i + 1]) {
+        include.push(sizedRest[++i] as string);
+        continue;
+      }
+      if (arg === "--exclude" && sizedRest[i + 1]) {
+        exclude.push(sizedRest[++i] as string);
+        continue;
+      }
+      if (arg === "--context" && sizedRest[i + 1]) {
+        options.context_lines = positiveInt("--context", sizedRest[++i], 0);
         continue;
       }
       if (arg !== undefined) {
         pathArgs.push(arg);
       }
     }
+    if (include.length > 0) {
+      options.include = include;
+    }
+    if (exclude.length > 0) {
+      options.exclude = exclude;
+    }
     const path = resolveSearchPath(pathArgs[0] ?? process.cwd());
-    await runLocate(path, literal, content, jsonFlag, mode, limit, ignoreCase);
+    await runLocate(path, literal, content, jsonFlag, options);
     return;
   }
 

package/src/help.ts

@@ -96,10 +96,17 @@ export function printCommandHelp(command: string): void {
       writeStdout("  --mode MODE         count | locations | lines (default: lines)");
       writeStdout("  --limit N           Optional hit cap (default: all matches)");
       writeStdout("  --ignore-case       Case-insensitive match");
+      writeStdout("  --match-variants    Also match camelCase/snake_case/kebab-case/CONSTANT_CASE");
+      writeStdout("  --include GLOB      Only search files matching this glob (repeatable)");
+      writeStdout("  --exclude GLOB      Skip files matching this glob (repeatable)");
+      writeStdout("  --context N         Lines of context around each match (mode=lines)");
       writeStdout("  --content TYPE      code | docs | config | all (default: code config)");
       writeStdout("  --json              JSON output (default when piped)");
       section("Example");
       writeStdout("  miru locate MIRU_BENCHMARK_HISTORY_PATH . --mode locations");
+      writeStdout(
+        '  miru locate rateLimit . --match-variants --include "apps/tldr/**" --context 3',
+      );
       writeStdout("");
       return;
     case "expand":

package/src/installer/config.ts

@@ -260,26 +260,114 @@ function removeJsonMemberText(text: string, sectionKey: string, memberKey: strin
   return `${text.slice(0, removeStart)}${text.slice(removeEnd)}`;
 }
 
+/** True only when // or /* appear outside of strings (URLs like https:// must not match). */
 function hasJsoncSyntax(text: string): boolean {
-  return text.includes("//") || text.includes("/*");
+  let inString = false;
+  let quote = "";
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i] ?? "";
+    const next = text[i + 1] ?? "";
+    if (inString) {
+      if (ch === "\\") {
+        i++;
+        continue;
+      }
+      if (ch === quote) {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      inString = true;
+      quote = ch;
+      continue;
+    }
+    if (ch === "/" && next === "/") {
+      return true;
+    }
+    if (ch === "/" && next === "*") {
+      return true;
+    }
+  }
+  return false;
 }
 
+/**
+ * Locate a section object at the document root only.
+ * Nested keys with the same name (e.g. Claude Code projects.*.mcpServers) are ignored.
+ */
 function findSectionRange(
   text: string,
   sectionKey: string,
 ): { openBrace: number; closeBrace: number; indent: string } | null {
-  const keyMatch = new RegExp(`(^|\\n)([ \\t]*)"${escapeRegExp(sectionKey)}"\\s*:\\s*\\{`).exec(
-    text,
-  );
-  if (!keyMatch) {
-    return null;
-  }
-  const openBrace = text.indexOf("{", keyMatch.index);
-  const closeBrace = findMatchingBrace(text, openBrace);
-  if (openBrace < 0 || closeBrace < 0) {
-    return null;
+  const keyPrefix = new RegExp(`^"${escapeRegExp(sectionKey)}"\\s*:\\s*\\{`);
+  let depth = 0;
+  let inString = false;
+  let quote = "";
+  let inLineComment = false;
+  let inBlockComment = false;
+
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i] ?? "";
+    const next = text[i + 1] ?? "";
+    if (inLineComment) {
+      if (ch === "\n") inLineComment = false;
+      continue;
+    }
+    if (inBlockComment) {
+      if (ch === "*" && next === "/") {
+        inBlockComment = false;
+        i++;
+      }
+      continue;
+    }
+    if (inString) {
+      if (ch === "\\") {
+        i++;
+        continue;
+      }
+      if (ch === quote) {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === "/" && next === "/") {
+      inLineComment = true;
+      i++;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      inBlockComment = true;
+      i++;
+      continue;
+    }
+    if (depth === 1 && ch === '"') {
+      const match = keyPrefix.exec(text.slice(i));
+      if (match) {
+        const lineStart = text.lastIndexOf("\n", i) + 1;
+        const indent = /^[ \t]*/.exec(text.slice(lineStart, i))?.[0] ?? "";
+        const openBrace = i + match[0].length - 1;
+        const closeBrace = findMatchingBrace(text, openBrace);
+        if (closeBrace < 0) {
+          return null;
+        }
+        return { openBrace, closeBrace, indent };
+      }
+    }
+    if (ch === '"' || ch === "'") {
+      inString = true;
+      quote = ch;
+      continue;
+    }
+    if (ch === "{") {
+      depth++;
+      continue;
+    }
+    if (ch === "}") {
+      depth--;
+    }
   }
-  return { openBrace, closeBrace, indent: keyMatch[2] ?? "" };
+  return null;
 }
 
 function findMatchingBrace(text: string, openIndex: number): number {

package/src/installer/search-policy.ts

@@ -141,7 +141,12 @@ export const MCP_LOCATE_TOOL_DESCRIPTION =
   "Exact substring locator over the Miru index. Use for known literals (env vars, symbols, error codes, quoted text) — not meaning-based questions (`search`). " +
   "Returns ALL matches by default as compact {n,files,hits} — do NOT fall back to Grep/rg when n is large. " +
   "Prefer mode=locations (or count for totals only); use lines when you need matching line text. " +
-  "Optional `limit` only if you intentionally want a sample. In benchmark mode, includes compact token savings vs agent Grep.";
+  "Optional `limit` only if you intentionally want a sample. " +
+  "Pass an array to `literal` to match several spellings in one call; " +
+  'or set `match_variants: true` to also match other ways the same word is written in code (e.g. "rateLimit" also finds "rate_limit"). ' +
+  "Use `include`/`exclude` (gitignore-style globs) to scope to part of a monorepo. " +
+  "Use `context_lines` in `lines` mode to get surrounding lines inline instead of a follow-up `expand`/Read. " +
+  "In benchmark mode, includes compact token savings vs agent Grep.";
 
 export const MCP_EXPAND_TOOL_DESCRIPTION =
   "More context in the SAME file as a search hit. Pass `file_path` + `anchor_line` from the hit; " +

package/src/literal.ts

@@ -1,18 +1,28 @@
 /** Exact literal location over already-indexed Miru chunks (no disk re-walk). */
 
+import ignore from "ignore";
 import type { Chunk } from "./types.ts";
 
 export type LiteralMode = "count" | "locations" | "lines";
 
+export const DEFAULT_LITERAL_MODE: LiteralMode = "lines";
+
 export interface LiteralHit {
   file_path: string;
   line: number;
   /** Present only in `lines` mode. */
   text?: string;
+  /** Present only in `lines` mode when `context_lines` is set. */
+  context?: string[];
+  /** Line number of `context[0]`. */
+  context_start_line?: number;
 }
 
 export interface LiteralLocateResult {
+  /** Human-readable label — the input literal, or `|`-joined for multi-literal calls. */
   literal: string;
+  /** All literal variants actually searched (OR-matched). Present only when more than one. */
+  literals?: string[];
   mode: LiteralMode;
   /** Total unique file:line matches. */
   n: number;
@@ -31,6 +41,17 @@ export interface LiteralLocateOptions {
    */
   limit?: number;
   ignore_case?: boolean;
+  /**
+   * Expand each literal into its identifier-casing variants (camelCase, PascalCase,
+   * snake_case, kebab-case, CONSTANT_CASE) and OR-match all of them.
+   */
+  match_variants?: boolean;
+  /** Gitignore-style glob patterns; only chunks from matching files are searched. */
+  include?: string[];
+  /** Gitignore-style glob patterns; chunks from matching files are skipped. */
+  exclude?: string[];
+  /** Lines of context before/after each match, `lines` mode only (like `grep -C`). */
+  context_lines?: number;
 }
 
 function resolveLimit(limit: number | undefined): number | null {
@@ -40,45 +61,134 @@ function resolveLimit(limit: number | undefined): number | null {
   return Math.max(1, Math.floor(limit));
 }
 
-function includesLiteral(haystack: string, needle: string, ignoreCase: boolean): boolean {
-  if (!ignoreCase) {
-    return haystack.includes(needle);
+function lineMatchesAny(
+  haystack: string,
+  needles: readonly string[],
+  ignoreCase: boolean,
+): boolean {
+  const hay = ignoreCase ? haystack.toLowerCase() : haystack;
+  for (const needle of needles) {
+    const n = ignoreCase ? needle.toLowerCase() : needle;
+    if (hay.includes(n)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/** Splits an identifier into lowercase words, honoring camelCase/PascalCase humps and _/- separators. */
+function splitIdentifierWords(literal: string): string[] {
+  const normalized = literal.replace(/[_\-\s]+/g, " ");
+  const humped = normalized
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+    .replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2");
+  return humped
+    .split(" ")
+    .map((w) => w.trim())
+    .filter(Boolean);
+}
+
+/** camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE variants of one identifier. */
+function identifierVariants(literal: string): string[] {
+  const words = splitIdentifierWords(literal);
+  if (words.length === 0) {
+    return [];
   }
-  return haystack.toLowerCase().includes(needle.toLowerCase());
+  const lower = words.map((w) => w.toLowerCase());
+  const capitalized = lower.map((w) => w.charAt(0).toUpperCase() + w.slice(1));
+
+  return [
+    lower[0] + capitalized.slice(1).join(""),
+    capitalized.join(""),
+    lower.join("_"),
+    lower.join("-"),
+    lower.join("_").toUpperCase(),
+  ];
+}
+
+function expandLiterals(literals: readonly string[], matchVariants: boolean): string[] {
+  const seen = new Set<string>();
+  for (const lit of literals) {
+    if (!lit) {
+      continue;
+    }
+    seen.add(lit);
+    if (matchVariants) {
+      for (const variant of identifierVariants(lit)) {
+        if (variant) {
+          seen.add(variant);
+        }
+      }
+    }
+  }
+  return [...seen];
+}
+
+function filterChunksByGlob(
+  chunks: readonly Chunk[],
+  include: string[] | undefined,
+  exclude: string[] | undefined,
+): readonly Chunk[] {
+  if (!include?.length && !exclude?.length) {
+    return chunks;
+  }
+  const includeMatcher = include?.length ? ignore().add(include) : null;
+  const excludeMatcher = exclude?.length ? ignore().add(exclude) : null;
+
+  return chunks.filter((chunk) => {
+    const path = chunk.file_path.replace(/^\/+/, "");
+    if (includeMatcher && !includeMatcher.ignores(path)) {
+      return false;
+    }
+    if (excludeMatcher && excludeMatcher.ignores(path)) {
+      return false;
+    }
+    return true;
+  });
 }
 
 /**
- * Scan indexed chunks for an exact substring. Dedupes by file:line when chunks overlap.
+ * Scan indexed chunks for an exact substring (or, with an array `literal`/`match_variants`,
+ * any of several OR-matched substrings). Dedupes by file:line when chunks overlap.
  * Only covers indexed content (same corpus as `search` / `expand`).
  * Returns every match unless `limit` is set.
  */
 export function locateLiteral(
   chunks: readonly Chunk[],
-  literal: string,
+  literal: string | readonly string[],
   options: LiteralLocateOptions = {},
 ): LiteralLocateResult {
-  const needle = literal;
-  const mode = options.mode ?? "lines";
+  const mode = options.mode ?? DEFAULT_LITERAL_MODE;
   const ignoreCase = options.ignore_case === true;
   const limit = resolveLimit(options.limit);
+  const contextLines =
+    options.context_lines != null && Number.isFinite(options.context_lines)
+      ? Math.max(0, Math.floor(options.context_lines))
+      : 0;
 
-  if (!needle) {
-    return { literal: needle, mode, n: 0, files: 0, truncated: false, hits: [] };
+  const inputLiterals = (Array.isArray(literal) ? literal : [literal]).filter((l) => l.length > 0);
+  const label = inputLiterals.join(" | ");
+  const needles = expandLiterals(inputLiterals, options.match_variants === true);
+
+  if (needles.length === 0) {
+    return { literal: label, mode, n: 0, files: 0, truncated: false, hits: [] };
   }
 
+  const scopedChunks = filterChunksByGlob(chunks, options.include, options.exclude);
+
   const seen = new Set<string>();
   const fileSet = new Set<string>();
   const hits: LiteralHit[] = [];
   let n = 0;
 
-  for (const chunk of chunks) {
-    if (!includesLiteral(chunk.content, needle, ignoreCase)) {
+  for (const chunk of scopedChunks) {
+    if (!lineMatchesAny(chunk.content, needles, ignoreCase)) {
       continue;
     }
     const lines = chunk.content.split("\n");
     for (let i = 0; i < lines.length; i++) {
       const lineText = lines[i] ?? "";
-      if (!includesLiteral(lineText, needle, ignoreCase)) {
+      if (!lineMatchesAny(lineText, needles, ignoreCase)) {
         continue;
       }
       const line = chunk.start_line + i;
@@ -98,19 +208,29 @@ export function locateLiteral(
       const hit: LiteralHit = { file_path: chunk.file_path, line };
       if (mode === "lines") {
         hit.text = lineText;
+        if (contextLines > 0) {
+          const ctxStart = Math.max(0, i - contextLines);
+          const ctxEnd = Math.min(lines.length - 1, i + contextLines);
+          hit.context = lines.slice(ctxStart, ctxEnd + 1);
+          hit.context_start_line = chunk.start_line + ctxStart;
+        }
       }
       hits.push(hit);
     }
   }
 
-  return {
-    literal: needle,
+  const result: LiteralLocateResult = {
+    literal: label,
     mode,
     n,
     files: fileSet.size,
     truncated: mode !== "count" && limit != null && n > hits.length,
     hits: mode === "count" ? [] : hits,
   };
+  if (needles.length > 1) {
+    result.literals = needles;
+  }
+  return result;
 }
 
 /** Compact agent-facing JSON (minimal keys). */
@@ -121,6 +241,9 @@ export function formatLiteralLocate(result: LiteralLocateResult): Record<string,
     n: result.n,
     files: result.files,
   };
+  if (result.literals) {
+    base.literals = result.literals;
+  }
 
   if (result.mode === "count") {
     return base;
@@ -130,10 +253,15 @@ export function formatLiteralLocate(result: LiteralLocateResult): Record<string,
     base.truncated = true;
   }
   base.hits = result.hits.map((hit) => {
+    const h: Record<string, unknown> = { f: hit.file_path, l: hit.line };
     if (hit.text !== undefined) {
-      return { f: hit.file_path, l: hit.line, t: hit.text };
+      h.t = hit.text;
+    }
+    if (hit.context !== undefined) {
+      h.ctx = hit.context;
+      h.ctx_l = hit.context_start_line;
     }
-    return { f: hit.file_path, l: hit.line };
+    return h;
   });
   return base;
 }

package/src/mcp/server.ts

@@ -17,7 +17,7 @@ import {
   MCP_SEARCH_TOOL_DESCRIPTION,
   MCP_SERVER_INSTRUCTIONS,
 } from "../installer/search-policy.ts";
-import { formatLiteralLocate, type LiteralMode } from "../literal.ts";
+import { formatLiteralLocate } from "../literal.ts";
 import type { ContentType } from "../types.ts";
 import {
   clampMcpTopK,
@@ -149,9 +149,11 @@ export function createMcpServer(
       description: MCP_LOCATE_TOOL_DESCRIPTION,
       inputSchema: {
         literal: z
-          .string()
-          .min(1)
-          .describe("Exact substring to find (env var, symbol, error code, quoted text)."),
+          .union([z.string().min(1), z.array(z.string().min(1)).min(1)])
+          .describe(
+            "Exact substring to find (env var, symbol, error code, quoted text). " +
+              "Pass an array to OR-match several substrings (e.g. spelling/casing variants) in one call.",
+          ),
         repo: z.string().describe(REPO_DESCRIPTION),
         mode: z
           .enum(["count", "locations", "lines"])
@@ -168,20 +170,37 @@ export function createMcpServer(
             "Optional cap on returned hits. Omit to return ALL matches (recommended). Do not fall back to Grep if n is large — use mode=count or locations instead.",
           ),
         ignore_case: z.boolean().optional().describe("Case-insensitive match (default false)."),
+        match_variants: z
+          .boolean()
+          .optional()
+          .describe(
+            'Also match other ways the same word might be written in code, e.g. "rateLimit" also finds "rate_limit" and "RATE_LIMIT".',
+          ),
+        include: z
+          .array(z.string().min(1))
+          .optional()
+          .describe(
+            'Gitignore-style glob patterns; only matching files are searched (e.g. "apps/tldr/**/*.go").',
+          ),
+        exclude: z
+          .array(z.string().min(1))
+          .optional()
+          .describe("Gitignore-style glob patterns; matching files are skipped."),
+        context_lines: z
+          .number()
+          .int()
+          .min(0)
+          .optional()
+          .describe("Lines of context before/after each match, like `grep -C` (mode=lines only)."),
       },
     },
-    async ({ literal, repo, mode, limit, ignore_case: ignoreCase }) => {
+    async ({ literal, repo, ...locateOpts }) => {
       try {
         const index = await getIndexForRepo(repo, cache);
-        const locateOpts = {
-          mode: (mode as LiteralMode | undefined) ?? "lines",
-          ...(limit != null ? { limit } : {}),
-          ignore_case: ignoreCase,
-        };
 
         if (benchmark) {
           const repoRoot = localRepoRoot(repo);
-          if (repoRoot) {
+          if (repoRoot && typeof literal === "string") {
             const comparison = await benchmarkLocateComparison({
               literal,
               repoPath: repoRoot,

package/src/miru-index.ts

@@ -450,7 +450,10 @@ export class MiruIndex {
    * Exact substring location over indexed chunks (no disk re-walk).
    * Prefer for known literals; use `search` for meaning-based questions.
    */
-  locateLiteral(literal: string, options?: LiteralLocateOptions): LiteralLocateResult {
+  locateLiteral(
+    literal: string | readonly string[],
+    options?: LiteralLocateOptions,
+  ): LiteralLocateResult {
     return locateLiteral(this.chunksInternal, literal, options);
   }
 }