@ai-matrx/chat 0.4.9 → 0.4.12

package/dist/utils/content-ir/surfaces/embedded-kind-json.d.ts

@@ -1,140 +0,0 @@
-/**
- * Recover complete self-described kind objects from ANY containing text.
- *
- * Markdown, code fences, and XML are arrival containers, not type authority.
- * Once a complete JSON object directly declares a non-empty `__kind`, that
- * object is its own Content IR region even when an outer parser already
- * classified the surrounding bytes as code, XML, or prose.
- *
- * Generic XML opts into literal-context exclusion so tag attributes, code,
- * comments, and CDATA remain examples owned by their container. Otherwise the
- * scanner is syntax-agnostic about the outer container. It only promotes candidates that independently pass JSON.parse and carry a
- * direct string discriminator. Failed/malformed candidates remain untouched.
- */
-export interface EmbeddedKindJsonRegion {
-    start: number;
-    end: number;
-    content: string;
-    kind: string;
-}
-export type EmbeddedKindJsonPiece = {
-    type: "container";
-    content: string;
-} | {
-    type: "kind";
-    content: string;
-    kind: string;
-}
-/**
- * JSON punctuation that only held kinds together — the `[`, `,` and `]` of
- * an array of kinds. Kept so the partition stays lossless; never rendered
- * (a lone `[` drawn as a JSON card is noise, not content — A6).
- */
- | {
-    type: "chrome";
-    content: string;
-}
-/**
- * The non-kind DATA of a JSON wrapper around kinds (`{"result":{…kind…},
- * "note":"x"}`, A7): `content` is the source span it replaces (lossless),
- * `json` is the wrapper's value with every kind removed — valid JSON, drawn
- * as genuine JSON. A wrapper that holds only kinds has no residual piece.
- */
- | {
-    type: "residual";
-    content: string;
-    json: string;
-};
-/**
- * For every `{` / `[` in `text`: the end (exclusive) of the string-aware
- * balanced JSON value opening there, or -1 (never balances). Each opener's
- * reading starts outside a string, exactly as if read alone; one right-to-left
- * pass reuses each nested opener's own answer (its reading from inside an
- * enclosing value is the same reading), so the whole table is linear — a
- * reading per opener was quadratic on thousands of unclosed `{` (round 11, P5).
- */
-export declare function balancedEnds(text: string): Int32Array;
-/** Outermost complete self-described objects, in source order. */
-export { frontMatterEnd } from "./json-kind-signal.js";
-export interface EmbeddedKindSearchOptions {
-    /** Generic XML: code, comments, CDATA and tags are literal (the XML card shows them). */
-    excludeLiteralContexts?: boolean;
-    /**
-     * With `excludeLiteralContexts` (an XML TAG — structure, ruling (b) round 3):
-     * a ```json / ```jsonc / ```json5 / unlabelled fence is NOT literal. A kind
-     * that is its whole body leaves with the fence's own lines as chrome, so
-     * the XML pieces around it hold no orphan fence marker.
-     */
-    liftJsonFences?: boolean;
-    /**
-     * Markdown: inline code spans and non-JSON fences are the model quoting
-     * source (`quotedSourceRanges`, the owner's ruling 2026-09-30) — never lifted.
-     */
-    excludeQuotedSource?: boolean;
-}
-export declare function findEmbeddedKindJsonRegions(source: string, options?: EmbeddedKindSearchOptions): EmbeddedKindJsonRegion[];
-/** Losslessly partition a container around every recovered kind region. */
-export declare function splitAroundEmbeddedKindJson(source: string, options?: EmbeddedKindSearchOptions): EmbeddedKindJsonPiece[];
-/**
- * A recovered PROSE piece, shaped exactly as the live stream shapes the same
- * bytes (A5, 2026-09-30): the stream splits `Here: {"__kind":…} after` into
- * three lines as it arrives, so its prose blocks are trimmed at the end (every
- * text block is) and, after a kind, start where the next character does — the
- * spaces after the object and the one line break that ended its line are the
- * boundary, not content. Both hosts call this on every text piece, so a live
- * message and its reload draw the same blocks.
- */
-export declare function normalizeRecoveredProsePiece(content: string, followsKind: boolean): string;
-/**
- * Every recovered container piece, by its container's block type: prose by
- * the rule above, code byte-verbatim, and a SECTION (`thinking`, `info`, …)
- * trimmed — the live stream splits a kind out of a section as it arrives
- * (A8) and each part is a section body, which is trimmed like a whole one.
- */
-export declare function normalizeRecoveredContainerPiece(content: string, containerType: string, followsKind: boolean): string;
-/**
- * A complete JSON value (object or array) that holds at least one kind, as
- * one region: a recovered kind region widened to the OUTERMOST complete,
- * parseable JSON value that contains it — a kindless wrapper
- * (`{"result":{…kind…},"note":…}`, A7) or an array of kinds and plain values.
- * For DESTINATION transforms (export, copy, speech) that convert the value
- * whole; the renderer partitions the same bytes with
- * {@link splitAroundEmbeddedKindJson}. Built on THE region finder above.
- */
-export interface KindCarryingJsonRegion {
-    start: number;
-    end: number;
-    content: string;
-    value: unknown;
-}
-export declare function findKindCarryingJsonValues(source: string, options?: {
-    excludeLiteralContexts?: boolean;
-}): KindCarryingJsonRegion[];
-/**
- * A kind that can never complete as written: [start, end) and the text of
- * its region. Two shapes, by the same ownership rule as the finder above:
- *  - a CLOSED object whose root declares `__kind` but does not parse (the
- *    finder's malformed owner) — bounded;
- *  - an UNCLOSED JSON object or array at the tail (a stream cut off, a
- *    truncated store) holding a `"__kind"` key anywhere — runs to the end,
- *    from its outermost opener (a kindless wrapper is cut with its kind).
- * For destinations that must say "<Kind> did not finish" instead of printing
- * the fragment. Complete values (kind or not) are skipped whole.
- */
-export interface BrokenKindJsonRegion {
-    start: number;
-    end: number;
-    content: string;
-}
-/**
- * Round 10 (C1): a broken region is bounded by its OWN JSON grammar. An opener
- * owns a kind key only when its grammar reaches the key; it runs to the end of
- * the text only while it is still validly open, else it ends at its cut. A
- * stray `[[`, `{"`, `{{`, `["`, an unrelated earlier object or a pasted
- * schema never extends a region over the prose after it. A balanced span that
- * does not parse is a region only when it reads once trailing commas go.
- * Linear: key positions once, each opener's grammar stops at its break.
- */
-export declare function findBrokenKindJsonRegions(source: string, options?: {
-    excludeLiteralContexts?: boolean;
-}): BrokenKindJsonRegion[];

