@c4a/extract 0.7.0 → 0.7.4

package/index.js

@@ -13156,6 +13156,8 @@ function keyTokens(key) {
   return key.replace(/([a-z0-9])([A-Z])/gu, "$1-$2").replace(/[^A-Za-z0-9]+/gu, "-").toLowerCase().split("-").filter(Boolean);
 }
 function sensitiveKey(key, value) {
+  if (value === INDEXER_OUTPUT_REDACTION_MARKER)
+    return false;
   const tokens = keyTokens(key);
   if (tokens.length === 0)
     return false;
@@ -13197,12 +13199,12 @@ function replaceWithCount(value, pattern, replacement, count) {
 function redactKnownText(value, count) {
   let output = value;
   output = replaceWithCount(output, /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/gu, INDEXER_OUTPUT_REDACTION_MARKER, count);
-  output = replaceWithCount(output, /(\bauthorization\s*:\s*(?:bearer|basic)\s+)[^\s,;]+/giu, (_match, prefix) => `${prefix}${INDEXER_OUTPUT_REDACTION_MARKER}`, count);
+  output = replaceWithCount(output, new RegExp(`(\\bauthorization\\s*:\\s*(?:bearer|basic)\\s+)` + `(?!${escapeRegExp(INDEXER_OUTPUT_REDACTION_MARKER)})[^\\s,;]+`, "giu"), (_match, prefix) => `${prefix}${INDEXER_OUTPUT_REDACTION_MARKER}`, count);
   output = replaceWithCount(output, /([a-z][a-z0-9+.-]*:\/\/)[^\s/@:]+:[^\s/@]+@/giu, (_match, prefix) => `${prefix}${INDEXER_OUTPUT_REDACTION_MARKER}@`, count);
-  output = replaceWithCount(output, /([?&](?:access_token|refresh_token|api_key|password|secret)=)[^&#\s]+/giu, (_match, prefix) => `${prefix}${INDEXER_OUTPUT_REDACTION_MARKER}`, count);
+  output = replaceWithCount(output, new RegExp(`([?&](?:access_token|refresh_token|api_key|password|secret)=)` + `(?!${escapeRegExp(INDEXER_OUTPUT_REDACTION_MARKER)})[^&#\\s]+`, "giu"), (_match, prefix) => `${prefix}${INDEXER_OUTPUT_REDACTION_MARKER}`, count);
   const key = "(?:[A-Za-z0-9_.-]*(?:password|passwd|pwd|secret|token|credential|cookie)[A-Za-z0-9_.-]*|api[-_]?key|access[-_]?(?:key|token)|private[-_]?key|client[-_]?secret|authorization)";
   const assignment = `(?:=\\s*|:\\s+(?=\\S)|:\\s*(?=["']))`;
-  output = replaceWithCount(output, new RegExp(`((?:["']?${key}["']?)\\s*${assignment})(?:"(?:\\\\.|[^"])*"|'(?:\\\\.|[^'])*'|[^\\s,;}\\]]+)`, "giu"), (_match, prefix) => `${prefix}"${INDEXER_OUTPUT_REDACTION_MARKER}"`, count);
+  output = replaceWithCount(output, new RegExp(`((?:["']?${key}["']?)\\s*${assignment})` + `(?!["']?${escapeRegExp(INDEXER_OUTPUT_REDACTION_MARKER)})` + `(?:"(?:\\\\.|[^"])*"|'(?:\\\\.|[^'])*'|[^\\s,;}\\]]+)`, "giu"), (_match, prefix) => `${prefix}"${INDEXER_OUTPUT_REDACTION_MARKER}"`, count);
   return output;
 }
 function redactBlockedText(value, blocked, count) {
@@ -15552,7 +15554,7 @@ function selectedEntryFiles(input) {
     for (const entry of input.detected.entries) {
       const sourcePath = input.module.path === "." ? safeSourceRelativePath(entry.path) : safeSourceRelativePath(`${input.module.path}/${entry.path}`);
       if (!includedSourceFiles.has(sourcePath)) {
-        throw new Error(`Auto-detected entry is outside extractTs include: ${sourcePath}. Update include or configure entries in the Context project.`);
+        throw new Error(`Auto-detected entry is outside the parser include: ${sourcePath}. Update the Provider include or configured entries.`);
       }
     }
     return input.detected.entries;
@@ -15563,7 +15565,7 @@ function selectedEntryFiles(input) {
   }
   return sourceEntries.map((sourcePath, index) => {
     if (!includedSourceFiles.has(sourcePath)) {
-      throw new Error(`Configured extraction entry is missing or outside extractTs include: ${sourcePath}. Update entries or include in the Context project.`);
+      throw new Error(`Configured extraction entry is missing or outside the parser include: ${sourcePath}. Update the Provider entries or include.`);
     }
     const modulePath = moduleRelativeEntryPath(input.module.path, sourcePath);
     return {
@@ -16260,6 +16262,10 @@ var runCodeExtractCliFromFile = async (inputFile) => {
 };
 // src/evidenceAdapter.ts
 function fact2(input) {
+  const payload = redactIndexerOutput({
+    channel: "success-payload",
+    value: input.payload
+  }).value;
   return createIndexerEvidenceAdapterFact({
     source_ref: input.sourceRef,
     module_ref: input.moduleRef,
@@ -16267,10 +16273,21 @@ function fact2(input) {
     qualified_item_path: input.qualifiedItemPath,
     kind: input.kind,
     signature: input.signature,
-    payload: input.payload,
+    payload,
     denominator: input.denominator
   });
 }
+function uniqueFacts(facts) {
+  const byRef = new Map;
+  for (const value of facts) {
+    const previous = byRef.get(value.fact_ref);
+    if (previous !== undefined && indexerEvidenceAdapterProtocolDigest(previous) !== indexerEvidenceAdapterProtocolDigest(value)) {
+      throw new TypeError(`ExtractionResult emits conflicting facts for ${value.fact_ref}`);
+    }
+    byRef.set(value.fact_ref, previous ?? value);
+  }
+  return [...byRef.values()];
+}
 function semanticExtractionPayload(extraction) {
   return {
     version: extraction.version,
@@ -16287,7 +16304,9 @@ function semanticExtractionPayload(extraction) {
     stats: extraction.stats
   };
 }
-function relationSourceFile(relation, symbols) {
+function relationSourceFile(relation, symbols, filePaths) {
+  if (filePaths.has(relation.from))
+    return relation.from;
   const candidates = symbols.filter((symbol) => symbol.name === relation.from);
   if (candidates.length === 1)
     return candidates[0].file;
@@ -16298,6 +16317,13 @@ function relationSourceFile(relation, symbols) {
   }
   return null;
 }
+function relationQualifiedItemPath(relation) {
+  const identityDigest = indexerEvidenceAdapterProtocolDigest({
+    from: relation.from,
+    to: relation.to
+  });
+  return `relation:${relation.type}@${relation.line ?? 0}#${identityDigest}`;
+}
 function diagnosticPayload(diagnostic) {
   return {
     code: diagnostic.code,
@@ -16317,6 +16343,7 @@ function extractionResultToEvidenceAdapterResult(extraction, invocation) {
   }
   const coverageByPath = new Map(coverage.files.map((file) => [file.path, file]));
   const fileInfoByPath = new Map(extraction.files.map((file) => [file.path, file]));
+  const filePaths = new Set([...coverageByPath.keys(), ...fileInfoByPath.keys()]);
   for (const file of extraction.files) {
     if (!coverageByPath.has(file.path)) {
       throw new TypeError(`ExtractionResult file ${file.path} has no coverage disposition`);
@@ -16333,7 +16360,7 @@ function extractionResultToEvidenceAdapterResult(extraction, invocation) {
   const generatedDiagnostics = [];
   const relationsByFile = new Map;
   for (const relation of extraction.relations) {
-    const file = relationSourceFile(relation, extraction.symbols);
+    const file = relationSourceFile(relation, extraction.symbols, filePaths);
     if (file === null || coverageByPath.get(file)?.disposition !== "analyzed") {
       generatedDiagnostics.push({
         code: "relation-locator-unresolved",
@@ -16403,7 +16430,7 @@ function extractionResultToEvidenceAdapterResult(extraction, invocation) {
           sourceRef: invocation.authorized_scope.source_ref,
           moduleRef: invocation.module_ref,
           normalizedPath,
-          qualifiedItemPath: `relation:${relation.type}:${relation.from}->${relation.to}@${relation.line ?? 0}`,
+          qualifiedItemPath: relationQualifiedItemPath(relation),
           kind: "code-relation",
           signature: relation,
           payload: relation,
@@ -16419,7 +16446,7 @@ function extractionResultToEvidenceAdapterResult(extraction, invocation) {
       role,
       coverage_tier: coverage.tier,
       disposition: coverageFile.disposition,
-      facts
+      facts: uniqueFacts(facts)
     };
   });
   const diagnostics = [
@@ -16463,6 +16490,845 @@ function extractionResultToEvidenceAdapterResult(extraction, invocation) {
 function extractionResultToEvidenceAdapterMaterialization(extraction, invocation) {
   return materializeIndexerEvidenceAdapterResult(extractionResultToEvidenceAdapterResult(extraction, invocation));
 }
+// ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/scanner.js
+function createScanner(text, ignoreTrivia = false) {
+  const len = text.length;
+  let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
+  function scanHexDigits(count, exact) {
+    let digits = 0;
+    let value2 = 0;
+    while (digits < count || !exact) {
+      let ch = text.charCodeAt(pos);
+      if (ch >= 48 && ch <= 57) {
+        value2 = value2 * 16 + ch - 48;
+      } else if (ch >= 65 && ch <= 70) {
+        value2 = value2 * 16 + ch - 65 + 10;
+      } else if (ch >= 97 && ch <= 102) {
+        value2 = value2 * 16 + ch - 97 + 10;
+      } else {
+        break;
+      }
+      pos++;
+      digits++;
+    }
+    if (digits < count) {
+      value2 = -1;
+    }
+    return value2;
+  }
+  function setPosition(newPosition) {
+    pos = newPosition;
+    value = "";
+    tokenOffset = 0;
+    token = 16;
+    scanError = 0;
+  }
+  function scanNumber() {
+    let start = pos;
+    if (text.charCodeAt(pos) === 48) {
+      pos++;
+    } else {
+      pos++;
+      while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+      }
+    }
+    if (pos < text.length && text.charCodeAt(pos) === 46) {
+      pos++;
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+      } else {
+        scanError = 3;
+        return text.substring(start, pos);
+      }
+    }
+    let end = pos;
+    if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
+      pos++;
+      if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) {
+        pos++;
+      }
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+        end = pos;
+      } else {
+        scanError = 3;
+      }
+    }
+    return text.substring(start, end);
+  }
+  function scanString() {
+    let result = "", start = pos;
+    while (true) {
+      if (pos >= len) {
+        result += text.substring(start, pos);
+        scanError = 2;
+        break;
+      }
+      const ch = text.charCodeAt(pos);
+      if (ch === 34) {
+        result += text.substring(start, pos);
+        pos++;
+        break;
+      }
+      if (ch === 92) {
+        result += text.substring(start, pos);
+        pos++;
+        if (pos >= len) {
+          scanError = 2;
+          break;
+        }
+        const ch2 = text.charCodeAt(pos++);
+        switch (ch2) {
+          case 34:
+            result += '"';
+            break;
+          case 92:
+            result += "\\";
+            break;
+          case 47:
+            result += "/";
+            break;
+          case 98:
+            result += "\b";
+            break;
+          case 102:
+            result += "\f";
+            break;
+          case 110:
+            result += `
+`;
+            break;
+          case 114:
+            result += "\r";
+            break;
+          case 116:
+            result += "\t";
+            break;
+          case 117:
+            const ch3 = scanHexDigits(4, true);
+            if (ch3 >= 0) {
+              result += String.fromCharCode(ch3);
+            } else {
+              scanError = 4;
+            }
+            break;
+          default:
+            scanError = 5;
+        }
+        start = pos;
+        continue;
+      }
+      if (ch >= 0 && ch <= 31) {
+        if (isLineBreak(ch)) {
+          result += text.substring(start, pos);
+          scanError = 2;
+          break;
+        } else {
+          scanError = 6;
+        }
+      }
+      pos++;
+    }
+    return result;
+  }
+  function scanNext() {
+    value = "";
+    scanError = 0;
+    tokenOffset = pos;
+    lineStartOffset = lineNumber;
+    prevTokenLineStartOffset = tokenLineStartOffset;
+    if (pos >= len) {
+      tokenOffset = len;
+      return token = 17;
+    }
+    let code = text.charCodeAt(pos);
+    if (isWhiteSpace(code)) {
+      do {
+        pos++;
+        value += String.fromCharCode(code);
+        code = text.charCodeAt(pos);
+      } while (isWhiteSpace(code));
+      return token = 15;
+    }
+    if (isLineBreak(code)) {
+      pos++;
+      value += String.fromCharCode(code);
+      if (code === 13 && text.charCodeAt(pos) === 10) {
+        pos++;
+        value += `
+`;
+      }
+      lineNumber++;
+      tokenLineStartOffset = pos;
+      return token = 14;
+    }
+    switch (code) {
+      case 123:
+        pos++;
+        return token = 1;
+      case 125:
+        pos++;
+        return token = 2;
+      case 91:
+        pos++;
+        return token = 3;
+      case 93:
+        pos++;
+        return token = 4;
+      case 58:
+        pos++;
+        return token = 6;
+      case 44:
+        pos++;
+        return token = 5;
+      case 34:
+        pos++;
+        value = scanString();
+        return token = 10;
+      case 47:
+        const start = pos - 1;
+        if (text.charCodeAt(pos + 1) === 47) {
+          pos += 2;
+          while (pos < len) {
+            if (isLineBreak(text.charCodeAt(pos))) {
+              break;
+            }
+            pos++;
+          }
+          value = text.substring(start, pos);
+          return token = 12;
+        }
+        if (text.charCodeAt(pos + 1) === 42) {
+          pos += 2;
+          const safeLength = len - 1;
+          let commentClosed = false;
+          while (pos < safeLength) {
+            const ch = text.charCodeAt(pos);
+            if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
+              pos += 2;
+              commentClosed = true;
+              break;
+            }
+            pos++;
+            if (isLineBreak(ch)) {
+              if (ch === 13 && text.charCodeAt(pos) === 10) {
+                pos++;
+              }
+              lineNumber++;
+              tokenLineStartOffset = pos;
+            }
+          }
+          if (!commentClosed) {
+            pos++;
+            scanError = 1;
+          }
+          value = text.substring(start, pos);
+          return token = 13;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+      case 45:
+        value += String.fromCharCode(code);
+        pos++;
+        if (pos === len || !isDigit(text.charCodeAt(pos))) {
+          return token = 16;
+        }
+      case 48:
+      case 49:
+      case 50:
+      case 51:
+      case 52:
+      case 53:
+      case 54:
+      case 55:
+      case 56:
+      case 57:
+        value += scanNumber();
+        return token = 11;
+      default:
+        while (pos < len && isUnknownContentCharacter(code)) {
+          pos++;
+          code = text.charCodeAt(pos);
+        }
+        if (tokenOffset !== pos) {
+          value = text.substring(tokenOffset, pos);
+          switch (value) {
+            case "true":
+              return token = 8;
+            case "false":
+              return token = 9;
+            case "null":
+              return token = 7;
+          }
+          return token = 16;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+    }
+  }
+  function isUnknownContentCharacter(code) {
+    if (isWhiteSpace(code) || isLineBreak(code)) {
+      return false;
+    }
+    switch (code) {
+      case 125:
+      case 93:
+      case 123:
+      case 91:
+      case 34:
+      case 58:
+      case 44:
+      case 47:
+        return false;
+    }
+    return true;
+  }
+  function scanNextNonTrivia() {
+    let result;
+    do {
+      result = scanNext();
+    } while (result >= 12 && result <= 15);
+    return result;
+  }
+  return {
+    setPosition,
+    getPosition: () => pos,
+    scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+    getToken: () => token,
+    getTokenValue: () => value,
+    getTokenOffset: () => tokenOffset,
+    getTokenLength: () => pos - tokenOffset,
+    getTokenStartLine: () => lineStartOffset,
+    getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+    getTokenError: () => scanError
+  };
+}
+function isWhiteSpace(ch) {
+  return ch === 32 || ch === 9;
+}
+function isLineBreak(ch) {
+  return ch === 10 || ch === 13;
+}
+function isDigit(ch) {
+  return ch >= 48 && ch <= 57;
+}
+var CharacterCodes;
+(function(CharacterCodes2) {
+  CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
+  CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
+  CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
+  CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
+  CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
+  CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
+  CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
+  CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
+  CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
+  CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
+  CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
+  CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
+  CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
+  CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
+  CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
+  CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
+  CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
+  CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
+  CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
+  CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
+  CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
+  CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
+  CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
+  CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
+  CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
+  CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
+  CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
+  CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
+  CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
+  CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
+  CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
+  CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
+  CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
+  CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
+  CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
+  CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
+  CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
+  CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
+  CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
+  CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
+  CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
+  CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
+  CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
+  CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
+  CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
+  CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
+  CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
+  CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
+  CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
+  CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
+  CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
+  CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
+  CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
+  CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
+  CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
+  CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
+  CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
+  CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
+  CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
+  CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
+  CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
+  CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
+  CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
+  CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
+  CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
+  CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
+  CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
+  CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
+  CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
+  CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
+  CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
+  CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
+  CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
+  CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
+  CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
+  CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
+  CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
+  CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
+  CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
+  CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
+})(CharacterCodes || (CharacterCodes = {}));
+
+// ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/string-intern.js
+var cachedSpaces = new Array(20).fill(0).map((_, index) => {
+  return " ".repeat(index);
+});
+var maxCachedValues = 200;
+var cachedBreakLinesWithSpaces = {
+  " ": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `
+` + " ".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + " ".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `\r
+` + " ".repeat(index);
+    })
+  },
+  "\t": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `
+` + "\t".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + "\t".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `\r
+` + "\t".repeat(index);
+    })
+  }
+};
+
+// ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/parser.js
+var ParseOptions;
+(function(ParseOptions2) {
+  ParseOptions2.DEFAULT = {
+    allowTrailingComma: false
+  };
+})(ParseOptions || (ParseOptions = {}));
+function parseTree(text, errors3 = [], options = ParseOptions.DEFAULT) {
+  let currentParent = { type: "array", offset: -1, length: -1, children: [], parent: undefined };
+  function ensurePropertyComplete(endOffset) {
+    if (currentParent.type === "property") {
+      currentParent.length = endOffset - currentParent.offset;
+      currentParent = currentParent.parent;
+    }
+  }
+  function onValue(valueNode) {
+    currentParent.children.push(valueNode);
+    return valueNode;
+  }
+  const visitor = {
+    onObjectBegin: (offset) => {
+      currentParent = onValue({ type: "object", offset, length: -1, parent: currentParent, children: [] });
+    },
+    onObjectProperty: (name, offset, length) => {
+      currentParent = onValue({ type: "property", offset, length: -1, parent: currentParent, children: [] });
+      currentParent.children.push({ type: "string", value: name, offset, length, parent: currentParent });
+    },
+    onObjectEnd: (offset, length) => {
+      ensurePropertyComplete(offset + length);
+      currentParent.length = offset + length - currentParent.offset;
+      currentParent = currentParent.parent;
+      ensurePropertyComplete(offset + length);
+    },
+    onArrayBegin: (offset, length) => {
+      currentParent = onValue({ type: "array", offset, length: -1, parent: currentParent, children: [] });
+    },
+    onArrayEnd: (offset, length) => {
+      currentParent.length = offset + length - currentParent.offset;
+      currentParent = currentParent.parent;
+      ensurePropertyComplete(offset + length);
+    },
+    onLiteralValue: (value, offset, length) => {
+      onValue({ type: getNodeType(value), offset, length, parent: currentParent, value });
+      ensurePropertyComplete(offset + length);
+    },
+    onSeparator: (sep2, offset, length) => {
+      if (currentParent.type === "property") {
+        if (sep2 === ":") {
+          currentParent.colonOffset = offset;
+        } else if (sep2 === ",") {
+          ensurePropertyComplete(offset);
+        }
+      }
+    },
+    onError: (error, offset, length) => {
+      errors3.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  const result = currentParent.children[0];
+  if (result) {
+    delete result.parent;
+  }
+  return result;
+}
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+  const _scanner = createScanner(text, false);
+  const _jsonPath = [];
+  let suppressedCallbacks = 0;
+  function toNoArgVisit(visitFunction) {
+    return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisit(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisitWithPath(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+  }
+  function toBeginVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks++;
+      } else {
+        let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice());
+        if (cbReturn === false) {
+          suppressedCallbacks = 1;
+        }
+      }
+    } : () => true;
+  }
+  function toEndVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks--;
+      }
+      if (suppressedCallbacks === 0) {
+        visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
+      }
+    } : () => true;
+  }
+  const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+  const disallowComments = options && options.disallowComments;
+  const allowTrailingComma = options && options.allowTrailingComma;
+  function scanNext() {
+    while (true) {
+      const token = _scanner.scan();
+      switch (_scanner.getTokenError()) {
+        case 4:
+          handleError(14);
+          break;
+        case 5:
+          handleError(15);
+          break;
+        case 3:
+          handleError(13);
+          break;
+        case 1:
+          if (!disallowComments) {
+            handleError(11);
+          }
+          break;
+        case 2:
+          handleError(12);
+          break;
+        case 6:
+          handleError(16);
+          break;
+      }
+      switch (token) {
+        case 12:
+        case 13:
+          if (disallowComments) {
+            handleError(10);
+          } else {
+            onComment();
+          }
+          break;
+        case 16:
+          handleError(1);
+          break;
+        case 15:
+        case 14:
+          break;
+        default:
+          return token;
+      }
+    }
+  }
+  function handleError(error, skipUntilAfter = [], skipUntil = []) {
+    onError(error);
+    if (skipUntilAfter.length + skipUntil.length > 0) {
+      let token = _scanner.getToken();
+      while (token !== 17) {
+        if (skipUntilAfter.indexOf(token) !== -1) {
+          scanNext();
+          break;
+        } else if (skipUntil.indexOf(token) !== -1) {
+          break;
+        }
+        token = scanNext();
+      }
+    }
+  }
+  function parseString(isValue) {
+    const value = _scanner.getTokenValue();
+    if (isValue) {
+      onLiteralValue(value);
+    } else {
+      onObjectProperty(value);
+      _jsonPath.push(value);
+    }
+    scanNext();
+    return true;
+  }
+  function parseLiteral() {
+    switch (_scanner.getToken()) {
+      case 11:
+        const tokenValue = _scanner.getTokenValue();
+        let value = Number(tokenValue);
+        if (isNaN(value)) {
+          handleError(2);
+          value = 0;
+        }
+        onLiteralValue(value);
+        break;
+      case 7:
+        onLiteralValue(null);
+        break;
+      case 8:
+        onLiteralValue(true);
+        break;
+      case 9:
+        onLiteralValue(false);
+        break;
+      default:
+        return false;
+    }
+    scanNext();
+    return true;
+  }
+  function parseProperty() {
+    if (_scanner.getToken() !== 10) {
+      handleError(3, [], [2, 5]);
+      return false;
+    }
+    parseString(false);
+    if (_scanner.getToken() === 6) {
+      onSeparator(":");
+      scanNext();
+      if (!parseValue()) {
+        handleError(4, [], [2, 5]);
+      }
+    } else {
+      handleError(5, [], [2, 5]);
+    }
+    _jsonPath.pop();
+    return true;
+  }
+  function parseObject() {
+    onObjectBegin();
+    scanNext();
+    let needsComma = false;
+    while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 2 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (!parseProperty()) {
+        handleError(4, [], [2, 5]);
+      }
+      needsComma = true;
+    }
+    onObjectEnd();
+    if (_scanner.getToken() !== 2) {
+      handleError(7, [2], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseArray() {
+    onArrayBegin();
+    scanNext();
+    let isFirstElement = true;
+    let needsComma = false;
+    while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 4 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (isFirstElement) {
+        _jsonPath.push(0);
+        isFirstElement = false;
+      } else {
+        _jsonPath[_jsonPath.length - 1]++;
+      }
+      if (!parseValue()) {
+        handleError(4, [], [4, 5]);
+      }
+      needsComma = true;
+    }
+    onArrayEnd();
+    if (!isFirstElement) {
+      _jsonPath.pop();
+    }
+    if (_scanner.getToken() !== 4) {
+      handleError(8, [4], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseValue() {
+    switch (_scanner.getToken()) {
+      case 3:
+        return parseArray();
+      case 1:
+        return parseObject();
+      case 10:
+        return parseString(true);
+      default:
+        return parseLiteral();
+    }
+  }
+  scanNext();
+  if (_scanner.getToken() === 17) {
+    if (options.allowEmptyContent) {
+      return true;
+    }
+    handleError(4, [], []);
+    return false;
+  }
+  if (!parseValue()) {
+    handleError(4, [], []);
+    return false;
+  }
+  if (_scanner.getToken() !== 17) {
+    handleError(9, [], []);
+  }
+  return true;
+}
+function getNodeType(value) {
+  switch (typeof value) {
+    case "boolean":
+      return "boolean";
+    case "number":
+      return "number";
+    case "string":
+      return "string";
+    case "object": {
+      if (!value) {
+        return "null";
+      } else if (Array.isArray(value)) {
+        return "array";
+      }
+      return "object";
+    }
+    default:
+      return "null";
+  }
+}
+
+// ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/main.js
+var ScanError;
+(function(ScanError2) {
+  ScanError2[ScanError2["None"] = 0] = "None";
+  ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+  ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+  ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+  ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
+  ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+  ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+var SyntaxKind;
+(function(SyntaxKind2) {
+  SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
+  SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
+  SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
+  SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
+  SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
+  SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
+  SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
+  SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
+  SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
+  SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
+  SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
+  SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+  SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+  SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+  SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
+  SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
+  SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
+var parseTree2 = parseTree;
+var ParseErrorCode;
+(function(ParseErrorCode2) {
+  ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
+  ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+  ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+  ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
+  ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
+  ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+  ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+  ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+  ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
+  ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+  ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
+
 // ../../node_modules/.bun/eslint-visitor-keys@5.0.1/node_modules/eslint-visitor-keys/lib/visitor-keys.js
 var KEYS = {
   ArrayExpression: ["elements"],
@@ -16766,7 +17632,7 @@ function isControl(cp) {
 function isWhitespace(cp) {
   return cp === CodePoint.TABULATION || cp === CodePoint.SPACE;
 }
-function isEOL(cp) {
+function isEOL2(cp) {
   return cp === CodePoint.LINE_FEED || cp === CodePoint.CARRIAGE_RETURN;
 }
 function isUpperLetter(cp) {
@@ -16778,11 +17644,11 @@ function isLowerLetter(cp) {
 function isLetter(cp) {
   return isLowerLetter(cp) || isUpperLetter(cp);
 }
-function isDigit(cp) {
+function isDigit2(cp) {
   return cp >= CodePoint.DIGIT_0 && cp <= CodePoint.DIGIT_9;
 }
 function isHexDig(cp) {
-  return isDigit(cp) || cp >= CodePoint.LATIN_SMALL_A && cp <= CodePoint.LATIN_SMALL_F || cp >= CodePoint.LATIN_CAPITAL_A && cp <= CodePoint.LATIN_CAPITAL_F;
+  return isDigit2(cp) || cp >= CodePoint.LATIN_SMALL_A && cp <= CodePoint.LATIN_SMALL_F || cp >= CodePoint.LATIN_CAPITAL_A && cp <= CodePoint.LATIN_CAPITAL_F;
 }
 function isOctalDig(cp) {
   return cp >= CodePoint.DIGIT_0 && cp <= CodePoint.DIGIT_7;
@@ -17044,7 +17910,7 @@ var Tokenizer = class {
     }
   }
   DATA(cp) {
-    while (isWhitespace(cp) || isEOL(cp))
+    while (isWhitespace(cp) || isEOL2(cp))
       cp = this.nextCode();
     if (cp === CodePoint.HASH) {
       this.startToken();
@@ -17071,7 +17937,7 @@ var Tokenizer = class {
         this.startToken();
         return this.back("NAN_OR_INF");
       }
-      if (isDigit(cp)) {
+      if (isDigit2(cp)) {
         this.startToken();
         return this.back("NUMBER");
       }
@@ -17095,7 +17961,7 @@ var Tokenizer = class {
       if (isControlOtherThanTab(c))
         this.reportParseErrorControlChar();
     };
-    while (!isEOL(cp) && cp !== CodePoint.EOF) {
+    while (!isEOL2(cp) && cp !== CodePoint.EOF) {
       processCommentChar(cp);
       cp = this.nextCode();
     }
@@ -17285,7 +18151,7 @@ var Tokenizer = class {
   SIGN(cp) {
     if (cp === CodePoint.LATIN_SMALL_N || cp === CodePoint.LATIN_SMALL_I)
       return this.back("NAN_OR_INF");
-    if (isDigit(cp))
+    if (isDigit2(cp))
       return this.back("NUMBER");
     return this.reportParseError("unexpected-char");
   }
@@ -17314,7 +18180,7 @@ var Tokenizer = class {
       if (sign === CodePoint.NULL) {
         const startPos = this.codePointIterator.start;
         const nextCp$1 = this.nextCode();
-        if (isDigit(nextCp$1)) {
+        if (isDigit2(nextCp$1)) {
           const nextNextCp = this.nextCode();
           if (nextNextCp === CodePoint.COLON) {
             this.data = {
@@ -17328,9 +18194,9 @@ var Tokenizer = class {
             };
             return "TIME_MINUTE";
           }
-          if (isDigit(nextNextCp)) {
+          if (isDigit2(nextNextCp)) {
             const nextNextNextCp = this.nextCode();
-            if (isDigit(nextNextNextCp) && this.eatCode(CodePoint.DASH)) {
+            if (isDigit2(nextNextNextCp) && this.eatCode(CodePoint.DASH)) {
               this.data = {
                 hasDate: true,
                 year: Number(String.fromCodePoint(CodePoint.DIGIT_0, nextCp$1, nextNextCp, nextNextNextCp)),
@@ -17371,7 +18237,7 @@ var Tokenizer = class {
       this.endToken("Integer", "start", "0", 10);
       return this.back("DATA");
     }
-    const { out, nextCp, hasUnderscore } = this.parseDigits(cp, isDigit);
+    const { out, nextCp, hasUnderscore } = this.parseDigits(cp, isDigit2);
     if (nextCp === CodePoint.DASH && sign === CodePoint.NULL && !hasUnderscore && out.length === 4) {
       this.data = {
         hasDate: true,
@@ -17430,7 +18296,7 @@ var Tokenizer = class {
   }
   FRACTIONAL_RIGHT(cp) {
     const { minus, absInt } = this.data;
-    const { out, nextCp } = this.parseDigits(cp, isDigit);
+    const { out, nextCp } = this.parseDigits(cp, isDigit2);
     const absNum = [
       ...absInt,
       CodePoint.DOT,
@@ -17454,7 +18320,7 @@ var Tokenizer = class {
       minus = cp === CodePoint.DASH;
       cp = this.nextCode();
     }
-    const { out } = this.parseDigits(cp, isDigit);
+    const { out } = this.parseDigits(cp, isDigit2);
     const right = out;
     if (minus)
       right.unshift(CodePoint.DASH);
@@ -17482,10 +18348,10 @@ var Tokenizer = class {
   }
   DATE_MONTH(cp) {
     const start = this.codePointIterator.start;
-    if (!isDigit(cp))
+    if (!isDigit2(cp))
       return this.reportParseError("unexpected-char");
     cp = this.nextCode();
-    if (!isDigit(cp))
+    if (!isDigit2(cp))
       return this.reportParseError("unexpected-char");
     cp = this.nextCode();
     if (cp !== CodePoint.DASH)
@@ -17497,10 +18363,10 @@ var Tokenizer = class {
   }
   DATE_DAY(cp) {
     const start = this.codePointIterator.start;
-    if (!isDigit(cp))
+    if (!isDigit2(cp))
       return this.reportParseError("unexpected-char");
     cp = this.nextCode();
-    if (!isDigit(cp))
+    if (!isDigit2(cp))
       return this.reportParseError("unexpected-char");
     const end = this.codePointIterator.end;
     const data = this.data;
@@ -17512,7 +18378,7 @@ var Tokenizer = class {
       return "TIME_HOUR";
     if (cp === CodePoint.SPACE) {
       const startPos = this.codePointIterator.start;
-      if (isDigit(this.nextCode()) && isDigit(this.nextCode())) {
+      if (isDigit2(this.nextCode()) && isDigit2(this.nextCode())) {
         this.moveAt(startPos);
         return "TIME_HOUR";
       }
@@ -17524,10 +18390,10 @@ var Tokenizer = class {
   }
   TIME_HOUR(cp) {
     const start = this.codePointIterator.start;
-    if (!isDigit(cp))
+    if (!isDigit2(cp))
       return this.reportParseError("unexpected-char");
     cp = this.nextCode();
-    if (!isDigit(cp))
+    if (!isDigit2(cp))
       return this.reportParseError("unexpected-char");
     cp = this.nextCode();
     if (cp !== CodePoint.COLON)
@@ -17539,10 +18405,10 @@ var Tokenizer = class {
   }
   TIME_MINUTE(cp) {
     const start = this.codePointIterator.start;
-    if (!isDigit(cp))
+    if (!isDigit2(cp))
       return this.reportParseError("unexpected-char");
     cp = this.nextCode();
-    if (!isDigit(cp))
+    if (!isDigit2(cp))
       return this.reportParseError("unexpected-char");
     const end = this.codePointIterator.end;
     const data = this.data;
@@ -17558,10 +18424,10 @@ var Tokenizer = class {
   }
   TIME_SECOND(cp) {
     const start = this.codePointIterator.start;
-    if (!isDigit(cp))
+    if (!isDigit2(cp))
       return this.reportParseError("unexpected-char");
     cp = this.nextCode();
-    if (!isDigit(cp))
+    if (!isDigit2(cp))
       return this.reportParseError("unexpected-char");
     const end = this.codePointIterator.end;
     const data = this.data;
@@ -17574,10 +18440,10 @@ var Tokenizer = class {
     return this.processTimeEnd(cp, data);
   }
   TIME_SEC_FRAC(cp) {
-    if (!isDigit(cp))
+    if (!isDigit2(cp))
       return this.reportParseError("unexpected-char");
     const start = this.codePointIterator.start;
-    while (isDigit(cp))
+    while (isDigit2(cp))
       cp = this.nextCode();
     const end = this.codePointIterator.start;
     const data = this.data;
@@ -17604,11 +18470,11 @@ var Tokenizer = class {
     return this.back("DATA");
   }
   TIME_OFFSET(cp) {
-    if (!isDigit(cp))
+    if (!isDigit2(cp))
       return this.reportParseError("unexpected-char");
     const hourStart = this.codePointIterator.start;
     cp = this.nextCode();
-    if (!isDigit(cp))
+    if (!isDigit2(cp))
       return this.reportParseError("unexpected-char");
     cp = this.nextCode();
     if (cp !== CodePoint.COLON)
@@ -17616,10 +18482,10 @@ var Tokenizer = class {
     const hourEnd = this.codePointIterator.start;
     cp = this.nextCode();
     const minuteStart = this.codePointIterator.start;
-    if (!isDigit(cp))
+    if (!isDigit2(cp))
       return this.reportParseError("unexpected-char");
     cp = this.nextCode();
-    if (!isDigit(cp))
+    if (!isDigit2(cp))
       return this.reportParseError("unexpected-char");
     const minuteEnd = this.codePointIterator.end;
     const hour = Number(this.text.slice(hourStart, hourEnd));
@@ -17683,7 +18549,7 @@ var Tokenizer = class {
   }
 };
 function isUnquotedKeyChar(cp, tomlVersion) {
-  if (isLetter(cp) || isDigit(cp) || cp === CodePoint.UNDERSCORE || cp === CodePoint.DASH)
+  if (isLetter(cp) || isDigit2(cp) || cp === CodePoint.UNDERSCORE || cp === CodePoint.DASH)
     return true;
   if (tomlVersion.lt(1, 1))
     return false;
@@ -18762,11 +19628,9 @@ function yamlLocation(document, lineCounter, logicalPath, documentPrefixLength)
   const position = lineCounter.linePos(offset);
   return { line: position.line, column: position.col };
 }
-function parseYamlLike(context, source, strictJson) {
-  if (strictJson)
-    JSON.parse(source);
+function parseYamlLike(context, source) {
   const lineCounter = new import_yaml2.LineCounter;
-  const documents = strictJson ? [import_yaml2.parseDocument(source, { lineCounter, schema: "json", strict: true, uniqueKeys: true })] : import_yaml2.parseAllDocuments(source, { lineCounter, strict: true, uniqueKeys: true });
+  const documents = import_yaml2.parseAllDocuments(source, { lineCounter, strict: true, uniqueKeys: true });
   if (documents.length === 0)
     throw new TypeError("configuration document is empty");
   for (const [documentIndex, document] of documents.entries()) {
@@ -18778,6 +19642,74 @@ function parseYamlLike(context, source, strictJson) {
     walkValue(context, value, prefix, (path5) => yamlLocation(document, lineCounter, path5, prefix.length));
   }
 }
+function jsonLineStarts(source) {
+  const starts = [0];
+  for (let index = 0;index < source.length; index += 1) {
+    if (source.charCodeAt(index) === 10)
+      starts.push(index + 1);
+  }
+  return starts;
+}
+function jsonLocation(lineStarts, offset) {
+  let low = 0;
+  let high = lineStarts.length;
+  while (low + 1 < high) {
+    const middle = Math.floor((low + high) / 2);
+    if (lineStarts[middle] <= offset)
+      low = middle;
+    else
+      high = middle;
+  }
+  return { line: low + 1, column: offset - lineStarts[low] + 1 };
+}
+function jsonScalar(node2) {
+  if (node2.type === "null")
+    return null;
+  if (node2.type === "string" || node2.type === "number" || node2.type === "boolean") {
+    return node2.value;
+  }
+  throw new TypeError(`unsupported JSON scalar node ${node2.type}`);
+}
+function walkJsonNode(context, node2, keyPath, lineStarts) {
+  const location = jsonLocation(lineStarts, node2.offset);
+  if (node2.type === "object") {
+    addValue(context, keyPath, {}, location);
+    const keys = new Set;
+    for (const property of node2.children ?? []) {
+      const [keyNode, valueNode] = property.children ?? [];
+      if (property.type !== "property" || keyNode?.type !== "string" || typeof keyNode.value !== "string" || valueNode === undefined) {
+        throw new TypeError("JSON object property is unstable");
+      }
+      if (keys.has(keyNode.value))
+        throw new TypeError("JSON object contains a duplicate key");
+      keys.add(keyNode.value);
+      walkJsonNode(context, valueNode, [...keyPath, keyNode.value], lineStarts);
+    }
+    return;
+  }
+  if (node2.type === "array") {
+    addValue(context, keyPath, [], location);
+    for (const [index, child] of (node2.children ?? []).entries()) {
+      walkJsonNode(context, child, [...keyPath, String(index)], lineStarts);
+    }
+    return;
+  }
+  if (node2.type === "property")
+    throw new TypeError("JSON property cannot be a value root");
+  addValue(context, keyPath, jsonScalar(node2), location);
+}
+function parseJsonLike(context, source) {
+  const errors3 = [];
+  const root = parseTree2(source, errors3, {
+    allowTrailingComma: true,
+    disallowComments: false,
+    allowEmptyContent: false
+  });
+  if (root === undefined || errors3.length > 0) {
+    throw new TypeError("JSON configuration syntax is invalid");
+  }
+  walkJsonNode(context, root, [], jsonLineStarts(source));
+}
 function tomlKey(node2) {
   return node2.keys.map((item) => item.type === "TOMLBare" ? item.name : item.value);
 }
@@ -18860,31 +19792,33 @@ function validatedAllowlists(options) {
   }
   return byFile;
 }
-function parseOne(path5, source, format, allowlist) {
-  if (format === "excluded")
-    return { path: path5, format, disposition: "excluded", values: [], diagnostics: [] };
+function parseOne(path5, source, format2, allowlist) {
+  if (format2 === "excluded")
+    return { path: path5, format: format2, disposition: "excluded", values: [], diagnostics: [] };
   const context = {
     path: path5,
-    format,
-    configRef: `config:${indexerEvidenceAdapterProtocolDigest({ path: path5, format })}`,
+    format: format2,
+    configRef: `config:${indexerEvidenceAdapterProtocolDigest({ path: path5, format: format2 })}`,
     allowlist,
     diagnostics: [],
     values: []
   };
   try {
-    if (format === "toml")
+    if (format2 === "toml")
       parseToml(context, source);
+    else if (format2 === "json")
+      parseJsonLike(context, source);
     else
-      parseYamlLike(context, source, format === "json");
-    return { path: path5, format, disposition: "analyzed", values: context.values, diagnostics: context.diagnostics };
+      parseYamlLike(context, source);
+    return { path: path5, format: format2, disposition: "analyzed", values: context.values, diagnostics: context.diagnostics };
   } catch {
     const root = locator(path5, [], { line: 1, column: 1 });
     return {
       path: path5,
-      format,
+      format: format2,
       disposition: "unsupported",
       values: [],
-      diagnostics: [{ code: "config-source-unsupported", severity: "error", locator: root, detail: `${format} configuration could not be analyzed` }]
+      diagnostics: [{ code: "config-source-unsupported", severity: "error", locator: root, detail: `${format2} configuration could not be analyzed` }]
     };
   }
 }
@@ -19119,7 +20053,7 @@ var detectTechStack = async (repoPath) => {
 };
 
 // src/index.ts
-var CONFIG_EVIDENCE_ADAPTER_EXPORT = "configSourcesToEvidenceAdapterResult";
+var CONFIG_EVIDENCE_ADAPTER_EXPORT = "configSourcesToEvidenceAdapterMaterialization";
 export {
   visibilitySchema,
   truncateSourceSpanHash,