@nexkit/json-repair 1.0.0

package/dist/index.cjs

@@ -0,0 +1,2400 @@
+'use strict';
+
+// src/scanner/tokens.ts
+var CH_OPEN_BRACE = 123;
+var CH_CLOSE_BRACE = 125;
+var CH_OPEN_BRACKET = 91;
+var CH_CLOSE_BRACKET = 93;
+var CH_COLON = 58;
+var CH_COMMA = 44;
+var CH_DOUBLE_QUOTE = 34;
+var CH_SINGLE_QUOTE = 39;
+var CH_BACKTICK = 96;
+var CH_LEFT_SINGLE_QUOTE = 8216;
+var CH_RIGHT_SINGLE_QUOTE = 8217;
+var CH_SINGLE_LOW_QUOTE = 8218;
+var CH_SINGLE_HIGH_REVERSED = 8219;
+var CH_LEFT_DOUBLE_QUOTE = 8220;
+var CH_RIGHT_DOUBLE_QUOTE = 8221;
+var CH_DOUBLE_LOW_QUOTE = 8222;
+var CH_DOUBLE_HIGH_REVERSED = 8223;
+var CH_BACKSLASH = 92;
+var CH_SLASH = 47;
+var CH_ASTERISK = 42;
+var CH_HASH = 35;
+var CH_MINUS = 45;
+var CH_PLUS = 43;
+var CH_DOT = 46;
+var CH_UNDERSCORE = 95;
+var CH_DOLLAR = 36;
+var CH_TAB = 9;
+var CH_LINE_FEED = 10;
+var CH_VERTICAL_TAB = 11;
+var CH_FORM_FEED = 12;
+var CH_CARRIAGE_RETURN = 13;
+var CH_SPACE = 32;
+var CH_NBSP = 160;
+var CH_BOM = 65279;
+var CH_LOWER_A = 97;
+var CH_LOWER_B = 98;
+var CH_LOWER_E = 101;
+var CH_LOWER_F = 102;
+var CH_LOWER_N = 110;
+var CH_LOWER_R = 114;
+var CH_LOWER_T = 116;
+var CH_LOWER_U = 117;
+var CH_LOWER_X = 120;
+var CH_LOWER_Z = 122;
+var CH_UPPER_A = 65;
+var CH_UPPER_E = 69;
+var CH_UPPER_F = 70;
+var CH_UPPER_X = 88;
+var CH_UPPER_Z = 90;
+var CH_ZERO = 48;
+var CH_NINE = 57;
+var CH_HIGH_SURROGATE_START = 55296;
+var CH_HIGH_SURROGATE_END = 56319;
+var CH_LOW_SURROGATE_START = 56320;
+var CH_LOW_SURROGATE_END = 57343;
+var CH_EOF = -1;
+function isWhitespace(code) {
+  switch (code) {
+    case CH_SPACE:
+    case CH_TAB:
+    case CH_LINE_FEED:
+    case CH_CARRIAGE_RETURN:
+    case CH_VERTICAL_TAB:
+    case CH_FORM_FEED:
+    case CH_NBSP:
+    case CH_BOM:
+    case 5760:
+    /* OGHAM SPACE MARK */
+    case 8232:
+    /* LINE SEPARATOR */
+    case 8233:
+    /* PARAGRAPH SEPARATOR */
+    case 8239:
+    /* NARROW NO-BREAK SPACE */
+    case 8287:
+    /* MEDIUM MATHEMATICAL SPACE */
+    case 12288:
+      return true;
+    default:
+      return code >= 8192 && code <= 8202;
+  }
+}
+function isJsonWhitespace(code) {
+  return code === CH_SPACE || code === CH_TAB || code === CH_LINE_FEED || code === CH_CARRIAGE_RETURN;
+}
+function isLineBreak(code) {
+  return code === CH_LINE_FEED || code === CH_CARRIAGE_RETURN;
+}
+function isDigit(code) {
+  return code >= CH_ZERO && code <= CH_NINE;
+}
+function isHexDigit(code) {
+  return code >= CH_ZERO && code <= CH_NINE || code >= CH_UPPER_A && code <= CH_UPPER_F || code >= CH_LOWER_A && code <= CH_LOWER_F;
+}
+function isQuote(code) {
+  switch (code) {
+    case CH_DOUBLE_QUOTE:
+    case CH_SINGLE_QUOTE:
+    case CH_BACKTICK:
+    case CH_LEFT_SINGLE_QUOTE:
+    case CH_RIGHT_SINGLE_QUOTE:
+    case CH_SINGLE_LOW_QUOTE:
+    case CH_SINGLE_HIGH_REVERSED:
+    case CH_LEFT_DOUBLE_QUOTE:
+    case CH_RIGHT_DOUBLE_QUOTE:
+    case CH_DOUBLE_LOW_QUOTE:
+    case CH_DOUBLE_HIGH_REVERSED:
+      return true;
+    default:
+      return false;
+  }
+}
+function closersFor(code) {
+  switch (code) {
+    case CH_LEFT_DOUBLE_QUOTE:
+    case CH_DOUBLE_LOW_QUOTE:
+    case CH_DOUBLE_HIGH_REVERSED:
+      return [CH_RIGHT_DOUBLE_QUOTE, code];
+    case CH_RIGHT_DOUBLE_QUOTE:
+      return [CH_RIGHT_DOUBLE_QUOTE, CH_LEFT_DOUBLE_QUOTE];
+    case CH_LEFT_SINGLE_QUOTE:
+    case CH_SINGLE_LOW_QUOTE:
+    case CH_SINGLE_HIGH_REVERSED:
+      return [CH_RIGHT_SINGLE_QUOTE, code];
+    case CH_RIGHT_SINGLE_QUOTE:
+      return [CH_RIGHT_SINGLE_QUOTE, CH_LEFT_SINGLE_QUOTE];
+    default:
+      return [code, -1];
+  }
+}
+function isStandardQuote(code) {
+  return code === CH_DOUBLE_QUOTE;
+}
+function isIdentifierStart(code) {
+  return code >= CH_LOWER_A && code <= CH_LOWER_Z || code >= CH_UPPER_A && code <= CH_UPPER_Z || code === CH_UNDERSCORE || code === CH_DOLLAR || code >= 192;
+}
+function isIdentifierPart(code) {
+  return isIdentifierStart(code) || isDigit(code) || code === CH_MINUS || code === CH_DOT;
+}
+function isStructural(code) {
+  switch (code) {
+    case CH_OPEN_BRACE:
+    case CH_CLOSE_BRACE:
+    case CH_OPEN_BRACKET:
+    case CH_CLOSE_BRACKET:
+    case CH_COLON:
+    case CH_COMMA:
+    case CH_EOF:
+      return true;
+    default:
+      return false;
+  }
+}
+function isHighSurrogate(code) {
+  return code >= CH_HIGH_SURROGATE_START && code <= CH_HIGH_SURROGATE_END;
+}
+function isLowSurrogate(code) {
+  return code >= CH_LOW_SURROGATE_START && code <= CH_LOW_SURROGATE_END;
+}
+function toLowerAscii(code) {
+  return code >= CH_UPPER_A && code <= CH_UPPER_Z ? code + 32 : code;
+}
+
+// src/scanner/scanner.ts
+var Scanner = class {
+  /** The original, uncut input. */
+  source;
+  /** First offset of the region being parsed. */
+  start;
+  /** Offset one past the last character of the region. */
+  end;
+  /** Current offset. Always within `[start, end]`. */
+  index;
+  /** Offsets at which each line begins; built lazily by {@link positionAt}. */
+  lineStarts;
+  constructor(source, start = 0, end = source.length) {
+    this.source = source;
+    this.start = start;
+    this.end = end;
+    this.index = start;
+  }
+  /** Reports whether the cursor has reached the end of the region. */
+  eof() {
+    return this.index >= this.end;
+  }
+  /** Returns the code unit at the cursor, or {@link CH_EOF} at the end. */
+  peek() {
+    return this.index < this.end ? this.source.charCodeAt(this.index) : CH_EOF;
+  }
+  /** Returns the text between two absolute offsets. */
+  slice(from, to) {
+    return this.source.slice(from, to);
+  }
+  /**
+   * Resolves an absolute offset to a one-based line and column.
+   *
+   * `\n`, `\r\n` and a lone `\r` all end a line. U+2028 and U+2029 do not:
+   * JSON treats them as ordinary string content, and counting them would make
+   * positions disagree with what an editor shows.
+   */
+  positionAt(offset) {
+    const starts = this.lineStarts ?? (this.lineStarts = buildLineStarts(this.source));
+    let low = 0;
+    let high = starts.length - 1;
+    while (low < high) {
+      const mid = low + high + 1 >>> 1;
+      if (starts[mid] <= offset) {
+        low = mid;
+      } else {
+        high = mid - 1;
+      }
+    }
+    return { line: low + 1, column: offset - starts[low] + 1 };
+  }
+};
+function buildLineStarts(source) {
+  const starts = [0];
+  const length = source.length;
+  for (let index = 0; index < length; index += 1) {
+    const code = source.charCodeAt(index);
+    if (code === CH_CARRIAGE_RETURN) {
+      if (index + 1 < length && source.charCodeAt(index + 1) === CH_LINE_FEED) {
+        index += 1;
+      }
+      starts.push(index + 1);
+    } else if (code === CH_LINE_FEED) {
+      starts.push(index + 1);
+    }
+  }
+  return starts;
+}
+
+// src/errors/JsonRepairError.ts
+var ERROR_BRAND = /* @__PURE__ */ Symbol.for("json-repair.error");
+var SNIPPET_RADIUS = 24;
+var JsonRepairError = class extends Error {
+  /** Always `'JsonRepairError'`, so the name survives minification. */
+  name = "JsonRepairError";
+  /** Stable, machine-readable failure reason. */
+  code;
+  /** Zero-based offset into the original input, in UTF-16 code units. */
+  position;
+  /** One-based line number in the original input. */
+  line;
+  /** One-based column number in the original input. */
+  column;
+  /** A short excerpt of the input around {@link JsonRepairError.position}. */
+  snippet;
+  /** Cross-realm brand; see {@link isJsonRepairError}. */
+  [ERROR_BRAND] = true;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.code = code;
+    this.position = details.position;
+    this.line = details.line;
+    this.column = details.column;
+    this.snippet = details.snippet;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  /**
+   * Reports whether a value is a {@link JsonRepairError}, including instances
+   * created by a different copy of this package.
+   *
+   * Prefer this over `instanceof` — see {@link ERROR_BRAND}.
+   */
+  static isJsonRepairError(value) {
+    return typeof value === "object" && value !== null && value[ERROR_BRAND] === true;
+  }
+};
+function isJsonRepairError(value) {
+  return JsonRepairError.isJsonRepairError(value);
+}
+function createError(code, message, source, position) {
+  const clamped = position < 0 ? 0 : position > source.length ? source.length : position;
+  const { line, column } = new Scanner(source).positionAt(clamped);
+  return new JsonRepairError(code, message, {
+    position: clamped,
+    line,
+    column,
+    snippet: buildSnippet(source, clamped)
+  });
+}
+function buildSnippet(source, position) {
+  const clamped = position < 0 ? 0 : position > source.length ? source.length : position;
+  const start = clamped - SNIPPET_RADIUS < 0 ? 0 : clamped - SNIPPET_RADIUS;
+  const end = clamped + SNIPPET_RADIUS > source.length ? source.length : clamped + SNIPPET_RADIUS;
+  let excerpt = "";
+  for (let index = start; index < end; index += 1) {
+    excerpt += escapeForDisplay(source.charCodeAt(index));
+  }
+  return `${start > 0 ? "\u2026" : ""}${excerpt}${end < source.length ? "\u2026" : ""}`;
+}
+function escapeForDisplay(code) {
+  switch (code) {
+    case 8:
+      return "\\b";
+    case 9:
+      return "\\t";
+    case 10:
+      return "\\n";
+    case 12:
+      return "\\f";
+    case 13:
+      return "\\r";
+  }
+  if (code < 32 || code === 127) {
+    return `\\u${code.toString(16).padStart(4, "0")}`;
+  }
+  return String.fromCharCode(code);
+}
+
+// src/limits.ts
+function assertString(input, parameter) {
+  if (typeof input !== "string") {
+    throw new JsonRepairError(
+      "INVALID_INPUT",
+      `Parameter "${parameter}" must be a string, received ${input === null ? "null" : typeof input}.`
+    );
+  }
+}
+function assertInputLength(input, maxLength) {
+  if (input.length > maxLength) {
+    throw new JsonRepairError(
+      "MAX_LENGTH_EXCEEDED",
+      `Input is ${input.length} characters, which exceeds the maximum of ${maxLength}.`,
+      { position: maxLength }
+    );
+  }
+}
+function assertStructuralDepth(source, start, end, maxDepth) {
+  let depth = 0;
+  let index = start;
+  while (index < end) {
+    const code = source.charCodeAt(index);
+    if (code === CH_DOUBLE_QUOTE) {
+      index = skipValidString(source, index + 1, end);
+      continue;
+    }
+    if (code === CH_OPEN_BRACE || code === CH_OPEN_BRACKET) {
+      depth += 1;
+      if (depth > maxDepth) {
+        throw createError(
+          "MAX_DEPTH_EXCEEDED",
+          `Nesting depth exceeds the maximum of ${maxDepth}.`,
+          source,
+          index
+        );
+      }
+    } else if (code === CH_CLOSE_BRACE || code === CH_CLOSE_BRACKET) {
+      depth -= 1;
+    }
+    index += 1;
+  }
+}
+function skipValidString(source, from, end) {
+  let index = from;
+  while (index < end) {
+    const code = source.charCodeAt(index);
+    if (code === CH_BACKSLASH) {
+      index += 2;
+      continue;
+    }
+    if (code === CH_DOUBLE_QUOTE) {
+      return index + 1;
+    }
+    index += 1;
+  }
+  return end;
+}
+
+// src/native.ts
+var parseJsonStrict = JSON.parse;
+
+// src/types.ts
+var REPAIR_TYPES = [
+  "removed-byte-order-mark",
+  "extracted-json",
+  "removed-comment",
+  "normalized-whitespace",
+  "removed-trailing-comma",
+  "removed-extra-comma",
+  "removed-stray-token",
+  "removed-trailing-content",
+  "removed-incomplete-member",
+  "added-missing-comma",
+  "added-missing-colon",
+  "added-missing-value",
+  "added-closing-brace",
+  "added-closing-bracket",
+  "normalized-quotes",
+  "normalized-literal",
+  "normalized-number",
+  "quoted-key",
+  "quoted-value",
+  "escaped-character",
+  "fixed-escape",
+  "terminated-string-at-eof",
+  "terminated-string-at-newline"
+];
+var MAX_SUPPORTED_DEPTH = 1024;
+
+// src/options.ts
+var DEFAULT_MAX_LENGTH = 1e7;
+var DEFAULT_MAX_DEPTH = 512;
+function resolveOptions(options) {
+  const source = asOptionBag(options);
+  const mode = resolveMode(source.mode);
+  return {
+    mode,
+    aggressive: mode === "aggressive",
+    extract: resolveFlag(source.extract, "extract", true),
+    allowComments: resolveFlag(source.allowComments, "allowComments", true),
+    allowSingleQuotes: resolveFlag(source.allowSingleQuotes, "allowSingleQuotes", true),
+    allowUnquotedKeys: resolveFlag(source.allowUnquotedKeys, "allowUnquotedKeys", true),
+    fixTrailingCommas: resolveFlag(source.fixTrailingCommas, "fixTrailingCommas", true),
+    fixMissingBrackets: resolveFlag(source.fixMissingBrackets, "fixMissingBrackets", true),
+    maxLength: resolveLimit(source.maxLength, "maxLength", DEFAULT_MAX_LENGTH, 1, Infinity),
+    maxDepth: resolveLimit(source.maxDepth, "maxDepth", DEFAULT_MAX_DEPTH, 1, MAX_SUPPORTED_DEPTH),
+    maxRepairs: resolveLimit(source.maxRepairs, "maxRepairs", Infinity, 0, Infinity),
+    returnMetadata: resolveFlag(source.returnMetadata, "returnMetadata", false)
+  };
+}
+function asOptionBag(options) {
+  if (options === void 0) {
+    return {};
+  }
+  if (typeof options !== "object" || options === null) {
+    throw new JsonRepairError(
+      "INVALID_INPUT",
+      `Options must be an object, received ${describe(options)}.`
+    );
+  }
+  return options;
+}
+function resolveExtractOptions(options) {
+  const source = asOptionBag(options);
+  const select = resolveSelect(source.select);
+  return { ...resolveOptions({ ...source, extract: true }), select };
+}
+function resolveSelect(select) {
+  if (select === void 0) {
+    return "best";
+  }
+  if (select !== "best" && select !== "first" && select !== "last" && select !== "largest") {
+    throw new JsonRepairError(
+      "INVALID_INPUT",
+      `Option "select" must be "best", "first", "last" or "largest", received ${describe(select)}.`
+    );
+  }
+  return select;
+}
+function withMode(options, mode) {
+  return { ...options, mode, aggressive: mode === "aggressive" };
+}
+function resolveMode(mode) {
+  if (mode === void 0) {
+    return "safe";
+  }
+  if (mode !== "safe" && mode !== "aggressive") {
+    throw new JsonRepairError(
+      "INVALID_INPUT",
+      `Option "mode" must be "safe" or "aggressive", received ${describe(mode)}.`
+    );
+  }
+  return mode;
+}
+function resolveFlag(value, name, fallback) {
+  if (value === void 0) {
+    return fallback;
+  }
+  if (typeof value !== "boolean") {
+    throw new JsonRepairError(
+      "INVALID_INPUT",
+      `Option "${name}" must be a boolean, received ${describe(value)}.`
+    );
+  }
+  return value;
+}
+function resolveLimit(value, name, fallback, min, max) {
+  if (value === void 0) {
+    return fallback;
+  }
+  if (typeof value !== "number" || Number.isNaN(value)) {
+    throw new JsonRepairError(
+      "INVALID_INPUT",
+      `Option "${name}" must be a number, received ${describe(value)}.`
+    );
+  }
+  if (value !== Infinity && !Number.isInteger(value)) {
+    throw new JsonRepairError(
+      "INVALID_INPUT",
+      `Option "${name}" must be an integer or Infinity, received ${value}.`
+    );
+  }
+  if (value < min || value > max) {
+    const ceiling = max === Infinity ? "Infinity" : String(max);
+    throw new JsonRepairError(
+      "INVALID_INPUT",
+      `Option "${name}" must be between ${min} and ${ceiling}, received ${value}.`
+    );
+  }
+  return value;
+}
+function describe(value) {
+  if (value === null) {
+    return "null";
+  }
+  switch (typeof value) {
+    case "string":
+      return JSON.stringify(value);
+    case "number":
+    case "boolean":
+    case "undefined":
+      return String(value);
+    case "bigint":
+      return `${String(value)}n`;
+    default:
+      return typeof value;
+  }
+}
+
+// src/repair/brackets.ts
+function closeUnterminated(ctx, kind, position) {
+  if (!ctx.options.fixMissingBrackets) {
+    ctx.fail(kind === "object" ? "Object is never closed" : "Array is never closed", position);
+  }
+  ctx.record(kind === "object" ? "added-closing-brace" : "added-closing-bracket", position);
+}
+function dropStrayCloser(ctx) {
+  const position = ctx.scanner.index;
+  const atEnd = position === ctx.lastContentIndex;
+  if (!atEnd && !ctx.options.aggressive) {
+    const character = ctx.scanner.peek() === CH_CLOSE_BRACE ? "}" : "]";
+    ctx.refuse(`Unexpected "${character}" with no matching opening bracket`, position);
+  }
+  ctx.record("removed-stray-token", position);
+  ctx.scanner.index = position + 1;
+}
+
+// src/repair/comments.ts
+function skipTrivia(ctx) {
+  const { scanner } = ctx;
+  const { source, end } = scanner;
+  const allowComments = ctx.options.allowComments;
+  let index = scanner.index;
+  for (; ; ) {
+    let exotic = -1;
+    while (index < end) {
+      const code2 = source.charCodeAt(index);
+      if (!isWhitespace(code2)) {
+        break;
+      }
+      if (exotic < 0 && !isJsonWhitespace(code2)) {
+        exotic = index;
+      }
+      index += 1;
+    }
+    if (exotic >= 0) {
+      scanner.index = index;
+      ctx.record("normalized-whitespace", exotic);
+    }
+    if (index >= end || !allowComments) {
+      break;
+    }
+    const commentStart = index;
+    const code = source.charCodeAt(index);
+    if (code === CH_HASH) {
+      index = skipToLineEnd(source, index + 1, end);
+    } else if (code === CH_SLASH && index + 1 < end) {
+      const nextCode = source.charCodeAt(index + 1);
+      if (nextCode === CH_SLASH) {
+        index = skipToLineEnd(source, index + 2, end);
+      } else if (nextCode === CH_ASTERISK) {
+        index = skipBlockComment(source, index + 2, end);
+      } else {
+        break;
+      }
+    } else {
+      break;
+    }
+    scanner.index = index;
+    ctx.record("removed-comment", commentStart);
+  }
+  scanner.index = index;
+}
+function scanTrivia(source, from, end, allowComments) {
+  let index = from;
+  for (; ; ) {
+    while (index < end && isWhitespace(source.charCodeAt(index))) {
+      index += 1;
+    }
+    if (index >= end || !allowComments) {
+      return index;
+    }
+    const code = source.charCodeAt(index);
+    if (code === CH_HASH) {
+      index = skipToLineEnd(source, index + 1, end);
+    } else if (code === CH_SLASH && index + 1 < end) {
+      const nextCode = source.charCodeAt(index + 1);
+      if (nextCode === CH_SLASH) {
+        index = skipToLineEnd(source, index + 2, end);
+      } else if (nextCode === CH_ASTERISK) {
+        index = skipBlockComment(source, index + 2, end);
+      } else {
+        return index;
+      }
+    } else {
+      return index;
+    }
+  }
+}
+function skipToLineEnd(source, from, end) {
+  let index = from;
+  while (index < end && !isLineBreak(source.charCodeAt(index))) {
+    index += 1;
+  }
+  return index;
+}
+function skipBlockComment(source, from, end) {
+  let index = from;
+  while (index < end) {
+    if (source.charCodeAt(index) === CH_ASTERISK && index + 1 < end && source.charCodeAt(index + 1) === CH_SLASH) {
+      return index + 2;
+    }
+    index += 1;
+  }
+  return end;
+}
+
+// src/repair/literals.ts
+function readLiteral(ctx, start, end) {
+  const { source } = ctx.scanner;
+  const length = end - start;
+  if (length < 3 || length > 9) {
+    return "not-a-literal";
+  }
+  const canonical = matchJsonLiteral(source, start, end, length);
+  if (canonical !== void 0) {
+    if (matchesExactly(source, start, canonical)) {
+      ctx.writeSpan(start, end);
+    } else {
+      ctx.write(canonical);
+      ctx.record("normalized-literal", start, `Rewrote a literal as ${canonical}`);
+    }
+    return "emitted";
+  }
+  const nullish = matchNullish(source, start, end, length);
+  if (nullish === void 0) {
+    return "not-a-literal";
+  }
+  if (nullish === "lossy" && !ctx.options.aggressive) {
+    return "needs-aggressive";
+  }
+  ctx.write("null");
+  ctx.record("normalized-literal", start, "Rewrote a non-JSON literal as null");
+  return "emitted";
+}
+function matchJsonLiteral(source, start, end, length) {
+  if (length === 4) {
+    if (matchesWord(source, start, end, "true")) {
+      return "true";
+    }
+    if (matchesWord(source, start, end, "null")) {
+      return "null";
+    }
+    return void 0;
+  }
+  if (length === 5 && matchesWord(source, start, end, "false")) {
+    return "false";
+  }
+  return void 0;
+}
+function matchNullish(source, start, end, length) {
+  switch (length) {
+    case 3:
+      return matchesWord(source, start, end, "nan") ? "lossy" : void 0;
+    case 4:
+      return matchesWord(source, start, end, "none") ? "equivalent" : void 0;
+    case 8:
+      return matchesWord(source, start, end, "infinity") ? "lossy" : void 0;
+    case 9:
+      return matchesWord(source, start, end, "undefined") || matchesWord(source, start, end, "-infinity") ? "lossy" : void 0;
+    default:
+      return void 0;
+  }
+}
+function matchesWord(source, start, end, word) {
+  if (end - start !== word.length) {
+    return false;
+  }
+  for (let offset = 0; offset < word.length; offset += 1) {
+    if (toLowerAscii(source.charCodeAt(start + offset)) !== word.charCodeAt(offset)) {
+      return false;
+    }
+  }
+  return true;
+}
+function matchesExactly(source, start, word) {
+  for (let offset = 0; offset < word.length; offset += 1) {
+    if (source.charCodeAt(start + offset) !== word.charCodeAt(offset)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/repair/numbers.ts
+function readNumber(ctx, start, end) {
+  const { source } = ctx.scanner;
+  if (isValidJsonNumber(source, start, end)) {
+    ctx.writeSpan(start, end);
+    return true;
+  }
+  const aggressive = ctx.options.aggressive;
+  let index = start;
+  let sign = "";
+  let normalized = false;
+  const first = source.charCodeAt(index);
+  if (first === CH_PLUS) {
+    index += 1;
+    normalized = true;
+  } else if (first === CH_MINUS) {
+    sign = "-";
+    index += 1;
+  }
+  if (aggressive && isHexPrefix(source, index, end)) {
+    return readHex(ctx, start, index, end, sign);
+  }
+  let usedUnderscore = false;
+  let integerDigits = "";
+  while (index < end) {
+    const code = source.charCodeAt(index);
+    if (isDigit(code)) {
+      integerDigits += source.charAt(index);
+    } else if (code === CH_UNDERSCORE) {
+      usedUnderscore = true;
+    } else {
+      break;
+    }
+    index += 1;
+  }
+  let fractionDigits = "";
+  let sawDot = false;
+  if (index < end && source.charCodeAt(index) === CH_DOT) {
+    sawDot = true;
+    index += 1;
+    while (index < end) {
+      const code = source.charCodeAt(index);
+      if (isDigit(code)) {
+        fractionDigits += source.charAt(index);
+      } else if (code === CH_UNDERSCORE) {
+        usedUnderscore = true;
+      } else {
+        break;
+      }
+      index += 1;
+    }
+  }
+  let exponent = "";
+  if (index < end) {
+    const code = source.charCodeAt(index);
+    if (code === CH_LOWER_E || code === CH_UPPER_E) {
+      let cursor = index + 1;
+      let exponentSign = "";
+      if (cursor < end) {
+        const signCode = source.charCodeAt(cursor);
+        if (signCode === CH_PLUS || signCode === CH_MINUS) {
+          exponentSign = signCode === CH_MINUS ? "-" : "";
+          cursor += 1;
+        }
+      }
+      const digitsStart = cursor;
+      while (cursor < end && isDigit(source.charCodeAt(cursor))) {
+        cursor += 1;
+      }
+      if (cursor > digitsStart) {
+        exponent = `e${exponentSign}${source.slice(digitsStart, cursor)}`;
+      } else {
+        normalized = true;
+      }
+      index = cursor;
+    }
+  }
+  if (index !== end || integerDigits.length === 0 && fractionDigits.length === 0) {
+    return false;
+  }
+  if (usedUnderscore) {
+    if (!aggressive) {
+      return false;
+    }
+    normalized = true;
+  }
+  let integerPart = integerDigits;
+  if (integerPart.length === 0) {
+    integerPart = "0";
+    normalized = true;
+  } else if (integerPart.length > 1 && integerPart.charCodeAt(0) === CH_ZERO) {
+    if (!aggressive) {
+      return false;
+    }
+    let cut = 0;
+    while (cut < integerPart.length - 1 && integerPart.charCodeAt(cut) === CH_ZERO) {
+      cut += 1;
+    }
+    integerPart = integerPart.slice(cut);
+    normalized = true;
+  }
+  if (sawDot && fractionDigits.length === 0) {
+    normalized = true;
+  }
+  if (!normalized) {
+    return false;
+  }
+  ctx.write(sign);
+  ctx.write(integerPart);
+  if (fractionDigits.length > 0) {
+    ctx.write(".");
+    ctx.write(fractionDigits);
+  }
+  ctx.write(exponent);
+  ctx.record("normalized-number", start);
+  return true;
+}
+function isValidJsonNumber(source, start, end) {
+  let index = start;
+  if (index < end && source.charCodeAt(index) === CH_MINUS) {
+    index += 1;
+  }
+  if (index >= end) {
+    return false;
+  }
+  if (source.charCodeAt(index) === CH_ZERO) {
+    index += 1;
+  } else {
+    if (!isDigit(source.charCodeAt(index))) {
+      return false;
+    }
+    while (index < end && isDigit(source.charCodeAt(index))) {
+      index += 1;
+    }
+  }
+  if (index < end && source.charCodeAt(index) === CH_DOT) {
+    index += 1;
+    const digitsStart = index;
+    while (index < end && isDigit(source.charCodeAt(index))) {
+      index += 1;
+    }
+    if (index === digitsStart) {
+      return false;
+    }
+  }
+  if (index < end) {
+    const code = source.charCodeAt(index);
+    if (code !== CH_LOWER_E && code !== CH_UPPER_E) {
+      return false;
+    }
+    index += 1;
+    if (index < end) {
+      const signCode = source.charCodeAt(index);
+      if (signCode === CH_PLUS || signCode === CH_MINUS) {
+        index += 1;
+      }
+    }
+    const digitsStart = index;
+    while (index < end && isDigit(source.charCodeAt(index))) {
+      index += 1;
+    }
+    if (index === digitsStart) {
+      return false;
+    }
+  }
+  return index === end;
+}
+function isHexPrefix(source, index, end) {
+  if (index + 2 >= end || source.charCodeAt(index) !== CH_ZERO) {
+    return false;
+  }
+  const marker = source.charCodeAt(index + 1);
+  return marker === CH_LOWER_X || marker === CH_UPPER_X;
+}
+function readHex(ctx, start, prefixStart, end, sign) {
+  const { source } = ctx.scanner;
+  const digitsStart = prefixStart + 2;
+  let index = digitsStart;
+  while (index < end && isHexDigit(source.charCodeAt(index))) {
+    index += 1;
+  }
+  if (index !== end || index === digitsStart) {
+    return false;
+  }
+  const value = BigInt(source.slice(prefixStart, end));
+  ctx.write(sign);
+  ctx.write(value.toString());
+  ctx.record("normalized-number", start);
+  return true;
+}
+
+// src/parser/probe.ts
+var PROBE_WINDOW = 256;
+var SCAN_UNTERMINATED = -1;
+var SCAN_BUDGET = -2;
+function probeContinuation(ctx, from, slot) {
+  if (ctx.probeBudget <= 0) {
+    return true;
+  }
+  const { source, end } = ctx.scanner;
+  const window = end < from + PROBE_WINDOW ? end : from + PROBE_WINDOW;
+  const allowComments = ctx.options.allowComments;
+  const aggressive = ctx.options.aggressive;
+  const index = scanTrivia(source, from, window, allowComments);
+  ctx.probeBudget -= index - from + 1;
+  if (index >= end) {
+    return true;
+  }
+  if (index >= window) {
+    return true;
+  }
+  const code = source.charCodeAt(index);
+  switch (slot) {
+    case "object-key":
+      if (code === CH_COLON) {
+        return true;
+      }
+      return aggressive && (code === CH_COMMA || code === CH_CLOSE_BRACE);
+    case "object-value":
+      if (code === CH_CLOSE_BRACE || code === CH_CLOSE_BRACKET) {
+        return true;
+      }
+      if (code === CH_COMMA) {
+        return looksLikeMember(ctx, index + 1, window, allowComments);
+      }
+      if (isQuote(code) || isIdentifierStart(code)) {
+        return looksLikeMember(ctx, index, window, allowComments);
+      }
+      return false;
+    case "array-element":
+    case "document":
+      if (code === CH_CLOSE_BRACKET || code === CH_CLOSE_BRACE) {
+        return true;
+      }
+      if (code === CH_COMMA) {
+        return looksLikeElement(ctx, index + 1, window, allowComments);
+      }
+      if (isQuote(code)) {
+        return looksLikeElement(ctx, index, window, allowComments);
+      }
+      return false;
+    default:
+      return true;
+  }
+}
+function looksLikeMember(ctx, from, window, allowComments) {
+  const { source, end } = ctx.scanner;
+  const keyStart = scanTrivia(source, from, window, allowComments);
+  ctx.probeBudget -= keyStart - from + 1;
+  if (keyStart >= end || keyStart >= window) {
+    return true;
+  }
+  const code = source.charCodeAt(keyStart);
+  if (code === CH_CLOSE_BRACE || code === CH_COMMA) {
+    return true;
+  }
+  const keyEnd = scanKey(source, keyStart, window, end);
+  ctx.probeBudget -= (keyEnd < 0 ? window - keyStart : keyEnd - keyStart) + 1;
+  if (keyEnd === SCAN_BUDGET) {
+    return true;
+  }
+  if (keyEnd < 0) {
+    return false;
+  }
+  const afterKey = scanTrivia(source, keyEnd, window, allowComments);
+  if (afterKey >= end || afterKey >= window) {
+    return true;
+  }
+  return source.charCodeAt(afterKey) === CH_COLON;
+}
+function looksLikeElement(ctx, from, window, allowComments) {
+  const { source, end } = ctx.scanner;
+  const valueStart = scanTrivia(source, from, window, allowComments);
+  ctx.probeBudget -= valueStart - from + 1;
+  if (valueStart >= end || valueStart >= window) {
+    return true;
+  }
+  const code = source.charCodeAt(valueStart);
+  if (code === CH_CLOSE_BRACKET || code === CH_COMMA) {
+    return true;
+  }
+  const valueEnd = scanValueToken(source, valueStart, window, end);
+  ctx.probeBudget -= (valueEnd < 0 ? window - valueStart : valueEnd - valueStart) + 1;
+  if (valueEnd === SCAN_BUDGET) {
+    return true;
+  }
+  if (valueEnd < 0) {
+    return false;
+  }
+  const afterValue = scanTrivia(source, valueEnd, window, allowComments);
+  if (afterValue >= end || afterValue >= window) {
+    return true;
+  }
+  const next = source.charCodeAt(afterValue);
+  return next === CH_COMMA || next === CH_CLOSE_BRACKET;
+}
+function scanKey(source, from, window, end) {
+  const code = source.charCodeAt(from);
+  if (isQuote(code)) {
+    return scanString(source, from, window, end);
+  }
+  if (!isIdentifierStart(code)) {
+    return SCAN_UNTERMINATED;
+  }
+  let index = from + 1;
+  while (index < window && isIdentifierPart(source.charCodeAt(index))) {
+    index += 1;
+  }
+  return index >= window && index < end ? SCAN_BUDGET : index;
+}
+function scanValueToken(source, from, window, end) {
+  const code = source.charCodeAt(from);
+  if (isQuote(code)) {
+    return scanString(source, from, window, end);
+  }
+  if (code === CH_OPEN_BRACE || code === CH_OPEN_BRACKET) {
+    return SCAN_BUDGET;
+  }
+  if (!isDigit(code) && !isIdentifierStart(code) && code !== CH_MINUS && code !== CH_PLUS) {
+    return SCAN_UNTERMINATED;
+  }
+  let index = from + 1;
+  while (index < window) {
+    const next = source.charCodeAt(index);
+    if (!isIdentifierPart(next) && !isDigit(next) && next !== CH_PLUS && next !== CH_DOT) {
+      break;
+    }
+    index += 1;
+  }
+  return index >= window && index < end ? SCAN_BUDGET : index;
+}
+function scanString(source, from, window, end) {
+  const opener = source.charCodeAt(from);
+  const closers = closersFor(opener);
+  let index = from + 1;
+  while (index < window) {
+    const code = source.charCodeAt(index);
+    if (code === CH_BACKSLASH) {
+      index += 2;
+      continue;
+    }
+    if (code === closers[0] || code === closers[1]) {
+      return index + 1;
+    }
+    index += 1;
+  }
+  return index >= end ? SCAN_UNTERMINATED : SCAN_BUDGET;
+}
+
+// src/repair/quotes.ts
+var ESC_SHORT = 2;
+var ESC_UNICODE = 6;
+var ESC_DANGLING = -1;
+var ESC_TRUNCATED_UNICODE = -2;
+var ESC_BAD_UNICODE = -3;
+var ESC_QUOTE = -4;
+var ESC_CONTROL = -5;
+var ESC_UNKNOWN = -6;
+function readString(ctx, slot) {
+  const { scanner } = ctx;
+  const { source, end } = scanner;
+  const start = scanner.index;
+  const opener = source.charCodeAt(start);
+  const standard = isStandardQuote(opener);
+  const closers = closersFor(opener);
+  const closerA = closers[0];
+  const closerB = closers[1];
+  if (!standard) {
+    ctx.record("normalized-quotes", start);
+  }
+  ctx.write('"');
+  let index = start + 1;
+  let spanStart = index;
+  let checkpoint;
+  let reportedControlEnd = -1;
+  while (index < end) {
+    const code = source.charCodeAt(index);
+    if (code === CH_BACKSLASH) {
+      const kind = classifyEscape(source, index, end);
+      if (kind >= 0) {
+        index += kind;
+        continue;
+      }
+      ctx.writeSpan(spanStart, index);
+      switch (kind) {
+        case ESC_DANGLING:
+          ctx.record("fixed-escape", index, "Removed a trailing backslash with nothing to escape");
+          index = end;
+          break;
+        case ESC_TRUNCATED_UNICODE:
+          ctx.record("fixed-escape", index, "Removed a truncated \\u escape at end of input");
+          index = end;
+          break;
+        case ESC_BAD_UNICODE:
+          ctx.write("\\\\u");
+          ctx.record("fixed-escape", index, "Escaped an incomplete \\u sequence");
+          index += 2;
+          break;
+        case ESC_QUOTE: {
+          const quoted = source.charCodeAt(index + 1);
+          ctx.write(quoted === CH_DOUBLE_QUOTE ? '\\"' : source[index + 1]);
+          ctx.record("fixed-escape", index, "Unescaped a quote that JSON does not escape");
+          index += 2;
+          break;
+        }
+        case ESC_CONTROL:
+          ctx.write(escapeControl(source.charCodeAt(index + 1)));
+          ctx.record("fixed-escape", index, "Replaced a backslash before a control character");
+          index += 2;
+          break;
+        default:
+          ctx.write("\\\\");
+          ctx.write(source[index + 1]);
+          ctx.record("fixed-escape", index, "Escaped a backslash that began an unknown sequence");
+          index += 2;
+          break;
+      }
+      spanStart = index;
+      continue;
+    }
+    if (code === closerA || code === closerB) {
+      if (probeContinuation(ctx, index + 1, slot)) {
+        ctx.writeSpan(spanStart, index);
+        ctx.write('"');
+        scanner.index = index + 1;
+        return;
+      }
+      if (standard && !ctx.options.aggressive) {
+        if (checkpoint !== void 0 && ctx.canRewindTo(checkpoint)) {
+          closeAtCheckpoint(ctx, checkpoint);
+          return;
+        }
+        ctx.writeSpan(spanStart, index);
+        ctx.write('"');
+        scanner.index = index + 1;
+        return;
+      }
+      ctx.writeSpan(spanStart, index);
+      if (standard) {
+        ctx.write('\\"');
+        ctx.record("escaped-character", index, "Escaped a quote inside a string");
+      } else {
+        ctx.write(source[index]);
+      }
+      index += 1;
+      spanStart = index;
+      continue;
+    }
+    if (code < 32) {
+      ctx.writeSpan(spanStart, index);
+      if (code === CH_LINE_FEED || code === CH_CARRIAGE_RETURN) {
+        checkpoint = ctx.checkpoint(index);
+      }
+      if (index !== reportedControlEnd) {
+        ctx.record("escaped-character", index, "Escaped a raw control character in a string");
+      }
+      reportedControlEnd = index + 1;
+      ctx.write(escapeControl(code));
+      index += 1;
+      spanStart = index;
+      continue;
+    }
+    if (code === CH_DOUBLE_QUOTE) {
+      ctx.writeSpan(spanStart, index);
+      ctx.write('\\"');
+      index += 1;
+      spanStart = index;
+      continue;
+    }
+    if (isHighSurrogate(code)) {
+      if (index + 1 < end && isLowSurrogate(source.charCodeAt(index + 1))) {
+        index += 2;
+        continue;
+      }
+      index = escapeStrayUnit(ctx, spanStart, index, code);
+      spanStart = index;
+      continue;
+    }
+    if (isLowSurrogate(code)) {
+      index = escapeStrayUnit(ctx, spanStart, index, code);
+      spanStart = index;
+      continue;
+    }
+    index += 1;
+  }
+  ctx.writeSpan(spanStart, index);
+  if (checkpoint !== void 0 && ctx.canRewindTo(checkpoint) && tailIsStructural(source, checkpoint.index, end)) {
+    closeAtCheckpoint(ctx, checkpoint);
+    return;
+  }
+  ctx.write('"');
+  ctx.record("terminated-string-at-eof", end);
+  scanner.index = end;
+}
+function writeQuotedSpan(ctx, from, to) {
+  const { source } = ctx.scanner;
+  ctx.write('"');
+  let spanStart = from;
+  for (let index = from; index < to; index += 1) {
+    const code = source.charCodeAt(index);
+    let replacement;
+    if (code === CH_DOUBLE_QUOTE) {
+      replacement = '\\"';
+    } else if (code === CH_BACKSLASH) {
+      replacement = "\\\\";
+    } else if (code < 32) {
+      replacement = escapeControl(code);
+    } else if (isHighSurrogate(code)) {
+      if (index + 1 < to && isLowSurrogate(source.charCodeAt(index + 1))) {
+        index += 1;
+        continue;
+      }
+      replacement = escapeUnit(code);
+    } else if (isLowSurrogate(code)) {
+      replacement = escapeUnit(code);
+    }
+    if (replacement !== void 0) {
+      ctx.writeSpan(spanStart, index);
+      ctx.write(replacement);
+      spanStart = index + 1;
+    }
+  }
+  ctx.writeSpan(spanStart, to);
+  ctx.write('"');
+}
+function escapeStrayUnit(ctx, spanStart, index, code) {
+  ctx.writeSpan(spanStart, index);
+  ctx.write(escapeUnit(code));
+  ctx.record("escaped-character", index, "Escaped an unpaired surrogate");
+  return index + 1;
+}
+function closeAtCheckpoint(ctx, checkpoint) {
+  ctx.rewindTo(checkpoint);
+  ctx.write('"');
+  ctx.record("terminated-string-at-newline", checkpoint.index);
+}
+function classifyEscape(source, index, end) {
+  if (index + 1 >= end) {
+    return ESC_DANGLING;
+  }
+  const escaped = source.charCodeAt(index + 1);
+  switch (escaped) {
+    case CH_DOUBLE_QUOTE:
+    case CH_BACKSLASH:
+    case CH_SLASH:
+    case CH_LOWER_B:
+    case CH_LOWER_F:
+    case CH_LOWER_N:
+    case CH_LOWER_R:
+    case CH_LOWER_T:
+      return ESC_SHORT;
+    case CH_LOWER_U:
+      if (index + 5 < end && isHexDigit(source.charCodeAt(index + 2)) && isHexDigit(source.charCodeAt(index + 3)) && isHexDigit(source.charCodeAt(index + 4)) && isHexDigit(source.charCodeAt(index + 5))) {
+        return ESC_UNICODE;
+      }
+      return index + 6 > end ? ESC_TRUNCATED_UNICODE : ESC_BAD_UNICODE;
+  }
+  if (isQuote(escaped)) {
+    return ESC_QUOTE;
+  }
+  return escaped < 32 ? ESC_CONTROL : ESC_UNKNOWN;
+}
+function tailIsStructural(source, from, end) {
+  for (let index = from; index < end; index += 1) {
+    const code = source.charCodeAt(index);
+    if (code === CH_CLOSE_BRACE || code === CH_CLOSE_BRACKET || code === CH_COMMA || isWhitespace(code)) {
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+function escapeControl(code) {
+  switch (code) {
+    case 8:
+      return "\\b";
+    case 9:
+      return "\\t";
+    case 10:
+      return "\\n";
+    case 12:
+      return "\\f";
+    case 13:
+      return "\\r";
+    default:
+      return escapeUnit(code);
+  }
+}
+function escapeUnit(code) {
+  return `\\u${code.toString(16).padStart(4, "0")}`;
+}
+
+// src/repair/trailing-comma.ts
+function readSeparator(ctx) {
+  skipTrivia(ctx);
+  const code = ctx.scanner.peek();
+  if (code === CH_COMMA) {
+    const commaPosition = ctx.scanner.index;
+    ctx.scanner.index += 1;
+    skipTrivia(ctx);
+    const next = ctx.scanner.peek();
+    if (next === CH_CLOSE_BRACE || next === CH_CLOSE_BRACKET || next === CH_EOF) {
+      if (!ctx.options.fixTrailingCommas) {
+        ctx.fail("Trailing comma before the end of the container", commaPosition);
+      }
+      ctx.record("removed-trailing-comma", commaPosition);
+      return "trailing-comma";
+    }
+    return "comma";
+  }
+  if (code === CH_CLOSE_BRACE || code === CH_CLOSE_BRACKET || code === CH_EOF) {
+    return "end";
+  }
+  ctx.record("added-missing-comma", ctx.scanner.index);
+  return "missing";
+}
+
+// src/parser/parser.ts
+function parseDocument(ctx) {
+  skipTrivia(ctx);
+  if (ctx.scanner.eof()) {
+    throw ctx.error("NO_JSON_FOUND", "No JSON value found", ctx.scanner.index);
+  }
+  if (parseValue(ctx, "document", false) === "dropped") {
+    throw ctx.error("NO_JSON_FOUND", "No JSON value found", ctx.scanner.index);
+  }
+}
+function parseValue(ctx, slot, mayDrop) {
+  const { scanner } = ctx;
+  for (; ; ) {
+    skipTrivia(ctx);
+    const start = scanner.index;
+    const code = scanner.peek();
+    if (code === CH_EOF) {
+      return "dropped";
+    }
+    if (code === CH_OPEN_BRACE) {
+      return parseObject(ctx, mayDrop);
+    }
+    if (code === CH_OPEN_BRACKET) {
+      return parseArray(ctx, mayDrop);
+    }
+    if (isQuote(code)) {
+      if (code !== CH_DOUBLE_QUOTE && !ctx.options.allowSingleQuotes) {
+        ctx.fail("Non-standard string delimiter, and allowSingleQuotes is disabled", start);
+      }
+      readString(ctx, slot);
+      return "ok";
+    }
+    if (code === CH_CLOSE_BRACE || code === CH_CLOSE_BRACKET || code === CH_COMMA || code === CH_COLON) {
+      if (!ctx.options.aggressive) {
+        ctx.refuse("Expected a value", start);
+      }
+      ctx.write("null");
+      ctx.record("added-missing-value", start);
+      return "ok";
+    }
+    const coreEnd = scanCoreToken(ctx, start);
+    if (coreEnd > start) {
+      return parseBareValue(ctx, start, coreEnd);
+    }
+    if (!ctx.options.aggressive) {
+      ctx.fail(`Unexpected character ${describeChar(scanner.source, start)}`, start);
+    }
+    ctx.record("removed-stray-token", start);
+    scanner.index = start + 1;
+  }
+}
+function parseObject(ctx, mayDrop) {
+  const { scanner } = ctx;
+  const openPosition = scanner.index;
+  const entry = ctx.checkpoint(openPosition);
+  scanner.index += 1;
+  ctx.enter(openPosition);
+  ctx.openBraces += 1;
+  ctx.write("{");
+  let members = 0;
+  let closed = false;
+  let truncated = false;
+  let previousIndex = -1;
+  for (; ; ) {
+    skipTrivia(ctx);
+    if (scanner.index === previousIndex) {
+      ctx.fail("Parser made no progress", scanner.index);
+    }
+    previousIndex = scanner.index;
+    const code = scanner.peek();
+    if (code === CH_EOF) {
+      closeUnterminated(ctx, "object", scanner.index);
+      truncated = true;
+      break;
+    }
+    if (code === CH_CLOSE_BRACE) {
+      scanner.index += 1;
+      closed = true;
+      break;
+    }
+    if (code === CH_CLOSE_BRACKET) {
+      if (ctx.openBrackets > 0) {
+        closeUnterminated(ctx, "object", scanner.index);
+        break;
+      }
+      dropStrayCloser(ctx);
+      continue;
+    }
+    if (code === CH_COMMA) {
+      ctx.record("removed-extra-comma", scanner.index);
+      scanner.index += 1;
+      continue;
+    }
+    if (!canStartKey(ctx, code)) {
+      if (!ctx.options.aggressive) {
+        ctx.fail(
+          `Expected an object key, found ${describeChar(scanner.source, scanner.index)}`,
+          scanner.index
+        );
+      }
+      ctx.record("removed-stray-token", scanner.index);
+      scanner.index += 1;
+      continue;
+    }
+    const slot = ctx.checkpoint(scanner.index);
+    if (members > 0) {
+      ctx.write(",");
+    }
+    if (parseMember(ctx) === "dropped") {
+      ctx.restore(slot);
+      scanner.index = scanner.end;
+      ctx.record("removed-incomplete-member", slot.index);
+      closeUnterminated(ctx, "object", slot.index);
+      truncated = true;
+      break;
+    }
+    members += 1;
+    readSeparator(ctx);
+  }
+  ctx.write("}");
+  ctx.openBraces -= 1;
+  ctx.leave();
+  if (mayDrop && truncated && !closed && members === 0) {
+    ctx.restore(entry);
+    scanner.index = scanner.end;
+    return "dropped";
+  }
+  return "ok";
+}
+function parseMember(ctx) {
+  const { scanner } = ctx;
+  parseKey(ctx);
+  skipTrivia(ctx);
+  const afterKey = scanner.index;
+  const next = scanner.peek();
+  if (next === CH_EOF) {
+    return "dropped";
+  }
+  if (next === CH_COLON) {
+    scanner.index += 1;
+  } else if (next === CH_CLOSE_BRACE || next === CH_COMMA) {
+    if (!ctx.options.aggressive) {
+      ctx.refuse("Object key has no value", afterKey);
+    }
+    ctx.record("added-missing-colon", afterKey);
+    ctx.write(":null");
+    ctx.record("added-missing-value", afterKey);
+    return "ok";
+  } else if (isQuote(next)) {
+    if (!ctx.options.aggressive) {
+      ctx.refuse('Expected ":" between key and value', afterKey);
+    }
+    ctx.record("added-missing-colon", afterKey);
+  } else {
+    ctx.record("added-missing-colon", afterKey);
+  }
+  ctx.write(":");
+  return parseValue(ctx, "object-value", true);
+}
+function parseKey(ctx) {
+  const { scanner } = ctx;
+  const { source, end } = scanner;
+  const start = scanner.index;
+  const code = scanner.peek();
+  if (isQuote(code)) {
+    readString(ctx, "object-key");
+    return;
+  }
+  let index = start;
+  if (isIdentifierStart(code)) {
+    index += 1;
+    while (index < end && isIdentifierPart(source.charCodeAt(index))) {
+      index += 1;
+    }
+  } else {
+    index = scanBareKey(ctx, start);
+  }
+  writeQuotedSpan(ctx, start, index);
+  ctx.record("quoted-key", start);
+  scanner.index = index;
+}
+function canStartKey(ctx, code) {
+  if (isQuote(code)) {
+    return code === CH_DOUBLE_QUOTE || ctx.options.allowSingleQuotes;
+  }
+  if (!ctx.options.allowUnquotedKeys) {
+    return false;
+  }
+  if (isIdentifierStart(code)) {
+    return true;
+  }
+  return ctx.options.aggressive && !isStructural(code);
+}
+function parseArray(ctx, mayDrop) {
+  const { scanner } = ctx;
+  const openPosition = scanner.index;
+  const entry = ctx.checkpoint(openPosition);
+  scanner.index += 1;
+  ctx.enter(openPosition);
+  ctx.openBrackets += 1;
+  ctx.write("[");
+  let elements = 0;
+  let closed = false;
+  let truncated = false;
+  let previousIndex = -1;
+  for (; ; ) {
+    skipTrivia(ctx);
+    if (scanner.index === previousIndex) {
+      ctx.fail("Parser made no progress", scanner.index);
+    }
+    previousIndex = scanner.index;
+    const code = scanner.peek();
+    if (code === CH_EOF) {
+      closeUnterminated(ctx, "array", scanner.index);
+      truncated = true;
+      break;
+    }
+    if (code === CH_CLOSE_BRACKET) {
+      scanner.index += 1;
+      closed = true;
+      break;
+    }
+    if (code === CH_CLOSE_BRACE) {
+      if (ctx.openBraces > 0) {
+        closeUnterminated(ctx, "array", scanner.index);
+        break;
+      }
+      dropStrayCloser(ctx);
+      continue;
+    }
+    if (code === CH_COMMA) {
+      if (!ctx.options.aggressive) {
+        ctx.refuse("Array element is missing", scanner.index);
+      }
+      if (elements > 0) {
+        ctx.write(",");
+      }
+      ctx.write("null");
+      ctx.record("added-missing-value", scanner.index);
+      elements += 1;
+      scanner.index += 1;
+      continue;
+    }
+    const slot = ctx.checkpoint(scanner.index);
+    if (elements > 0) {
+      ctx.write(",");
+    }
+    if (parseValue(ctx, "array-element", true) === "dropped") {
+      ctx.restore(slot);
+      scanner.index = scanner.end;
+      ctx.record("removed-incomplete-member", slot.index);
+      closeUnterminated(ctx, "array", slot.index);
+      truncated = true;
+      break;
+    }
+    elements += 1;
+    readSeparator(ctx);
+  }
+  ctx.write("]");
+  ctx.openBrackets -= 1;
+  ctx.leave();
+  if (mayDrop && truncated && !closed && elements === 0) {
+    ctx.restore(entry);
+    scanner.index = scanner.end;
+    return "dropped";
+  }
+  return "ok";
+}
+function parseBareValue(ctx, start, coreEnd) {
+  const { scanner } = ctx;
+  const literal = readLiteral(ctx, start, coreEnd);
+  if (literal === "emitted") {
+    scanner.index = coreEnd;
+    return "ok";
+  }
+  if (literal === "needs-aggressive") {
+    ctx.refuse(`"${scanner.slice(start, coreEnd)}" is not a JSON literal`, start);
+  }
+  if (readNumber(ctx, start, coreEnd)) {
+    scanner.index = coreEnd;
+    return "ok";
+  }
+  if (!ctx.options.aggressive) {
+    ctx.refuse(`Unquoted value "${scanner.slice(start, coreEnd)}"`, start);
+  }
+  const valueEnd = extendBareValue(ctx, coreEnd);
+  writeQuotedSpan(ctx, start, valueEnd);
+  ctx.record("quoted-value", start);
+  scanner.index = valueEnd;
+  return "ok";
+}
+function scanCoreToken(ctx, from) {
+  const { source, end } = ctx.scanner;
+  const allowComments = ctx.options.allowComments;
+  let index = from;
+  while (index < end) {
+    const code = source.charCodeAt(index);
+    if (isWhitespace(code) || isStructural(code) || isQuote(code) || startsComment(source, index, end, allowComments)) {
+      break;
+    }
+    index += 1;
+  }
+  return index;
+}
+function extendBareValue(ctx, from) {
+  const { source, end } = ctx.scanner;
+  const allowComments = ctx.options.allowComments;
+  let index = from;
+  let lastContent = from;
+  while (index < end) {
+    const code = source.charCodeAt(index);
+    if (isStructural(code) || startsComment(source, index, end, allowComments)) {
+      break;
+    }
+    if (!isWhitespace(code)) {
+      lastContent = index + 1;
+    }
+    index += 1;
+  }
+  return lastContent;
+}
+function scanBareKey(ctx, from) {
+  const { source, end } = ctx.scanner;
+  const allowComments = ctx.options.allowComments;
+  let index = from;
+  let lastContent = from + 1;
+  while (index < end) {
+    const code = source.charCodeAt(index);
+    if (code === CH_COLON || isStructural(code) || startsComment(source, index, end, allowComments)) {
+      break;
+    }
+    if (!isWhitespace(code)) {
+      lastContent = index + 1;
+    }
+    index += 1;
+  }
+  return lastContent;
+}
+function startsComment(source, index, end, allowComments) {
+  if (!allowComments) {
+    return false;
+  }
+  const code = source.charCodeAt(index);
+  if (code === CH_HASH) {
+    return true;
+  }
+  if (code !== CH_SLASH || index + 1 >= end) {
+    return false;
+  }
+  const next = source.charCodeAt(index + 1);
+  return next === CH_SLASH || next === CH_ASTERISK;
+}
+function describeChar(source, index) {
+  const code = source.charCodeAt(index);
+  if (Number.isNaN(code)) {
+    return "end of input";
+  }
+  if (code < 32 || code === 127) {
+    return `"\\u${code.toString(16).padStart(4, "0")}"`;
+  }
+  return `"${source.charAt(index)}"`;
+}
+
+// src/repair/messages.ts
+var MESSAGES = {
+  "removed-byte-order-mark": "Removed a leading byte order mark",
+  "extracted-json": "Extracted JSON from surrounding text",
+  "removed-comment": "Removed a comment",
+  "normalized-whitespace": "Replaced whitespace that JSON does not allow between tokens",
+  "removed-trailing-comma": "Removed a trailing comma",
+  "removed-extra-comma": "Removed a redundant comma",
+  "removed-stray-token": "Removed a closing bracket that matched nothing",
+  "removed-trailing-content": "Removed content after the end of the JSON value",
+  "removed-incomplete-member": "Removed a truncated final member",
+  "added-missing-comma": "Inserted a missing comma",
+  "added-missing-colon": "Inserted a missing colon",
+  "added-missing-value": "Inserted null for a missing value",
+  "added-closing-brace": "Closed an unterminated object",
+  "added-closing-bracket": "Closed an unterminated array",
+  "normalized-quotes": "Converted non-standard quotes to double quotes",
+  "normalized-literal": "Rewrote a non-JSON literal",
+  "normalized-number": "Rewrote a non-JSON number",
+  "quoted-key": "Quoted an unquoted key",
+  "quoted-value": "Quoted an unquoted value",
+  "escaped-character": "Escaped a character that JSON forbids raw",
+  "fixed-escape": "Corrected an invalid escape sequence",
+  "terminated-string-at-eof": "Closed a string left open at end of input",
+  "terminated-string-at-newline": "Closed a string at a line break, discarding the rest of the line"
+};
+function describeRepair(type) {
+  return MESSAGES[type];
+}
+
+// src/parser/state.ts
+var PROBE_BUDGET_FACTOR = 4;
+var RepairContext = class {
+  scanner;
+  options;
+  /** Repairs applied so far, in the order they were discovered. */
+  repairs = [];
+  /** Pieces of the output, joined once at the end. */
+  chunks = [];
+  /** Current nesting depth. */
+  depth = 0;
+  /** Open `{` containers, used for O(1) stray-closer classification. */
+  openBraces = 0;
+  /** Open `[` containers, used for O(1) stray-closer classification. */
+  openBrackets = 0;
+  /** Remaining lookahead budget; see {@link PROBE_BUDGET_FACTOR}. */
+  probeBudget;
+  /**
+   * Highest offset the parser has already rewound to.
+   *
+   * Rewinding is only ever allowed to move forward, which guarantees the parse
+   * cannot loop between two readings of the same unterminated string.
+   */
+  lastRewind = -1;
+  constructor(scanner, options) {
+    this.scanner = scanner;
+    this.options = options;
+    this.probeBudget = (scanner.end - scanner.start) * PROBE_BUDGET_FACTOR;
+  }
+  /* ── Output ───────────────────────────────────────────────────────────── */
+  /** Appends literal text to the output. */
+  write(text) {
+    this.chunks.push(text);
+  }
+  /**
+   * Appends a span of the original input verbatim.
+   *
+   * Copying spans rather than characters keeps the number of output chunks
+   * proportional to the number of tokens, not to the length of the input.
+   */
+  writeSpan(from, to) {
+    if (to > from) {
+      this.chunks.push(this.scanner.slice(from, to));
+    }
+  }
+  /** Concatenates everything written so far. */
+  output() {
+    return this.chunks.join("");
+  }
+  /* ── Checkpoints ──────────────────────────────────────────────────────── */
+  /** Captures the current output, repair log and cursor for a later rewind. */
+  checkpoint(index) {
+    return { index, chunkCount: this.chunks.length, repairCount: this.repairs.length };
+  }
+  /**
+   * Reports whether the parser may rewind to `checkpoint`.
+   *
+   * Refusing a backwards rewind is what makes the unterminated-string heuristic
+   * terminating: every rewind strictly advances the furthest point already
+   * reconsidered.
+   */
+  canRewindTo(checkpoint) {
+    return checkpoint.index > this.lastRewind;
+  }
+  /**
+   * Returns the parser to `checkpoint`, discarding the output written and the
+   * repairs recorded since it was taken, and marks the point as reconsidered.
+   *
+   * Truncating the repair log matters: without it, a rewound attempt would
+   * report repairs that are not present in the text it finally emits.
+   */
+  rewindTo(checkpoint) {
+    this.restore(checkpoint);
+    this.lastRewind = checkpoint.index;
+  }
+  /**
+   * Returns the parser to `checkpoint` without marking it as reconsidered.
+   *
+   * Used to un-write a construct the parser decided to drop rather than re-read
+   * — a member truncated by a cut-off stream, for instance. Unlike
+   * {@link rewindTo} these restores never re-scan the same text, so they cannot
+   * loop and must not consume the rewind budget.
+   */
+  restore(checkpoint) {
+    this.chunks.length = checkpoint.chunkCount;
+    this.repairs.length = checkpoint.repairCount;
+    this.scanner.index = checkpoint.index;
+  }
+  /**
+   * Absolute offset of the last non-whitespace character in the region, or
+   * `-1` if there is none.
+   *
+   * Computed once per parse. Recomputing it per token would make input such as
+   * half a megabyte of `}` quadratic, which is precisely the shape an attacker
+   * would send.
+   */
+  get lastContentIndex() {
+    if (this.lastContentCache === -2) {
+      this.lastContentCache = findLastContent(
+        this.scanner.source,
+        this.scanner.start,
+        this.scanner.end
+      );
+    }
+    return this.lastContentCache;
+  }
+  lastContentCache = -2;
+  /* ── Repair log ───────────────────────────────────────────────────────── */
+  /**
+   * Records a repair at an absolute offset in the original input.
+   *
+   * @throws {JsonRepairError} `MAX_REPAIRS_EXCEEDED` once the budget is spent.
+   */
+  record(type, position, message) {
+    if (this.repairs.length >= this.options.maxRepairs) {
+      throw this.error(
+        "MAX_REPAIRS_EXCEEDED",
+        `Input needs more than ${this.options.maxRepairs} repairs.`,
+        position
+      );
+    }
+    const { line, column } = this.scanner.positionAt(position);
+    this.repairs.push({
+      type,
+      position,
+      line,
+      column,
+      message: message ?? describeRepair(type)
+    });
+  }
+  /* ── Depth ────────────────────────────────────────────────────────────── */
+  /**
+   * Enters a nested container.
+   *
+   * @throws {JsonRepairError} `MAX_DEPTH_EXCEEDED` beyond the configured depth.
+   */
+  enter(position) {
+    this.depth += 1;
+    if (this.depth > this.options.maxDepth) {
+      throw this.error(
+        "MAX_DEPTH_EXCEEDED",
+        `Input nests deeper than the configured maximum of ${this.options.maxDepth}.`,
+        position
+      );
+    }
+  }
+  /** Leaves a nested container. */
+  leave() {
+    this.depth -= 1;
+  }
+  /* ── Failure ──────────────────────────────────────────────────────────── */
+  /** Builds a positioned error without throwing it. */
+  error(code, message, position) {
+    const { line, column } = this.scanner.positionAt(position);
+    return new JsonRepairError(code, `${message} (line ${line}, column ${column})`, {
+      position,
+      line,
+      column,
+      snippet: buildSnippet(this.scanner.source, position)
+    });
+  }
+  /**
+   * Aborts the attempt because the input cannot be read as JSON at all.
+   *
+   * @throws {JsonRepairError} `UNREPAIRABLE_JSON`.
+   */
+  fail(message, position) {
+    throw this.error("UNREPAIRABLE_JSON", message, position);
+  }
+  /**
+   * Aborts the attempt because safe mode declines to choose between readings.
+   *
+   * Callers reach this only when `mode: 'aggressive'` has a defined answer, so
+   * the message always points at the escape hatch.
+   *
+   * @throws {JsonRepairError} `AMBIGUOUS_REPAIR`.
+   */
+  refuse(message, position) {
+    throw this.error(
+      "AMBIGUOUS_REPAIR",
+      `${message}; retry with mode: "aggressive" to apply a best-effort repair.`,
+      position
+    );
+  }
+};
+function findLastContent(source, start, end) {
+  for (let index = end - 1; index >= start; index -= 1) {
+    if (!isWhitespace(source.charCodeAt(index))) {
+      return index;
+    }
+  }
+  return -1;
+}
+
+// src/repair/markdown.ts
+var CH_TILDE = 126;
+var MIN_FENCE_LENGTH = 3;
+var MAX_FENCE_INDENT = 3;
+function scanFences(source, start, end) {
+  const fences = [];
+  let lineStart = start;
+  while (lineStart < end) {
+    const lineEnd = findLineEnd(source, lineStart, end);
+    const marker = readFenceMarker(source, lineStart, lineEnd);
+    if (marker === void 0) {
+      lineStart = nextLineStart(source, lineEnd, end);
+      continue;
+    }
+    const bodyStart = nextLineStart(source, lineEnd, end);
+    const closing = findClosingFence(source, bodyStart, end, marker.char, marker.length);
+    fences.push({
+      bodyStart,
+      bodyEnd: closing.bodyEnd,
+      jsonTagged: isJsonInfoString(source, marker.infoStart, lineEnd)
+    });
+    lineStart = closing.next;
+  }
+  return fences;
+}
+function findValueStarts(source, start, end, limit) {
+  const starts = [];
+  for (let index = start; index < end && starts.length < limit; index += 1) {
+    const code = source.charCodeAt(index);
+    if (code === CH_OPEN_BRACE || code === CH_OPEN_BRACKET) {
+      starts.push(index);
+    }
+  }
+  return starts;
+}
+function skipLeadingWhitespace(source, start, end) {
+  let index = start;
+  while (index < end && isWhitespace(source.charCodeAt(index))) {
+    index += 1;
+  }
+  return index;
+}
+function trimTrailingWhitespace(source, start, end) {
+  let index = end;
+  while (index > start && isWhitespace(source.charCodeAt(index - 1))) {
+    index -= 1;
+  }
+  return index;
+}
+function readFenceMarker(source, lineStart, lineEnd) {
+  let index = lineStart;
+  let indent = 0;
+  while (index < lineEnd && indent <= MAX_FENCE_INDENT) {
+    const code = source.charCodeAt(index);
+    if (code !== CH_SPACE && code !== CH_TAB) {
+      break;
+    }
+    indent += 1;
+    index += 1;
+  }
+  if (index >= lineEnd || indent > MAX_FENCE_INDENT) {
+    return void 0;
+  }
+  const char = source.charCodeAt(index);
+  if (char !== CH_BACKTICK && char !== CH_TILDE) {
+    return void 0;
+  }
+  const runStart = index;
+  while (index < lineEnd && source.charCodeAt(index) === char) {
+    index += 1;
+  }
+  const length = index - runStart;
+  return length >= MIN_FENCE_LENGTH ? { char, length, infoStart: index } : void 0;
+}
+function findClosingFence(source, bodyStart, end, char, length) {
+  let lineStart = bodyStart;
+  while (lineStart < end) {
+    const lineEnd = findLineEnd(source, lineStart, end);
+    const marker = readFenceMarker(source, lineStart, lineEnd);
+    if (marker?.char === char && marker.length >= length) {
+      return { bodyEnd: lineStart, next: nextLineStart(source, lineEnd, end) };
+    }
+    lineStart = nextLineStart(source, lineEnd, end);
+  }
+  return { bodyEnd: end, next: end };
+}
+function isJsonInfoString(source, from, lineEnd) {
+  let index = from;
+  while (index < lineEnd && isWhitespace(source.charCodeAt(index))) {
+    index += 1;
+  }
+  const wordStart = index;
+  while (index < lineEnd) {
+    const code = toLowerAscii(source.charCodeAt(index));
+    if (code < 48 || code > 57 && code < 97 || code > 122) {
+      break;
+    }
+    index += 1;
+  }
+  const length = index - wordStart;
+  if (length < 4 || length > 5) {
+    return false;
+  }
+  if (toLowerAscii(source.charCodeAt(wordStart)) !== 106 || toLowerAscii(source.charCodeAt(wordStart + 1)) !== 115 || toLowerAscii(source.charCodeAt(wordStart + 2)) !== 111 || toLowerAscii(source.charCodeAt(wordStart + 3)) !== 110) {
+    return false;
+  }
+  if (length === 4) {
+    return true;
+  }
+  const suffix = toLowerAscii(source.charCodeAt(wordStart + 4));
+  return suffix === 99 || suffix === 53;
+}
+function findLineEnd(source, from, end) {
+  let index = from;
+  while (index < end && !isLineBreak(source.charCodeAt(index))) {
+    index += 1;
+  }
+  return index;
+}
+function nextLineStart(source, lineEnd, end) {
+  if (lineEnd >= end) {
+    return end;
+  }
+  let index = lineEnd + 1;
+  if (source.charCodeAt(lineEnd) !== CH_LINE_FEED && index < end && source.charCodeAt(index) === CH_LINE_FEED) {
+    index += 1;
+  }
+  return index;
+}
+
+// src/extract.ts
+var MAX_CANDIDATES = 256;
+var MAX_FAILED_ATTEMPTS = 32;
+function extractJson(input, options) {
+  const resolved = resolveExtractOptions(options);
+  const region = prepare(input, resolved);
+  const attempts = solve(input, region.start, region.end, resolved);
+  const chosen = rankAttempts(attempts, resolved.select);
+  return input.slice(chosen.start, chosen.end);
+}
+function extractAllJson(input, options) {
+  const resolved = resolveExtractOptions(options);
+  const region = prepare(input, resolved);
+  let attempts;
+  try {
+    attempts = solve(input, region.start, region.end, resolved);
+  } catch (error) {
+    if (isJsonRepairError(error) && error.code === "NO_JSON_FOUND") {
+      return [];
+    }
+    throw error;
+  }
+  return attempts.map((attempt) => input.slice(attempt.start, attempt.end));
+}
+function prepare(input, options) {
+  assertString(input, "input");
+  assertInputLength(input, options.maxLength);
+  return {
+    start: input.length > 0 && input.charCodeAt(0) === CH_BOM ? 1 : 0,
+    end: input.length
+  };
+}
+function solve(source, start, end, options) {
+  const tiers = buildCandidateTiers(source, start, end, options);
+  const safe = collectAttempts(source, tiers, withMode(options, "safe"));
+  if (safe.attempts.length > 0) {
+    return safe.attempts;
+  }
+  if (!options.aggressive) {
+    throw safe.error ?? noJsonFound(source, start);
+  }
+  const loose = collectAttempts(source, tiers, options);
+  if (loose.attempts.length > 0) {
+    return loose.attempts;
+  }
+  throw loose.error ?? safe.error ?? noJsonFound(source, start);
+}
+function buildCandidateTiers(source, start, end, options) {
+  const whole = wholeRegionCandidate(source, start, end);
+  if (!options.extract) {
+    return whole === void 0 ? [] : [[whole]];
+  }
+  const tagged = [];
+  const fenced = [];
+  for (const fence of scanFences(source, start, end)) {
+    const target = fence.jsonTagged ? tagged : fenced;
+    const starts = findValueStarts(source, fence.bodyStart, fence.bodyEnd, MAX_CANDIDATES);
+    for (const offset of starts) {
+      target.push({ start: offset, limit: fence.bodyEnd });
+    }
+    if (starts.length === 0) {
+      const body = wholeRegionCandidate(source, fence.bodyStart, fence.bodyEnd);
+      if (body !== void 0) {
+        target.push(body);
+      }
+    }
+  }
+  const bare = findValueStarts(source, start, end, MAX_CANDIDATES).map((offset) => ({
+    start: offset,
+    limit: end
+  }));
+  const tiers = [];
+  for (const tier of [tagged, fenced, bare]) {
+    if (tier.length > 0) {
+      tiers.push(tier);
+    }
+  }
+  if (whole !== void 0 && startsJsonValue(source, whole.start, end)) {
+    tiers.push([whole]);
+  }
+  return tiers;
+}
+var VALUE_WORDS = ["true", "false", "null", "nan", "none", "infinity", "undefined"];
+function startsJsonValue(source, from, end) {
+  const code = source.charCodeAt(from);
+  if (code === CH_OPEN_BRACE || code === CH_OPEN_BRACKET || code === CH_MINUS || code === CH_PLUS || code === CH_DOT || isDigit(code) || isQuote(code)) {
+    return true;
+  }
+  return VALUE_WORDS.some((word) => matchesWord2(source, from, end, word));
+}
+function matchesWord2(source, from, end, word) {
+  if (from + word.length > end) {
+    return false;
+  }
+  for (let index = 0; index < word.length; index += 1) {
+    if (toLowerAscii(source.charCodeAt(from + index)) !== word.charCodeAt(index)) {
+      return false;
+    }
+  }
+  return true;
+}
+function collectAttempts(source, tiers, options) {
+  let firstError;
+  let failures = 0;
+  for (const tier of tiers) {
+    const attempts = [];
+    let barrier = -1;
+    for (const candidate of tier) {
+      if (candidate.start < barrier) {
+        continue;
+      }
+      if (failures >= MAX_FAILED_ATTEMPTS) {
+        break;
+      }
+      let attempt;
+      try {
+        attempt = tryCandidate(source, candidate, options);
+      } catch (error) {
+        if (!isJsonRepairError(error)) {
+          throw error;
+        }
+        failures += 1;
+        firstError ??= error;
+        barrier = Math.max(barrier, findStructuralEnd(source, candidate.start, candidate.limit));
+        continue;
+      }
+      attempts.push(attempt);
+      barrier = Math.max(barrier, attempt.end);
+    }
+    if (attempts.length > 0) {
+      return { attempts, error: void 0 };
+    }
+  }
+  return { attempts: [], error: firstError };
+}
+function findStructuralEnd(source, start, end) {
+  const open = [];
+  for (let index = start; index < end; index += 1) {
+    const code = source.charCodeAt(index);
+    if (isQuote(code)) {
+      index += 1;
+      while (index < end) {
+        const inner = source.charCodeAt(index);
+        if (inner === CH_BACKSLASH) {
+          index += 1;
+        } else if (inner === code) {
+          break;
+        }
+        index += 1;
+      }
+      continue;
+    }
+    if (code === CH_OPEN_BRACE || code === CH_OPEN_BRACKET) {
+      open.push(code);
+      continue;
+    }
+    if (code !== CH_CLOSE_BRACE && code !== CH_CLOSE_BRACKET) {
+      continue;
+    }
+    const opener = code === CH_CLOSE_BRACE ? CH_OPEN_BRACE : CH_OPEN_BRACKET;
+    const frame = open.lastIndexOf(opener);
+    if (frame < 0) {
+      continue;
+    }
+    open.length = frame;
+    if (open.length === 0) {
+      return index + 1;
+    }
+  }
+  return end;
+}
+function tryCandidate(source, candidate, options) {
+  const scanner = new Scanner(source, candidate.start, candidate.limit);
+  const context = new RepairContext(scanner, options);
+  parseDocument(context);
+  const end = scanner.index;
+  const { repairs } = context;
+  if (repairs.length === 0) {
+    const slice = source.slice(candidate.start, end);
+    const parsed2 = tryParse(slice);
+    if (parsed2 !== void 0) {
+      return { start: candidate.start, end, json: slice, value: parsed2.value, repairs };
+    }
+  }
+  const json = context.output();
+  const parsed = tryParse(json);
+  if (parsed === void 0) {
+    throw createError(
+      "UNREPAIRABLE_JSON",
+      "The repaired output is not valid JSON. This is a defect in @nexkit/json-repair; please report it along with the input that triggered it.",
+      source,
+      candidate.start
+    );
+  }
+  return { start: candidate.start, end, json, value: parsed.value, repairs };
+}
+function rankAttempts(attempts, select) {
+  const first = attempts[0];
+  if (first === void 0) {
+    throw new Error("rankAttempts requires at least one attempt");
+  }
+  if (select === "first") {
+    return first;
+  }
+  if (select === "last") {
+    return attempts[attempts.length - 1];
+  }
+  let best = first;
+  for (let index = 1; index < attempts.length; index += 1) {
+    const attempt = attempts[index];
+    if (select === "largest" ? isLarger(attempt, best) : isBetter(attempt, best)) {
+      best = attempt;
+    }
+  }
+  return best;
+}
+function isBetter(attempt, best) {
+  const span = attempt.end - attempt.start;
+  const bestSpan = best.end - best.start;
+  if (span !== bestSpan) {
+    return span > bestSpan;
+  }
+  return attempt.repairs.length < best.repairs.length;
+}
+function isLarger(attempt, best) {
+  return attempt.end - attempt.start > best.end - best.start;
+}
+function wholeRegionCandidate(source, start, end) {
+  const from = skipLeadingWhitespace(source, start, end);
+  const to = trimTrailingWhitespace(source, from, end);
+  return from < to ? { start: from, limit: end } : void 0;
+}
+function tryParse(text) {
+  try {
+    return { value: parseJsonStrict(text) };
+  } catch {
+    return void 0;
+  }
+}
+function noJsonFound(source, position) {
+  return createError("NO_JSON_FOUND", "No JSON value was found in the input.", source, position);
+}
+
+// src/repair.ts
+function repairJson(input, options) {
+  const resolved = resolveOptions(options);
+  const outcome = repairInternal(input, resolved);
+  if (!resolved.returnMetadata) {
+    return outcome.json;
+  }
+  return { json: outcome.json, changed: outcome.changed, repairs: outcome.repairs };
+}
+function repairInternal(input, options) {
+  const region = prepare(input, options);
+  const fast = tryFastPath(input, region.start, options);
+  if (fast !== void 0) {
+    return fast;
+  }
+  const attempts = solve(input, region.start, region.end, options);
+  const chosen = rankAttempts(attempts, "best");
+  const repairs = buildRepairLog(input, region, chosen);
+  if (repairs.length > options.maxRepairs) {
+    throw createError(
+      "MAX_REPAIRS_EXCEEDED",
+      `Repairing this input required ${repairs.length} changes, which exceeds the maximum of ${options.maxRepairs}.`,
+      input,
+      chosen.start
+    );
+  }
+  return {
+    json: chosen.json,
+    changed: chosen.json !== input,
+    repairs,
+    value: chosen.value
+  };
+}
+function tryFastPath(input, regionStart, options) {
+  const text = regionStart > 0 ? input.slice(regionStart) : input;
+  let value;
+  try {
+    value = parseJsonStrict(text);
+  } catch {
+    return void 0;
+  }
+  assertStructuralDepth(input, regionStart, input.length, options.maxDepth);
+  const repairs = regionStart > 0 ? [operation(new Scanner(input), "removed-byte-order-mark", 0)] : [];
+  if (repairs.length > options.maxRepairs) {
+    throw createError(
+      "MAX_REPAIRS_EXCEEDED",
+      `Removing the byte order mark exceeds the maximum of ${options.maxRepairs} repairs.`,
+      input,
+      0
+    );
+  }
+  return { json: text, changed: regionStart > 0, repairs, value };
+}
+function buildRepairLog(input, region, chosen) {
+  const scanner = new Scanner(input);
+  const repairs = [];
+  if (region.start > 0) {
+    repairs.push(operation(scanner, "removed-byte-order-mark", 0));
+  }
+  const before = classifyGap(input, region.start, chosen.start);
+  if (before === "content") {
+    repairs.push(operation(scanner, "extracted-json", chosen.start));
+  } else if (before === "exotic") {
+    repairs.push(operation(scanner, "normalized-whitespace", region.start));
+  }
+  for (const repair of chosen.repairs) {
+    repairs.push(repair);
+  }
+  const after = classifyGap(input, chosen.end, region.end);
+  if (after === "content") {
+    repairs.push(operation(scanner, "removed-trailing-content", chosen.end));
+  } else if (after === "exotic") {
+    repairs.push(operation(scanner, "normalized-whitespace", chosen.end));
+  }
+  return repairs;
+}
+function classifyGap(source, from, to) {
+  if (from >= to) {
+    return "empty";
+  }
+  let exotic = false;
+  for (let index = from; index < to; index += 1) {
+    const code = source.charCodeAt(index);
+    if (!isWhitespace(code)) {
+      return "content";
+    }
+    if (!isJsonWhitespace(code)) {
+      exotic = true;
+    }
+  }
+  return exotic ? "exotic" : "whitespace";
+}
+function operation(scanner, type, position) {
+  const { line, column } = scanner.positionAt(position);
+  return { type, position, line, column, message: describeRepair(type) };
+}
+
+// src/parse.ts
+function parseJson(input, options) {
+  return repairInternal(input, resolveOptions(options)).value;
+}
+
+exports.DEFAULT_MAX_DEPTH = DEFAULT_MAX_DEPTH;
+exports.DEFAULT_MAX_LENGTH = DEFAULT_MAX_LENGTH;
+exports.JsonRepairError = JsonRepairError;
+exports.MAX_SUPPORTED_DEPTH = MAX_SUPPORTED_DEPTH;
+exports.REPAIR_TYPES = REPAIR_TYPES;
+exports.extractAllJson = extractAllJson;
+exports.extractJson = extractJson;
+exports.isJsonRepairError = isJsonRepairError;
+exports.parseJson = parseJson;
+exports.repairJson = repairJson;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map