package/dist/utils/content-ir/surfaces/embedded-kind-json.js

@@ -1,527 +0,0 @@
-import { readXmlTag } from "../../xml/readXmlTag.js";
-import { fenceOpenerOf, findCodeRanges } from "@ai-matrx/content-ir/source";
-import { frontMatterEnd, isJsonFenceLanguage, kindGrammar, quotedSourceRanges } from "./json-kind-signal.js";
-function matchingJsonObjectEnd(source, start) {
-  if (source[start] !== "{" && source[start] !== "[") return null;
-  const stack = [source[start]];
-  let inString = false;
-  let escaped = false;
-  for (let index = start + 1; index < source.length; index++) {
-    const char = source[index];
-    if (inString) {
-      if (escaped) {
-        escaped = false;
-      } else if (char === "\\") {
-        escaped = true;
-      } else if (char === '"') {
-        inString = false;
-      }
-      continue;
-    }
-    if (char === '"') {
-      inString = true;
-      continue;
-    }
-    if (char === "{" || char === "[") {
-      stack.push(char);
-      continue;
-    }
-    if (char !== "}" && char !== "]") continue;
-    const opening = stack.pop();
-    if (char === "}" && opening !== "{" || char === "]" && opening !== "[") {
-      return null;
-    }
-    if (stack.length === 0) return index + 1;
-  }
-  return null;
-}
-function balancedEnds(text) {
-  const ends = new Int32Array(text.length).fill(-1);
-  const stack = [];
-  for (let start = text.length - 1; start >= 0; start--) {
-    const open = text[start];
-    if (open !== "{" && open !== "[") continue;
-    stack.length = 0;
-    stack.push(open === "{" ? "}" : "]");
-    let inString = false;
-    for (let i = start + 1; i < text.length; i++) {
-      const ch = text[i];
-      if (inString) {
-        if (ch === "\\") i++;
-        else if (ch === '"') inString = false;
-        continue;
-      }
-      if (ch === '"') inString = true;
-      else if (ch === "{" || ch === "[") {
-        const end = ends[i];
-        if (end < 0) break;
-        i = end - 1;
-      } else if (ch === "}" || ch === "]") {
-        if (stack.pop() !== ch) break;
-        ends[start] = i + 1;
-        break;
-      }
-    }
-  }
-  return ends;
-}
-function lazyJsonEnds(source) {
-  let table;
-  return (start) => {
-    if (source[start] !== "{" && source[start] !== "[") return null;
-    table ??= balancedEnds(source);
-    const end = table[start];
-    return end < 0 ? null : end;
-  };
-}
-function skipWhitespace(source, cursor) {
-  while (/\s/.test(source[cursor] ?? "")) cursor++;
-  return cursor;
-}
-function jsonStringEnd(source, start) {
-  if (source[start] !== '"') return null;
-  let escaped = false;
-  for (let cursor = start + 1; cursor < source.length; cursor++) {
-    const char = source[cursor];
-    if (escaped) {
-      escaped = false;
-    } else if (char === "\\") {
-      escaped = true;
-    } else if (char === '"') {
-      return cursor + 1;
-    }
-  }
-  return null;
-}
-function jsonValueEnd(source, start) {
-  const char = source[start];
-  if (char === '"') return jsonStringEnd(source, start);
-  if (char === "{" || char === "[") return matchingJsonObjectEnd(source, start);
-  const end = source.slice(start).search(/[\s,}\]]/);
-  const tokenEnd = end === -1 ? source.length : start + end;
-  const token = source.slice(start, tokenEnd);
-  return /^(?:true|false|null|-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)$/.test(
-    token
-  ) ? tokenEnd : null;
-}
-function malformedKindOwnerEnd(source, start, boundary = source.length) {
-  let cursor = skipWhitespace(source, start + 1);
-  let kindFound = false;
-  const ownerEnd = () => kindFound ? boundary : null;
-  while (cursor < boundary) {
-    const keyStart = cursor;
-    const keyEnd = jsonStringEnd(source, keyStart);
-    if (keyEnd === null || keyEnd > boundary) return ownerEnd();
-    let key;
-    try {
-      key = JSON.parse(source.slice(keyStart, keyEnd));
-    } catch {
-      return ownerEnd();
-    }
-    cursor = skipWhitespace(source, keyEnd);
-    if (cursor >= boundary || source[cursor] !== ":") return ownerEnd();
-    cursor = skipWhitespace(source, cursor + 1);
-    const valueStart = cursor;
-    const valueEnd = jsonValueEnd(source, valueStart);
-    if (valueEnd === null || valueEnd > boundary) return ownerEnd();
-    if (key === "__kind") {
-      try {
-        const value = JSON.parse(source.slice(valueStart, valueEnd));
-        kindFound ||= typeof value === "string" && value.trim().length > 0;
-      } catch {
-        return ownerEnd();
-      }
-    }
-    cursor = skipWhitespace(source, valueEnd);
-    if (source[cursor] === "}") return kindFound ? cursor + 1 : null;
-    if (cursor >= boundary || source[cursor] !== ",") return ownerEnd();
-    cursor = skipWhitespace(source, cursor + 1);
-  }
-  return ownerEnd();
-}
-function jsonStringRanges(source, start, end) {
-  const ranges = [];
-  for (let cursor = start; cursor < end; cursor++) {
-    if (source[cursor] !== '"') continue;
-    const stringEnd = jsonStringEnd(source, cursor);
-    if (stringEnd === null || stringEnd > end) break;
-    ranges.push([cursor, stringEnd]);
-    cursor = stringEnd - 1;
-  }
-  return ranges;
-}
-function declaredKind(candidate) {
-  try {
-    const parsed = JSON.parse(candidate);
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-      return null;
-    }
-    const kind = parsed.__kind;
-    return typeof kind === "string" && kind.trim() ? kind : null;
-  } catch {
-    return null;
-  }
-}
-function literalRanges(source, liftJsonFences = false) {
-  const ranges = [];
-  const code = liftJsonFences ? findCodeRanges(source).filter((range) => !isJsonFenceRange(source, range)) : findCodeRanges(source);
-  let next = 0;
-  let cursor = 0;
-  while (cursor < source.length) {
-    while (next < code.length && code[next].start < cursor) next++;
-    const range = code[next];
-    if (range && range.start === cursor) {
-      ranges.push([range.start, range.end]);
-      cursor = range.end;
-      next++;
-      continue;
-    }
-    if (source.startsWith("<!--", cursor)) {
-      const end = source.indexOf("-->", cursor + 4);
-      const rangeEnd = end === -1 ? source.length : end + 3;
-      ranges.push([cursor, rangeEnd]);
-      cursor = rangeEnd;
-      continue;
-    }
-    if (source.startsWith("<![CDATA[", cursor)) {
-      const end = source.indexOf("]]>", cursor + 9);
-      const rangeEnd = end === -1 ? source.length : end + 3;
-      ranges.push([cursor, rangeEnd]);
-      cursor = rangeEnd;
-      continue;
-    }
-    if (source[cursor] === "<") {
-      const tag = readXmlTag(source, cursor);
-      if (tag) {
-        const end = cursor + tag.raw.length;
-        ranges.push([cursor, end]);
-        cursor = end;
-        continue;
-      }
-      if (/^<[A-Za-z_][\w.:-]*\s/.test(source.slice(cursor, cursor + 64)) && !tagCloses(source, cursor)) {
-        ranges.push([cursor, source.length]);
-        break;
-      }
-    }
-    cursor++;
-  }
-  return ranges;
-}
-function tagCloses(source, start) {
-  let quote = null;
-  for (let i = start + 1; i < source.length; i++) {
-    const ch = source[i];
-    if (quote) {
-      if (ch === quote) quote = null;
-    } else if (ch === "'" || ch === '"') quote = ch;
-    else if (ch === ">") return true;
-  }
-  return false;
-}
-function isJsonFenceRange(source, range) {
-  if (range.kind !== "fence") return false;
-  const raw = source.slice(range.start, range.end);
-  const newline = raw.indexOf("\n");
-  const opener = fenceOpenerOf((newline === -1 ? raw : raw.slice(0, newline)).trimStart());
-  return opener !== null && isJsonFenceLanguage(opener.lang);
-}
-function jsonFenceChromeSpans(source, regions) {
-  const spans = [];
-  for (const range of findCodeRanges(source)) {
-    if (!isJsonFenceRange(source, range)) continue;
-    const inside = regions.filter((r) => r.start >= range.start && r.end <= range.end);
-    if (inside.length !== 1) continue;
-    const region = inside[0];
-    const head = source.slice(range.start, region.start);
-    const tail = source.slice(region.end, range.end);
-    if (!/^[^\n]*\n\s*$/.test(head) || !/^\s*(?:[`~]{3,}[ \t]*)?$/.test(tail)) continue;
-    spans.push([range.start, region.start]);
-    if (region.end < range.end) spans.push([region.end, range.end]);
-  }
-  return spans;
-}
-import { frontMatterEnd as frontMatterEnd2 } from "./json-kind-signal.js";
-function findEmbeddedKindJsonRegions(source, options = {}) {
-  const regions = [];
-  const endOf = lazyJsonEnds(source);
-  const excluded = [
-    ...options.excludeLiteralContexts ? literalRanges(source, options.liftJsonFences === true) : [],
-    ...options.excludeQuotedSource ? quotedSourceRanges(source) : []
-  ].sort((a, b) => a[0] - b[0]);
-  const jsonStrings = [];
-  let excludedIndex = 0;
-  let jsonStringIndex = 0;
-  for (let start = frontMatterEnd(source); start < source.length; start++) {
-    while (excludedIndex < excluded.length && excluded[excludedIndex][1] <= start) {
-      excludedIndex++;
-    }
-    while (jsonStringIndex < jsonStrings.length && jsonStrings[jsonStringIndex][1] <= start) {
-      jsonStringIndex++;
-    }
-    if (excludedIndex < excluded.length && start >= excluded[excludedIndex][0] && start < excluded[excludedIndex][1])
-      continue;
-    if (jsonStringIndex < jsonStrings.length && start >= jsonStrings[jsonStringIndex][0] && start < jsonStrings[jsonStringIndex][1])
-      continue;
-    if (source[start] !== "{") continue;
-    const end = endOf(start);
-    if (end === null) {
-      const verdict = kindGrammar(source, "json", start);
-      const bound = verdict.status === "broken" ? verdict.cut : source.length;
-      const ownerEnd = bound > start ? malformedKindOwnerEnd(source, start, bound) : null;
-      if (ownerEnd !== null) start = ownerEnd - 1;
-      continue;
-    }
-    const content = source.slice(start, end);
-    const kind = declaredKind(content);
-    if (!kind) {
-      const ownerEnd = malformedKindOwnerEnd(source, start, end);
-      if (ownerEnd !== null) {
-        start = ownerEnd - 1;
-        continue;
-      }
-      for (const range of jsonStringRanges(source, start, end)) jsonStrings.push(range);
-      continue;
-    }
-    regions.push({ start, end, content, kind });
-    start = end - 1;
-  }
-  return regions;
-}
-function kindArrayChromeSpans(source, regions) {
-  const spans = [];
-  let first = 0;
-  while (first < regions.length) {
-    let last = first;
-    while (last + 1 < regions.length && /^\s*,\s*$/.test(source.slice(regions[last].end, regions[last + 1].start))) {
-      last++;
-    }
-    const before = source.slice(0, regions[first].start);
-    const open = /\[\s*$/.exec(before);
-    const after = source.slice(regions[last].end);
-    const close = /^\s*\]/.exec(after);
-    if (open && close) {
-      spans.push([open.index, regions[first].start]);
-      for (let k = first; k < last; k++) {
-        spans.push([regions[k].end, regions[k + 1].start]);
-      }
-      spans.push([regions[last].end, regions[last].end + close[0].length]);
-    }
-    first = last + 1;
-  }
-  return spans;
-}
-function isKindValue(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return false;
-  }
-  const kind = value.__kind;
-  return typeof kind === "string" && kind.trim().length > 0;
-}
-function withoutKinds(value) {
-  if (Array.isArray(value)) {
-    return value.filter((item) => !isKindValue(item)).map(withoutKinds);
-  }
-  if (typeof value === "object" && value !== null) {
-    const out = {};
-    for (const [key, item] of Object.entries(value)) {
-      if (!isKindValue(item)) out[key] = withoutKinds(item);
-    }
-    return out;
-  }
-  return value;
-}
-function carriesData(value) {
-  if (Array.isArray(value)) return value.some(carriesData);
-  if (typeof value === "object" && value !== null) {
-    return Object.values(value).some(carriesData);
-  }
-  return true;
-}
-function isPureJsonStructure(span) {
-  return /^[\s{}[\],:]*$/.test(
-    span.replace(/"(?:[^"\\]|\\.)*"\s*:/g, "")
-  );
-}
-function wrapperPieces(source, regions) {
-  const trimmed = source.trim();
-  if (!/^[[{]/.test(trimmed)) return null;
-  let parsed;
-  try {
-    parsed = JSON.parse(trimmed);
-  } catch {
-    return null;
-  }
-  if (typeof parsed !== "object" || parsed === null || isKindValue(parsed)) {
-    return null;
-  }
-  const residual = withoutKinds(parsed);
-  const residualJson = carriesData(residual) ? JSON.stringify(residual, null, 2) : null;
-  const pieces = [];
-  let residualPlaced = residualJson === null;
-  const pushSpan = (content) => {
-    if (!content) return;
-    if (!residualPlaced && !isPureJsonStructure(content)) {
-      pieces.push({ type: "residual", content, json: residualJson });
-      residualPlaced = true;
-      return;
-    }
-    pieces.push({ type: "chrome", content });
-  };
-  let cursor = 0;
-  for (const region of regions) {
-    pushSpan(source.slice(cursor, region.start));
-    pieces.push({ type: "kind", content: region.content, kind: region.kind });
-    cursor = region.end;
-  }
-  pushSpan(source.slice(cursor));
-  if (!residualPlaced) {
-    pieces.push({ type: "residual", content: "", json: residualJson });
-  }
-  return pieces;
-}
-function splitAroundEmbeddedKindJson(source, options = {}) {
-  const regions = findEmbeddedKindJsonRegions(source, options);
-  if (regions.length === 0) return [{ type: "container", content: source }];
-  const wrapped = wrapperPieces(source, regions);
-  if (wrapped) return wrapped;
-  const marks = [
-    ...regions.map((r) => ({ start: r.start, end: r.end, type: "kind", kind: r.kind })),
-    ...[
-      ...kindArrayChromeSpans(source, regions),
-      ...options.excludeLiteralContexts && options.liftJsonFences ? jsonFenceChromeSpans(source, regions) : []
-    ].map(([start, end]) => ({
-      start,
-      end,
-      type: "chrome"
-    }))
-  ].sort((a, b) => a.start - b.start);
-  const pieces = [];
-  let cursor = 0;
-  for (const mark of marks) {
-    if (mark.start > cursor) {
-      pieces.push({
-        type: "container",
-        content: source.slice(cursor, mark.start)
-      });
-    }
-    if (mark.end > mark.start) {
-      pieces.push(
-        mark.type === "kind" ? { type: "kind", content: source.slice(mark.start, mark.end), kind: mark.kind } : { type: "chrome", content: source.slice(mark.start, mark.end) }
-      );
-    }
-    cursor = Math.max(cursor, mark.end);
-  }
-  if (cursor < source.length) {
-    pieces.push({ type: "container", content: source.slice(cursor) });
-  }
-  return pieces;
-}
-function normalizeRecoveredProsePiece(content, followsKind) {
-  const start = followsKind ? content.replace(/^[ \t]*(?:\r?\n)?/, "") : content;
-  return start.trimEnd();
-}
-function normalizeRecoveredContainerPiece(content, containerType, followsKind) {
-  if (containerType === "text") {
-    return normalizeRecoveredProsePiece(content, followsKind);
-  }
-  if (containerType === "code") return content;
-  return content.trim();
-}
-function findKindCarryingJsonValues(source, options = {}) {
-  const kinds = findEmbeddedKindJsonRegions(source, options);
-  if (kinds.length === 0) return [];
-  const excluded = options.excludeLiteralContexts ? literalRanges(source) : [];
-  const inLiteral = (index) => excluded.some(([start, end]) => index >= start && index < end);
-  const ends = balancedEnds(source);
-  const regions = [];
-  let floor = frontMatterEnd(source);
-  for (const region of kinds) {
-    if (region.start < floor) continue;
-    let best = { start: region.start, end: region.end, value: JSON.parse(region.content) };
-    for (let open = floor; open < region.start; open++) {
-      const char = source[open];
-      if (char !== "{" && char !== "[" || inLiteral(open)) continue;
-      const found = ends[open];
-      if (found < 0 || found < region.end) continue;
-      const end = found;
-      try {
-        best = { start: open, end, value: JSON.parse(source.slice(open, end)) };
-        break;
-      } catch {
-        continue;
-      }
-    }
-    regions.push({ ...best, content: source.slice(best.start, best.end) });
-    floor = best.end;
-  }
-  return regions;
-}
-const KIND_KEY_TEXT = /(?<!\\)"__kind"\s*:/;
-const KIND_KEY_TEXT_G = /(?<!\\)"__kind"\s*:/g;
-function findBrokenKindJsonRegions(source, options = {}) {
-  const broken = [];
-  if (!KIND_KEY_TEXT.test(source)) return broken;
-  const endOf = lazyJsonEnds(source);
-  const keys = [];
-  KIND_KEY_TEXT_G.lastIndex = 0;
-  for (let m = KIND_KEY_TEXT_G.exec(source); m; m = KIND_KEY_TEXT_G.exec(source)) keys.push(m.index);
-  let keyIndex = 0;
-  const excluded = options.excludeLiteralContexts ? literalRanges(source) : [];
-  let excludedIndex = 0;
-  for (let start = frontMatterEnd(source); start < source.length; start++) {
-    while (excludedIndex < excluded.length && excluded[excludedIndex][1] <= start) {
-      excludedIndex++;
-    }
-    if (excludedIndex < excluded.length && start >= excluded[excludedIndex][0] && start < excluded[excludedIndex][1]) {
-      start = excluded[excludedIndex][1] - 1;
-      continue;
-    }
-    const char = source[start];
-    if (char !== "{" && char !== "[") continue;
-    while (keyIndex < keys.length && keys[keyIndex] < start) keyIndex++;
-    if (keyIndex >= keys.length) break;
-    const key = keys[keyIndex];
-    const verdict = kindGrammar(source, "json", start);
-    if (verdict.status === "complete") {
-      try {
-        JSON.parse(source.slice(start, verdict.end));
-        start = verdict.end - 1;
-      } catch {
-      }
-      continue;
-    }
-    if (verdict.status === "prefix") {
-      broken.push({ start, end: source.length, content: source.slice(start) });
-      break;
-    }
-    if (verdict.at <= key) continue;
-    const end = endOf(start);
-    if (end !== null && lenientJson(source.slice(start, end))) {
-      broken.push({ start, end, content: source.slice(start, end) });
-      start = end - 1;
-      continue;
-    }
-    if (verdict.cut <= key) continue;
-    broken.push({ start, end: verdict.cut, content: source.slice(start, verdict.cut) });
-    start = verdict.cut - 1;
-  }
-  return broken;
-}
-function lenientJson(span) {
-  try {
-    JSON.parse(span.replace(/,(\s*[}\]])/g, "$1"));
-    return true;
-  } catch {
-    return false;
-  }
-}
-export {
-  balancedEnds,
-  findBrokenKindJsonRegions,
-  findEmbeddedKindJsonRegions,
-  findKindCarryingJsonValues,
-  frontMatterEnd2 as frontMatterEnd,
-  normalizeRecoveredContainerPiece,
-  normalizeRecoveredProsePiece,
-  splitAroundEmbeddedKindJson
-};