@ai-matrx/content-ir 0.22.6 → 0.23.0

package/dist/json-extract.cjs

@@ -0,0 +1,942 @@
+'use strict';
+
+var JSON5 = require('json5');
+var jsonrepair = require('jsonrepair');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var JSON5__default = /*#__PURE__*/_interopDefault(JSON5);
+
+// source/fence-nesting.ts
+var NESTING_FENCE_LANGUAGES = /* @__PURE__ */ new Set([
+  "markdown",
+  "md",
+  "mdx"
+]);
+function fenceNestsInnerFences(language) {
+  return !!language && NESTING_FENCE_LANGUAGES.has(language.toLowerCase());
+}
+var FENCE_WHITESPACE = " 	\n\r\f\v";
+function isFenceWhitespace(ch) {
+  return ch !== void 0 && ch !== "" && FENCE_WHITESPACE.includes(ch);
+}
+function trimFenceLine(line) {
+  let start = 0;
+  let end = line.length;
+  while (start < end && isFenceWhitespace(line[start])) start++;
+  while (end > start && isFenceWhitespace(line[end - 1])) end--;
+  return start === 0 && end === line.length ? line : line.slice(start, end);
+}
+var FENCE_OPENER_WHITESPACE = "	\n\v\f\r \xA0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF";
+function isOpenerWhitespace(ch) {
+  return ch !== void 0 && ch !== "" && FENCE_OPENER_WHITESPACE.includes(ch);
+}
+function parseFenceOpener(line) {
+  let start = 0;
+  let end = line.length;
+  while (start < end && isOpenerWhitespace(line[start])) start++;
+  while (end > start && isOpenerWhitespace(line[end - 1])) end--;
+  let ticks = 0;
+  while (start + ticks < end && line[start + ticks] === "`") ticks++;
+  if (ticks < 3) return null;
+  if (line.slice(start + ticks, end).includes("`")) return null;
+  let infoStart = start + ticks;
+  while (infoStart < end && isOpenerWhitespace(line[infoStart])) infoStart++;
+  let langEnd = infoStart;
+  while (langEnd < end && !isOpenerWhitespace(line[langEnd])) langEnd++;
+  return { ticks, lang: line.slice(infoStart, langEnd) };
+}
+function classifyInnerFenceLine(trimmed, openTicks, nests, nestedDepth) {
+  let ticks = 0;
+  while (ticks < trimmed.length && trimmed[ticks] === "`") ticks++;
+  if (ticks < 3) return "content";
+  const info = trimFenceLine(trimmed.slice(ticks));
+  if (info === "") {
+    if (ticks < openTicks) return "content";
+    if (nests && nestedDepth > 0) return "close-nested";
+    return "close-outer";
+  }
+  if (nests && ticks >= openTicks && !info.includes("`")) return "open-nested";
+  return "content";
+}
+
+// source/code-ranges.ts
+function fenceOpenerOf(content) {
+  const t = content.trimStart();
+  if (t.startsWith("```")) {
+    const parsed = parseFenceOpener(t);
+    if (!parsed) return null;
+    return { char: "`", ticks: parsed.ticks, lang: parsed.lang };
+  }
+  if (content.length - t.length <= 3 && t.startsWith("~~~")) {
+    const open = /^(~{3,})(.*)$/.exec(t);
+    if (!open) return null;
+    return { char: "~", ticks: open[1].length, lang: open[2].trim().split(/\s/)[0] ?? "" };
+  }
+  return null;
+}
+var LINE_START = { inString: false, escaped: false };
+var FenceReader = class {
+  opener;
+  depth = 0;
+  /** A nested fence was opened at some point. */
+  sawNested = false;
+  isJson;
+  nesting;
+  tildeCloser;
+  constructor(opener, options = {}) {
+    this.opener = opener;
+    this.isJson = opener.char === "`" && opener.lang === "json";
+    this.nesting = opener.char === "`" && (options.nesting ?? fenceNestsInnerFences(opener.lang));
+    this.tildeCloser = opener.char === "~" ? new RegExp(`^ {0,3}~{${opener.ticks},}[ \\t]*$`) : null;
+  }
+  /** How many nested fences are open right now. */
+  get nestedDepth() {
+    return this.depth;
+  }
+  feed(line) {
+    if (this.tildeCloser) return this.tildeCloser.test(line);
+    const trimmedLine = trimFenceLine(line);
+    const at = line.indexOf("```");
+    if (at === -1) return false;
+    if (this.isJson && jsonStringState(line, 0, at, LINE_START).inString) return false;
+    if (trimmedLine.startsWith("```")) {
+      const kind = classifyInnerFenceLine(trimmedLine, this.opener.ticks, this.nesting, this.depth);
+      if (kind === "close-outer") return true;
+      if (kind === "open-nested") {
+        this.depth++;
+        this.sawNested = true;
+      }
+      if (kind === "close-nested") this.depth--;
+    } else {
+      const closeTicks = backtickRunLength(line, at);
+      const after = trimFenceLine(line.slice(at + closeTicks));
+      if (closeTicks >= this.opener.ticks && after === "" && this.depth === 0) return true;
+    }
+    return false;
+  }
+};
+function closeFence(src, open, opener) {
+  const first = readFence(src, open, new FenceReader(opener));
+  if (first.closed || !first.reader.sawNested || first.reader.nestedDepth <= 0) return { line: first.line, closed: first.closed };
+  if (src.streaming) return { line: first.line, closed: false };
+  const strict = readFence(src, open, new FenceReader(opener, { nesting: false }));
+  return { line: strict.line, closed: strict.closed };
+}
+function readFence(src, open, reader) {
+  for (let k = open + 1; k < src.count; k++) {
+    if (src.openTail?.(k)) continue;
+    const line = src.line(k);
+    if (line === null) return { line: k - 1, closed: false, reader };
+    if (reader.feed(line)) return { line: k, closed: true, reader };
+  }
+  return { line: src.count - 1, closed: false, reader };
+}
+function jsonStringState(line, from, upTo, state) {
+  let { inString, escaped } = state;
+  for (let idx = from; idx < upTo; idx++) {
+    const ch = line[idx];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\" && inString) {
+      escaped = true;
+      continue;
+    }
+    if (ch === '"') inString = !inString;
+  }
+  return { inString, escaped };
+}
+function backtickRunLength(str, pos) {
+  let n = 0;
+  while (pos + n < str.length && str[pos + n] === "`") n++;
+  return n;
+}
+function quotePrefix(line) {
+  let depth = 0;
+  let offset = 0;
+  for (; ; ) {
+    const m = /^ {0,3}> ?/.exec(line.slice(offset));
+    if (!m) return { depth, offset };
+    depth++;
+    offset += m[0].length;
+  }
+}
+function stripQuotes(line, depth) {
+  let offset = 0;
+  for (let d = 0; d < depth; d++) {
+    const m = /^ {0,3}> ?/.exec(line.slice(offset));
+    if (!m) return null;
+    offset += m[0].length;
+  }
+  return line.slice(offset);
+}
+var LIST_ITEM = /^( *)([-*+]|\d{1,9}[.)])( +|\t|$)/;
+function leadingSpaces(s) {
+  let i = 0;
+  while (i < s.length && s[i] === " ") i++;
+  return i;
+}
+function scan(text) {
+  const starts = [];
+  const ends = [];
+  for (let pos = 0; ; ) {
+    const nl = text.indexOf("\n", pos);
+    const lineEnd = nl === -1 ? text.length : nl;
+    starts.push(pos);
+    ends.push(lineEnd > pos && text.charCodeAt(lineEnd - 1) === 13 ? lineEnd - 1 : lineEnd);
+    if (nl === -1) break;
+    pos = nl + 1;
+  }
+  const count = starts.length;
+  const raw = (k) => text.slice(starts[k], ends[k]);
+  const out = { ranges: [], fences: [], paragraphs: [], endsInFence: false, pendingPara: -1 };
+  const rawLines = { count, line: raw };
+  let segment = 0;
+  for (let k = 0; k < count; k++) {
+    const opener = fenceOpenerOf(raw(k));
+    if (!opener || opener.char !== "`") continue;
+    prose(text, starts, ends, raw, segment, k, out);
+    const end = closeFence(rawLines, k, opener);
+    out.ranges.push({ start: starts[k], end: ends[end.line], kind: "fence" });
+    out.fences.push([k, end.line, end.closed]);
+    out.pendingPara = -1;
+    if (!end.closed && end.line === count - 1) out.endsInFence = true;
+    k = end.line;
+    segment = k + 1;
+  }
+  prose(text, starts, ends, raw, segment, count, out);
+  return out;
+}
+function prose(text, starts, ends, raw, from, to, out) {
+  let para = -1;
+  let quoteDepth = 0;
+  let lists = [];
+  const closePara = (at) => {
+    if (para !== -1) out.paragraphs.push([para, at]);
+    para = -1;
+  };
+  for (let k = from; k < to; k++) {
+    const line = raw(k);
+    const { depth, offset } = quotePrefix(line);
+    if (depth !== quoteDepth) {
+      quoteDepth = depth;
+      lists = [];
+    }
+    let content = line.slice(offset);
+    if (content.trim() === "") {
+      closePara(starts[k]);
+      if (!(k === starts.length - 1 && line === "")) out.pendingPara = -1;
+      continue;
+    }
+    const indent = leadingSpaces(content);
+    while (lists.length && indent < lists[lists.length - 1]) lists.pop();
+    const item = LIST_ITEM.exec(content);
+    let column = lists.length ? lists[lists.length - 1] : 0;
+    if (item) {
+      const gap = item[3].length;
+      column = item[1].length + item[2].length + (gap >= 1 && gap <= 4 ? gap : 1);
+      lists.push(column);
+      content = content.slice(Math.min(column, content.length));
+    } else {
+      content = content.slice(Math.min(indent, column));
+    }
+    const opener = fenceOpenerOf(content);
+    if (!opener) {
+      if (para === -1) para = starts[k];
+      if (out.pendingPara === -1) out.pendingPara = starts[k];
+      continue;
+    }
+    closePara(starts[k]);
+    out.pendingPara = -1;
+    const col = column;
+    const src = {
+      count: to,
+      line: (j) => {
+        const inner = stripQuotes(raw(j), depth);
+        if (inner === null) return null;
+        if (opener.char === "~" && col > 0) {
+          const ind = leadingSpaces(inner);
+          if (inner.trim() !== "" && ind < col) return null;
+          return inner.slice(Math.min(ind, col));
+        }
+        return inner;
+      }
+    };
+    const end = closeFence(src, k, opener);
+    out.ranges.push({ start: starts[k], end: ends[end.line], kind: "fence" });
+    out.fences.push([k, end.line, end.closed]);
+    if (!end.closed && end.line === starts.length - 1) out.endsInFence = true;
+    k = end.line;
+  }
+  closePara(to < starts.length ? starts[to] : text.length);
+}
+var BacktickRuns = class {
+  /** Every run, in order: [start, length]. */
+  all = [];
+  byLength = /* @__PURE__ */ new Map();
+  indexOf = /* @__PURE__ */ new Map();
+  constructor(text, from, to) {
+    for (let k = from; k < to; ) {
+      if (text.charCodeAt(k) !== 96) {
+        k++;
+        continue;
+      }
+      let len = 1;
+      while (k + len < to && text.charCodeAt(k + len) === 96) len++;
+      this.indexOf.set(k, this.all.length);
+      this.all.push([k, len]);
+      const list = this.byLength.get(len);
+      if (list) list.push(k);
+      else this.byLength.set(len, [k]);
+      k += len;
+    }
+  }
+  /** Start of the first run of exactly `n` backticks at or after `after`, or -1. */
+  next(n, after) {
+    const list = this.byLength.get(n);
+    if (!list) return -1;
+    let lo = 0;
+    let hi = list.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (list[mid] < after) lo = mid + 1;
+      else hi = mid;
+    }
+    return list[lo] ?? -1;
+  }
+  /** Index of the run starting at `start` in `all`. */
+  index(start) {
+    return this.indexOf.get(start) ?? -1;
+  }
+};
+function codeSpans(text, from, to, out) {
+  let runs = null;
+  for (let i = from; i < to; ) {
+    const ch = text.charCodeAt(i);
+    if (ch === 92) {
+      i += 2;
+      continue;
+    }
+    if (ch !== 96) {
+      i++;
+      continue;
+    }
+    const n = backtickRunLength(text, i);
+    const len = Math.min(n, to - i);
+    runs ??= new BacktickRuns(text, from, to);
+    const close = runs.next(len, i + len);
+    if (close === -1) {
+      i += len;
+      continue;
+    }
+    out.push({ start: i, end: close + len, kind: "span" });
+    i = close + len;
+  }
+}
+function findCodeRanges(text) {
+  const s = scan(text);
+  const ranges = [...s.ranges];
+  for (const [from, to] of s.paragraphs) codeSpans(text, from, to, ranges);
+  return ranges.sort((a, b) => a.start - b.start);
+}
+function fenceParts(raw) {
+  const lines = raw.split("\n").map((l) => l.endsWith("\r") ? l.slice(0, -1) : l);
+  const { offset } = quotePrefix(lines[0] ?? "");
+  const opener = fenceOpenerOf((lines[0] ?? "").slice(offset).replace(/^ *(?:[-*+]|\d{1,9}[.)])(?= |\t|$) ?/, ""));
+  if (!opener) return null;
+  const rest = lines.slice(1);
+  const closed = rest.length > 0 && new FenceReader(opener, { nesting: false }).feed(rest[rest.length - 1]);
+  if (!closed) return { opener, body: rest.join("\n"), closed };
+  const last = rest[rest.length - 1];
+  const before = trimFenceLine(last).startsWith("```") ? "" : last.slice(0, last.indexOf("```"));
+  return { opener, body: [...rest.slice(0, -1), ...before.trim() ? [before] : []].join("\n"), closed };
+}
+
+// json-extract/json-structural.ts
+function findBalancedEnd(text, startIndex, openChar, closeChar) {
+  let depth = 1;
+  let inString = false;
+  let escapeNext = false;
+  for (let i = startIndex + 1; i < text.length; i++) {
+    const ch = text[i];
+    if (escapeNext) {
+      escapeNext = false;
+      continue;
+    }
+    if (ch === "\\") {
+      if (inString) escapeNext = true;
+      continue;
+    }
+    if (ch === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) continue;
+    if (ch === openChar) {
+      depth++;
+    } else if (ch === closeChar) {
+      depth--;
+      if (depth === 0) {
+        return { endIndex: i, isComplete: true };
+      }
+    }
+  }
+  return { endIndex: text.length - 1, isComplete: false };
+}
+function computeClosingSequence(text) {
+  const stack = [];
+  let inString = false;
+  let escapeNext = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (escapeNext) {
+      escapeNext = false;
+      continue;
+    }
+    if (ch === "\\") {
+      if (inString) escapeNext = true;
+      continue;
+    }
+    if (ch === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) continue;
+    if (ch === "{") stack.push("}");
+    else if (ch === "[") stack.push("]");
+    else if (ch === "}" || ch === "]") stack.pop();
+  }
+  return stack.reverse().join("");
+}
+function findAllFencedBlocks(text) {
+  const blocks = [];
+  for (const range of findCodeRanges(text)) {
+    if (range.kind !== "fence") continue;
+    const parts = fenceParts(text.slice(range.start, range.end));
+    const openerEnd = text.indexOf("\n", range.start);
+    const contentStart = openerEnd === -1 || openerEnd >= range.end ? range.end : openerEnd + 1;
+    blocks.push({
+      content: parts?.body ?? text.slice(contentStart, range.end),
+      language: (parts?.opener.lang ?? "").toLowerCase(),
+      fenceStart: range.start,
+      contentStart,
+      fenceEnd: range.end,
+      isComplete: parts?.closed ?? false
+    });
+  }
+  return blocks;
+}
+function findBareJsonCandidates(text, excludeRanges = []) {
+  const candidates = [];
+  let inString = false;
+  let escapeNext = false;
+  const isExcluded = (idx) => excludeRanges.some(([s, e]) => idx >= s && idx < e);
+  for (let i = 0; i < text.length; i++) {
+    if (isExcluded(i)) continue;
+    const ch = text[i];
+    if (escapeNext) {
+      escapeNext = false;
+      continue;
+    }
+    if (ch === "\\") {
+      if (inString) escapeNext = true;
+      continue;
+    }
+    if (ch === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) continue;
+    if (ch === "{" || ch === "[") {
+      const closeChar = ch === "{" ? "}" : "]";
+      const result = findBalancedEnd(text, i, ch, closeChar);
+      candidates.push({
+        startIndex: i,
+        endIndex: result.endIndex,
+        openChar: ch,
+        isComplete: result.isComplete
+      });
+      if (result.isComplete) {
+        i = result.endIndex;
+      } else {
+        break;
+      }
+    }
+  }
+  return candidates;
+}
+function tryParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function tryRepairAndParse(text) {
+  const direct = tryParse(text);
+  if (direct !== void 0) return { value: direct, repaired: false };
+  let repaired = text;
+  repaired = repaired.replace(/,(\s*[}\]])/g, "$1");
+  const result = tryParse(repaired);
+  if (result !== void 0) return { value: result, repaired: true };
+  repaired = text;
+  repaired = repaired.replace(/\bTrue\b/g, "true");
+  repaired = repaired.replace(/\bFalse\b/g, "false");
+  repaired = repaired.replace(/\bNone\b/g, "null");
+  repaired = repaired.replace(/,(\s*[}\]])/g, "$1");
+  const result2 = tryParse(repaired);
+  if (result2 !== void 0) return { value: result2, repaired: true };
+  try {
+    return { value: JSON5__default.default.parse(text), repaired: true };
+  } catch {
+    return void 0;
+  }
+}
+function classifyValue(value) {
+  if (Array.isArray(value)) return "array";
+  if (value !== null && typeof value === "object") return "object";
+  return "primitive";
+}
+function extractFromFencedBlocks(_text, blocks, opts) {
+  const results = [];
+  const jsonBlocks = blocks.filter(
+    (b) => b.language === "json" || b.language === ""
+  );
+  for (const block of jsonBlocks) {
+    if (results.length >= opts.maxResults) break;
+    const content = block.content.trim();
+    if (!content) continue;
+    if (block.isComplete) {
+      const parsed = opts.repairEnabled ? tryRepairAndParse(content) : (() => {
+        const v = tryParse(content);
+        return v !== void 0 ? { value: v, repaired: false } : void 0;
+      })();
+      if (parsed !== void 0) {
+        results.push({
+          value: parsed.value,
+          type: classifyValue(parsed.value),
+          source: "fenced",
+          startIndex: block.fenceStart,
+          endIndex: block.fenceEnd,
+          isComplete: true,
+          repairApplied: parsed.repaired,
+          warnings: parsed.repaired ? ["Repair applied (trailing comma or Python syntax)"] : []
+        });
+      }
+    } else if (opts.isStreaming) {
+      const attempted = attemptStreamingClose(content, opts.repairEnabled);
+      if (attempted) {
+        results.push({
+          value: attempted.value,
+          type: classifyValue(attempted.value),
+          source: "fenced",
+          startIndex: block.fenceStart,
+          endIndex: block.fenceEnd,
+          isComplete: false,
+          repairApplied: attempted.repaired,
+          warnings: [
+            "Incomplete fenced block \u2014 auto-closed for streaming preview"
+          ]
+        });
+      }
+    }
+  }
+  return results;
+}
+function attemptStreamingClose(content, repairEnabled) {
+  const candidates = buildStreamingCloseCandidates(content.trim());
+  for (const candidate of candidates) {
+    if (repairEnabled) {
+      const result = tryRepairAndParse(candidate);
+      if (result) return { value: result.value, repaired: true };
+    }
+    const direct = tryParse(candidate);
+    if (direct !== void 0) return { value: direct, repaired: true };
+  }
+  return void 0;
+}
+function buildStreamingCloseCandidates(text) {
+  const candidates = [];
+  const inString = isInsideString(text);
+  if (inString) {
+    const closedString = text + '"';
+    const closingForString = computeClosingSequence(closedString);
+    candidates.push(closedString + closingForString);
+    candidates.push(closedString + ": null" + closingForString);
+    candidates.push(closedString + ': ""' + closingForString);
+  }
+  if (!inString && /:\s*$/.test(text)) {
+    const closingD = computeClosingSequence(text);
+    candidates.push(text + ' ""' + closingD);
+    candidates.push(text + " null" + closingD);
+  }
+  if (!inString && /,\s*$/.test(text)) {
+    const truncated = text.replace(/,\s*$/, "");
+    const closingE = computeClosingSequence(truncated);
+    candidates.push(truncated + closingE);
+  }
+  const lastClean = findLastCleanBreak(text);
+  if (lastClean > 0 && lastClean < text.length) {
+    const truncated = text.slice(0, lastClean);
+    const closingB = computeClosingSequence(truncated);
+    candidates.push(truncated + closingB);
+  }
+  const closingC = computeClosingSequence(text);
+  if (closingC) {
+    candidates.push(text + closingC);
+  }
+  if (!inString && !computeClosingSequence(text)) {
+    candidates.push(text);
+  }
+  return candidates;
+}
+function findLastCleanBreak(text) {
+  let inStr = false;
+  let escapeNext = false;
+  let lastBreak = 0;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (escapeNext) {
+      escapeNext = false;
+      continue;
+    }
+    if (ch === "\\") {
+      if (inStr) escapeNext = true;
+      continue;
+    }
+    if (ch === '"') {
+      inStr = !inStr;
+      continue;
+    }
+    if (inStr) continue;
+    if (ch === "," || ch === "}" || ch === "]") {
+      lastBreak = i + 1;
+    }
+  }
+  return lastBreak;
+}
+function isInsideString(text) {
+  let inString = false;
+  let escapeNext = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (escapeNext) {
+      escapeNext = false;
+      continue;
+    }
+    if (ch === "\\") {
+      if (inString) escapeNext = true;
+      continue;
+    }
+    if (ch === '"') {
+      inString = !inString;
+    }
+  }
+  return inString;
+}
+function extractFromBareBlocks(text, fencedBlocks, opts) {
+  const results = [];
+  const excludeRanges = fencedBlocks.map((b) => [
+    b.fenceStart,
+    b.fenceEnd
+  ]);
+  const candidates = findBareJsonCandidates(text, excludeRanges);
+  for (const candidate of candidates) {
+    if (results.length >= opts.maxResults) break;
+    if (candidate.isComplete) {
+      const raw2 = text.slice(candidate.startIndex, candidate.endIndex + 1);
+      const parsed = opts.repairEnabled ? tryRepairAndParse(raw2) : (() => {
+        const v = tryParse(raw2);
+        return v !== void 0 ? { value: v, repaired: false } : void 0;
+      })();
+      if (parsed !== void 0) {
+        results.push({
+          value: parsed.value,
+          type: classifyValue(parsed.value),
+          source: "bare-block",
+          startIndex: candidate.startIndex,
+          endIndex: candidate.endIndex + 1,
+          isComplete: true,
+          repairApplied: parsed.repaired,
+          warnings: parsed.repaired ? ["Repair applied to bare JSON block"] : ["JSON found without code fence markers"]
+        });
+      }
+      continue;
+    }
+    if (!opts.isStreaming) continue;
+    const raw = text.slice(candidate.startIndex, candidate.endIndex + 1);
+    const attempted = attemptStreamingClose(raw, opts.repairEnabled);
+    if (attempted) {
+      results.push({
+        value: attempted.value,
+        type: classifyValue(attempted.value),
+        source: "bare-block",
+        startIndex: candidate.startIndex,
+        endIndex: candidate.endIndex + 1,
+        isComplete: false,
+        repairApplied: attempted.repaired,
+        warnings: ["Incomplete bare JSON \u2014 auto-closed for streaming preview"]
+      });
+    }
+  }
+  return results;
+}
+function extractFromWholeString(text, opts) {
+  const trimmed = text.trim();
+  if (!trimmed) return [];
+  const parsed = opts.repairEnabled ? tryRepairAndParse(trimmed) : (() => {
+    const v = tryParse(trimmed);
+    return v !== void 0 ? { value: v, repaired: false } : void 0;
+  })();
+  if (parsed !== void 0) {
+    return [
+      {
+        value: parsed.value,
+        type: classifyValue(parsed.value),
+        source: "whole-string",
+        startIndex: 0,
+        endIndex: text.length,
+        isComplete: true,
+        repairApplied: parsed.repaired,
+        warnings: [
+          "Entire input parsed as JSON (no fences or structure detected)"
+        ]
+      }
+    ];
+  }
+  return [];
+}
+function repairIsFaithful(text, value) {
+  const first = text[0];
+  if (first !== "{" && first !== "[") return false;
+  if (first === "{" && !(value !== null && typeof value === "object" && !Array.isArray(value))) return false;
+  if (first === "[" && !Array.isArray(value)) return false;
+  return text.includes(":") || text.includes('"');
+}
+function dropStrayClosers(text) {
+  const stack = [];
+  let out = "";
+  let inString = false;
+  let escapeNext = false;
+  for (const ch of text) {
+    if (escapeNext) {
+      escapeNext = false;
+      out += ch;
+      continue;
+    }
+    if (inString) {
+      if (ch === "\\") escapeNext = true;
+      else if (ch === '"') inString = false;
+      out += ch;
+      continue;
+    }
+    if (ch === '"') inString = true;
+    else if (ch === "{" || ch === "[") stack.push(ch);
+    else if (ch === "}" || ch === "]") {
+      const top = stack[stack.length - 1];
+      if (top === void 0 || top === "{" !== (ch === "}")) continue;
+      stack.pop();
+    }
+    out += ch;
+  }
+  return out;
+}
+function extractWholeDocumentRepair(text) {
+  const trimmed = text.trim();
+  if (trimmed[0] !== "{" && trimmed[0] !== "[") return void 0;
+  if (tryRepairAndParse(trimmed) !== void 0) return void 0;
+  let value;
+  for (const attempt of [trimmed, dropStrayClosers(trimmed)]) {
+    try {
+      value = JSON.parse(jsonrepair.jsonrepair(attempt));
+      break;
+    } catch {
+      value = void 0;
+    }
+  }
+  if (value === void 0) return void 0;
+  if (!repairIsFaithful(trimmed, value)) return void 0;
+  return {
+    value,
+    type: classifyValue(value),
+    source: "whole-string",
+    startIndex: text.indexOf(trimmed),
+    endIndex: text.indexOf(trimmed) + trimmed.length,
+    isComplete: true,
+    repairApplied: true,
+    warnings: [
+      "Whole document had malformed syntax; recovered via jsonrepair instead of a fragment"
+    ]
+  };
+}
+var DEFAULTS = {
+  isStreaming: false,
+  allowFuzzy: false,
+  maxResults: Infinity,
+  repairEnabled: true
+};
+function extractAllJson(text, options) {
+  if (!text || typeof text !== "string") return [];
+  const opts = { ...DEFAULTS, ...options };
+  if (!opts.isStreaming && opts.repairEnabled) {
+    const whole = extractWholeDocumentRepair(text);
+    if (whole) return [whole];
+  }
+  const allFenced = findAllFencedBlocks(text);
+  const fencedResults = extractFromFencedBlocks(text, allFenced, opts);
+  if (fencedResults.length >= opts.maxResults) {
+    return fencedResults.slice(0, opts.maxResults);
+  }
+  const remaining = opts.maxResults - fencedResults.length;
+  let bareResults = [];
+  if (opts.allowFuzzy || fencedResults.length === 0) {
+    bareResults = extractFromBareBlocks(text, allFenced, {
+      ...opts,
+      maxResults: remaining
+    });
+  }
+  const combined = [...fencedResults, ...bareResults];
+  if (combined.length >= opts.maxResults) {
+    return combined.slice(0, opts.maxResults);
+  }
+  if (opts.isStreaming) {
+    return combined;
+  }
+  if (opts.allowFuzzy && combined.length === 0) {
+    const wholeResults = extractFromWholeString(text, opts);
+    return wholeResults.slice(0, opts.maxResults);
+  }
+  return combined;
+}
+function extractFirstJson(text, options) {
+  const results = extractAllJson(text, { ...options, maxResults: 1 });
+  return results[0] ?? null;
+}
+function extractFirstObject(text, options) {
+  const results = extractAllJson(text, options);
+  return results.find((r) => r.type === "object") ?? null;
+}
+function containsJson(text, options) {
+  return extractAllJson(text, { ...options, maxResults: 1 }).length > 0;
+}
+
+// json-extract/streaming-json-tracker.ts
+var INITIAL_STATE = {
+  results: [],
+  isAllComplete: true,
+  hasOpenFence: false,
+  revision: 0,
+  textLength: 0
+};
+var StreamingJsonTracker = class {
+  text = "";
+  state = { ...INITIAL_STATE };
+  opts;
+  lastResultsHash = "";
+  constructor(options) {
+    this.opts = {
+      maxResults: options?.maxResults ?? Infinity,
+      repairEnabled: options?.repairEnabled ?? true,
+      fuzzyOnFinalize: options?.fuzzyOnFinalize ?? true
+    };
+  }
+  /**
+   * Append a new chunk of text and re-extract. Returns the new state.
+   * Only bumps `revision` if the extraction results actually changed.
+   */
+  append(chunk) {
+    this.text += chunk;
+    return this.extract(true);
+  }
+  /**
+   * Run a final extraction pass with full strategies (including fuzzy).
+   * Call once when the stream is complete.
+   */
+  finalize() {
+    return this.extract(false);
+  }
+  /** Replace the entire accumulated text (useful if you manage accumulation externally). */
+  setFullText(text) {
+    this.text = text;
+    return this.extract(true);
+  }
+  /** Get the current state without re-extracting. */
+  getState() {
+    return this.state;
+  }
+  /** Get the accumulated text. */
+  getText() {
+    return this.text;
+  }
+  /** Reset to initial state. */
+  reset() {
+    this.text = "";
+    this.state = { ...INITIAL_STATE };
+    this.lastResultsHash = "";
+  }
+  // ---------------------------------------------------------------------------
+  // Internal
+  // ---------------------------------------------------------------------------
+  extract(isStreaming) {
+    const options = {
+      isStreaming,
+      allowFuzzy: isStreaming ? false : this.opts.fuzzyOnFinalize,
+      maxResults: this.opts.maxResults,
+      repairEnabled: this.opts.repairEnabled
+    };
+    const results = extractAllJson(this.text, options);
+    const hash = this.computeHash(results);
+    if (hash !== this.lastResultsHash) {
+      this.lastResultsHash = hash;
+      this.state = {
+        results,
+        isAllComplete: results.every((r) => r.isComplete),
+        hasOpenFence: results.some(
+          (r) => r.source === "fenced" && !r.isComplete
+        ),
+        revision: this.state.revision + 1,
+        textLength: this.text.length
+      };
+    } else {
+      this.state = {
+        ...this.state,
+        textLength: this.text.length
+      };
+    }
+    return this.state;
+  }
+  /**
+   * Cheap hash of extraction results for change detection.
+   * We hash on: count, types, completeness, and the stringified values.
+   * This avoids deep-equality checks on every chunk.
+   */
+  computeHash(results) {
+    if (results.length === 0) return "empty";
+    const parts = [];
+    for (const r of results) {
+      parts.push(
+        `${r.type}:${r.source}:${r.isComplete}:${r.startIndex}-${r.endIndex}`
+      );
+      try {
+        parts.push(JSON.stringify(r.value));
+      } catch {
+        parts.push("unstringifiable");
+      }
+    }
+    return parts.join("|");
+  }
+};
+
+exports.StreamingJsonTracker = StreamingJsonTracker;
+exports.computeClosingSequence = computeClosingSequence;
+exports.containsJson = containsJson;
+exports.extractAllJson = extractAllJson;
+exports.extractFirstJson = extractFirstJson;
+exports.extractFirstObject = extractFirstObject;
+exports.findAllFencedBlocks = findAllFencedBlocks;
+exports.findBalancedEnd = findBalancedEnd;
+exports.findBareJsonCandidates = findBareJsonCandidates;
+//# sourceMappingURL=json-extract.cjs.map
+//# sourceMappingURL=json-extract.cjs.map