Initial commit: n8n Strike API node

- Add Strike API credentials configuration
- Implement Strike node with 9 resources (Account, Balance, Currency Exchange, Deposit, Invoice, Payment, Payment Method, Payout, Rates)
- Add comprehensive operation descriptions for all resources
- Include CLAUDE.MD documentation
- Set up build configuration with TypeScript, ESLint, and Prettier

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

node_modules/jsonrepair/lib/cjs/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "JSONRepairError", {
+  enumerable: true,
+  get: function () {
+    return _JSONRepairError.JSONRepairError;
+  }
+});
+Object.defineProperty(exports, "jsonrepair", {
+  enumerable: true,
+  get: function () {
+    return _jsonrepair.jsonrepair;
+  }
+});
+var _jsonrepair = require("./regular/jsonrepair.js");
+var _JSONRepairError = require("./utils/JSONRepairError.js");
+//# sourceMappingURL=index.js.map

node_modules/jsonrepair/lib/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_jsonrepair","require","_JSONRepairError"],"sources":["../../src/index.ts"],"sourcesContent":["// Cross-platform, non-streaming JavaScript API\nexport { jsonrepair } from './regular/jsonrepair.js'\nexport { JSONRepairError } from './utils/JSONRepairError.js'\n"],"mappings":";;;;;;;;;;;;;;;;;AACA,IAAAA,WAAA,GAAAC,OAAA;AACA,IAAAC,gBAAA,GAAAD,OAAA","ignoreList":[]}

node_modules/jsonrepair/lib/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

node_modules/jsonrepair/lib/cjs/regular/jsonrepair.js

@@ -0,0 +1,746 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.jsonrepair = jsonrepair;
+var _JSONRepairError = require("../utils/JSONRepairError.js");
+var _stringUtils = require("../utils/stringUtils.js");
+const controlCharacters = {
+  '\b': '\\b',
+  '\f': '\\f',
+  '\n': '\\n',
+  '\r': '\\r',
+  '\t': '\\t'
+};
+
+// map with all escape characters
+const escapeCharacters = {
+  '"': '"',
+  '\\': '\\',
+  '/': '/',
+  b: '\b',
+  f: '\f',
+  n: '\n',
+  r: '\r',
+  t: '\t'
+  // note that \u is handled separately in parseString()
+};
+
+/**
+ * Repair a string containing an invalid JSON document.
+ * For example changes JavaScript notation into JSON notation.
+ *
+ * Example:
+ *
+ *     try {
+ *       const json = "{name: 'John'}"
+ *       const repaired = jsonrepair(json)
+ *       console.log(repaired)
+ *       // '{"name": "John"}'
+ *     } catch (err) {
+ *       console.error(err)
+ *     }
+ *
+ */
+function jsonrepair(text) {
+  let i = 0; // current index in text
+  let output = ''; // generated output
+
+  parseMarkdownCodeBlock(['```', '[```', '{```']);
+  const processed = parseValue();
+  if (!processed) {
+    throwUnexpectedEnd();
+  }
+  parseMarkdownCodeBlock(['```', '```]', '```}']);
+  const processedComma = parseCharacter(',');
+  if (processedComma) {
+    parseWhitespaceAndSkipComments();
+  }
+  if ((0, _stringUtils.isStartOfValue)(text[i]) && (0, _stringUtils.endsWithCommaOrNewline)(output)) {
+    // start of a new value after end of the root level object: looks like
+    // newline delimited JSON -> turn into a root level array
+    if (!processedComma) {
+      // repair missing comma
+      output = (0, _stringUtils.insertBeforeLastWhitespace)(output, ',');
+    }
+    parseNewlineDelimitedJSON();
+  } else if (processedComma) {
+    // repair: remove trailing comma
+    output = (0, _stringUtils.stripLastOccurrence)(output, ',');
+  }
+
+  // repair redundant end quotes
+  while (text[i] === '}' || text[i] === ']') {
+    i++;
+    parseWhitespaceAndSkipComments();
+  }
+  if (i >= text.length) {
+    // reached the end of the document properly
+    return output;
+  }
+  throwUnexpectedCharacter();
+  function parseValue() {
+    parseWhitespaceAndSkipComments();
+    const processed = parseObject() || parseArray() || parseString() || parseNumber() || parseKeywords() || parseUnquotedString(false) || parseRegex();
+    parseWhitespaceAndSkipComments();
+    return processed;
+  }
+  function parseWhitespaceAndSkipComments() {
+    let skipNewline = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+    const start = i;
+    let changed = parseWhitespace(skipNewline);
+    do {
+      changed = parseComment();
+      if (changed) {
+        changed = parseWhitespace(skipNewline);
+      }
+    } while (changed);
+    return i > start;
+  }
+  function parseWhitespace(skipNewline) {
+    const _isWhiteSpace = skipNewline ? _stringUtils.isWhitespace : _stringUtils.isWhitespaceExceptNewline;
+    let whitespace = '';
+    while (true) {
+      if (_isWhiteSpace(text, i)) {
+        whitespace += text[i];
+        i++;
+      } else if ((0, _stringUtils.isSpecialWhitespace)(text, i)) {
+        // repair special whitespace
+        whitespace += ' ';
+        i++;
+      } else {
+        break;
+      }
+    }
+    if (whitespace.length > 0) {
+      output += whitespace;
+      return true;
+    }
+    return false;
+  }
+  function parseComment() {
+    // find a block comment '/* ... */'
+    if (text[i] === '/' && text[i + 1] === '*') {
+      // repair block comment by skipping it
+      while (i < text.length && !atEndOfBlockComment(text, i)) {
+        i++;
+      }
+      i += 2;
+      return true;
+    }
+
+    // find a line comment '// ...'
+    if (text[i] === '/' && text[i + 1] === '/') {
+      // repair line comment by skipping it
+      while (i < text.length && text[i] !== '\n') {
+        i++;
+      }
+      return true;
+    }
+    return false;
+  }
+  function parseMarkdownCodeBlock(blocks) {
+    // find and skip over a Markdown fenced code block:
+    //     ``` ... ```
+    // or
+    //     ```json ... ```
+    if (skipMarkdownCodeBlock(blocks)) {
+      if ((0, _stringUtils.isFunctionNameCharStart)(text[i])) {
+        // strip the optional language specifier like "json"
+        while (i < text.length && (0, _stringUtils.isFunctionNameChar)(text[i])) {
+          i++;
+        }
+      }
+      parseWhitespaceAndSkipComments();
+      return true;
+    }
+    return false;
+  }
+  function skipMarkdownCodeBlock(blocks) {
+    parseWhitespace(true);
+    for (const block of blocks) {
+      const end = i + block.length;
+      if (text.slice(i, end) === block) {
+        i = end;
+        return true;
+      }
+    }
+    return false;
+  }
+  function parseCharacter(char) {
+    if (text[i] === char) {
+      output += text[i];
+      i++;
+      return true;
+    }
+    return false;
+  }
+  function skipCharacter(char) {
+    if (text[i] === char) {
+      i++;
+      return true;
+    }
+    return false;
+  }
+  function skipEscapeCharacter() {
+    return skipCharacter('\\');
+  }
+
+  /**
+   * Skip ellipsis like "[1,2,3,...]" or "[1,2,3,...,9]" or "[...,7,8,9]"
+   * or a similar construct in objects.
+   */
+  function skipEllipsis() {
+    parseWhitespaceAndSkipComments();
+    if (text[i] === '.' && text[i + 1] === '.' && text[i + 2] === '.') {
+      // repair: remove the ellipsis (three dots) and optionally a comma
+      i += 3;
+      parseWhitespaceAndSkipComments();
+      skipCharacter(',');
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Parse an object like '{"key": "value"}'
+   */
+  function parseObject() {
+    if (text[i] === '{') {
+      output += '{';
+      i++;
+      parseWhitespaceAndSkipComments();
+
+      // repair: skip leading comma like in {, message: "hi"}
+      if (skipCharacter(',')) {
+        parseWhitespaceAndSkipComments();
+      }
+      let initial = true;
+      while (i < text.length && text[i] !== '}') {
+        let processedComma;
+        if (!initial) {
+          processedComma = parseCharacter(',');
+          if (!processedComma) {
+            // repair missing comma
+            output = (0, _stringUtils.insertBeforeLastWhitespace)(output, ',');
+          }
+          parseWhitespaceAndSkipComments();
+        } else {
+          processedComma = true;
+          initial = false;
+        }
+        skipEllipsis();
+        const processedKey = parseString() || parseUnquotedString(true);
+        if (!processedKey) {
+          if (text[i] === '}' || text[i] === '{' || text[i] === ']' || text[i] === '[' || text[i] === undefined) {
+            // repair trailing comma
+            output = (0, _stringUtils.stripLastOccurrence)(output, ',');
+          } else {
+            throwObjectKeyExpected();
+          }
+          break;
+        }
+        parseWhitespaceAndSkipComments();
+        const processedColon = parseCharacter(':');
+        const truncatedText = i >= text.length;
+        if (!processedColon) {
+          if ((0, _stringUtils.isStartOfValue)(text[i]) || truncatedText) {
+            // repair missing colon
+            output = (0, _stringUtils.insertBeforeLastWhitespace)(output, ':');
+          } else {
+            throwColonExpected();
+          }
+        }
+        const processedValue = parseValue();
+        if (!processedValue) {
+          if (processedColon || truncatedText) {
+            // repair missing object value
+            output += 'null';
+          } else {
+            throwColonExpected();
+          }
+        }
+      }
+      if (text[i] === '}') {
+        output += '}';
+        i++;
+      } else {
+        // repair missing end bracket
+        output = (0, _stringUtils.insertBeforeLastWhitespace)(output, '}');
+      }
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Parse an array like '["item1", "item2", ...]'
+   */
+  function parseArray() {
+    if (text[i] === '[') {
+      output += '[';
+      i++;
+      parseWhitespaceAndSkipComments();
+
+      // repair: skip leading comma like in [,1,2,3]
+      if (skipCharacter(',')) {
+        parseWhitespaceAndSkipComments();
+      }
+      let initial = true;
+      while (i < text.length && text[i] !== ']') {
+        if (!initial) {
+          const processedComma = parseCharacter(',');
+          if (!processedComma) {
+            // repair missing comma
+            output = (0, _stringUtils.insertBeforeLastWhitespace)(output, ',');
+          }
+        } else {
+          initial = false;
+        }
+        skipEllipsis();
+        const processedValue = parseValue();
+        if (!processedValue) {
+          // repair trailing comma
+          output = (0, _stringUtils.stripLastOccurrence)(output, ',');
+          break;
+        }
+      }
+      if (text[i] === ']') {
+        output += ']';
+        i++;
+      } else {
+        // repair missing closing array bracket
+        output = (0, _stringUtils.insertBeforeLastWhitespace)(output, ']');
+      }
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Parse and repair Newline Delimited JSON (NDJSON):
+   * multiple JSON objects separated by a newline character
+   */
+  function parseNewlineDelimitedJSON() {
+    // repair NDJSON
+    let initial = true;
+    let processedValue = true;
+    while (processedValue) {
+      if (!initial) {
+        // parse optional comma, insert when missing
+        const processedComma = parseCharacter(',');
+        if (!processedComma) {
+          // repair: add missing comma
+          output = (0, _stringUtils.insertBeforeLastWhitespace)(output, ',');
+        }
+      } else {
+        initial = false;
+      }
+      processedValue = parseValue();
+    }
+    if (!processedValue) {
+      // repair: remove trailing comma
+      output = (0, _stringUtils.stripLastOccurrence)(output, ',');
+    }
+
+    // repair: wrap the output inside array brackets
+    output = `[\n${output}\n]`;
+  }
+
+  /**
+   * Parse a string enclosed by double quotes "...". Can contain escaped quotes
+   * Repair strings enclosed in single quotes or special quotes
+   * Repair an escaped string
+   *
+   * The function can run in two stages:
+   * - First, it assumes the string has a valid end quote
+   * - If it turns out that the string does not have a valid end quote followed
+   *   by a delimiter (which should be the case), the function runs again in a
+   *   more conservative way, stopping the string at the first next delimiter
+   *   and fixing the string by inserting a quote there, or stopping at a
+   *   stop index detected in the first iteration.
+   */
+  function parseString() {
+    let stopAtDelimiter = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    let stopAtIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : -1;
+    let skipEscapeChars = text[i] === '\\';
+    if (skipEscapeChars) {
+      // repair: remove the first escape character
+      i++;
+      skipEscapeChars = true;
+    }
+    if ((0, _stringUtils.isQuote)(text[i])) {
+      // double quotes are correct JSON,
+      // single quotes come from JavaScript for example, we assume it will have a correct single end quote too
+      // otherwise, we will match any double-quote-like start with a double-quote-like end,
+      // or any single-quote-like start with a single-quote-like end
+      const isEndQuote = (0, _stringUtils.isDoubleQuote)(text[i]) ? _stringUtils.isDoubleQuote : (0, _stringUtils.isSingleQuote)(text[i]) ? _stringUtils.isSingleQuote : (0, _stringUtils.isSingleQuoteLike)(text[i]) ? _stringUtils.isSingleQuoteLike : _stringUtils.isDoubleQuoteLike;
+      const iBefore = i;
+      const oBefore = output.length;
+      let str = '"';
+      i++;
+      while (true) {
+        if (i >= text.length) {
+          // end of text, we are missing an end quote
+
+          const iPrev = prevNonWhitespaceIndex(i - 1);
+          if (!stopAtDelimiter && (0, _stringUtils.isDelimiter)(text.charAt(iPrev))) {
+            // if the text ends with a delimiter, like ["hello],
+            // so the missing end quote should be inserted before this delimiter
+            // retry parsing the string, stopping at the first next delimiter
+            i = iBefore;
+            output = output.substring(0, oBefore);
+            return parseString(true);
+          }
+
+          // repair missing quote
+          str = (0, _stringUtils.insertBeforeLastWhitespace)(str, '"');
+          output += str;
+          return true;
+        }
+        if (i === stopAtIndex) {
+          // use the stop index detected in the first iteration, and repair end quote
+          str = (0, _stringUtils.insertBeforeLastWhitespace)(str, '"');
+          output += str;
+          return true;
+        }
+        if (isEndQuote(text[i])) {
+          // end quote
+          // let us check what is before and after the quote to verify whether this is a legit end quote
+          const iQuote = i;
+          const oQuote = str.length;
+          str += '"';
+          i++;
+          output += str;
+          parseWhitespaceAndSkipComments(false);
+          if (stopAtDelimiter || i >= text.length || (0, _stringUtils.isDelimiter)(text[i]) || (0, _stringUtils.isQuote)(text[i]) || (0, _stringUtils.isDigit)(text[i])) {
+            // The quote is followed by the end of the text, a delimiter,
+            // or a next value. So the quote is indeed the end of the string.
+            parseConcatenatedString();
+            return true;
+          }
+          const iPrevChar = prevNonWhitespaceIndex(iQuote - 1);
+          const prevChar = text.charAt(iPrevChar);
+          if (prevChar === ',') {
+            // A comma followed by a quote, like '{"a":"b,c,"d":"e"}'.
+            // We assume that the quote is a start quote, and that the end quote
+            // should have been located right before the comma but is missing.
+            i = iBefore;
+            output = output.substring(0, oBefore);
+            return parseString(false, iPrevChar);
+          }
+          if ((0, _stringUtils.isDelimiter)(prevChar)) {
+            // This is not the right end quote: it is preceded by a delimiter,
+            // and NOT followed by a delimiter. So, there is an end quote missing
+            // parse the string again and then stop at the first next delimiter
+            i = iBefore;
+            output = output.substring(0, oBefore);
+            return parseString(true);
+          }
+
+          // revert to right after the quote but before any whitespace, and continue parsing the string
+          output = output.substring(0, oBefore);
+          i = iQuote + 1;
+
+          // repair unescaped quote
+          str = `${str.substring(0, oQuote)}\\${str.substring(oQuote)}`;
+        } else if (stopAtDelimiter && (0, _stringUtils.isUnquotedStringDelimiter)(text[i])) {
+          // we're in the mode to stop the string at the first delimiter
+          // because there is an end quote missing
+
+          // test start of an url like "https://..." (this would be parsed as a comment)
+          if (text[i - 1] === ':' && _stringUtils.regexUrlStart.test(text.substring(iBefore + 1, i + 2))) {
+            while (i < text.length && _stringUtils.regexUrlChar.test(text[i])) {
+              str += text[i];
+              i++;
+            }
+          }
+
+          // repair missing quote
+          str = (0, _stringUtils.insertBeforeLastWhitespace)(str, '"');
+          output += str;
+          parseConcatenatedString();
+          return true;
+        } else if (text[i] === '\\') {
+          // handle escaped content like \n or \u2605
+          const char = text.charAt(i + 1);
+          const escapeChar = escapeCharacters[char];
+          if (escapeChar !== undefined) {
+            str += text.slice(i, i + 2);
+            i += 2;
+          } else if (char === 'u') {
+            let j = 2;
+            while (j < 6 && (0, _stringUtils.isHex)(text[i + j])) {
+              j++;
+            }
+            if (j === 6) {
+              str += text.slice(i, i + 6);
+              i += 6;
+            } else if (i + j >= text.length) {
+              // repair invalid or truncated unicode char at the end of the text
+              // by removing the unicode char and ending the string here
+              i = text.length;
+            } else {
+              throwInvalidUnicodeCharacter();
+            }
+          } else {
+            // repair invalid escape character: remove it
+            str += char;
+            i += 2;
+          }
+        } else {
+          // handle regular characters
+          const char = text.charAt(i);
+          if (char === '"' && text[i - 1] !== '\\') {
+            // repair unescaped double quote
+            str += `\\${char}`;
+            i++;
+          } else if ((0, _stringUtils.isControlCharacter)(char)) {
+            // unescaped control character
+            str += controlCharacters[char];
+            i++;
+          } else {
+            if (!(0, _stringUtils.isValidStringCharacter)(char)) {
+              throwInvalidCharacter(char);
+            }
+            str += char;
+            i++;
+          }
+        }
+        if (skipEscapeChars) {
+          // repair: skipped escape character (nothing to do)
+          skipEscapeCharacter();
+        }
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Repair concatenated strings like "hello" + "world", change this into "helloworld"
+   */
+  function parseConcatenatedString() {
+    let processed = false;
+    parseWhitespaceAndSkipComments();
+    while (text[i] === '+') {
+      processed = true;
+      i++;
+      parseWhitespaceAndSkipComments();
+
+      // repair: remove the end quote of the first string
+      output = (0, _stringUtils.stripLastOccurrence)(output, '"', true);
+      const start = output.length;
+      const parsedStr = parseString();
+      if (parsedStr) {
+        // repair: remove the start quote of the second string
+        output = (0, _stringUtils.removeAtIndex)(output, start, 1);
+      } else {
+        // repair: remove the + because it is not followed by a string
+        output = (0, _stringUtils.insertBeforeLastWhitespace)(output, '"');
+      }
+    }
+    return processed;
+  }
+
+  /**
+   * Parse a number like 2.4 or 2.4e6
+   */
+  function parseNumber() {
+    const start = i;
+    if (text[i] === '-') {
+      i++;
+      if (atEndOfNumber()) {
+        repairNumberEndingWithNumericSymbol(start);
+        return true;
+      }
+      if (!(0, _stringUtils.isDigit)(text[i])) {
+        i = start;
+        return false;
+      }
+    }
+
+    // Note that in JSON leading zeros like "00789" are not allowed.
+    // We will allow all leading zeros here though and at the end of parseNumber
+    // check against trailing zeros and repair that if needed.
+    // Leading zeros can have meaning, so we should not clear them.
+    while ((0, _stringUtils.isDigit)(text[i])) {
+      i++;
+    }
+    if (text[i] === '.') {
+      i++;
+      if (atEndOfNumber()) {
+        repairNumberEndingWithNumericSymbol(start);
+        return true;
+      }
+      if (!(0, _stringUtils.isDigit)(text[i])) {
+        i = start;
+        return false;
+      }
+      while ((0, _stringUtils.isDigit)(text[i])) {
+        i++;
+      }
+    }
+    if (text[i] === 'e' || text[i] === 'E') {
+      i++;
+      if (text[i] === '-' || text[i] === '+') {
+        i++;
+      }
+      if (atEndOfNumber()) {
+        repairNumberEndingWithNumericSymbol(start);
+        return true;
+      }
+      if (!(0, _stringUtils.isDigit)(text[i])) {
+        i = start;
+        return false;
+      }
+      while ((0, _stringUtils.isDigit)(text[i])) {
+        i++;
+      }
+    }
+
+    // if we're not at the end of the number by this point, allow this to be parsed as another type
+    if (!atEndOfNumber()) {
+      i = start;
+      return false;
+    }
+    if (i > start) {
+      // repair a number with leading zeros like "00789"
+      const num = text.slice(start, i);
+      const hasInvalidLeadingZero = /^0\d/.test(num);
+      output += hasInvalidLeadingZero ? `"${num}"` : num;
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Parse keywords true, false, null
+   * Repair Python keywords True, False, None
+   */
+  function parseKeywords() {
+    return parseKeyword('true', 'true') || parseKeyword('false', 'false') || parseKeyword('null', 'null') ||
+    // repair Python keywords True, False, None
+    parseKeyword('True', 'true') || parseKeyword('False', 'false') || parseKeyword('None', 'null');
+  }
+  function parseKeyword(name, value) {
+    if (text.slice(i, i + name.length) === name) {
+      output += value;
+      i += name.length;
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Repair an unquoted string by adding quotes around it
+   * Repair a MongoDB function call like NumberLong("2")
+   * Repair a JSONP function call like callback({...});
+   */
+  function parseUnquotedString(isKey) {
+    // note that the symbol can end with whitespaces: we stop at the next delimiter
+    // also, note that we allow strings to contain a slash / in order to support repairing regular expressions
+    const start = i;
+    if ((0, _stringUtils.isFunctionNameCharStart)(text[i])) {
+      while (i < text.length && (0, _stringUtils.isFunctionNameChar)(text[i])) {
+        i++;
+      }
+      let j = i;
+      while ((0, _stringUtils.isWhitespace)(text, j)) {
+        j++;
+      }
+      if (text[j] === '(') {
+        // repair a MongoDB function call like NumberLong("2")
+        // repair a JSONP function call like callback({...});
+        i = j + 1;
+        parseValue();
+        if (text[i] === ')') {
+          // repair: skip close bracket of function call
+          i++;
+          if (text[i] === ';') {
+            // repair: skip semicolon after JSONP call
+            i++;
+          }
+        }
+        return true;
+      }
+    }
+    while (i < text.length && !(0, _stringUtils.isUnquotedStringDelimiter)(text[i]) && !(0, _stringUtils.isQuote)(text[i]) && (!isKey || text[i] !== ':')) {
+      i++;
+    }
+
+    // test start of an url like "https://..." (this would be parsed as a comment)
+    if (text[i - 1] === ':' && _stringUtils.regexUrlStart.test(text.substring(start, i + 2))) {
+      while (i < text.length && _stringUtils.regexUrlChar.test(text[i])) {
+        i++;
+      }
+    }
+    if (i > start) {
+      // repair unquoted string
+      // also, repair undefined into null
+
+      // first, go back to prevent getting trailing whitespaces in the string
+      while ((0, _stringUtils.isWhitespace)(text, i - 1) && i > 0) {
+        i--;
+      }
+      const symbol = text.slice(start, i);
+      output += symbol === 'undefined' ? 'null' : JSON.stringify(symbol);
+      if (text[i] === '"') {
+        // we had a missing start quote, but now we encountered the end quote, so we can skip that one
+        i++;
+      }
+      return true;
+    }
+  }
+  function parseRegex() {
+    if (text[i] === '/') {
+      const start = i;
+      i++;
+      while (i < text.length && (text[i] !== '/' || text[i - 1] === '\\')) {
+        i++;
+      }
+      i++;
+      output += `"${text.substring(start, i)}"`;
+      return true;
+    }
+  }
+  function prevNonWhitespaceIndex(start) {
+    let prev = start;
+    while (prev > 0 && (0, _stringUtils.isWhitespace)(text, prev)) {
+      prev--;
+    }
+    return prev;
+  }
+  function atEndOfNumber() {
+    return i >= text.length || (0, _stringUtils.isDelimiter)(text[i]) || (0, _stringUtils.isWhitespace)(text, i);
+  }
+  function repairNumberEndingWithNumericSymbol(start) {
+    // repair numbers cut off at the end
+    // this will only be called when we end after a '.', '-', or 'e' and does not
+    // change the number more than it needs to make it valid JSON
+    output += `${text.slice(start, i)}0`;
+  }
+  function throwInvalidCharacter(char) {
+    throw new _JSONRepairError.JSONRepairError(`Invalid character ${JSON.stringify(char)}`, i);
+  }
+  function throwUnexpectedCharacter() {
+    throw new _JSONRepairError.JSONRepairError(`Unexpected character ${JSON.stringify(text[i])}`, i);
+  }
+  function throwUnexpectedEnd() {
+    throw new _JSONRepairError.JSONRepairError('Unexpected end of json string', text.length);
+  }
+  function throwObjectKeyExpected() {
+    throw new _JSONRepairError.JSONRepairError('Object key expected', i);
+  }
+  function throwColonExpected() {
+    throw new _JSONRepairError.JSONRepairError('Colon expected', i);
+  }
+  function throwInvalidUnicodeCharacter() {
+    const chars = text.slice(i, i + 6);
+    throw new _JSONRepairError.JSONRepairError(`Invalid unicode character "${chars}"`, i);
+  }
+}
+function atEndOfBlockComment(text, i) {
+  return text[i] === '*' && text[i + 1] === '/';
+}
+//# sourceMappingURL=jsonrepair.js.map

node_modules/jsonrepair/lib/cjs/stream.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "jsonrepairTransform", {
+  enumerable: true,
+  get: function () {
+    return _stream.jsonrepairTransform;
+  }
+});
+var _stream = require("./streaming/stream.js");
+//# sourceMappingURL=stream.js.map

node_modules/jsonrepair/lib/cjs/stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.js","names":["_stream","require"],"sources":["../../src/stream.ts"],"sourcesContent":["// Node.js streaming API\nexport { type JsonRepairTransformOptions, jsonrepairTransform } from './streaming/stream.js'\n"],"mappings":";;;;;;;;;;;AACA,IAAAA,OAAA,GAAAC,OAAA","ignoreList":[]}

node_modules/jsonrepair/lib/cjs/streaming/buffer/InputBuffer.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createInputBuffer = createInputBuffer;
+function createInputBuffer() {
+  let buffer = '';
+  let offset = 0;
+  let currentLength = 0;
+  let closed = false;
+  function ensure(index) {
+    if (index < offset) {
+      throw new Error(`${indexOutOfRangeMessage} (index: ${index}, offset: ${offset})`);
+    }
+    if (index >= currentLength) {
+      if (!closed) {
+        throw new Error(`${indexOutOfRangeMessage} (index: ${index})`);
+      }
+    }
+  }
+  function push(chunk) {
+    buffer += chunk;
+    currentLength += chunk.length;
+  }
+  function flush(position) {
+    if (position > currentLength) {
+      return;
+    }
+    buffer = buffer.substring(position - offset);
+    offset = position;
+  }
+  function charAt(index) {
+    ensure(index);
+    return buffer.charAt(index - offset);
+  }
+  function charCodeAt(index) {
+    ensure(index);
+    return buffer.charCodeAt(index - offset);
+  }
+  function substring(start, end) {
+    ensure(end - 1); // -1 because end is excluded
+    ensure(start);
+    return buffer.slice(start - offset, end - offset);
+  }
+  function length() {
+    if (!closed) {
+      throw new Error('Cannot get length: input is not yet closed');
+    }
+    return currentLength;
+  }
+  function isEnd(index) {
+    if (!closed) {
+      ensure(index);
+    }
+    return index >= currentLength;
+  }
+  function close() {
+    closed = true;
+  }
+  return {
+    push,
+    flush,
+    charAt,
+    charCodeAt,
+    substring,
+    length,
+    currentLength: () => currentLength,
+    currentBufferSize: () => buffer.length,
+    isEnd,
+    close
+  };
+}
+const indexOutOfRangeMessage = 'Index out of range, please configure a larger buffer size';
+//# sourceMappingURL=InputBuffer.js.map

node_modules/jsonrepair/lib/cjs/streaming/buffer/InputBuffer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InputBuffer.js","names":["createInputBuffer","buffer","offset","currentLength","closed","ensure","index","Error","indexOutOfRangeMessage","push","chunk","length","flush","position","substring","charAt","charCodeAt","start","end","slice","isEnd","close","currentBufferSize"],"sources":["../../../../src/streaming/buffer/InputBuffer.ts"],"sourcesContent":["export interface InputBuffer {\n  push: (chunk: string) => void\n  flush: (position: number) => void\n  charAt: (index: number) => string\n  charCodeAt: (index: number) => number\n  substring: (start: number, end: number) => string\n  length: () => number\n  currentLength: () => number\n  currentBufferSize: () => number\n  isEnd: (index: number) => boolean\n  close: () => void\n}\n\nexport function createInputBuffer(): InputBuffer {\n  let buffer = ''\n  let offset = 0\n  let currentLength = 0\n  let closed = false\n\n  function ensure(index: number) {\n    if (index < offset) {\n      throw new Error(`${indexOutOfRangeMessage} (index: ${index}, offset: ${offset})`)\n    }\n\n    if (index >= currentLength) {\n      if (!closed) {\n        throw new Error(`${indexOutOfRangeMessage} (index: ${index})`)\n      }\n    }\n  }\n\n  function push(chunk: string) {\n    buffer += chunk\n    currentLength += chunk.length\n  }\n\n  function flush(position: number) {\n    if (position > currentLength) {\n      return\n    }\n\n    buffer = buffer.substring(position - offset)\n    offset = position\n  }\n\n  function charAt(index: number): string {\n    ensure(index)\n\n    return buffer.charAt(index - offset)\n  }\n\n  function charCodeAt(index: number): number {\n    ensure(index)\n\n    return buffer.charCodeAt(index - offset)\n  }\n\n  function substring(start: number, end: number): string {\n    ensure(end - 1) // -1 because end is excluded\n    ensure(start)\n\n    return buffer.slice(start - offset, end - offset)\n  }\n\n  function length(): number {\n    if (!closed) {\n      throw new Error('Cannot get length: input is not yet closed')\n    }\n\n    return currentLength\n  }\n\n  function isEnd(index: number): boolean {\n    if (!closed) {\n      ensure(index)\n    }\n\n    return index >= currentLength\n  }\n\n  function close() {\n    closed = true\n  }\n\n  return {\n    push,\n    flush,\n    charAt,\n    charCodeAt,\n    substring,\n    length,\n    currentLength: () => currentLength,\n    currentBufferSize: () => buffer.length,\n    isEnd,\n    close\n  }\n}\n\nconst indexOutOfRangeMessage = 'Index out of range, please configure a larger buffer size'\n"],"mappings":";;;;;;AAaO,SAASA,iBAAiBA,CAAA,EAAgB;EAC/C,IAAIC,MAAM,GAAG,EAAE;EACf,IAAIC,MAAM,GAAG,CAAC;EACd,IAAIC,aAAa,GAAG,CAAC;EACrB,IAAIC,MAAM,GAAG,KAAK;EAElB,SAASC,MAAMA,CAACC,KAAa,EAAE;IAC7B,IAAIA,KAAK,GAAGJ,MAAM,EAAE;MAClB,MAAM,IAAIK,KAAK,CAAC,GAAGC,sBAAsB,YAAYF,KAAK,aAAaJ,MAAM,GAAG,CAAC;IACnF;IAEA,IAAII,KAAK,IAAIH,aAAa,EAAE;MAC1B,IAAI,CAACC,MAAM,EAAE;QACX,MAAM,IAAIG,KAAK,CAAC,GAAGC,sBAAsB,YAAYF,KAAK,GAAG,CAAC;MAChE;IACF;EACF;EAEA,SAASG,IAAIA,CAACC,KAAa,EAAE;IAC3BT,MAAM,IAAIS,KAAK;IACfP,aAAa,IAAIO,KAAK,CAACC,MAAM;EAC/B;EAEA,SAASC,KAAKA,CAACC,QAAgB,EAAE;IAC/B,IAAIA,QAAQ,GAAGV,aAAa,EAAE;MAC5B;IACF;IAEAF,MAAM,GAAGA,MAAM,CAACa,SAAS,CAACD,QAAQ,GAAGX,MAAM,CAAC;IAC5CA,MAAM,GAAGW,QAAQ;EACnB;EAEA,SAASE,MAAMA,CAACT,KAAa,EAAU;IACrCD,MAAM,CAACC,KAAK,CAAC;IAEb,OAAOL,MAAM,CAACc,MAAM,CAACT,KAAK,GAAGJ,MAAM,CAAC;EACtC;EAEA,SAASc,UAAUA,CAACV,KAAa,EAAU;IACzCD,MAAM,CAACC,KAAK,CAAC;IAEb,OAAOL,MAAM,CAACe,UAAU,CAACV,KAAK,GAAGJ,MAAM,CAAC;EAC1C;EAEA,SAASY,SAASA,CAACG,KAAa,EAAEC,GAAW,EAAU;IACrDb,MAAM,CAACa,GAAG,GAAG,CAAC,CAAC,EAAC;IAChBb,MAAM,CAACY,KAAK,CAAC;IAEb,OAAOhB,MAAM,CAACkB,KAAK,CAACF,KAAK,GAAGf,MAAM,EAAEgB,GAAG,GAAGhB,MAAM,CAAC;EACnD;EAEA,SAASS,MAAMA,CAAA,EAAW;IACxB,IAAI,CAACP,MAAM,EAAE;MACX,MAAM,IAAIG,KAAK,CAAC,4CAA4C,CAAC;IAC/D;IAEA,OAAOJ,aAAa;EACtB;EAEA,SAASiB,KAAKA,CAACd,KAAa,EAAW;IACrC,IAAI,CAACF,MAAM,EAAE;MACXC,MAAM,CAACC,KAAK,CAAC;IACf;IAEA,OAAOA,KAAK,IAAIH,aAAa;EAC/B;EAEA,SAASkB,KAAKA,CAAA,EAAG;IACfjB,MAAM,GAAG,IAAI;EACf;EAEA,OAAO;IACLK,IAAI;IACJG,KAAK;IACLG,MAAM;IACNC,UAAU;IACVF,SAAS;IACTH,MAAM;IACNR,aAAa,EAAEA,CAAA,KAAMA,aAAa;IAClCmB,iBAAiB,EAAEA,CAAA,KAAMrB,MAAM,CAACU,MAAM;IACtCS,KAAK;IACLC;EACF,CAAC;AACH;AAEA,MAAMb,sBAAsB,GAAG,2DAA2D","ignoreList":[]}

node_modules/jsonrepair/lib/cjs/streaming/buffer/OutputBuffer.js

@@ -0,0 +1,117 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createOutputBuffer = createOutputBuffer;
+var _stringUtils = require("../../utils/stringUtils.js");
+function createOutputBuffer(_ref) {
+  let {
+    write,
+    chunkSize,
+    bufferSize
+  } = _ref;
+  let buffer = '';
+  let offset = 0;
+  function flushChunks() {
+    let minSize = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : bufferSize;
+    while (buffer.length >= minSize + chunkSize) {
+      const chunk = buffer.substring(0, chunkSize);
+      write(chunk);
+      offset += chunkSize;
+      buffer = buffer.substring(chunkSize);
+    }
+  }
+  function flush() {
+    flushChunks(0);
+    if (buffer.length > 0) {
+      write(buffer);
+      offset += buffer.length;
+      buffer = '';
+    }
+  }
+  function push(text) {
+    buffer += text;
+    flushChunks();
+  }
+  function unshift(text) {
+    if (offset > 0) {
+      throw new Error(`Cannot unshift: ${flushedMessage}`);
+    }
+    buffer = text + buffer;
+    flushChunks();
+  }
+  function remove(start, end) {
+    if (start < offset) {
+      throw new Error(`Cannot remove: ${flushedMessage}`);
+    }
+    if (end !== undefined) {
+      buffer = buffer.substring(0, start - offset) + buffer.substring(end - offset);
+    } else {
+      buffer = buffer.substring(0, start - offset);
+    }
+  }
+  function insertAt(index, text) {
+    if (index < offset) {
+      throw new Error(`Cannot insert: ${flushedMessage}`);
+    }
+    buffer = buffer.substring(0, index - offset) + text + buffer.substring(index - offset);
+  }
+  function length() {
+    return offset + buffer.length;
+  }
+  function stripLastOccurrence(textToStrip) {
+    let stripRemainingText = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    const bufferIndex = buffer.lastIndexOf(textToStrip);
+    if (bufferIndex !== -1) {
+      if (stripRemainingText) {
+        buffer = buffer.substring(0, bufferIndex);
+      } else {
+        buffer = buffer.substring(0, bufferIndex) + buffer.substring(bufferIndex + textToStrip.length);
+      }
+    }
+  }
+  function insertBeforeLastWhitespace(textToInsert) {
+    let bufferIndex = buffer.length; // index relative to the start of the buffer, not taking `offset` into account
+
+    if (!(0, _stringUtils.isWhitespace)(buffer, bufferIndex - 1)) {
+      // no trailing whitespaces
+      push(textToInsert);
+      return;
+    }
+    while ((0, _stringUtils.isWhitespace)(buffer, bufferIndex - 1)) {
+      bufferIndex--;
+    }
+    if (bufferIndex <= 0) {
+      throw new Error(`Cannot insert: ${flushedMessage}`);
+    }
+    buffer = buffer.substring(0, bufferIndex) + textToInsert + buffer.substring(bufferIndex);
+    flushChunks();
+  }
+  function endsWithIgnoringWhitespace(char) {
+    let i = buffer.length - 1;
+    while (i > 0) {
+      if (char === buffer.charAt(i)) {
+        return true;
+      }
+      if (!(0, _stringUtils.isWhitespace)(buffer, i)) {
+        return false;
+      }
+      i--;
+    }
+    return false;
+  }
+  return {
+    push,
+    unshift,
+    remove,
+    insertAt,
+    length,
+    flush,
+    stripLastOccurrence,
+    insertBeforeLastWhitespace,
+    endsWithIgnoringWhitespace
+  };
+}
+const flushedMessage = 'start of the output is already flushed from the buffer';
+//# sourceMappingURL=OutputBuffer.js.map

node_modules/jsonrepair/lib/cjs/streaming/core.js

@@ -0,0 +1,824 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.jsonrepairCore = jsonrepairCore;
+var _JSONRepairError = require("../utils/JSONRepairError.js");
+var _stringUtils = require("../utils/stringUtils.js");
+var _InputBuffer = require("./buffer/InputBuffer.js");
+var _OutputBuffer = require("./buffer/OutputBuffer.js");
+var _stack = require("./stack.js");
+const controlCharacters = {
+  '\b': '\\b',
+  '\f': '\\f',
+  '\n': '\\n',
+  '\r': '\\r',
+  '\t': '\\t'
+};
+
+// map with all escape characters
+const escapeCharacters = {
+  '"': '"',
+  '\\': '\\',
+  '/': '/',
+  b: '\b',
+  f: '\f',
+  n: '\n',
+  r: '\r',
+  t: '\t'
+  // note that \u is handled separately in parseString()
+};
+function jsonrepairCore(_ref) {
+  let {
+    onData,
+    bufferSize = 65536,
+    chunkSize = 65536
+  } = _ref;
+  const input = (0, _InputBuffer.createInputBuffer)();
+  const output = (0, _OutputBuffer.createOutputBuffer)({
+    write: onData,
+    bufferSize,
+    chunkSize
+  });
+  let i = 0;
+  let iFlushed = 0;
+  const stack = (0, _stack.createStack)();
+  function flushInputBuffer() {
+    while (iFlushed < i - bufferSize - chunkSize) {
+      iFlushed += chunkSize;
+      input.flush(iFlushed);
+    }
+  }
+  function transform(chunk) {
+    input.push(chunk);
+    while (i < input.currentLength() - bufferSize && parse()) {
+      // loop until there is nothing more to process
+    }
+    flushInputBuffer();
+  }
+  function flush() {
+    input.close();
+    while (parse()) {
+      // loop until there is nothing more to process
+    }
+    output.flush();
+  }
+  function parse() {
+    parseWhitespaceAndSkipComments();
+    switch (stack.type) {
+      case _stack.StackType.object:
+        {
+          switch (stack.caret) {
+            case _stack.Caret.beforeKey:
+              return skipEllipsis() || parseObjectKey() || parseUnexpectedColon() || parseRepairTrailingComma() || parseRepairObjectEndOrComma();
+            case _stack.Caret.beforeValue:
+              return parseValue() || parseRepairMissingObjectValue();
+            case _stack.Caret.afterValue:
+              return parseObjectComma() || parseObjectEnd() || parseRepairObjectEndOrComma();
+            default:
+              return false;
+          }
+        }
+      case _stack.StackType.array:
+        {
+          switch (stack.caret) {
+            case _stack.Caret.beforeValue:
+              return skipEllipsis() || parseValue() || parseRepairTrailingComma() || parseRepairArrayEnd();
+            case _stack.Caret.afterValue:
+              return parseArrayComma() || parseArrayEnd() || parseRepairMissingComma() || parseRepairArrayEnd();
+            default:
+              return false;
+          }
+        }
+      case _stack.StackType.ndJson:
+        {
+          switch (stack.caret) {
+            case _stack.Caret.beforeValue:
+              return parseValue() || parseRepairTrailingComma();
+            case _stack.Caret.afterValue:
+              return parseArrayComma() || parseRepairMissingComma() || parseRepairNdJsonEnd();
+            default:
+              return false;
+          }
+        }
+      case _stack.StackType.functionCall:
+        {
+          switch (stack.caret) {
+            case _stack.Caret.beforeValue:
+              return parseValue();
+            case _stack.Caret.afterValue:
+              return parseFunctionCallEnd();
+            default:
+              return false;
+          }
+        }
+      case _stack.StackType.root:
+        {
+          switch (stack.caret) {
+            case _stack.Caret.beforeValue:
+              return parseRootStart();
+            case _stack.Caret.afterValue:
+              return parseRootEnd();
+            default:
+              return false;
+          }
+        }
+      default:
+        return false;
+    }
+  }
+  function parseValue() {
+    return parseObjectStart() || parseArrayStart() || parseString() || parseNumber() || parseKeywords() || parseRepairUnquotedString() || parseRepairRegex();
+  }
+  function parseObjectStart() {
+    if (parseCharacter('{')) {
+      parseWhitespaceAndSkipComments();
+      skipEllipsis();
+      if (skipCharacter(',')) {
+        parseWhitespaceAndSkipComments();
+      }
+      if (parseCharacter('}')) {
+        return stack.update(_stack.Caret.afterValue);
+      }
+      return stack.push(_stack.StackType.object, _stack.Caret.beforeKey);
+    }
+    return false;
+  }
+  function parseArrayStart() {
+    if (parseCharacter('[')) {
+      parseWhitespaceAndSkipComments();
+      skipEllipsis();
+      if (skipCharacter(',')) {
+        parseWhitespaceAndSkipComments();
+      }
+      if (parseCharacter(']')) {
+        return stack.update(_stack.Caret.afterValue);
+      }
+      return stack.push(_stack.StackType.array, _stack.Caret.beforeValue);
+    }
+    return false;
+  }
+  function parseRepairUnquotedString() {
+    let j = i;
+    if ((0, _stringUtils.isFunctionNameCharStart)(input.charAt(j))) {
+      while (!input.isEnd(j) && (0, _stringUtils.isFunctionNameChar)(input.charAt(j))) {
+        j++;
+      }
+      let k = j;
+      while ((0, _stringUtils.isWhitespace)(input, k)) {
+        k++;
+      }
+      if (input.charAt(k) === '(') {
+        // repair a MongoDB function call like NumberLong("2")
+        // repair a JSONP function call like callback({...});
+        k++;
+        i = k;
+        return stack.push(_stack.StackType.functionCall, _stack.Caret.beforeValue);
+      }
+    }
+    j = findNextDelimiter(false, j);
+    if (j !== null) {
+      // test start of an url like "https://..." (this would be parsed as a comment)
+      if (input.charAt(j - 1) === ':' && _stringUtils.regexUrlStart.test(input.substring(i, j + 2))) {
+        while (!input.isEnd(j) && _stringUtils.regexUrlChar.test(input.charAt(j))) {
+          j++;
+        }
+      }
+      const symbol = input.substring(i, j);
+      i = j;
+      output.push(symbol === 'undefined' ? 'null' : JSON.stringify(symbol));
+      if (input.charAt(i) === '"') {
+        // we had a missing start quote, but now we encountered the end quote, so we can skip that one
+        i++;
+      }
+      return stack.update(_stack.Caret.afterValue);
+    }
+    return false;
+  }
+  function parseRepairRegex() {
+    if (input.charAt(i) === '/') {
+      const start = i;
+      i++;
+      while (!input.isEnd(i) && (input.charAt(i) !== '/' || input.charAt(i - 1) === '\\')) {
+        i++;
+      }
+      i++;
+      output.push(`"${input.substring(start, i)}"`);
+      return stack.update(_stack.Caret.afterValue);
+    }
+  }
+  function parseRepairMissingObjectValue() {
+    // repair missing object value
+    output.push('null');
+    return stack.update(_stack.Caret.afterValue);
+  }
+  function parseRepairTrailingComma() {
+    // repair trailing comma
+    if (output.endsWithIgnoringWhitespace(',')) {
+      output.stripLastOccurrence(',');
+      return stack.update(_stack.Caret.afterValue);
+    }
+    return false;
+  }
+  function parseUnexpectedColon() {
+    if (input.charAt(i) === ':') {
+      throwObjectKeyExpected();
+    }
+    return false;
+  }
+  function parseUnexpectedEnd() {
+    if (input.isEnd(i)) {
+      throwUnexpectedEnd();
+    } else {
+      throwUnexpectedCharacter();
+    }
+    return false;
+  }
+  function parseObjectKey() {
+    const parsedKey = parseString() || parseUnquotedKey();
+    if (parsedKey) {
+      parseWhitespaceAndSkipComments();
+      if (parseCharacter(':')) {
+        // expect a value after the :
+        return stack.update(_stack.Caret.beforeValue);
+      }
+      const truncatedText = input.isEnd(i);
+      if ((0, _stringUtils.isStartOfValue)(input.charAt(i)) || truncatedText) {
+        // repair missing colon
+        output.insertBeforeLastWhitespace(':');
+        return stack.update(_stack.Caret.beforeValue);
+      }
+      throwColonExpected();
+    }
+    return false;
+  }
+  function parseObjectComma() {
+    if (parseCharacter(',')) {
+      return stack.update(_stack.Caret.beforeKey);
+    }
+    return false;
+  }
+  function parseObjectEnd() {
+    if (parseCharacter('}')) {
+      return stack.pop();
+    }
+    return false;
+  }
+  function parseRepairObjectEndOrComma() {
+    // repair missing object end and trailing comma
+    if (input.charAt(i) === '{') {
+      output.stripLastOccurrence(',');
+      output.insertBeforeLastWhitespace('}');
+      return stack.pop();
+    }
+
+    // repair missing comma
+    if (!input.isEnd(i) && (0, _stringUtils.isStartOfValue)(input.charAt(i))) {
+      output.insertBeforeLastWhitespace(',');
+      return stack.update(_stack.Caret.beforeKey);
+    }
+
+    // repair missing closing brace
+    output.insertBeforeLastWhitespace('}');
+    return stack.pop();
+  }
+  function parseArrayComma() {
+    if (parseCharacter(',')) {
+      return stack.update(_stack.Caret.beforeValue);
+    }
+    return false;
+  }
+  function parseArrayEnd() {
+    if (parseCharacter(']')) {
+      return stack.pop();
+    }
+    return false;
+  }
+  function parseRepairMissingComma() {
+    // repair missing comma
+    if (!input.isEnd(i) && (0, _stringUtils.isStartOfValue)(input.charAt(i))) {
+      output.insertBeforeLastWhitespace(',');
+      return stack.update(_stack.Caret.beforeValue);
+    }
+    return false;
+  }
+  function parseRepairArrayEnd() {
+    // repair missing closing bracket
+    output.insertBeforeLastWhitespace(']');
+    return stack.pop();
+  }
+  function parseRepairNdJsonEnd() {
+    if (input.isEnd(i)) {
+      output.push('\n]');
+      return stack.pop();
+    }
+    throwUnexpectedEnd();
+    return false; // just to make TS happy
+  }
+  function parseFunctionCallEnd() {
+    if (skipCharacter(')')) {
+      skipCharacter(';');
+    }
+    return stack.pop();
+  }
+  function parseRootStart() {
+    parseMarkdownCodeBlock(['```', '[```', '{```']);
+    return parseValue() || parseUnexpectedEnd();
+  }
+  function parseRootEnd() {
+    parseMarkdownCodeBlock(['```', '```]', '```}']);
+    const parsedComma = parseCharacter(',');
+    parseWhitespaceAndSkipComments();
+    if ((0, _stringUtils.isStartOfValue)(input.charAt(i)) && (output.endsWithIgnoringWhitespace(',') || output.endsWithIgnoringWhitespace('\n'))) {
+      // start of a new value after end of the root level object: looks like
+      // newline delimited JSON -> turn into a root level array
+      if (!parsedComma) {
+        // repair missing comma
+        output.insertBeforeLastWhitespace(',');
+      }
+      output.unshift('[\n');
+      return stack.push(_stack.StackType.ndJson, _stack.Caret.beforeValue);
+    }
+    if (parsedComma) {
+      // repair: remove trailing comma
+      output.stripLastOccurrence(',');
+      return stack.update(_stack.Caret.afterValue);
+    }
+
+    // repair redundant end braces and brackets
+    while (input.charAt(i) === '}' || input.charAt(i) === ']') {
+      i++;
+      parseWhitespaceAndSkipComments();
+    }
+    if (!input.isEnd(i)) {
+      throwUnexpectedCharacter();
+    }
+    return false;
+  }
+  function parseWhitespaceAndSkipComments() {
+    let skipNewline = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+    const start = i;
+    let changed = parseWhitespace(skipNewline);
+    do {
+      changed = parseComment();
+      if (changed) {
+        changed = parseWhitespace(skipNewline);
+      }
+    } while (changed);
+    return i > start;
+  }
+  function parseWhitespace(skipNewline) {
+    const _isWhiteSpace = skipNewline ? _stringUtils.isWhitespace : _stringUtils.isWhitespaceExceptNewline;
+    let whitespace = '';
+    while (true) {
+      if (_isWhiteSpace(input, i)) {
+        whitespace += input.charAt(i);
+        i++;
+      } else if ((0, _stringUtils.isSpecialWhitespace)(input, i)) {
+        // repair special whitespace
+        whitespace += ' ';
+        i++;
+      } else {
+        break;
+      }
+    }
+    if (whitespace.length > 0) {
+      output.push(whitespace);
+      return true;
+    }
+    return false;
+  }
+  function parseComment() {
+    // find a block comment '/* ... */'
+    if (input.charAt(i) === '/' && input.charAt(i + 1) === '*') {
+      // repair block comment by skipping it
+      while (!input.isEnd(i) && !atEndOfBlockComment(i)) {
+        i++;
+      }
+      i += 2;
+      return true;
+    }
+
+    // find a line comment '// ...'
+    if (input.charAt(i) === '/' && input.charAt(i + 1) === '/') {
+      // repair line comment by skipping it
+      while (!input.isEnd(i) && input.charAt(i) !== '\n') {
+        i++;
+      }
+      return true;
+    }
+    return false;
+  }
+  function parseMarkdownCodeBlock(blocks) {
+    // find and skip over a Markdown fenced code block:
+    //     ``` ... ```
+    // or
+    //     ```json ... ```
+    if (skipMarkdownCodeBlock(blocks)) {
+      if ((0, _stringUtils.isFunctionNameCharStart)(input.charAt(i))) {
+        // strip the optional language specifier like "json"
+        while (!input.isEnd(i) && (0, _stringUtils.isFunctionNameChar)(input.charAt(i))) {
+          i++;
+        }
+      }
+      parseWhitespaceAndSkipComments();
+      return true;
+    }
+    return false;
+  }
+  function skipMarkdownCodeBlock(blocks) {
+    for (const block of blocks) {
+      const end = i + block.length;
+      if (input.substring(i, end) === block) {
+        i = end;
+        return true;
+      }
+    }
+    return false;
+  }
+  function parseCharacter(char) {
+    if (input.charAt(i) === char) {
+      output.push(input.charAt(i));
+      i++;
+      return true;
+    }
+    return false;
+  }
+  function skipCharacter(char) {
+    if (input.charAt(i) === char) {
+      i++;
+      return true;
+    }
+    return false;
+  }
+  function skipEscapeCharacter() {
+    return skipCharacter('\\');
+  }
+
+  /**
+   * Skip ellipsis like "[1,2,3,...]" or "[1,2,3,...,9]" or "[...,7,8,9]"
+   * or a similar construct in objects.
+   */
+  function skipEllipsis() {
+    parseWhitespaceAndSkipComments();
+    if (input.charAt(i) === '.' && input.charAt(i + 1) === '.' && input.charAt(i + 2) === '.') {
+      // repair: remove the ellipsis (three dots) and optionally a comma
+      i += 3;
+      parseWhitespaceAndSkipComments();
+      skipCharacter(',');
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Parse a string enclosed by double quotes "...". Can contain escaped quotes
+   * Repair strings enclosed in single quotes or special quotes
+   * Repair an escaped string
+   *
+   * The function can run in two stages:
+   * - First, it assumes the string has a valid end quote
+   * - If it turns out that the string does not have a valid end quote followed
+   *   by a delimiter (which should be the case), the function runs again in a
+   *   more conservative way, stopping the string at the first next delimiter
+   *   and fixing the string by inserting a quote there, or stopping at a
+   *   stop index detected in the first iteration.
+   */
+  function parseString() {
+    let stopAtDelimiter = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    let stopAtIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : -1;
+    let skipEscapeChars = input.charAt(i) === '\\';
+    if (skipEscapeChars) {
+      // repair: remove the first escape character
+      i++;
+      skipEscapeChars = true;
+    }
+    if ((0, _stringUtils.isQuote)(input.charAt(i))) {
+      // double quotes are correct JSON,
+      // single quotes come from JavaScript for example, we assume it will have a correct single end quote too
+      // otherwise, we will match any double-quote-like start with a double-quote-like end,
+      // or any single-quote-like start with a single-quote-like end
+      const isEndQuote = (0, _stringUtils.isDoubleQuote)(input.charAt(i)) ? _stringUtils.isDoubleQuote : (0, _stringUtils.isSingleQuote)(input.charAt(i)) ? _stringUtils.isSingleQuote : (0, _stringUtils.isSingleQuoteLike)(input.charAt(i)) ? _stringUtils.isSingleQuoteLike : _stringUtils.isDoubleQuoteLike;
+      const iBefore = i;
+      const oBefore = output.length();
+      output.push('"');
+      i++;
+      while (true) {
+        if (input.isEnd(i)) {
+          // end of text, we have a missing quote somewhere
+
+          const iPrev = prevNonWhitespaceIndex(i - 1);
+          if (!stopAtDelimiter && (0, _stringUtils.isDelimiter)(input.charAt(iPrev))) {
+            // if the text ends with a delimiter, like ["hello],
+            // so the missing end quote should be inserted before this delimiter
+            // retry parsing the string, stopping at the first next delimiter
+            i = iBefore;
+            output.remove(oBefore);
+            return parseString(true);
+          }
+
+          // repair missing quote
+          output.insertBeforeLastWhitespace('"');
+          return stack.update(_stack.Caret.afterValue);
+        }
+        if (i === stopAtIndex) {
+          // use the stop index detected in the first iteration, and repair end quote
+          output.insertBeforeLastWhitespace('"');
+          return stack.update(_stack.Caret.afterValue);
+        }
+        if (isEndQuote(input.charAt(i))) {
+          // end quote
+          // let us check what is before and after the quote to verify whether this is a legit end quote
+          const iQuote = i;
+          const oQuote = output.length();
+          output.push('"');
+          i++;
+          parseWhitespaceAndSkipComments(false);
+          if (stopAtDelimiter || input.isEnd(i) || (0, _stringUtils.isDelimiter)(input.charAt(i)) || (0, _stringUtils.isQuote)(input.charAt(i)) || (0, _stringUtils.isDigit)(input.charAt(i))) {
+            // The quote is followed by the end of the text, a delimiter, or a next value
+            // so the quote is indeed the end of the string
+            parseConcatenatedString();
+            return stack.update(_stack.Caret.afterValue);
+          }
+          const iPrevChar = prevNonWhitespaceIndex(iQuote - 1);
+          const prevChar = input.charAt(iPrevChar);
+          if (prevChar === ',') {
+            // A comma followed by a quote, like '{"a":"b,c,"d":"e"}'.
+            // We assume that the quote is a start quote, and that the end quote
+            // should have been located right before the comma but is missing.
+            i = iBefore;
+            output.remove(oBefore);
+            return parseString(false, iPrevChar);
+          }
+          if ((0, _stringUtils.isDelimiter)(prevChar)) {
+            // This is not the right end quote: it is preceded by a delimiter,
+            // and NOT followed by a delimiter. So, there is an end quote missing
+            // parse the string again and then stop at the first next delimiter
+            i = iBefore;
+            output.remove(oBefore);
+            return parseString(true);
+          }
+
+          // revert to right after the quote but before any whitespace, and continue parsing the string
+          output.remove(oQuote + 1);
+          i = iQuote + 1;
+
+          // repair unescaped quote
+          output.insertAt(oQuote, '\\');
+        } else if (stopAtDelimiter && (0, _stringUtils.isUnquotedStringDelimiter)(input.charAt(i))) {
+          // we're in the mode to stop the string at the first delimiter
+          // because there is an end quote missing
+
+          // test start of an url like "https://..." (this would be parsed as a comment)
+          if (input.charAt(i - 1) === ':' && _stringUtils.regexUrlStart.test(input.substring(iBefore + 1, i + 2))) {
+            while (!input.isEnd(i) && _stringUtils.regexUrlChar.test(input.charAt(i))) {
+              output.push(input.charAt(i));
+              i++;
+            }
+          }
+
+          // repair missing quote
+          output.insertBeforeLastWhitespace('"');
+          parseConcatenatedString();
+          return stack.update(_stack.Caret.afterValue);
+        } else if (input.charAt(i) === '\\') {
+          // handle escaped content like \n or \u2605
+          const char = input.charAt(i + 1);
+          const escapeChar = escapeCharacters[char];
+          if (escapeChar !== undefined) {
+            output.push(input.substring(i, i + 2));
+            i += 2;
+          } else if (char === 'u') {
+            let j = 2;
+            while (j < 6 && (0, _stringUtils.isHex)(input.charAt(i + j))) {
+              j++;
+            }
+            if (j === 6) {
+              output.push(input.substring(i, i + 6));
+              i += 6;
+            } else if (input.isEnd(i + j)) {
+              // repair invalid or truncated unicode char at the end of the text
+              // by removing the unicode char and ending the string here
+              i += j;
+            } else {
+              throwInvalidUnicodeCharacter();
+            }
+          } else {
+            // repair invalid escape character: remove it
+            output.push(char);
+            i += 2;
+          }
+        } else {
+          // handle regular characters
+          const char = input.charAt(i);
+          if (char === '"' && input.charAt(i - 1) !== '\\') {
+            // repair unescaped double quote
+            output.push(`\\${char}`);
+            i++;
+          } else if ((0, _stringUtils.isControlCharacter)(char)) {
+            // unescaped control character
+            output.push(controlCharacters[char]);
+            i++;
+          } else {
+            if (!(0, _stringUtils.isValidStringCharacter)(char)) {
+              throwInvalidCharacter(char);
+            }
+            output.push(char);
+            i++;
+          }
+        }
+        if (skipEscapeChars) {
+          // repair: skipped escape character (nothing to do)
+          skipEscapeCharacter();
+        }
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Repair concatenated strings like "hello" + "world", change this into "helloworld"
+   */
+  function parseConcatenatedString() {
+    let parsed = false;
+    parseWhitespaceAndSkipComments();
+    while (input.charAt(i) === '+') {
+      parsed = true;
+      i++;
+      parseWhitespaceAndSkipComments();
+
+      // repair: remove the end quote of the first string
+      output.stripLastOccurrence('"', true);
+      const start = output.length();
+      const parsedStr = parseString();
+      if (parsedStr) {
+        // repair: remove the start quote of the second string
+        output.remove(start, start + 1);
+      } else {
+        // repair: remove the + because it is not followed by a string
+        output.insertBeforeLastWhitespace('"');
+      }
+    }
+    return parsed;
+  }
+
+  /**
+   * Parse a number like 2.4 or 2.4e6
+   */
+  function parseNumber() {
+    const start = i;
+    if (input.charAt(i) === '-') {
+      i++;
+      if (atEndOfNumber()) {
+        repairNumberEndingWithNumericSymbol(start);
+        return stack.update(_stack.Caret.afterValue);
+      }
+      if (!(0, _stringUtils.isDigit)(input.charAt(i))) {
+        i = start;
+        return false;
+      }
+    }
+
+    // Note that in JSON leading zeros like "00789" are not allowed.
+    // We will allow all leading zeros here though and at the end of parseNumber
+    // check against trailing zeros and repair that if needed.
+    // Leading zeros can have meaning, so we should not clear them.
+    while ((0, _stringUtils.isDigit)(input.charAt(i))) {
+      i++;
+    }
+    if (input.charAt(i) === '.') {
+      i++;
+      if (atEndOfNumber()) {
+        repairNumberEndingWithNumericSymbol(start);
+        return stack.update(_stack.Caret.afterValue);
+      }
+      if (!(0, _stringUtils.isDigit)(input.charAt(i))) {
+        i = start;
+        return false;
+      }
+      while ((0, _stringUtils.isDigit)(input.charAt(i))) {
+        i++;
+      }
+    }
+    if (input.charAt(i) === 'e' || input.charAt(i) === 'E') {
+      i++;
+      if (input.charAt(i) === '-' || input.charAt(i) === '+') {
+        i++;
+      }
+      if (atEndOfNumber()) {
+        repairNumberEndingWithNumericSymbol(start);
+        return stack.update(_stack.Caret.afterValue);
+      }
+      if (!(0, _stringUtils.isDigit)(input.charAt(i))) {
+        i = start;
+        return false;
+      }
+      while ((0, _stringUtils.isDigit)(input.charAt(i))) {
+        i++;
+      }
+    }
+
+    // if we're not at the end of the number by this point, allow this to be parsed as another type
+    if (!atEndOfNumber()) {
+      i = start;
+      return false;
+    }
+    if (i > start) {
+      // repair a number with leading zeros like "00789"
+      const num = input.substring(start, i);
+      const hasInvalidLeadingZero = /^0\d/.test(num);
+      output.push(hasInvalidLeadingZero ? `"${num}"` : num);
+      return stack.update(_stack.Caret.afterValue);
+    }
+    return false;
+  }
+
+  /**
+   * Parse keywords true, false, null
+   * Repair Python keywords True, False, None
+   */
+  function parseKeywords() {
+    return parseKeyword('true', 'true') || parseKeyword('false', 'false') || parseKeyword('null', 'null') ||
+    // repair Python keywords True, False, None
+    parseKeyword('True', 'true') || parseKeyword('False', 'false') || parseKeyword('None', 'null');
+  }
+  function parseKeyword(name, value) {
+    if (input.substring(i, i + name.length) === name) {
+      output.push(value);
+      i += name.length;
+      return stack.update(_stack.Caret.afterValue);
+    }
+    return false;
+  }
+  function parseUnquotedKey() {
+    let end = findNextDelimiter(true, i);
+    if (end !== null) {
+      // first, go back to prevent getting trailing whitespaces in the string
+      while ((0, _stringUtils.isWhitespace)(input, end - 1) && end > i) {
+        end--;
+      }
+      const symbol = input.substring(i, end);
+      output.push(JSON.stringify(symbol));
+      i = end;
+      if (input.charAt(i) === '"') {
+        // we had a missing start quote, but now we encountered the end quote, so we can skip that one
+        i++;
+      }
+      return stack.update(_stack.Caret.afterValue); // we do not have a state Caret.afterKey, therefore we use afterValue here
+    }
+    return false;
+  }
+  function findNextDelimiter(isKey, start) {
+    // note that the symbol can end with whitespaces: we stop at the next delimiter
+    // also, note that we allow strings to contain a slash / in order to support repairing regular expressions
+    let j = start;
+    while (!input.isEnd(j) && !(0, _stringUtils.isUnquotedStringDelimiter)(input.charAt(j)) && !(0, _stringUtils.isQuote)(input.charAt(j)) && (!isKey || input.charAt(j) !== ':')) {
+      j++;
+    }
+    return j > i ? j : null;
+  }
+  function prevNonWhitespaceIndex(start) {
+    let prev = start;
+    while (prev > 0 && (0, _stringUtils.isWhitespace)(input, prev)) {
+      prev--;
+    }
+    return prev;
+  }
+  function atEndOfNumber() {
+    return input.isEnd(i) || (0, _stringUtils.isDelimiter)(input.charAt(i)) || (0, _stringUtils.isWhitespace)(input, i);
+  }
+  function repairNumberEndingWithNumericSymbol(start) {
+    // repair numbers cut off at the end
+    // this will only be called when we end after a '.', '-', or 'e' and does not
+    // change the number more than it needs to make it valid JSON
+    output.push(`${input.substring(start, i)}0`);
+  }
+  function throwInvalidCharacter(char) {
+    throw new _JSONRepairError.JSONRepairError(`Invalid character ${JSON.stringify(char)}`, i);
+  }
+  function throwUnexpectedCharacter() {
+    throw new _JSONRepairError.JSONRepairError(`Unexpected character ${JSON.stringify(input.charAt(i))}`, i);
+  }
+  function throwUnexpectedEnd() {
+    throw new _JSONRepairError.JSONRepairError('Unexpected end of json string', i);
+  }
+  function throwObjectKeyExpected() {
+    throw new _JSONRepairError.JSONRepairError('Object key expected', i);
+  }
+  function throwColonExpected() {
+    throw new _JSONRepairError.JSONRepairError('Colon expected', i);
+  }
+  function throwInvalidUnicodeCharacter() {
+    const chars = input.substring(i, i + 6);
+    throw new _JSONRepairError.JSONRepairError(`Invalid unicode character "${chars}"`, i);
+  }
+  function atEndOfBlockComment(i) {
+    return input.charAt(i) === '*' && input.charAt(i + 1) === '/';
+  }
+  return {
+    transform,
+    flush
+  };
+}
+//# sourceMappingURL=core.js.map

node_modules/jsonrepair/lib/cjs/streaming/stack.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.StackType = exports.Caret = void 0;
+exports.createStack = createStack;
+let Caret = exports.Caret = /*#__PURE__*/function (Caret) {
+  Caret["beforeValue"] = "beforeValue";
+  Caret["afterValue"] = "afterValue";
+  Caret["beforeKey"] = "beforeKey";
+  return Caret;
+}({});
+let StackType = exports.StackType = /*#__PURE__*/function (StackType) {
+  StackType["root"] = "root";
+  StackType["object"] = "object";
+  StackType["array"] = "array";
+  StackType["ndJson"] = "ndJson";
+  StackType["functionCall"] = "dataType";
+  return StackType;
+}({});
+function createStack() {
+  const stack = [StackType.root];
+  let caret = Caret.beforeValue;
+  return {
+    get type() {
+      return last(stack);
+    },
+    get caret() {
+      return caret;
+    },
+    pop() {
+      stack.pop();
+      caret = Caret.afterValue;
+      return true;
+    },
+    push(type, newCaret) {
+      stack.push(type);
+      caret = newCaret;
+      return true;
+    },
+    update(newCaret) {
+      caret = newCaret;
+      return true;
+    }
+  };
+}
+function last(array) {
+  return array[array.length - 1];
+}
+//# sourceMappingURL=stack.js.map

node_modules/jsonrepair/lib/cjs/streaming/stack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stack.js","names":["Caret","exports","StackType","createStack","stack","root","caret","beforeValue","type","last","pop","afterValue","push","newCaret","update","array","length"],"sources":["../../../src/streaming/stack.ts"],"sourcesContent":["export enum Caret {\n  beforeValue = 'beforeValue',\n  afterValue = 'afterValue',\n  beforeKey = 'beforeKey'\n}\n\nexport enum StackType {\n  root = 'root',\n  object = 'object',\n  array = 'array',\n  ndJson = 'ndJson',\n  functionCall = 'dataType'\n}\n\nexport function createStack() {\n  const stack: StackType[] = [StackType.root]\n  let caret = Caret.beforeValue\n\n  return {\n    get type() {\n      return last(stack)\n    },\n\n    get caret() {\n      return caret\n    },\n\n    pop(): true {\n      stack.pop()\n      caret = Caret.afterValue\n\n      return true\n    },\n\n    push(type: StackType, newCaret: Caret): true {\n      stack.push(type)\n      caret = newCaret\n\n      return true\n    },\n\n    update(newCaret: Caret): true {\n      caret = newCaret\n\n      return true\n    }\n  }\n}\n\nfunction last<T>(array: T[]): T | undefined {\n  return array[array.length - 1]\n}\n"],"mappings":";;;;;;;IAAYA,KAAK,GAAAC,OAAA,CAAAD,KAAA,0BAALA,KAAK;EAALA,KAAK;EAALA,KAAK;EAALA,KAAK;EAAA,OAALA,KAAK;AAAA;AAAA,IAMLE,SAAS,GAAAD,OAAA,CAAAC,SAAA,0BAATA,SAAS;EAATA,SAAS;EAATA,SAAS;EAATA,SAAS;EAATA,SAAS;EAATA,SAAS;EAAA,OAATA,SAAS;AAAA;AAQd,SAASC,WAAWA,CAAA,EAAG;EAC5B,MAAMC,KAAkB,GAAG,CAACF,SAAS,CAACG,IAAI,CAAC;EAC3C,IAAIC,KAAK,GAAGN,KAAK,CAACO,WAAW;EAE7B,OAAO;IACL,IAAIC,IAAIA,CAAA,EAAG;MACT,OAAOC,IAAI,CAACL,KAAK,CAAC;IACpB,CAAC;IAED,IAAIE,KAAKA,CAAA,EAAG;MACV,OAAOA,KAAK;IACd,CAAC;IAEDI,GAAGA,CAAA,EAAS;MACVN,KAAK,CAACM,GAAG,CAAC,CAAC;MACXJ,KAAK,GAAGN,KAAK,CAACW,UAAU;MAExB,OAAO,IAAI;IACb,CAAC;IAEDC,IAAIA,CAACJ,IAAe,EAAEK,QAAe,EAAQ;MAC3CT,KAAK,CAACQ,IAAI,CAACJ,IAAI,CAAC;MAChBF,KAAK,GAAGO,QAAQ;MAEhB,OAAO,IAAI;IACb,CAAC;IAEDC,MAAMA,CAACD,QAAe,EAAQ;MAC5BP,KAAK,GAAGO,QAAQ;MAEhB,OAAO,IAAI;IACb;EACF,CAAC;AACH;AAEA,SAASJ,IAAIA,CAAIM,KAAU,EAAiB;EAC1C,OAAOA,KAAK,CAACA,KAAK,CAACC,MAAM,GAAG,CAAC,CAAC;AAChC","ignoreList":[]}

node_modules/jsonrepair/lib/cjs/streaming/stream.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.jsonrepairTransform = jsonrepairTransform;
+var _nodeStream = require("node:stream");
+var _core = require("./core.js");
+function jsonrepairTransform(options) {
+  const repair = (0, _core.jsonrepairCore)({
+    onData: chunk => transform.push(chunk),
+    bufferSize: options?.bufferSize,
+    chunkSize: options?.chunkSize
+  });
+  const transform = new _nodeStream.Transform({
+    transform(chunk, _encoding, callback) {
+      try {
+        repair.transform(chunk.toString());
+      } catch (err) {
+        this.emit('error', err);
+      } finally {
+        callback();
+      }
+    },
+    flush(callback) {
+      try {
+        repair.flush();
+      } catch (err) {
+        this.emit('error', err);
+      } finally {
+        callback();
+      }
+    }
+  });
+  return transform;
+}
+//# sourceMappingURL=stream.js.map

node_modules/jsonrepair/lib/cjs/streaming/stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.js","names":["_nodeStream","require","_core","jsonrepairTransform","options","repair","jsonrepairCore","onData","chunk","transform","push","bufferSize","chunkSize","Transform","_encoding","callback","toString","err","emit","flush"],"sources":["../../../src/streaming/stream.ts"],"sourcesContent":["import { Transform } from 'node:stream'\nimport { jsonrepairCore } from './core.js'\n\nexport interface JsonRepairTransformOptions {\n  chunkSize?: number\n  bufferSize?: number\n}\n\nexport function jsonrepairTransform(options?: JsonRepairTransformOptions): Transform {\n  const repair = jsonrepairCore({\n    onData: (chunk) => transform.push(chunk),\n    bufferSize: options?.bufferSize,\n    chunkSize: options?.chunkSize\n  })\n\n  const transform = new Transform({\n    transform(chunk, _encoding, callback) {\n      try {\n        repair.transform(chunk.toString())\n      } catch (err) {\n        this.emit('error', err)\n      } finally {\n        callback()\n      }\n    },\n\n    flush(callback) {\n      try {\n        repair.flush()\n      } catch (err) {\n        this.emit('error', err)\n      } finally {\n        callback()\n      }\n    }\n  })\n\n  return transform\n}\n"],"mappings":";;;;;;AAAA,IAAAA,WAAA,GAAAC,OAAA;AACA,IAAAC,KAAA,GAAAD,OAAA;AAOO,SAASE,mBAAmBA,CAACC,OAAoC,EAAa;EACnF,MAAMC,MAAM,GAAG,IAAAC,oBAAc,EAAC;IAC5BC,MAAM,EAAGC,KAAK,IAAKC,SAAS,CAACC,IAAI,CAACF,KAAK,CAAC;IACxCG,UAAU,EAAEP,OAAO,EAAEO,UAAU;IAC/BC,SAAS,EAAER,OAAO,EAAEQ;EACtB,CAAC,CAAC;EAEF,MAAMH,SAAS,GAAG,IAAII,qBAAS,CAAC;IAC9BJ,SAASA,CAACD,KAAK,EAAEM,SAAS,EAAEC,QAAQ,EAAE;MACpC,IAAI;QACFV,MAAM,CAACI,SAAS,CAACD,KAAK,CAACQ,QAAQ,CAAC,CAAC,CAAC;MACpC,CAAC,CAAC,OAAOC,GAAG,EAAE;QACZ,IAAI,CAACC,IAAI,CAAC,OAAO,EAAED,GAAG,CAAC;MACzB,CAAC,SAAS;QACRF,QAAQ,CAAC,CAAC;MACZ;IACF,CAAC;IAEDI,KAAKA,CAACJ,QAAQ,EAAE;MACd,IAAI;QACFV,MAAM,CAACc,KAAK,CAAC,CAAC;MAChB,CAAC,CAAC,OAAOF,GAAG,EAAE;QACZ,IAAI,CAACC,IAAI,CAAC,OAAO,EAAED,GAAG,CAAC;MACzB,CAAC,SAAS;QACRF,QAAQ,CAAC,CAAC;MACZ;IACF;EACF,CAAC,CAAC;EAEF,OAAON,SAAS;AAClB","ignoreList":[]}

node_modules/jsonrepair/lib/cjs/utils/JSONRepairError.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.JSONRepairError = void 0;
+class JSONRepairError extends Error {
+  constructor(message, position) {
+    super(`${message} at position ${position}`);
+    this.position = position;
+  }
+}
+exports.JSONRepairError = JSONRepairError;
+//# sourceMappingURL=JSONRepairError.js.map

node_modules/jsonrepair/lib/cjs/utils/JSONRepairError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JSONRepairError.js","names":["JSONRepairError","Error","constructor","message","position","exports"],"sources":["../../../src/utils/JSONRepairError.ts"],"sourcesContent":["export class JSONRepairError extends Error {\n  position: number\n\n  constructor(message: string, position: number) {\n    super(`${message} at position ${position}`)\n\n    this.position = position\n  }\n}\n"],"mappings":";;;;;;AAAO,MAAMA,eAAe,SAASC,KAAK,CAAC;EAGzCC,WAAWA,CAACC,OAAe,EAAEC,QAAgB,EAAE;IAC7C,KAAK,CAAC,GAAGD,OAAO,gBAAgBC,QAAQ,EAAE,CAAC;IAE3C,IAAI,CAACA,QAAQ,GAAGA,QAAQ;EAC1B;AACF;AAACC,OAAA,CAAAL,eAAA,GAAAA,eAAA","ignoreList":[]}

node_modules/jsonrepair/lib/cjs/utils/stringUtils.js

@@ -0,0 +1,174 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.endsWithCommaOrNewline = endsWithCommaOrNewline;
+exports.insertBeforeLastWhitespace = insertBeforeLastWhitespace;
+exports.isControlCharacter = isControlCharacter;
+exports.isDelimiter = isDelimiter;
+exports.isDigit = isDigit;
+exports.isDoubleQuote = isDoubleQuote;
+exports.isDoubleQuoteLike = isDoubleQuoteLike;
+exports.isFunctionNameChar = isFunctionNameChar;
+exports.isFunctionNameCharStart = isFunctionNameCharStart;
+exports.isHex = isHex;
+exports.isQuote = isQuote;
+exports.isSingleQuote = isSingleQuote;
+exports.isSingleQuoteLike = isSingleQuoteLike;
+exports.isSpecialWhitespace = isSpecialWhitespace;
+exports.isStartOfValue = isStartOfValue;
+exports.isUnquotedStringDelimiter = isUnquotedStringDelimiter;
+exports.isValidStringCharacter = isValidStringCharacter;
+exports.isWhitespace = isWhitespace;
+exports.isWhitespaceExceptNewline = isWhitespaceExceptNewline;
+exports.regexUrlStart = exports.regexUrlChar = void 0;
+exports.removeAtIndex = removeAtIndex;
+exports.stripLastOccurrence = stripLastOccurrence;
+const codeSpace = 0x20; // " "
+const codeNewline = 0xa; // "\n"
+const codeTab = 0x9; // "\t"
+const codeReturn = 0xd; // "\r"
+const codeNonBreakingSpace = 0xa0;
+const codeEnQuad = 0x2000;
+const codeHairSpace = 0x200a;
+const codeNarrowNoBreakSpace = 0x202f;
+const codeMediumMathematicalSpace = 0x205f;
+const codeIdeographicSpace = 0x3000;
+function isHex(char) {
+  return /^[0-9A-Fa-f]$/.test(char);
+}
+function isDigit(char) {
+  return char >= '0' && char <= '9';
+}
+function isValidStringCharacter(char) {
+  // note that the valid range is between \u{0020} and \u{10ffff},
+  // but in JavaScript it is not possible to create a code point larger than
+  // \u{10ffff}, so there is no need to test for that here.
+  return char >= '\u0020';
+}
+function isDelimiter(char) {
+  return ',:[]/{}()\n+'.includes(char);
+}
+function isFunctionNameCharStart(char) {
+  return char >= 'a' && char <= 'z' || char >= 'A' && char <= 'Z' || char === '_' || char === '$';
+}
+function isFunctionNameChar(char) {
+  return char >= 'a' && char <= 'z' || char >= 'A' && char <= 'Z' || char === '_' || char === '$' || char >= '0' && char <= '9';
+}
+
+// matches "https://" and other schemas
+const regexUrlStart = exports.regexUrlStart = /^(http|https|ftp|mailto|file|data|irc):\/\/$/;
+
+// matches all valid URL characters EXCEPT "[", "]", and ",", since that are important JSON delimiters
+const regexUrlChar = exports.regexUrlChar = /^[A-Za-z0-9-._~:/?#@!$&'()*+;=]$/;
+function isUnquotedStringDelimiter(char) {
+  return ',[]/{}\n+'.includes(char);
+}
+function isStartOfValue(char) {
+  return isQuote(char) || regexStartOfValue.test(char);
+}
+
+// alpha, number, minus, or opening bracket or brace
+const regexStartOfValue = /^[[{\w-]$/;
+function isControlCharacter(char) {
+  return char === '\n' || char === '\r' || char === '\t' || char === '\b' || char === '\f';
+}
+/**
+ * Check if the given character is a whitespace character like space, tab, or
+ * newline
+ */
+function isWhitespace(text, index) {
+  const code = text.charCodeAt(index);
+  return code === codeSpace || code === codeNewline || code === codeTab || code === codeReturn;
+}
+
+/**
+ * Check if the given character is a whitespace character like space or tab,
+ * but NOT a newline
+ */
+function isWhitespaceExceptNewline(text, index) {
+  const code = text.charCodeAt(index);
+  return code === codeSpace || code === codeTab || code === codeReturn;
+}
+
+/**
+ * Check if the given character is a special whitespace character, some
+ * unicode variant
+ */
+function isSpecialWhitespace(text, index) {
+  const code = text.charCodeAt(index);
+  return code === codeNonBreakingSpace || code >= codeEnQuad && code <= codeHairSpace || code === codeNarrowNoBreakSpace || code === codeMediumMathematicalSpace || code === codeIdeographicSpace;
+}
+
+/**
+ * Test whether the given character is a quote or double quote character.
+ * Also tests for special variants of quotes.
+ */
+function isQuote(char) {
+  // the first check double quotes, since that occurs most often
+  return isDoubleQuoteLike(char) || isSingleQuoteLike(char);
+}
+
+/**
+ * Test whether the given character is a double quote character.
+ * Also tests for special variants of double quotes.
+ */
+function isDoubleQuoteLike(char) {
+  return char === '"' || char === '\u201c' || char === '\u201d';
+}
+
+/**
+ * Test whether the given character is a double quote character.
+ * Does NOT test for special variants of double quotes.
+ */
+function isDoubleQuote(char) {
+  return char === '"';
+}
+
+/**
+ * Test whether the given character is a single quote character.
+ * Also tests for special variants of single quotes.
+ */
+function isSingleQuoteLike(char) {
+  return char === "'" || char === '\u2018' || char === '\u2019' || char === '\u0060' || char === '\u00b4';
+}
+
+/**
+ * Test whether the given character is a single quote character.
+ * Does NOT test for special variants of single quotes.
+ */
+function isSingleQuote(char) {
+  return char === "'";
+}
+
+/**
+ * Strip last occurrence of textToStrip from text
+ */
+function stripLastOccurrence(text, textToStrip) {
+  let stripRemainingText = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  const index = text.lastIndexOf(textToStrip);
+  return index !== -1 ? text.substring(0, index) + (stripRemainingText ? '' : text.substring(index + 1)) : text;
+}
+function insertBeforeLastWhitespace(text, textToInsert) {
+  let index = text.length;
+  if (!isWhitespace(text, index - 1)) {
+    // no trailing whitespaces
+    return text + textToInsert;
+  }
+  while (isWhitespace(text, index - 1)) {
+    index--;
+  }
+  return text.substring(0, index) + textToInsert + text.substring(index);
+}
+function removeAtIndex(text, start, count) {
+  return text.substring(0, start) + text.substring(start + count);
+}
+
+/**
+ * Test whether a string ends with a newline or comma character and optional whitespace
+ */
+function endsWithCommaOrNewline(text) {
+  return /[,\n][ \t\r]*$/.test(text);
+}
+//# sourceMappingURL=stringUtils.js.map

node_modules/jsonrepair/lib/esm/index.js

@@ -0,0 +1,4 @@
+// Cross-platform, non-streaming JavaScript API
+export { jsonrepair } from './regular/jsonrepair.js';
+export { JSONRepairError } from './utils/JSONRepairError.js';
+//# sourceMappingURL=index.js.map

node_modules/jsonrepair/lib/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["jsonrepair","JSONRepairError"],"sources":["../../src/index.ts"],"sourcesContent":["// Cross-platform, non-streaming JavaScript API\nexport { jsonrepair } from './regular/jsonrepair.js'\nexport { JSONRepairError } from './utils/JSONRepairError.js'\n"],"mappings":"AAAA;AACA,SAASA,UAAU,QAAQ,yBAAyB;AACpD,SAASC,eAAe,QAAQ,4BAA4B","ignoreList":[]}

node_modules/jsonrepair/lib/esm/regular/jsonrepair.js

@@ -0,0 +1,740 @@
+import { JSONRepairError } from '../utils/JSONRepairError.js';
+import { endsWithCommaOrNewline, insertBeforeLastWhitespace, isControlCharacter, isDelimiter, isDigit, isDoubleQuote, isDoubleQuoteLike, isFunctionNameChar, isFunctionNameCharStart, isHex, isQuote, isSingleQuote, isSingleQuoteLike, isSpecialWhitespace, isStartOfValue, isUnquotedStringDelimiter, isValidStringCharacter, isWhitespace, isWhitespaceExceptNewline, regexUrlChar, regexUrlStart, removeAtIndex, stripLastOccurrence } from '../utils/stringUtils.js';
+const controlCharacters = {
+  '\b': '\\b',
+  '\f': '\\f',
+  '\n': '\\n',
+  '\r': '\\r',
+  '\t': '\\t'
+};
+
+// map with all escape characters
+const escapeCharacters = {
+  '"': '"',
+  '\\': '\\',
+  '/': '/',
+  b: '\b',
+  f: '\f',
+  n: '\n',
+  r: '\r',
+  t: '\t'
+  // note that \u is handled separately in parseString()
+};
+
+/**
+ * Repair a string containing an invalid JSON document.
+ * For example changes JavaScript notation into JSON notation.
+ *
+ * Example:
+ *
+ *     try {
+ *       const json = "{name: 'John'}"
+ *       const repaired = jsonrepair(json)
+ *       console.log(repaired)
+ *       // '{"name": "John"}'
+ *     } catch (err) {
+ *       console.error(err)
+ *     }
+ *
+ */
+export function jsonrepair(text) {
+  let i = 0; // current index in text
+  let output = ''; // generated output
+
+  parseMarkdownCodeBlock(['```', '[```', '{```']);
+  const processed = parseValue();
+  if (!processed) {
+    throwUnexpectedEnd();
+  }
+  parseMarkdownCodeBlock(['```', '```]', '```}']);
+  const processedComma = parseCharacter(',');
+  if (processedComma) {
+    parseWhitespaceAndSkipComments();
+  }
+  if (isStartOfValue(text[i]) && endsWithCommaOrNewline(output)) {
+    // start of a new value after end of the root level object: looks like
+    // newline delimited JSON -> turn into a root level array
+    if (!processedComma) {
+      // repair missing comma
+      output = insertBeforeLastWhitespace(output, ',');
+    }
+    parseNewlineDelimitedJSON();
+  } else if (processedComma) {
+    // repair: remove trailing comma
+    output = stripLastOccurrence(output, ',');
+  }
+
+  // repair redundant end quotes
+  while (text[i] === '}' || text[i] === ']') {
+    i++;
+    parseWhitespaceAndSkipComments();
+  }
+  if (i >= text.length) {
+    // reached the end of the document properly
+    return output;
+  }
+  throwUnexpectedCharacter();
+  function parseValue() {
+    parseWhitespaceAndSkipComments();
+    const processed = parseObject() || parseArray() || parseString() || parseNumber() || parseKeywords() || parseUnquotedString(false) || parseRegex();
+    parseWhitespaceAndSkipComments();
+    return processed;
+  }
+  function parseWhitespaceAndSkipComments() {
+    let skipNewline = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+    const start = i;
+    let changed = parseWhitespace(skipNewline);
+    do {
+      changed = parseComment();
+      if (changed) {
+        changed = parseWhitespace(skipNewline);
+      }
+    } while (changed);
+    return i > start;
+  }
+  function parseWhitespace(skipNewline) {
+    const _isWhiteSpace = skipNewline ? isWhitespace : isWhitespaceExceptNewline;
+    let whitespace = '';
+    while (true) {
+      if (_isWhiteSpace(text, i)) {
+        whitespace += text[i];
+        i++;
+      } else if (isSpecialWhitespace(text, i)) {
+        // repair special whitespace
+        whitespace += ' ';
+        i++;
+      } else {
+        break;
+      }
+    }
+    if (whitespace.length > 0) {
+      output += whitespace;
+      return true;
+    }
+    return false;
+  }
+  function parseComment() {
+    // find a block comment '/* ... */'
+    if (text[i] === '/' && text[i + 1] === '*') {
+      // repair block comment by skipping it
+      while (i < text.length && !atEndOfBlockComment(text, i)) {
+        i++;
+      }
+      i += 2;
+      return true;
+    }
+
+    // find a line comment '// ...'
+    if (text[i] === '/' && text[i + 1] === '/') {
+      // repair line comment by skipping it
+      while (i < text.length && text[i] !== '\n') {
+        i++;
+      }
+      return true;
+    }
+    return false;
+  }
+  function parseMarkdownCodeBlock(blocks) {
+    // find and skip over a Markdown fenced code block:
+    //     ``` ... ```
+    // or
+    //     ```json ... ```
+    if (skipMarkdownCodeBlock(blocks)) {
+      if (isFunctionNameCharStart(text[i])) {
+        // strip the optional language specifier like "json"
+        while (i < text.length && isFunctionNameChar(text[i])) {
+          i++;
+        }
+      }
+      parseWhitespaceAndSkipComments();
+      return true;
+    }
+    return false;
+  }
+  function skipMarkdownCodeBlock(blocks) {
+    parseWhitespace(true);
+    for (const block of blocks) {
+      const end = i + block.length;
+      if (text.slice(i, end) === block) {
+        i = end;
+        return true;
+      }
+    }
+    return false;
+  }
+  function parseCharacter(char) {
+    if (text[i] === char) {
+      output += text[i];
+      i++;
+      return true;
+    }
+    return false;
+  }
+  function skipCharacter(char) {
+    if (text[i] === char) {
+      i++;
+      return true;
+    }
+    return false;
+  }
+  function skipEscapeCharacter() {
+    return skipCharacter('\\');
+  }
+
+  /**
+   * Skip ellipsis like "[1,2,3,...]" or "[1,2,3,...,9]" or "[...,7,8,9]"
+   * or a similar construct in objects.
+   */
+  function skipEllipsis() {
+    parseWhitespaceAndSkipComments();
+    if (text[i] === '.' && text[i + 1] === '.' && text[i + 2] === '.') {
+      // repair: remove the ellipsis (three dots) and optionally a comma
+      i += 3;
+      parseWhitespaceAndSkipComments();
+      skipCharacter(',');
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Parse an object like '{"key": "value"}'
+   */
+  function parseObject() {
+    if (text[i] === '{') {
+      output += '{';
+      i++;
+      parseWhitespaceAndSkipComments();
+
+      // repair: skip leading comma like in {, message: "hi"}
+      if (skipCharacter(',')) {
+        parseWhitespaceAndSkipComments();
+      }
+      let initial = true;
+      while (i < text.length && text[i] !== '}') {
+        let processedComma;
+        if (!initial) {
+          processedComma = parseCharacter(',');
+          if (!processedComma) {
+            // repair missing comma
+            output = insertBeforeLastWhitespace(output, ',');
+          }
+          parseWhitespaceAndSkipComments();
+        } else {
+          processedComma = true;
+          initial = false;
+        }
+        skipEllipsis();
+        const processedKey = parseString() || parseUnquotedString(true);
+        if (!processedKey) {
+          if (text[i] === '}' || text[i] === '{' || text[i] === ']' || text[i] === '[' || text[i] === undefined) {
+            // repair trailing comma
+            output = stripLastOccurrence(output, ',');
+          } else {
+            throwObjectKeyExpected();
+          }
+          break;
+        }
+        parseWhitespaceAndSkipComments();
+        const processedColon = parseCharacter(':');
+        const truncatedText = i >= text.length;
+        if (!processedColon) {
+          if (isStartOfValue(text[i]) || truncatedText) {
+            // repair missing colon
+            output = insertBeforeLastWhitespace(output, ':');
+          } else {
+            throwColonExpected();
+          }
+        }
+        const processedValue = parseValue();
+        if (!processedValue) {
+          if (processedColon || truncatedText) {
+            // repair missing object value
+            output += 'null';
+          } else {
+            throwColonExpected();
+          }
+        }
+      }
+      if (text[i] === '}') {
+        output += '}';
+        i++;
+      } else {
+        // repair missing end bracket
+        output = insertBeforeLastWhitespace(output, '}');
+      }
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Parse an array like '["item1", "item2", ...]'
+   */
+  function parseArray() {
+    if (text[i] === '[') {
+      output += '[';
+      i++;
+      parseWhitespaceAndSkipComments();
+
+      // repair: skip leading comma like in [,1,2,3]
+      if (skipCharacter(',')) {
+        parseWhitespaceAndSkipComments();
+      }
+      let initial = true;
+      while (i < text.length && text[i] !== ']') {
+        if (!initial) {
+          const processedComma = parseCharacter(',');
+          if (!processedComma) {
+            // repair missing comma
+            output = insertBeforeLastWhitespace(output, ',');
+          }
+        } else {
+          initial = false;
+        }
+        skipEllipsis();
+        const processedValue = parseValue();
+        if (!processedValue) {
+          // repair trailing comma
+          output = stripLastOccurrence(output, ',');
+          break;
+        }
+      }
+      if (text[i] === ']') {
+        output += ']';
+        i++;
+      } else {
+        // repair missing closing array bracket
+        output = insertBeforeLastWhitespace(output, ']');
+      }
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Parse and repair Newline Delimited JSON (NDJSON):
+   * multiple JSON objects separated by a newline character
+   */
+  function parseNewlineDelimitedJSON() {
+    // repair NDJSON
+    let initial = true;
+    let processedValue = true;
+    while (processedValue) {
+      if (!initial) {
+        // parse optional comma, insert when missing
+        const processedComma = parseCharacter(',');
+        if (!processedComma) {
+          // repair: add missing comma
+          output = insertBeforeLastWhitespace(output, ',');
+        }
+      } else {
+        initial = false;
+      }
+      processedValue = parseValue();
+    }
+    if (!processedValue) {
+      // repair: remove trailing comma
+      output = stripLastOccurrence(output, ',');
+    }
+
+    // repair: wrap the output inside array brackets
+    output = `[\n${output}\n]`;
+  }
+
+  /**
+   * Parse a string enclosed by double quotes "...". Can contain escaped quotes
+   * Repair strings enclosed in single quotes or special quotes
+   * Repair an escaped string
+   *
+   * The function can run in two stages:
+   * - First, it assumes the string has a valid end quote
+   * - If it turns out that the string does not have a valid end quote followed
+   *   by a delimiter (which should be the case), the function runs again in a
+   *   more conservative way, stopping the string at the first next delimiter
+   *   and fixing the string by inserting a quote there, or stopping at a
+   *   stop index detected in the first iteration.
+   */
+  function parseString() {
+    let stopAtDelimiter = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    let stopAtIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : -1;
+    let skipEscapeChars = text[i] === '\\';
+    if (skipEscapeChars) {
+      // repair: remove the first escape character
+      i++;
+      skipEscapeChars = true;
+    }
+    if (isQuote(text[i])) {
+      // double quotes are correct JSON,
+      // single quotes come from JavaScript for example, we assume it will have a correct single end quote too
+      // otherwise, we will match any double-quote-like start with a double-quote-like end,
+      // or any single-quote-like start with a single-quote-like end
+      const isEndQuote = isDoubleQuote(text[i]) ? isDoubleQuote : isSingleQuote(text[i]) ? isSingleQuote : isSingleQuoteLike(text[i]) ? isSingleQuoteLike : isDoubleQuoteLike;
+      const iBefore = i;
+      const oBefore = output.length;
+      let str = '"';
+      i++;
+      while (true) {
+        if (i >= text.length) {
+          // end of text, we are missing an end quote
+
+          const iPrev = prevNonWhitespaceIndex(i - 1);
+          if (!stopAtDelimiter && isDelimiter(text.charAt(iPrev))) {
+            // if the text ends with a delimiter, like ["hello],
+            // so the missing end quote should be inserted before this delimiter
+            // retry parsing the string, stopping at the first next delimiter
+            i = iBefore;
+            output = output.substring(0, oBefore);
+            return parseString(true);
+          }
+
+          // repair missing quote
+          str = insertBeforeLastWhitespace(str, '"');
+          output += str;
+          return true;
+        }
+        if (i === stopAtIndex) {
+          // use the stop index detected in the first iteration, and repair end quote
+          str = insertBeforeLastWhitespace(str, '"');
+          output += str;
+          return true;
+        }
+        if (isEndQuote(text[i])) {
+          // end quote
+          // let us check what is before and after the quote to verify whether this is a legit end quote
+          const iQuote = i;
+          const oQuote = str.length;
+          str += '"';
+          i++;
+          output += str;
+          parseWhitespaceAndSkipComments(false);
+          if (stopAtDelimiter || i >= text.length || isDelimiter(text[i]) || isQuote(text[i]) || isDigit(text[i])) {
+            // The quote is followed by the end of the text, a delimiter,
+            // or a next value. So the quote is indeed the end of the string.
+            parseConcatenatedString();
+            return true;
+          }
+          const iPrevChar = prevNonWhitespaceIndex(iQuote - 1);
+          const prevChar = text.charAt(iPrevChar);
+          if (prevChar === ',') {
+            // A comma followed by a quote, like '{"a":"b,c,"d":"e"}'.
+            // We assume that the quote is a start quote, and that the end quote
+            // should have been located right before the comma but is missing.
+            i = iBefore;
+            output = output.substring(0, oBefore);
+            return parseString(false, iPrevChar);
+          }
+          if (isDelimiter(prevChar)) {
+            // This is not the right end quote: it is preceded by a delimiter,
+            // and NOT followed by a delimiter. So, there is an end quote missing
+            // parse the string again and then stop at the first next delimiter
+            i = iBefore;
+            output = output.substring(0, oBefore);
+            return parseString(true);
+          }
+
+          // revert to right after the quote but before any whitespace, and continue parsing the string
+          output = output.substring(0, oBefore);
+          i = iQuote + 1;
+
+          // repair unescaped quote
+          str = `${str.substring(0, oQuote)}\\${str.substring(oQuote)}`;
+        } else if (stopAtDelimiter && isUnquotedStringDelimiter(text[i])) {
+          // we're in the mode to stop the string at the first delimiter
+          // because there is an end quote missing
+
+          // test start of an url like "https://..." (this would be parsed as a comment)
+          if (text[i - 1] === ':' && regexUrlStart.test(text.substring(iBefore + 1, i + 2))) {
+            while (i < text.length && regexUrlChar.test(text[i])) {
+              str += text[i];
+              i++;
+            }
+          }
+
+          // repair missing quote
+          str = insertBeforeLastWhitespace(str, '"');
+          output += str;
+          parseConcatenatedString();
+          return true;
+        } else if (text[i] === '\\') {
+          // handle escaped content like \n or \u2605
+          const char = text.charAt(i + 1);
+          const escapeChar = escapeCharacters[char];
+          if (escapeChar !== undefined) {
+            str += text.slice(i, i + 2);
+            i += 2;
+          } else if (char === 'u') {
+            let j = 2;
+            while (j < 6 && isHex(text[i + j])) {
+              j++;
+            }
+            if (j === 6) {
+              str += text.slice(i, i + 6);
+              i += 6;
+            } else if (i + j >= text.length) {
+              // repair invalid or truncated unicode char at the end of the text
+              // by removing the unicode char and ending the string here
+              i = text.length;
+            } else {
+              throwInvalidUnicodeCharacter();
+            }
+          } else {
+            // repair invalid escape character: remove it
+            str += char;
+            i += 2;
+          }
+        } else {
+          // handle regular characters
+          const char = text.charAt(i);
+          if (char === '"' && text[i - 1] !== '\\') {
+            // repair unescaped double quote
+            str += `\\${char}`;
+            i++;
+          } else if (isControlCharacter(char)) {
+            // unescaped control character
+            str += controlCharacters[char];
+            i++;
+          } else {
+            if (!isValidStringCharacter(char)) {
+              throwInvalidCharacter(char);
+            }
+            str += char;
+            i++;
+          }
+        }
+        if (skipEscapeChars) {
+          // repair: skipped escape character (nothing to do)
+          skipEscapeCharacter();
+        }
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Repair concatenated strings like "hello" + "world", change this into "helloworld"
+   */
+  function parseConcatenatedString() {
+    let processed = false;
+    parseWhitespaceAndSkipComments();
+    while (text[i] === '+') {
+      processed = true;
+      i++;
+      parseWhitespaceAndSkipComments();
+
+      // repair: remove the end quote of the first string
+      output = stripLastOccurrence(output, '"', true);
+      const start = output.length;
+      const parsedStr = parseString();
+      if (parsedStr) {
+        // repair: remove the start quote of the second string
+        output = removeAtIndex(output, start, 1);
+      } else {
+        // repair: remove the + because it is not followed by a string
+        output = insertBeforeLastWhitespace(output, '"');
+      }
+    }
+    return processed;
+  }
+
+  /**
+   * Parse a number like 2.4 or 2.4e6
+   */
+  function parseNumber() {
+    const start = i;
+    if (text[i] === '-') {
+      i++;
+      if (atEndOfNumber()) {
+        repairNumberEndingWithNumericSymbol(start);
+        return true;
+      }
+      if (!isDigit(text[i])) {
+        i = start;
+        return false;
+      }
+    }
+
+    // Note that in JSON leading zeros like "00789" are not allowed.
+    // We will allow all leading zeros here though and at the end of parseNumber
+    // check against trailing zeros and repair that if needed.
+    // Leading zeros can have meaning, so we should not clear them.
+    while (isDigit(text[i])) {
+      i++;
+    }
+    if (text[i] === '.') {
+      i++;
+      if (atEndOfNumber()) {
+        repairNumberEndingWithNumericSymbol(start);
+        return true;
+      }
+      if (!isDigit(text[i])) {
+        i = start;
+        return false;
+      }
+      while (isDigit(text[i])) {
+        i++;
+      }
+    }
+    if (text[i] === 'e' || text[i] === 'E') {
+      i++;
+      if (text[i] === '-' || text[i] === '+') {
+        i++;
+      }
+      if (atEndOfNumber()) {
+        repairNumberEndingWithNumericSymbol(start);
+        return true;
+      }
+      if (!isDigit(text[i])) {
+        i = start;
+        return false;
+      }
+      while (isDigit(text[i])) {
+        i++;
+      }
+    }
+
+    // if we're not at the end of the number by this point, allow this to be parsed as another type
+    if (!atEndOfNumber()) {
+      i = start;
+      return false;
+    }
+    if (i > start) {
+      // repair a number with leading zeros like "00789"
+      const num = text.slice(start, i);
+      const hasInvalidLeadingZero = /^0\d/.test(num);
+      output += hasInvalidLeadingZero ? `"${num}"` : num;
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Parse keywords true, false, null
+   * Repair Python keywords True, False, None
+   */
+  function parseKeywords() {
+    return parseKeyword('true', 'true') || parseKeyword('false', 'false') || parseKeyword('null', 'null') ||
+    // repair Python keywords True, False, None
+    parseKeyword('True', 'true') || parseKeyword('False', 'false') || parseKeyword('None', 'null');
+  }
+  function parseKeyword(name, value) {
+    if (text.slice(i, i + name.length) === name) {
+      output += value;
+      i += name.length;
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Repair an unquoted string by adding quotes around it
+   * Repair a MongoDB function call like NumberLong("2")
+   * Repair a JSONP function call like callback({...});
+   */
+  function parseUnquotedString(isKey) {
+    // note that the symbol can end with whitespaces: we stop at the next delimiter
+    // also, note that we allow strings to contain a slash / in order to support repairing regular expressions
+    const start = i;
+    if (isFunctionNameCharStart(text[i])) {
+      while (i < text.length && isFunctionNameChar(text[i])) {
+        i++;
+      }
+      let j = i;
+      while (isWhitespace(text, j)) {
+        j++;
+      }
+      if (text[j] === '(') {
+        // repair a MongoDB function call like NumberLong("2")
+        // repair a JSONP function call like callback({...});
+        i = j + 1;
+        parseValue();
+        if (text[i] === ')') {
+          // repair: skip close bracket of function call
+          i++;
+          if (text[i] === ';') {
+            // repair: skip semicolon after JSONP call
+            i++;
+          }
+        }
+        return true;
+      }
+    }
+    while (i < text.length && !isUnquotedStringDelimiter(text[i]) && !isQuote(text[i]) && (!isKey || text[i] !== ':')) {
+      i++;
+    }
+
+    // test start of an url like "https://..." (this would be parsed as a comment)
+    if (text[i - 1] === ':' && regexUrlStart.test(text.substring(start, i + 2))) {
+      while (i < text.length && regexUrlChar.test(text[i])) {
+        i++;
+      }
+    }
+    if (i > start) {
+      // repair unquoted string
+      // also, repair undefined into null
+
+      // first, go back to prevent getting trailing whitespaces in the string
+      while (isWhitespace(text, i - 1) && i > 0) {
+        i--;
+      }
+      const symbol = text.slice(start, i);
+      output += symbol === 'undefined' ? 'null' : JSON.stringify(symbol);
+      if (text[i] === '"') {
+        // we had a missing start quote, but now we encountered the end quote, so we can skip that one
+        i++;
+      }
+      return true;
+    }
+  }
+  function parseRegex() {
+    if (text[i] === '/') {
+      const start = i;
+      i++;
+      while (i < text.length && (text[i] !== '/' || text[i - 1] === '\\')) {
+        i++;
+      }
+      i++;
+      output += `"${text.substring(start, i)}"`;
+      return true;
+    }
+  }
+  function prevNonWhitespaceIndex(start) {
+    let prev = start;
+    while (prev > 0 && isWhitespace(text, prev)) {
+      prev--;
+    }
+    return prev;
+  }
+  function atEndOfNumber() {
+    return i >= text.length || isDelimiter(text[i]) || isWhitespace(text, i);
+  }
+  function repairNumberEndingWithNumericSymbol(start) {
+    // repair numbers cut off at the end
+    // this will only be called when we end after a '.', '-', or 'e' and does not
+    // change the number more than it needs to make it valid JSON
+    output += `${text.slice(start, i)}0`;
+  }
+  function throwInvalidCharacter(char) {
+    throw new JSONRepairError(`Invalid character ${JSON.stringify(char)}`, i);
+  }
+  function throwUnexpectedCharacter() {
+    throw new JSONRepairError(`Unexpected character ${JSON.stringify(text[i])}`, i);
+  }
+  function throwUnexpectedEnd() {
+    throw new JSONRepairError('Unexpected end of json string', text.length);
+  }
+  function throwObjectKeyExpected() {
+    throw new JSONRepairError('Object key expected', i);
+  }
+  function throwColonExpected() {
+    throw new JSONRepairError('Colon expected', i);
+  }
+  function throwInvalidUnicodeCharacter() {
+    const chars = text.slice(i, i + 6);
+    throw new JSONRepairError(`Invalid unicode character "${chars}"`, i);
+  }
+}
+function atEndOfBlockComment(text, i) {
+  return text[i] === '*' && text[i + 1] === '/';
+}
+//# sourceMappingURL=jsonrepair.js.map

node_modules/jsonrepair/lib/esm/stream.js

@@ -0,0 +1,3 @@
+// Node.js streaming API
+export { jsonrepairTransform } from './streaming/stream.js';
+//# sourceMappingURL=stream.js.map

node_modules/jsonrepair/lib/esm/stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.js","names":["jsonrepairTransform"],"sources":["../../src/stream.ts"],"sourcesContent":["// Node.js streaming API\nexport { type JsonRepairTransformOptions, jsonrepairTransform } from './streaming/stream.js'\n"],"mappings":"AAAA;AACA,SAA0CA,mBAAmB,QAAQ,uBAAuB","ignoreList":[]}

node_modules/jsonrepair/lib/esm/streaming/buffer/InputBuffer.js

@@ -0,0 +1,69 @@
+export function createInputBuffer() {
+  let buffer = '';
+  let offset = 0;
+  let currentLength = 0;
+  let closed = false;
+  function ensure(index) {
+    if (index < offset) {
+      throw new Error(`${indexOutOfRangeMessage} (index: ${index}, offset: ${offset})`);
+    }
+    if (index >= currentLength) {
+      if (!closed) {
+        throw new Error(`${indexOutOfRangeMessage} (index: ${index})`);
+      }
+    }
+  }
+  function push(chunk) {
+    buffer += chunk;
+    currentLength += chunk.length;
+  }
+  function flush(position) {
+    if (position > currentLength) {
+      return;
+    }
+    buffer = buffer.substring(position - offset);
+    offset = position;
+  }
+  function charAt(index) {
+    ensure(index);
+    return buffer.charAt(index - offset);
+  }
+  function charCodeAt(index) {
+    ensure(index);
+    return buffer.charCodeAt(index - offset);
+  }
+  function substring(start, end) {
+    ensure(end - 1); // -1 because end is excluded
+    ensure(start);
+    return buffer.slice(start - offset, end - offset);
+  }
+  function length() {
+    if (!closed) {
+      throw new Error('Cannot get length: input is not yet closed');
+    }
+    return currentLength;
+  }
+  function isEnd(index) {
+    if (!closed) {
+      ensure(index);
+    }
+    return index >= currentLength;
+  }
+  function close() {
+    closed = true;
+  }
+  return {
+    push,
+    flush,
+    charAt,
+    charCodeAt,
+    substring,
+    length,
+    currentLength: () => currentLength,
+    currentBufferSize: () => buffer.length,
+    isEnd,
+    close
+  };
+}
+const indexOutOfRangeMessage = 'Index out of range, please configure a larger buffer size';
+//# sourceMappingURL=InputBuffer.js.map

node_modules/jsonrepair/lib/esm/streaming/buffer/InputBuffer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InputBuffer.js","names":["createInputBuffer","buffer","offset","currentLength","closed","ensure","index","Error","indexOutOfRangeMessage","push","chunk","length","flush","position","substring","charAt","charCodeAt","start","end","slice","isEnd","close","currentBufferSize"],"sources":["../../../../src/streaming/buffer/InputBuffer.ts"],"sourcesContent":["export interface InputBuffer {\n  push: (chunk: string) => void\n  flush: (position: number) => void\n  charAt: (index: number) => string\n  charCodeAt: (index: number) => number\n  substring: (start: number, end: number) => string\n  length: () => number\n  currentLength: () => number\n  currentBufferSize: () => number\n  isEnd: (index: number) => boolean\n  close: () => void\n}\n\nexport function createInputBuffer(): InputBuffer {\n  let buffer = ''\n  let offset = 0\n  let currentLength = 0\n  let closed = false\n\n  function ensure(index: number) {\n    if (index < offset) {\n      throw new Error(`${indexOutOfRangeMessage} (index: ${index}, offset: ${offset})`)\n    }\n\n    if (index >= currentLength) {\n      if (!closed) {\n        throw new Error(`${indexOutOfRangeMessage} (index: ${index})`)\n      }\n    }\n  }\n\n  function push(chunk: string) {\n    buffer += chunk\n    currentLength += chunk.length\n  }\n\n  function flush(position: number) {\n    if (position > currentLength) {\n      return\n    }\n\n    buffer = buffer.substring(position - offset)\n    offset = position\n  }\n\n  function charAt(index: number): string {\n    ensure(index)\n\n    return buffer.charAt(index - offset)\n  }\n\n  function charCodeAt(index: number): number {\n    ensure(index)\n\n    return buffer.charCodeAt(index - offset)\n  }\n\n  function substring(start: number, end: number): string {\n    ensure(end - 1) // -1 because end is excluded\n    ensure(start)\n\n    return buffer.slice(start - offset, end - offset)\n  }\n\n  function length(): number {\n    if (!closed) {\n      throw new Error('Cannot get length: input is not yet closed')\n    }\n\n    return currentLength\n  }\n\n  function isEnd(index: number): boolean {\n    if (!closed) {\n      ensure(index)\n    }\n\n    return index >= currentLength\n  }\n\n  function close() {\n    closed = true\n  }\n\n  return {\n    push,\n    flush,\n    charAt,\n    charCodeAt,\n    substring,\n    length,\n    currentLength: () => currentLength,\n    currentBufferSize: () => buffer.length,\n    isEnd,\n    close\n  }\n}\n\nconst indexOutOfRangeMessage = 'Index out of range, please configure a larger buffer size'\n"],"mappings":"AAaA,OAAO,SAASA,iBAAiBA,CAAA,EAAgB;EAC/C,IAAIC,MAAM,GAAG,EAAE;EACf,IAAIC,MAAM,GAAG,CAAC;EACd,IAAIC,aAAa,GAAG,CAAC;EACrB,IAAIC,MAAM,GAAG,KAAK;EAElB,SAASC,MAAMA,CAACC,KAAa,EAAE;IAC7B,IAAIA,KAAK,GAAGJ,MAAM,EAAE;MAClB,MAAM,IAAIK,KAAK,CAAC,GAAGC,sBAAsB,YAAYF,KAAK,aAAaJ,MAAM,GAAG,CAAC;IACnF;IAEA,IAAII,KAAK,IAAIH,aAAa,EAAE;MAC1B,IAAI,CAACC,MAAM,EAAE;QACX,MAAM,IAAIG,KAAK,CAAC,GAAGC,sBAAsB,YAAYF,KAAK,GAAG,CAAC;MAChE;IACF;EACF;EAEA,SAASG,IAAIA,CAACC,KAAa,EAAE;IAC3BT,MAAM,IAAIS,KAAK;IACfP,aAAa,IAAIO,KAAK,CAACC,MAAM;EAC/B;EAEA,SAASC,KAAKA,CAACC,QAAgB,EAAE;IAC/B,IAAIA,QAAQ,GAAGV,aAAa,EAAE;MAC5B;IACF;IAEAF,MAAM,GAAGA,MAAM,CAACa,SAAS,CAACD,QAAQ,GAAGX,MAAM,CAAC;IAC5CA,MAAM,GAAGW,QAAQ;EACnB;EAEA,SAASE,MAAMA,CAACT,KAAa,EAAU;IACrCD,MAAM,CAACC,KAAK,CAAC;IAEb,OAAOL,MAAM,CAACc,MAAM,CAACT,KAAK,GAAGJ,MAAM,CAAC;EACtC;EAEA,SAASc,UAAUA,CAACV,KAAa,EAAU;IACzCD,MAAM,CAACC,KAAK,CAAC;IAEb,OAAOL,MAAM,CAACe,UAAU,CAACV,KAAK,GAAGJ,MAAM,CAAC;EAC1C;EAEA,SAASY,SAASA,CAACG,KAAa,EAAEC,GAAW,EAAU;IACrDb,MAAM,CAACa,GAAG,GAAG,CAAC,CAAC,EAAC;IAChBb,MAAM,CAACY,KAAK,CAAC;IAEb,OAAOhB,MAAM,CAACkB,KAAK,CAACF,KAAK,GAAGf,MAAM,EAAEgB,GAAG,GAAGhB,MAAM,CAAC;EACnD;EAEA,SAASS,MAAMA,CAAA,EAAW;IACxB,IAAI,CAACP,MAAM,EAAE;MACX,MAAM,IAAIG,KAAK,CAAC,4CAA4C,CAAC;IAC/D;IAEA,OAAOJ,aAAa;EACtB;EAEA,SAASiB,KAAKA,CAACd,KAAa,EAAW;IACrC,IAAI,CAACF,MAAM,EAAE;MACXC,MAAM,CAACC,KAAK,CAAC;IACf;IAEA,OAAOA,KAAK,IAAIH,aAAa;EAC/B;EAEA,SAASkB,KAAKA,CAAA,EAAG;IACfjB,MAAM,GAAG,IAAI;EACf;EAEA,OAAO;IACLK,IAAI;IACJG,KAAK;IACLG,MAAM;IACNC,UAAU;IACVF,SAAS;IACTH,MAAM;IACNR,aAAa,EAAEA,CAAA,KAAMA,aAAa;IAClCmB,iBAAiB,EAAEA,CAAA,KAAMrB,MAAM,CAACU,MAAM;IACtCS,KAAK;IACLC;EACF,CAAC;AACH;AAEA,MAAMb,sBAAsB,GAAG,2DAA2D","ignoreList":[]}

node_modules/jsonrepair/lib/esm/streaming/buffer/OutputBuffer.js

@@ -0,0 +1,111 @@
+import { isWhitespace } from '../../utils/stringUtils.js';
+export function createOutputBuffer(_ref) {
+  let {
+    write,
+    chunkSize,
+    bufferSize
+  } = _ref;
+  let buffer = '';
+  let offset = 0;
+  function flushChunks() {
+    let minSize = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : bufferSize;
+    while (buffer.length >= minSize + chunkSize) {
+      const chunk = buffer.substring(0, chunkSize);
+      write(chunk);
+      offset += chunkSize;
+      buffer = buffer.substring(chunkSize);
+    }
+  }
+  function flush() {
+    flushChunks(0);
+    if (buffer.length > 0) {
+      write(buffer);
+      offset += buffer.length;
+      buffer = '';
+    }
+  }
+  function push(text) {
+    buffer += text;
+    flushChunks();
+  }
+  function unshift(text) {
+    if (offset > 0) {
+      throw new Error(`Cannot unshift: ${flushedMessage}`);
+    }
+    buffer = text + buffer;
+    flushChunks();
+  }
+  function remove(start, end) {
+    if (start < offset) {
+      throw new Error(`Cannot remove: ${flushedMessage}`);
+    }
+    if (end !== undefined) {
+      buffer = buffer.substring(0, start - offset) + buffer.substring(end - offset);
+    } else {
+      buffer = buffer.substring(0, start - offset);
+    }
+  }
+  function insertAt(index, text) {
+    if (index < offset) {
+      throw new Error(`Cannot insert: ${flushedMessage}`);
+    }
+    buffer = buffer.substring(0, index - offset) + text + buffer.substring(index - offset);
+  }
+  function length() {
+    return offset + buffer.length;
+  }
+  function stripLastOccurrence(textToStrip) {
+    let stripRemainingText = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    const bufferIndex = buffer.lastIndexOf(textToStrip);
+    if (bufferIndex !== -1) {
+      if (stripRemainingText) {
+        buffer = buffer.substring(0, bufferIndex);
+      } else {
+        buffer = buffer.substring(0, bufferIndex) + buffer.substring(bufferIndex + textToStrip.length);
+      }
+    }
+  }
+  function insertBeforeLastWhitespace(textToInsert) {
+    let bufferIndex = buffer.length; // index relative to the start of the buffer, not taking `offset` into account
+
+    if (!isWhitespace(buffer, bufferIndex - 1)) {
+      // no trailing whitespaces
+      push(textToInsert);
+      return;
+    }
+    while (isWhitespace(buffer, bufferIndex - 1)) {
+      bufferIndex--;
+    }
+    if (bufferIndex <= 0) {
+      throw new Error(`Cannot insert: ${flushedMessage}`);
+    }
+    buffer = buffer.substring(0, bufferIndex) + textToInsert + buffer.substring(bufferIndex);
+    flushChunks();
+  }
+  function endsWithIgnoringWhitespace(char) {
+    let i = buffer.length - 1;
+    while (i > 0) {
+      if (char === buffer.charAt(i)) {
+        return true;
+      }
+      if (!isWhitespace(buffer, i)) {
+        return false;
+      }
+      i--;
+    }
+    return false;
+  }
+  return {
+    push,
+    unshift,
+    remove,
+    insertAt,
+    length,
+    flush,
+    stripLastOccurrence,
+    insertBeforeLastWhitespace,
+    endsWithIgnoringWhitespace
+  };
+}
+const flushedMessage = 'start of the output is already flushed from the buffer';
+//# sourceMappingURL=OutputBuffer.js.map

node_modules/jsonrepair/lib/esm/streaming/core.js

@@ -0,0 +1,818 @@
+import { JSONRepairError } from '../utils/JSONRepairError.js';
+import { isControlCharacter, isDelimiter, isDigit, isDoubleQuote, isDoubleQuoteLike, isFunctionNameChar, isFunctionNameCharStart, isHex, isQuote, isSingleQuote, isSingleQuoteLike, isSpecialWhitespace, isStartOfValue, isUnquotedStringDelimiter, isValidStringCharacter, isWhitespace, isWhitespaceExceptNewline, regexUrlChar, regexUrlStart } from '../utils/stringUtils.js';
+import { createInputBuffer } from './buffer/InputBuffer.js';
+import { createOutputBuffer } from './buffer/OutputBuffer.js';
+import { Caret, createStack, StackType } from './stack.js';
+const controlCharacters = {
+  '\b': '\\b',
+  '\f': '\\f',
+  '\n': '\\n',
+  '\r': '\\r',
+  '\t': '\\t'
+};
+
+// map with all escape characters
+const escapeCharacters = {
+  '"': '"',
+  '\\': '\\',
+  '/': '/',
+  b: '\b',
+  f: '\f',
+  n: '\n',
+  r: '\r',
+  t: '\t'
+  // note that \u is handled separately in parseString()
+};
+export function jsonrepairCore(_ref) {
+  let {
+    onData,
+    bufferSize = 65536,
+    chunkSize = 65536
+  } = _ref;
+  const input = createInputBuffer();
+  const output = createOutputBuffer({
+    write: onData,
+    bufferSize,
+    chunkSize
+  });
+  let i = 0;
+  let iFlushed = 0;
+  const stack = createStack();
+  function flushInputBuffer() {
+    while (iFlushed < i - bufferSize - chunkSize) {
+      iFlushed += chunkSize;
+      input.flush(iFlushed);
+    }
+  }
+  function transform(chunk) {
+    input.push(chunk);
+    while (i < input.currentLength() - bufferSize && parse()) {
+      // loop until there is nothing more to process
+    }
+    flushInputBuffer();
+  }
+  function flush() {
+    input.close();
+    while (parse()) {
+      // loop until there is nothing more to process
+    }
+    output.flush();
+  }
+  function parse() {
+    parseWhitespaceAndSkipComments();
+    switch (stack.type) {
+      case StackType.object:
+        {
+          switch (stack.caret) {
+            case Caret.beforeKey:
+              return skipEllipsis() || parseObjectKey() || parseUnexpectedColon() || parseRepairTrailingComma() || parseRepairObjectEndOrComma();
+            case Caret.beforeValue:
+              return parseValue() || parseRepairMissingObjectValue();
+            case Caret.afterValue:
+              return parseObjectComma() || parseObjectEnd() || parseRepairObjectEndOrComma();
+            default:
+              return false;
+          }
+        }
+      case StackType.array:
+        {
+          switch (stack.caret) {
+            case Caret.beforeValue:
+              return skipEllipsis() || parseValue() || parseRepairTrailingComma() || parseRepairArrayEnd();
+            case Caret.afterValue:
+              return parseArrayComma() || parseArrayEnd() || parseRepairMissingComma() || parseRepairArrayEnd();
+            default:
+              return false;
+          }
+        }
+      case StackType.ndJson:
+        {
+          switch (stack.caret) {
+            case Caret.beforeValue:
+              return parseValue() || parseRepairTrailingComma();
+            case Caret.afterValue:
+              return parseArrayComma() || parseRepairMissingComma() || parseRepairNdJsonEnd();
+            default:
+              return false;
+          }
+        }
+      case StackType.functionCall:
+        {
+          switch (stack.caret) {
+            case Caret.beforeValue:
+              return parseValue();
+            case Caret.afterValue:
+              return parseFunctionCallEnd();
+            default:
+              return false;
+          }
+        }
+      case StackType.root:
+        {
+          switch (stack.caret) {
+            case Caret.beforeValue:
+              return parseRootStart();
+            case Caret.afterValue:
+              return parseRootEnd();
+            default:
+              return false;
+          }
+        }
+      default:
+        return false;
+    }
+  }
+  function parseValue() {
+    return parseObjectStart() || parseArrayStart() || parseString() || parseNumber() || parseKeywords() || parseRepairUnquotedString() || parseRepairRegex();
+  }
+  function parseObjectStart() {
+    if (parseCharacter('{')) {
+      parseWhitespaceAndSkipComments();
+      skipEllipsis();
+      if (skipCharacter(',')) {
+        parseWhitespaceAndSkipComments();
+      }
+      if (parseCharacter('}')) {
+        return stack.update(Caret.afterValue);
+      }
+      return stack.push(StackType.object, Caret.beforeKey);
+    }
+    return false;
+  }
+  function parseArrayStart() {
+    if (parseCharacter('[')) {
+      parseWhitespaceAndSkipComments();
+      skipEllipsis();
+      if (skipCharacter(',')) {
+        parseWhitespaceAndSkipComments();
+      }
+      if (parseCharacter(']')) {
+        return stack.update(Caret.afterValue);
+      }
+      return stack.push(StackType.array, Caret.beforeValue);
+    }
+    return false;
+  }
+  function parseRepairUnquotedString() {
+    let j = i;
+    if (isFunctionNameCharStart(input.charAt(j))) {
+      while (!input.isEnd(j) && isFunctionNameChar(input.charAt(j))) {
+        j++;
+      }
+      let k = j;
+      while (isWhitespace(input, k)) {
+        k++;
+      }
+      if (input.charAt(k) === '(') {
+        // repair a MongoDB function call like NumberLong("2")
+        // repair a JSONP function call like callback({...});
+        k++;
+        i = k;
+        return stack.push(StackType.functionCall, Caret.beforeValue);
+      }
+    }
+    j = findNextDelimiter(false, j);
+    if (j !== null) {
+      // test start of an url like "https://..." (this would be parsed as a comment)
+      if (input.charAt(j - 1) === ':' && regexUrlStart.test(input.substring(i, j + 2))) {
+        while (!input.isEnd(j) && regexUrlChar.test(input.charAt(j))) {
+          j++;
+        }
+      }
+      const symbol = input.substring(i, j);
+      i = j;
+      output.push(symbol === 'undefined' ? 'null' : JSON.stringify(symbol));
+      if (input.charAt(i) === '"') {
+        // we had a missing start quote, but now we encountered the end quote, so we can skip that one
+        i++;
+      }
+      return stack.update(Caret.afterValue);
+    }
+    return false;
+  }
+  function parseRepairRegex() {
+    if (input.charAt(i) === '/') {
+      const start = i;
+      i++;
+      while (!input.isEnd(i) && (input.charAt(i) !== '/' || input.charAt(i - 1) === '\\')) {
+        i++;
+      }
+      i++;
+      output.push(`"${input.substring(start, i)}"`);
+      return stack.update(Caret.afterValue);
+    }
+  }
+  function parseRepairMissingObjectValue() {
+    // repair missing object value
+    output.push('null');
+    return stack.update(Caret.afterValue);
+  }
+  function parseRepairTrailingComma() {
+    // repair trailing comma
+    if (output.endsWithIgnoringWhitespace(',')) {
+      output.stripLastOccurrence(',');
+      return stack.update(Caret.afterValue);
+    }
+    return false;
+  }
+  function parseUnexpectedColon() {
+    if (input.charAt(i) === ':') {
+      throwObjectKeyExpected();
+    }
+    return false;
+  }
+  function parseUnexpectedEnd() {
+    if (input.isEnd(i)) {
+      throwUnexpectedEnd();
+    } else {
+      throwUnexpectedCharacter();
+    }
+    return false;
+  }
+  function parseObjectKey() {
+    const parsedKey = parseString() || parseUnquotedKey();
+    if (parsedKey) {
+      parseWhitespaceAndSkipComments();
+      if (parseCharacter(':')) {
+        // expect a value after the :
+        return stack.update(Caret.beforeValue);
+      }
+      const truncatedText = input.isEnd(i);
+      if (isStartOfValue(input.charAt(i)) || truncatedText) {
+        // repair missing colon
+        output.insertBeforeLastWhitespace(':');
+        return stack.update(Caret.beforeValue);
+      }
+      throwColonExpected();
+    }
+    return false;
+  }
+  function parseObjectComma() {
+    if (parseCharacter(',')) {
+      return stack.update(Caret.beforeKey);
+    }
+    return false;
+  }
+  function parseObjectEnd() {
+    if (parseCharacter('}')) {
+      return stack.pop();
+    }
+    return false;
+  }
+  function parseRepairObjectEndOrComma() {
+    // repair missing object end and trailing comma
+    if (input.charAt(i) === '{') {
+      output.stripLastOccurrence(',');
+      output.insertBeforeLastWhitespace('}');
+      return stack.pop();
+    }
+
+    // repair missing comma
+    if (!input.isEnd(i) && isStartOfValue(input.charAt(i))) {
+      output.insertBeforeLastWhitespace(',');
+      return stack.update(Caret.beforeKey);
+    }
+
+    // repair missing closing brace
+    output.insertBeforeLastWhitespace('}');
+    return stack.pop();
+  }
+  function parseArrayComma() {
+    if (parseCharacter(',')) {
+      return stack.update(Caret.beforeValue);
+    }
+    return false;
+  }
+  function parseArrayEnd() {
+    if (parseCharacter(']')) {
+      return stack.pop();
+    }
+    return false;
+  }
+  function parseRepairMissingComma() {
+    // repair missing comma
+    if (!input.isEnd(i) && isStartOfValue(input.charAt(i))) {
+      output.insertBeforeLastWhitespace(',');
+      return stack.update(Caret.beforeValue);
+    }
+    return false;
+  }
+  function parseRepairArrayEnd() {
+    // repair missing closing bracket
+    output.insertBeforeLastWhitespace(']');
+    return stack.pop();
+  }
+  function parseRepairNdJsonEnd() {
+    if (input.isEnd(i)) {
+      output.push('\n]');
+      return stack.pop();
+    }
+    throwUnexpectedEnd();
+    return false; // just to make TS happy
+  }
+  function parseFunctionCallEnd() {
+    if (skipCharacter(')')) {
+      skipCharacter(';');
+    }
+    return stack.pop();
+  }
+  function parseRootStart() {
+    parseMarkdownCodeBlock(['```', '[```', '{```']);
+    return parseValue() || parseUnexpectedEnd();
+  }
+  function parseRootEnd() {
+    parseMarkdownCodeBlock(['```', '```]', '```}']);
+    const parsedComma = parseCharacter(',');
+    parseWhitespaceAndSkipComments();
+    if (isStartOfValue(input.charAt(i)) && (output.endsWithIgnoringWhitespace(',') || output.endsWithIgnoringWhitespace('\n'))) {
+      // start of a new value after end of the root level object: looks like
+      // newline delimited JSON -> turn into a root level array
+      if (!parsedComma) {
+        // repair missing comma
+        output.insertBeforeLastWhitespace(',');
+      }
+      output.unshift('[\n');
+      return stack.push(StackType.ndJson, Caret.beforeValue);
+    }
+    if (parsedComma) {
+      // repair: remove trailing comma
+      output.stripLastOccurrence(',');
+      return stack.update(Caret.afterValue);
+    }
+
+    // repair redundant end braces and brackets
+    while (input.charAt(i) === '}' || input.charAt(i) === ']') {
+      i++;
+      parseWhitespaceAndSkipComments();
+    }
+    if (!input.isEnd(i)) {
+      throwUnexpectedCharacter();
+    }
+    return false;
+  }
+  function parseWhitespaceAndSkipComments() {
+    let skipNewline = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+    const start = i;
+    let changed = parseWhitespace(skipNewline);
+    do {
+      changed = parseComment();
+      if (changed) {
+        changed = parseWhitespace(skipNewline);
+      }
+    } while (changed);
+    return i > start;
+  }
+  function parseWhitespace(skipNewline) {
+    const _isWhiteSpace = skipNewline ? isWhitespace : isWhitespaceExceptNewline;
+    let whitespace = '';
+    while (true) {
+      if (_isWhiteSpace(input, i)) {
+        whitespace += input.charAt(i);
+        i++;
+      } else if (isSpecialWhitespace(input, i)) {
+        // repair special whitespace
+        whitespace += ' ';
+        i++;
+      } else {
+        break;
+      }
+    }
+    if (whitespace.length > 0) {
+      output.push(whitespace);
+      return true;
+    }
+    return false;
+  }
+  function parseComment() {
+    // find a block comment '/* ... */'
+    if (input.charAt(i) === '/' && input.charAt(i + 1) === '*') {
+      // repair block comment by skipping it
+      while (!input.isEnd(i) && !atEndOfBlockComment(i)) {
+        i++;
+      }
+      i += 2;
+      return true;
+    }
+
+    // find a line comment '// ...'
+    if (input.charAt(i) === '/' && input.charAt(i + 1) === '/') {
+      // repair line comment by skipping it
+      while (!input.isEnd(i) && input.charAt(i) !== '\n') {
+        i++;
+      }
+      return true;
+    }
+    return false;
+  }
+  function parseMarkdownCodeBlock(blocks) {
+    // find and skip over a Markdown fenced code block:
+    //     ``` ... ```
+    // or
+    //     ```json ... ```
+    if (skipMarkdownCodeBlock(blocks)) {
+      if (isFunctionNameCharStart(input.charAt(i))) {
+        // strip the optional language specifier like "json"
+        while (!input.isEnd(i) && isFunctionNameChar(input.charAt(i))) {
+          i++;
+        }
+      }
+      parseWhitespaceAndSkipComments();
+      return true;
+    }
+    return false;
+  }
+  function skipMarkdownCodeBlock(blocks) {
+    for (const block of blocks) {
+      const end = i + block.length;
+      if (input.substring(i, end) === block) {
+        i = end;
+        return true;
+      }
+    }
+    return false;
+  }
+  function parseCharacter(char) {
+    if (input.charAt(i) === char) {
+      output.push(input.charAt(i));
+      i++;
+      return true;
+    }
+    return false;
+  }
+  function skipCharacter(char) {
+    if (input.charAt(i) === char) {
+      i++;
+      return true;
+    }
+    return false;
+  }
+  function skipEscapeCharacter() {
+    return skipCharacter('\\');
+  }
+
+  /**
+   * Skip ellipsis like "[1,2,3,...]" or "[1,2,3,...,9]" or "[...,7,8,9]"
+   * or a similar construct in objects.
+   */
+  function skipEllipsis() {
+    parseWhitespaceAndSkipComments();
+    if (input.charAt(i) === '.' && input.charAt(i + 1) === '.' && input.charAt(i + 2) === '.') {
+      // repair: remove the ellipsis (three dots) and optionally a comma
+      i += 3;
+      parseWhitespaceAndSkipComments();
+      skipCharacter(',');
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Parse a string enclosed by double quotes "...". Can contain escaped quotes
+   * Repair strings enclosed in single quotes or special quotes
+   * Repair an escaped string
+   *
+   * The function can run in two stages:
+   * - First, it assumes the string has a valid end quote
+   * - If it turns out that the string does not have a valid end quote followed
+   *   by a delimiter (which should be the case), the function runs again in a
+   *   more conservative way, stopping the string at the first next delimiter
+   *   and fixing the string by inserting a quote there, or stopping at a
+   *   stop index detected in the first iteration.
+   */
+  function parseString() {
+    let stopAtDelimiter = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    let stopAtIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : -1;
+    let skipEscapeChars = input.charAt(i) === '\\';
+    if (skipEscapeChars) {
+      // repair: remove the first escape character
+      i++;
+      skipEscapeChars = true;
+    }
+    if (isQuote(input.charAt(i))) {
+      // double quotes are correct JSON,
+      // single quotes come from JavaScript for example, we assume it will have a correct single end quote too
+      // otherwise, we will match any double-quote-like start with a double-quote-like end,
+      // or any single-quote-like start with a single-quote-like end
+      const isEndQuote = isDoubleQuote(input.charAt(i)) ? isDoubleQuote : isSingleQuote(input.charAt(i)) ? isSingleQuote : isSingleQuoteLike(input.charAt(i)) ? isSingleQuoteLike : isDoubleQuoteLike;
+      const iBefore = i;
+      const oBefore = output.length();
+      output.push('"');
+      i++;
+      while (true) {
+        if (input.isEnd(i)) {
+          // end of text, we have a missing quote somewhere
+
+          const iPrev = prevNonWhitespaceIndex(i - 1);
+          if (!stopAtDelimiter && isDelimiter(input.charAt(iPrev))) {
+            // if the text ends with a delimiter, like ["hello],
+            // so the missing end quote should be inserted before this delimiter
+            // retry parsing the string, stopping at the first next delimiter
+            i = iBefore;
+            output.remove(oBefore);
+            return parseString(true);
+          }
+
+          // repair missing quote
+          output.insertBeforeLastWhitespace('"');
+          return stack.update(Caret.afterValue);
+        }
+        if (i === stopAtIndex) {
+          // use the stop index detected in the first iteration, and repair end quote
+          output.insertBeforeLastWhitespace('"');
+          return stack.update(Caret.afterValue);
+        }
+        if (isEndQuote(input.charAt(i))) {
+          // end quote
+          // let us check what is before and after the quote to verify whether this is a legit end quote
+          const iQuote = i;
+          const oQuote = output.length();
+          output.push('"');
+          i++;
+          parseWhitespaceAndSkipComments(false);
+          if (stopAtDelimiter || input.isEnd(i) || isDelimiter(input.charAt(i)) || isQuote(input.charAt(i)) || isDigit(input.charAt(i))) {
+            // The quote is followed by the end of the text, a delimiter, or a next value
+            // so the quote is indeed the end of the string
+            parseConcatenatedString();
+            return stack.update(Caret.afterValue);
+          }
+          const iPrevChar = prevNonWhitespaceIndex(iQuote - 1);
+          const prevChar = input.charAt(iPrevChar);
+          if (prevChar === ',') {
+            // A comma followed by a quote, like '{"a":"b,c,"d":"e"}'.
+            // We assume that the quote is a start quote, and that the end quote
+            // should have been located right before the comma but is missing.
+            i = iBefore;
+            output.remove(oBefore);
+            return parseString(false, iPrevChar);
+          }
+          if (isDelimiter(prevChar)) {
+            // This is not the right end quote: it is preceded by a delimiter,
+            // and NOT followed by a delimiter. So, there is an end quote missing
+            // parse the string again and then stop at the first next delimiter
+            i = iBefore;
+            output.remove(oBefore);
+            return parseString(true);
+          }
+
+          // revert to right after the quote but before any whitespace, and continue parsing the string
+          output.remove(oQuote + 1);
+          i = iQuote + 1;
+
+          // repair unescaped quote
+          output.insertAt(oQuote, '\\');
+        } else if (stopAtDelimiter && isUnquotedStringDelimiter(input.charAt(i))) {
+          // we're in the mode to stop the string at the first delimiter
+          // because there is an end quote missing
+
+          // test start of an url like "https://..." (this would be parsed as a comment)
+          if (input.charAt(i - 1) === ':' && regexUrlStart.test(input.substring(iBefore + 1, i + 2))) {
+            while (!input.isEnd(i) && regexUrlChar.test(input.charAt(i))) {
+              output.push(input.charAt(i));
+              i++;
+            }
+          }
+
+          // repair missing quote
+          output.insertBeforeLastWhitespace('"');
+          parseConcatenatedString();
+          return stack.update(Caret.afterValue);
+        } else if (input.charAt(i) === '\\') {
+          // handle escaped content like \n or \u2605
+          const char = input.charAt(i + 1);
+          const escapeChar = escapeCharacters[char];
+          if (escapeChar !== undefined) {
+            output.push(input.substring(i, i + 2));
+            i += 2;
+          } else if (char === 'u') {
+            let j = 2;
+            while (j < 6 && isHex(input.charAt(i + j))) {
+              j++;
+            }
+            if (j === 6) {
+              output.push(input.substring(i, i + 6));
+              i += 6;
+            } else if (input.isEnd(i + j)) {
+              // repair invalid or truncated unicode char at the end of the text
+              // by removing the unicode char and ending the string here
+              i += j;
+            } else {
+              throwInvalidUnicodeCharacter();
+            }
+          } else {
+            // repair invalid escape character: remove it
+            output.push(char);
+            i += 2;
+          }
+        } else {
+          // handle regular characters
+          const char = input.charAt(i);
+          if (char === '"' && input.charAt(i - 1) !== '\\') {
+            // repair unescaped double quote
+            output.push(`\\${char}`);
+            i++;
+          } else if (isControlCharacter(char)) {
+            // unescaped control character
+            output.push(controlCharacters[char]);
+            i++;
+          } else {
+            if (!isValidStringCharacter(char)) {
+              throwInvalidCharacter(char);
+            }
+            output.push(char);
+            i++;
+          }
+        }
+        if (skipEscapeChars) {
+          // repair: skipped escape character (nothing to do)
+          skipEscapeCharacter();
+        }
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Repair concatenated strings like "hello" + "world", change this into "helloworld"
+   */
+  function parseConcatenatedString() {
+    let parsed = false;
+    parseWhitespaceAndSkipComments();
+    while (input.charAt(i) === '+') {
+      parsed = true;
+      i++;
+      parseWhitespaceAndSkipComments();
+
+      // repair: remove the end quote of the first string
+      output.stripLastOccurrence('"', true);
+      const start = output.length();
+      const parsedStr = parseString();
+      if (parsedStr) {
+        // repair: remove the start quote of the second string
+        output.remove(start, start + 1);
+      } else {
+        // repair: remove the + because it is not followed by a string
+        output.insertBeforeLastWhitespace('"');
+      }
+    }
+    return parsed;
+  }
+
+  /**
+   * Parse a number like 2.4 or 2.4e6
+   */
+  function parseNumber() {
+    const start = i;
+    if (input.charAt(i) === '-') {
+      i++;
+      if (atEndOfNumber()) {
+        repairNumberEndingWithNumericSymbol(start);
+        return stack.update(Caret.afterValue);
+      }
+      if (!isDigit(input.charAt(i))) {
+        i = start;
+        return false;
+      }
+    }
+
+    // Note that in JSON leading zeros like "00789" are not allowed.
+    // We will allow all leading zeros here though and at the end of parseNumber
+    // check against trailing zeros and repair that if needed.
+    // Leading zeros can have meaning, so we should not clear them.
+    while (isDigit(input.charAt(i))) {
+      i++;
+    }
+    if (input.charAt(i) === '.') {
+      i++;
+      if (atEndOfNumber()) {
+        repairNumberEndingWithNumericSymbol(start);
+        return stack.update(Caret.afterValue);
+      }
+      if (!isDigit(input.charAt(i))) {
+        i = start;
+        return false;
+      }
+      while (isDigit(input.charAt(i))) {
+        i++;
+      }
+    }
+    if (input.charAt(i) === 'e' || input.charAt(i) === 'E') {
+      i++;
+      if (input.charAt(i) === '-' || input.charAt(i) === '+') {
+        i++;
+      }
+      if (atEndOfNumber()) {
+        repairNumberEndingWithNumericSymbol(start);
+        return stack.update(Caret.afterValue);
+      }
+      if (!isDigit(input.charAt(i))) {
+        i = start;
+        return false;
+      }
+      while (isDigit(input.charAt(i))) {
+        i++;
+      }
+    }
+
+    // if we're not at the end of the number by this point, allow this to be parsed as another type
+    if (!atEndOfNumber()) {
+      i = start;
+      return false;
+    }
+    if (i > start) {
+      // repair a number with leading zeros like "00789"
+      const num = input.substring(start, i);
+      const hasInvalidLeadingZero = /^0\d/.test(num);
+      output.push(hasInvalidLeadingZero ? `"${num}"` : num);
+      return stack.update(Caret.afterValue);
+    }
+    return false;
+  }
+
+  /**
+   * Parse keywords true, false, null
+   * Repair Python keywords True, False, None
+   */
+  function parseKeywords() {
+    return parseKeyword('true', 'true') || parseKeyword('false', 'false') || parseKeyword('null', 'null') ||
+    // repair Python keywords True, False, None
+    parseKeyword('True', 'true') || parseKeyword('False', 'false') || parseKeyword('None', 'null');
+  }
+  function parseKeyword(name, value) {
+    if (input.substring(i, i + name.length) === name) {
+      output.push(value);
+      i += name.length;
+      return stack.update(Caret.afterValue);
+    }
+    return false;
+  }
+  function parseUnquotedKey() {
+    let end = findNextDelimiter(true, i);
+    if (end !== null) {
+      // first, go back to prevent getting trailing whitespaces in the string
+      while (isWhitespace(input, end - 1) && end > i) {
+        end--;
+      }
+      const symbol = input.substring(i, end);
+      output.push(JSON.stringify(symbol));
+      i = end;
+      if (input.charAt(i) === '"') {
+        // we had a missing start quote, but now we encountered the end quote, so we can skip that one
+        i++;
+      }
+      return stack.update(Caret.afterValue); // we do not have a state Caret.afterKey, therefore we use afterValue here
+    }
+    return false;
+  }
+  function findNextDelimiter(isKey, start) {
+    // note that the symbol can end with whitespaces: we stop at the next delimiter
+    // also, note that we allow strings to contain a slash / in order to support repairing regular expressions
+    let j = start;
+    while (!input.isEnd(j) && !isUnquotedStringDelimiter(input.charAt(j)) && !isQuote(input.charAt(j)) && (!isKey || input.charAt(j) !== ':')) {
+      j++;
+    }
+    return j > i ? j : null;
+  }
+  function prevNonWhitespaceIndex(start) {
+    let prev = start;
+    while (prev > 0 && isWhitespace(input, prev)) {
+      prev--;
+    }
+    return prev;
+  }
+  function atEndOfNumber() {
+    return input.isEnd(i) || isDelimiter(input.charAt(i)) || isWhitespace(input, i);
+  }
+  function repairNumberEndingWithNumericSymbol(start) {
+    // repair numbers cut off at the end
+    // this will only be called when we end after a '.', '-', or 'e' and does not
+    // change the number more than it needs to make it valid JSON
+    output.push(`${input.substring(start, i)}0`);
+  }
+  function throwInvalidCharacter(char) {
+    throw new JSONRepairError(`Invalid character ${JSON.stringify(char)}`, i);
+  }
+  function throwUnexpectedCharacter() {
+    throw new JSONRepairError(`Unexpected character ${JSON.stringify(input.charAt(i))}`, i);
+  }
+  function throwUnexpectedEnd() {
+    throw new JSONRepairError('Unexpected end of json string', i);
+  }
+  function throwObjectKeyExpected() {
+    throw new JSONRepairError('Object key expected', i);
+  }
+  function throwColonExpected() {
+    throw new JSONRepairError('Colon expected', i);
+  }
+  function throwInvalidUnicodeCharacter() {
+    const chars = input.substring(i, i + 6);
+    throw new JSONRepairError(`Invalid unicode character "${chars}"`, i);
+  }
+  function atEndOfBlockComment(i) {
+    return input.charAt(i) === '*' && input.charAt(i + 1) === '/';
+  }
+  return {
+    transform,
+    flush
+  };
+}
+//# sourceMappingURL=core.js.map

node_modules/jsonrepair/lib/esm/streaming/stack.js

@@ -0,0 +1,44 @@
+export let Caret = /*#__PURE__*/function (Caret) {
+  Caret["beforeValue"] = "beforeValue";
+  Caret["afterValue"] = "afterValue";
+  Caret["beforeKey"] = "beforeKey";
+  return Caret;
+}({});
+export let StackType = /*#__PURE__*/function (StackType) {
+  StackType["root"] = "root";
+  StackType["object"] = "object";
+  StackType["array"] = "array";
+  StackType["ndJson"] = "ndJson";
+  StackType["functionCall"] = "dataType";
+  return StackType;
+}({});
+export function createStack() {
+  const stack = [StackType.root];
+  let caret = Caret.beforeValue;
+  return {
+    get type() {
+      return last(stack);
+    },
+    get caret() {
+      return caret;
+    },
+    pop() {
+      stack.pop();
+      caret = Caret.afterValue;
+      return true;
+    },
+    push(type, newCaret) {
+      stack.push(type);
+      caret = newCaret;
+      return true;
+    },
+    update(newCaret) {
+      caret = newCaret;
+      return true;
+    }
+  };
+}
+function last(array) {
+  return array[array.length - 1];
+}
+//# sourceMappingURL=stack.js.map

node_modules/jsonrepair/lib/esm/streaming/stack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stack.js","names":["Caret","StackType","createStack","stack","root","caret","beforeValue","type","last","pop","afterValue","push","newCaret","update","array","length"],"sources":["../../../src/streaming/stack.ts"],"sourcesContent":["export enum Caret {\n  beforeValue = 'beforeValue',\n  afterValue = 'afterValue',\n  beforeKey = 'beforeKey'\n}\n\nexport enum StackType {\n  root = 'root',\n  object = 'object',\n  array = 'array',\n  ndJson = 'ndJson',\n  functionCall = 'dataType'\n}\n\nexport function createStack() {\n  const stack: StackType[] = [StackType.root]\n  let caret = Caret.beforeValue\n\n  return {\n    get type() {\n      return last(stack)\n    },\n\n    get caret() {\n      return caret\n    },\n\n    pop(): true {\n      stack.pop()\n      caret = Caret.afterValue\n\n      return true\n    },\n\n    push(type: StackType, newCaret: Caret): true {\n      stack.push(type)\n      caret = newCaret\n\n      return true\n    },\n\n    update(newCaret: Caret): true {\n      caret = newCaret\n\n      return true\n    }\n  }\n}\n\nfunction last<T>(array: T[]): T | undefined {\n  return array[array.length - 1]\n}\n"],"mappings":"AAAA,WAAYA,KAAK,0BAALA,KAAK;EAALA,KAAK;EAALA,KAAK;EAALA,KAAK;EAAA,OAALA,KAAK;AAAA;AAMjB,WAAYC,SAAS,0BAATA,SAAS;EAATA,SAAS;EAATA,SAAS;EAATA,SAAS;EAATA,SAAS;EAATA,SAAS;EAAA,OAATA,SAAS;AAAA;AAQrB,OAAO,SAASC,WAAWA,CAAA,EAAG;EAC5B,MAAMC,KAAkB,GAAG,CAACF,SAAS,CAACG,IAAI,CAAC;EAC3C,IAAIC,KAAK,GAAGL,KAAK,CAACM,WAAW;EAE7B,OAAO;IACL,IAAIC,IAAIA,CAAA,EAAG;MACT,OAAOC,IAAI,CAACL,KAAK,CAAC;IACpB,CAAC;IAED,IAAIE,KAAKA,CAAA,EAAG;MACV,OAAOA,KAAK;IACd,CAAC;IAEDI,GAAGA,CAAA,EAAS;MACVN,KAAK,CAACM,GAAG,CAAC,CAAC;MACXJ,KAAK,GAAGL,KAAK,CAACU,UAAU;MAExB,OAAO,IAAI;IACb,CAAC;IAEDC,IAAIA,CAACJ,IAAe,EAAEK,QAAe,EAAQ;MAC3CT,KAAK,CAACQ,IAAI,CAACJ,IAAI,CAAC;MAChBF,KAAK,GAAGO,QAAQ;MAEhB,OAAO,IAAI;IACb,CAAC;IAEDC,MAAMA,CAACD,QAAe,EAAQ;MAC5BP,KAAK,GAAGO,QAAQ;MAEhB,OAAO,IAAI;IACb;EACF,CAAC;AACH;AAEA,SAASJ,IAAIA,CAAIM,KAAU,EAAiB;EAC1C,OAAOA,KAAK,CAACA,KAAK,CAACC,MAAM,GAAG,CAAC,CAAC;AAChC","ignoreList":[]}

node_modules/jsonrepair/lib/esm/streaming/stream.js

@@ -0,0 +1,31 @@
+import { Transform } from 'node:stream';
+import { jsonrepairCore } from './core.js';
+export function jsonrepairTransform(options) {
+  const repair = jsonrepairCore({
+    onData: chunk => transform.push(chunk),
+    bufferSize: options?.bufferSize,
+    chunkSize: options?.chunkSize
+  });
+  const transform = new Transform({
+    transform(chunk, _encoding, callback) {
+      try {
+        repair.transform(chunk.toString());
+      } catch (err) {
+        this.emit('error', err);
+      } finally {
+        callback();
+      }
+    },
+    flush(callback) {
+      try {
+        repair.flush();
+      } catch (err) {
+        this.emit('error', err);
+      } finally {
+        callback();
+      }
+    }
+  });
+  return transform;
+}
+//# sourceMappingURL=stream.js.map

node_modules/jsonrepair/lib/esm/streaming/stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.js","names":["Transform","jsonrepairCore","jsonrepairTransform","options","repair","onData","chunk","transform","push","bufferSize","chunkSize","_encoding","callback","toString","err","emit","flush"],"sources":["../../../src/streaming/stream.ts"],"sourcesContent":["import { Transform } from 'node:stream'\nimport { jsonrepairCore } from './core.js'\n\nexport interface JsonRepairTransformOptions {\n  chunkSize?: number\n  bufferSize?: number\n}\n\nexport function jsonrepairTransform(options?: JsonRepairTransformOptions): Transform {\n  const repair = jsonrepairCore({\n    onData: (chunk) => transform.push(chunk),\n    bufferSize: options?.bufferSize,\n    chunkSize: options?.chunkSize\n  })\n\n  const transform = new Transform({\n    transform(chunk, _encoding, callback) {\n      try {\n        repair.transform(chunk.toString())\n      } catch (err) {\n        this.emit('error', err)\n      } finally {\n        callback()\n      }\n    },\n\n    flush(callback) {\n      try {\n        repair.flush()\n      } catch (err) {\n        this.emit('error', err)\n      } finally {\n        callback()\n      }\n    }\n  })\n\n  return transform\n}\n"],"mappings":"AAAA,SAASA,SAAS,QAAQ,aAAa;AACvC,SAASC,cAAc,QAAQ,WAAW;AAO1C,OAAO,SAASC,mBAAmBA,CAACC,OAAoC,EAAa;EACnF,MAAMC,MAAM,GAAGH,cAAc,CAAC;IAC5BI,MAAM,EAAGC,KAAK,IAAKC,SAAS,CAACC,IAAI,CAACF,KAAK,CAAC;IACxCG,UAAU,EAAEN,OAAO,EAAEM,UAAU;IAC/BC,SAAS,EAAEP,OAAO,EAAEO;EACtB,CAAC,CAAC;EAEF,MAAMH,SAAS,GAAG,IAAIP,SAAS,CAAC;IAC9BO,SAASA,CAACD,KAAK,EAAEK,SAAS,EAAEC,QAAQ,EAAE;MACpC,IAAI;QACFR,MAAM,CAACG,SAAS,CAACD,KAAK,CAACO,QAAQ,CAAC,CAAC,CAAC;MACpC,CAAC,CAAC,OAAOC,GAAG,EAAE;QACZ,IAAI,CAACC,IAAI,CAAC,OAAO,EAAED,GAAG,CAAC;MACzB,CAAC,SAAS;QACRF,QAAQ,CAAC,CAAC;MACZ;IACF,CAAC;IAEDI,KAAKA,CAACJ,QAAQ,EAAE;MACd,IAAI;QACFR,MAAM,CAACY,KAAK,CAAC,CAAC;MAChB,CAAC,CAAC,OAAOF,GAAG,EAAE;QACZ,IAAI,CAACC,IAAI,CAAC,OAAO,EAAED,GAAG,CAAC;MACzB,CAAC,SAAS;QACRF,QAAQ,CAAC,CAAC;MACZ;IACF;EACF,CAAC,CAAC;EAEF,OAAOL,SAAS;AAClB","ignoreList":[]}

node_modules/jsonrepair/lib/esm/utils/JSONRepairError.js

@@ -0,0 +1,7 @@
+export class JSONRepairError extends Error {
+  constructor(message, position) {
+    super(`${message} at position ${position}`);
+    this.position = position;
+  }
+}
+//# sourceMappingURL=JSONRepairError.js.map

node_modules/jsonrepair/lib/esm/utils/JSONRepairError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JSONRepairError.js","names":["JSONRepairError","Error","constructor","message","position"],"sources":["../../../src/utils/JSONRepairError.ts"],"sourcesContent":["export class JSONRepairError extends Error {\n  position: number\n\n  constructor(message: string, position: number) {\n    super(`${message} at position ${position}`)\n\n    this.position = position\n  }\n}\n"],"mappings":"AAAA,OAAO,MAAMA,eAAe,SAASC,KAAK,CAAC;EAGzCC,WAAWA,CAACC,OAAe,EAAEC,QAAgB,EAAE;IAC7C,KAAK,CAAC,GAAGD,OAAO,gBAAgBC,QAAQ,EAAE,CAAC;IAE3C,IAAI,CAACA,QAAQ,GAAGA,QAAQ;EAC1B;AACF","ignoreList":[]}

node_modules/jsonrepair/lib/esm/utils/stringUtils.js

@@ -0,0 +1,147 @@
+const codeSpace = 0x20; // " "
+const codeNewline = 0xa; // "\n"
+const codeTab = 0x9; // "\t"
+const codeReturn = 0xd; // "\r"
+const codeNonBreakingSpace = 0xa0;
+const codeEnQuad = 0x2000;
+const codeHairSpace = 0x200a;
+const codeNarrowNoBreakSpace = 0x202f;
+const codeMediumMathematicalSpace = 0x205f;
+const codeIdeographicSpace = 0x3000;
+export function isHex(char) {
+  return /^[0-9A-Fa-f]$/.test(char);
+}
+export function isDigit(char) {
+  return char >= '0' && char <= '9';
+}
+export function isValidStringCharacter(char) {
+  // note that the valid range is between \u{0020} and \u{10ffff},
+  // but in JavaScript it is not possible to create a code point larger than
+  // \u{10ffff}, so there is no need to test for that here.
+  return char >= '\u0020';
+}
+export function isDelimiter(char) {
+  return ',:[]/{}()\n+'.includes(char);
+}
+export function isFunctionNameCharStart(char) {
+  return char >= 'a' && char <= 'z' || char >= 'A' && char <= 'Z' || char === '_' || char === '$';
+}
+export function isFunctionNameChar(char) {
+  return char >= 'a' && char <= 'z' || char >= 'A' && char <= 'Z' || char === '_' || char === '$' || char >= '0' && char <= '9';
+}
+
+// matches "https://" and other schemas
+export const regexUrlStart = /^(http|https|ftp|mailto|file|data|irc):\/\/$/;
+
+// matches all valid URL characters EXCEPT "[", "]", and ",", since that are important JSON delimiters
+export const regexUrlChar = /^[A-Za-z0-9-._~:/?#@!$&'()*+;=]$/;
+export function isUnquotedStringDelimiter(char) {
+  return ',[]/{}\n+'.includes(char);
+}
+export function isStartOfValue(char) {
+  return isQuote(char) || regexStartOfValue.test(char);
+}
+
+// alpha, number, minus, or opening bracket or brace
+const regexStartOfValue = /^[[{\w-]$/;
+export function isControlCharacter(char) {
+  return char === '\n' || char === '\r' || char === '\t' || char === '\b' || char === '\f';
+}
+/**
+ * Check if the given character is a whitespace character like space, tab, or
+ * newline
+ */
+export function isWhitespace(text, index) {
+  const code = text.charCodeAt(index);
+  return code === codeSpace || code === codeNewline || code === codeTab || code === codeReturn;
+}
+
+/**
+ * Check if the given character is a whitespace character like space or tab,
+ * but NOT a newline
+ */
+export function isWhitespaceExceptNewline(text, index) {
+  const code = text.charCodeAt(index);
+  return code === codeSpace || code === codeTab || code === codeReturn;
+}
+
+/**
+ * Check if the given character is a special whitespace character, some
+ * unicode variant
+ */
+export function isSpecialWhitespace(text, index) {
+  const code = text.charCodeAt(index);
+  return code === codeNonBreakingSpace || code >= codeEnQuad && code <= codeHairSpace || code === codeNarrowNoBreakSpace || code === codeMediumMathematicalSpace || code === codeIdeographicSpace;
+}
+
+/**
+ * Test whether the given character is a quote or double quote character.
+ * Also tests for special variants of quotes.
+ */
+export function isQuote(char) {
+  // the first check double quotes, since that occurs most often
+  return isDoubleQuoteLike(char) || isSingleQuoteLike(char);
+}
+
+/**
+ * Test whether the given character is a double quote character.
+ * Also tests for special variants of double quotes.
+ */
+export function isDoubleQuoteLike(char) {
+  return char === '"' || char === '\u201c' || char === '\u201d';
+}
+
+/**
+ * Test whether the given character is a double quote character.
+ * Does NOT test for special variants of double quotes.
+ */
+export function isDoubleQuote(char) {
+  return char === '"';
+}
+
+/**
+ * Test whether the given character is a single quote character.
+ * Also tests for special variants of single quotes.
+ */
+export function isSingleQuoteLike(char) {
+  return char === "'" || char === '\u2018' || char === '\u2019' || char === '\u0060' || char === '\u00b4';
+}
+
+/**
+ * Test whether the given character is a single quote character.
+ * Does NOT test for special variants of single quotes.
+ */
+export function isSingleQuote(char) {
+  return char === "'";
+}
+
+/**
+ * Strip last occurrence of textToStrip from text
+ */
+export function stripLastOccurrence(text, textToStrip) {
+  let stripRemainingText = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  const index = text.lastIndexOf(textToStrip);
+  return index !== -1 ? text.substring(0, index) + (stripRemainingText ? '' : text.substring(index + 1)) : text;
+}
+export function insertBeforeLastWhitespace(text, textToInsert) {
+  let index = text.length;
+  if (!isWhitespace(text, index - 1)) {
+    // no trailing whitespaces
+    return text + textToInsert;
+  }
+  while (isWhitespace(text, index - 1)) {
+    index--;
+  }
+  return text.substring(0, index) + textToInsert + text.substring(index);
+}
+export function removeAtIndex(text, start, count) {
+  return text.substring(0, start) + text.substring(start + count);
+}
+
+/**
+ * Test whether a string ends with a newline or comma character and optional whitespace
+ */
+export function endsWithCommaOrNewline(text) {
+  return /[,\n][ \t\r]*$/.test(text);
+}
+//# sourceMappingURL=stringUtils.js.map

node_modules/jsonrepair/lib/types/index.d.ts

@@ -0,0 +1,3 @@
+export { jsonrepair } from './regular/jsonrepair.js';
+export { JSONRepairError } from './utils/JSONRepairError.js';
+//# sourceMappingURL=index.d.ts.map

node_modules/jsonrepair/lib/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAA"}

node_modules/jsonrepair/lib/types/regular/jsonrepair.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Repair a string containing an invalid JSON document.
+ * For example changes JavaScript notation into JSON notation.
+ *
+ * Example:
+ *
+ *     try {
+ *       const json = "{name: 'John'}"
+ *       const repaired = jsonrepair(json)
+ *       console.log(repaired)
+ *       // '{"name": "John"}'
+ *     } catch (err) {
+ *       console.error(err)
+ *     }
+ *
+ */
+export declare function jsonrepair(text: string): string;
+//# sourceMappingURL=jsonrepair.d.ts.map

node_modules/jsonrepair/lib/types/regular/jsonrepair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonrepair.d.ts","sourceRoot":"","sources":["../../../src/regular/jsonrepair.ts"],"names":[],"mappings":"AAgDA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAq0B/C"}

node_modules/jsonrepair/lib/types/stream.d.ts

@@ -0,0 +1,2 @@
+export { type JsonRepairTransformOptions, jsonrepairTransform } from './streaming/stream.js';
+//# sourceMappingURL=stream.d.ts.map

node_modules/jsonrepair/lib/types/stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../src/stream.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,0BAA0B,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA"}

node_modules/jsonrepair/lib/types/streaming/buffer/InputBuffer.d.ts

@@ -0,0 +1,14 @@
+export interface InputBuffer {
+    push: (chunk: string) => void;
+    flush: (position: number) => void;
+    charAt: (index: number) => string;
+    charCodeAt: (index: number) => number;
+    substring: (start: number, end: number) => string;
+    length: () => number;
+    currentLength: () => number;
+    currentBufferSize: () => number;
+    isEnd: (index: number) => boolean;
+    close: () => void;
+}
+export declare function createInputBuffer(): InputBuffer;
+//# sourceMappingURL=InputBuffer.d.ts.map

node_modules/jsonrepair/lib/types/streaming/buffer/InputBuffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InputBuffer.d.ts","sourceRoot":"","sources":["../../../../src/streaming/buffer/InputBuffer.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAC7B,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;IACjC,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAA;IACjC,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAA;IACrC,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,MAAM,CAAA;IACjD,MAAM,EAAE,MAAM,MAAM,CAAA;IACpB,aAAa,EAAE,MAAM,MAAM,CAAA;IAC3B,iBAAiB,EAAE,MAAM,MAAM,CAAA;IAC/B,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAA;IACjC,KAAK,EAAE,MAAM,IAAI,CAAA;CAClB;AAED,wBAAgB,iBAAiB,IAAI,WAAW,CAmF/C"}

node_modules/jsonrepair/lib/types/streaming/buffer/OutputBuffer.d.ts

@@ -0,0 +1,18 @@
+export interface OutputBuffer {
+    push: (text: string) => void;
+    unshift: (text: string) => void;
+    remove: (start: number, end?: number) => void;
+    insertAt: (index: number, text: string) => void;
+    length: () => number;
+    flush: () => void;
+    stripLastOccurrence: (textToStrip: string, stripRemainingText?: boolean) => void;
+    insertBeforeLastWhitespace: (textToInsert: string) => void;
+    endsWithIgnoringWhitespace: (char: string) => boolean;
+}
+export interface OutputBufferOptions {
+    write: (chunk: string) => void;
+    chunkSize: number;
+    bufferSize: number;
+}
+export declare function createOutputBuffer({ write, chunkSize, bufferSize }: OutputBufferOptions): OutputBuffer;
+//# sourceMappingURL=OutputBuffer.d.ts.map

node_modules/jsonrepair/lib/types/streaming/buffer/OutputBuffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OutputBuffer.d.ts","sourceRoot":"","sources":["../../../../src/streaming/buffer/OutputBuffer.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IAC5B,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IAC/B,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;IAC7C,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IAC/C,MAAM,EAAE,MAAM,MAAM,CAAA;IACpB,KAAK,EAAE,MAAM,IAAI,CAAA;IAEjB,mBAAmB,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,kBAAkB,CAAC,EAAE,OAAO,KAAK,IAAI,CAAA;IAChF,0BAA0B,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,IAAI,CAAA;IAC1D,0BAA0B,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAA;CACtD;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAC9B,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,wBAAgB,kBAAkB,CAAC,EACjC,KAAK,EACL,SAAS,EACT,UAAU,EACX,EAAE,mBAAmB,GAAG,YAAY,CA6HpC"}

node_modules/jsonrepair/lib/types/streaming/core.d.ts

@@ -0,0 +1,11 @@
+export interface JsonRepairCoreOptions {
+    onData: (chunk: string) => void;
+    chunkSize?: number;
+    bufferSize?: number;
+}
+export interface JsonRepairCore {
+    transform: (chunk: string) => void;
+    flush: () => void;
+}
+export declare function jsonrepairCore({ onData, bufferSize, chunkSize }: JsonRepairCoreOptions): JsonRepairCore;
+//# sourceMappingURL=core.d.ts.map

node_modules/jsonrepair/lib/types/streaming/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../src/streaming/core.ts"],"names":[],"mappings":"AA+CA,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAClC,KAAK,EAAE,MAAM,IAAI,CAAA;CAClB;AAED,wBAAgB,cAAc,CAAC,EAC7B,MAAM,EACN,UAAkB,EAClB,SAAiB,EAClB,EAAE,qBAAqB,GAAG,cAAc,CA49BxC"}

node_modules/jsonrepair/lib/types/streaming/stack.d.ts

@@ -0,0 +1,20 @@
+export declare enum Caret {
+    beforeValue = "beforeValue",
+    afterValue = "afterValue",
+    beforeKey = "beforeKey"
+}
+export declare enum StackType {
+    root = "root",
+    object = "object",
+    array = "array",
+    ndJson = "ndJson",
+    functionCall = "dataType"
+}
+export declare function createStack(): {
+    readonly type: StackType;
+    readonly caret: Caret;
+    pop(): true;
+    push(type: StackType, newCaret: Caret): true;
+    update(newCaret: Caret): true;
+};
+//# sourceMappingURL=stack.d.ts.map

node_modules/jsonrepair/lib/types/streaming/stack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stack.d.ts","sourceRoot":"","sources":["../../../src/streaming/stack.ts"],"names":[],"mappings":"AAAA,oBAAY,KAAK;IACf,WAAW,gBAAgB;IAC3B,UAAU,eAAe;IACzB,SAAS,cAAc;CACxB;AAED,oBAAY,SAAS;IACnB,IAAI,SAAS;IACb,MAAM,WAAW;IACjB,KAAK,UAAU;IACf,MAAM,WAAW;IACjB,YAAY,aAAa;CAC1B;AAED,wBAAgB,WAAW;;;WAahB,IAAI;eAOA,SAAS,YAAY,KAAK,GAAG,IAAI;qBAO3B,KAAK,GAAG,IAAI;EAMhC"}

node_modules/jsonrepair/lib/types/streaming/stream.d.ts

@@ -0,0 +1,7 @@
+import { Transform } from 'node:stream';
+export interface JsonRepairTransformOptions {
+    chunkSize?: number;
+    bufferSize?: number;
+}
+export declare function jsonrepairTransform(options?: JsonRepairTransformOptions): Transform;
+//# sourceMappingURL=stream.d.ts.map

node_modules/jsonrepair/lib/types/streaming/stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../../src/streaming/stream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAGvC,MAAM,WAAW,0BAA0B;IACzC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,wBAAgB,mBAAmB,CAAC,OAAO,CAAC,EAAE,0BAA0B,GAAG,SAAS,CA8BnF"}

node_modules/jsonrepair/lib/types/utils/JSONRepairError.d.ts

@@ -0,0 +1,5 @@
+export declare class JSONRepairError extends Error {
+    position: number;
+    constructor(message: string, position: number);
+}
+//# sourceMappingURL=JSONRepairError.d.ts.map

node_modules/jsonrepair/lib/types/utils/JSONRepairError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JSONRepairError.d.ts","sourceRoot":"","sources":["../../../src/utils/JSONRepairError.ts"],"names":[],"mappings":"AAAA,qBAAa,eAAgB,SAAQ,KAAK;IACxC,QAAQ,EAAE,MAAM,CAAA;gBAEJ,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;CAK9C"}

node_modules/jsonrepair/lib/types/utils/stringUtils.d.ts

@@ -0,0 +1,65 @@
+export declare function isHex(char: string): boolean;
+export declare function isDigit(char: string): boolean;
+export declare function isValidStringCharacter(char: string): boolean;
+export declare function isDelimiter(char: string): boolean;
+export declare function isFunctionNameCharStart(char: string): boolean;
+export declare function isFunctionNameChar(char: string): boolean;
+export declare const regexUrlStart: RegExp;
+export declare const regexUrlChar: RegExp;
+export declare function isUnquotedStringDelimiter(char: string): boolean;
+export declare function isStartOfValue(char: string): boolean;
+export declare function isControlCharacter(char: string): char is "\n" | "\r" | "\t" | "\b" | "\f";
+export interface Text {
+    charCodeAt: (index: number) => number;
+}
+/**
+ * Check if the given character is a whitespace character like space, tab, or
+ * newline
+ */
+export declare function isWhitespace(text: Text, index: number): boolean;
+/**
+ * Check if the given character is a whitespace character like space or tab,
+ * but NOT a newline
+ */
+export declare function isWhitespaceExceptNewline(text: Text, index: number): boolean;
+/**
+ * Check if the given character is a special whitespace character, some
+ * unicode variant
+ */
+export declare function isSpecialWhitespace(text: Text, index: number): boolean;
+/**
+ * Test whether the given character is a quote or double quote character.
+ * Also tests for special variants of quotes.
+ */
+export declare function isQuote(char: string): boolean;
+/**
+ * Test whether the given character is a double quote character.
+ * Also tests for special variants of double quotes.
+ */
+export declare function isDoubleQuoteLike(char: string): boolean;
+/**
+ * Test whether the given character is a double quote character.
+ * Does NOT test for special variants of double quotes.
+ */
+export declare function isDoubleQuote(char: string): boolean;
+/**
+ * Test whether the given character is a single quote character.
+ * Also tests for special variants of single quotes.
+ */
+export declare function isSingleQuoteLike(char: string): boolean;
+/**
+ * Test whether the given character is a single quote character.
+ * Does NOT test for special variants of single quotes.
+ */
+export declare function isSingleQuote(char: string): boolean;
+/**
+ * Strip last occurrence of textToStrip from text
+ */
+export declare function stripLastOccurrence(text: string, textToStrip: string, stripRemainingText?: boolean): string;
+export declare function insertBeforeLastWhitespace(text: string, textToInsert: string): string;
+export declare function removeAtIndex(text: string, start: number, count: number): string;
+/**
+ * Test whether a string ends with a newline or comma character and optional whitespace
+ */
+export declare function endsWithCommaOrNewline(text: string): boolean;
+//# sourceMappingURL=stringUtils.d.ts.map

node_modules/jsonrepair/lib/types/utils/stringUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/stringUtils.ts"],"names":[],"mappings":"AAWA,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE3C;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE7C;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAK5D;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEjD;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,WAInD;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,WAQ9C;AAGD,eAAO,MAAM,aAAa,QAAiD,CAAA;AAG3E,eAAO,MAAM,YAAY,QAAqC,CAAA;AAE9D,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE/D;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpD;AAKD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,4CAE9C;AAED,MAAM,WAAW,IAAI;IACnB,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAA;CACtC;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAI/D;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAI5E;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAUtE;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAG7C;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAIvD;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,kBAAkB,UAAQ,GACzB,MAAM,CAKR;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAarF;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,UAEvE;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE5D"}

node_modules/jsonrepair/lib/umd/jsonrepair.js

@@ -0,0 +1,903 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.JSONRepair = {}));
+})(this, (function (exports) { 'use strict';
+
+  class JSONRepairError extends Error {
+    constructor(message, position) {
+      super(`${message} at position ${position}`);
+      this.position = position;
+    }
+  }
+
+  const codeSpace = 0x20; // " "
+  const codeNewline = 0xa; // "\n"
+  const codeTab = 0x9; // "\t"
+  const codeReturn = 0xd; // "\r"
+  const codeNonBreakingSpace = 0xa0;
+  const codeEnQuad = 0x2000;
+  const codeHairSpace = 0x200a;
+  const codeNarrowNoBreakSpace = 0x202f;
+  const codeMediumMathematicalSpace = 0x205f;
+  const codeIdeographicSpace = 0x3000;
+  function isHex(char) {
+    return /^[0-9A-Fa-f]$/.test(char);
+  }
+  function isDigit(char) {
+    return char >= '0' && char <= '9';
+  }
+  function isValidStringCharacter(char) {
+    // note that the valid range is between \u{0020} and \u{10ffff},
+    // but in JavaScript it is not possible to create a code point larger than
+    // \u{10ffff}, so there is no need to test for that here.
+    return char >= '\u0020';
+  }
+  function isDelimiter(char) {
+    return ',:[]/{}()\n+'.includes(char);
+  }
+  function isFunctionNameCharStart(char) {
+    return char >= 'a' && char <= 'z' || char >= 'A' && char <= 'Z' || char === '_' || char === '$';
+  }
+  function isFunctionNameChar(char) {
+    return char >= 'a' && char <= 'z' || char >= 'A' && char <= 'Z' || char === '_' || char === '$' || char >= '0' && char <= '9';
+  }
+
+  // matches "https://" and other schemas
+  const regexUrlStart = /^(http|https|ftp|mailto|file|data|irc):\/\/$/;
+
+  // matches all valid URL characters EXCEPT "[", "]", and ",", since that are important JSON delimiters
+  const regexUrlChar = /^[A-Za-z0-9-._~:/?#@!$&'()*+;=]$/;
+  function isUnquotedStringDelimiter(char) {
+    return ',[]/{}\n+'.includes(char);
+  }
+  function isStartOfValue(char) {
+    return isQuote(char) || regexStartOfValue.test(char);
+  }
+
+  // alpha, number, minus, or opening bracket or brace
+  const regexStartOfValue = /^[[{\w-]$/;
+  function isControlCharacter(char) {
+    return char === '\n' || char === '\r' || char === '\t' || char === '\b' || char === '\f';
+  }
+  /**
+   * Check if the given character is a whitespace character like space, tab, or
+   * newline
+   */
+  function isWhitespace(text, index) {
+    const code = text.charCodeAt(index);
+    return code === codeSpace || code === codeNewline || code === codeTab || code === codeReturn;
+  }
+
+  /**
+   * Check if the given character is a whitespace character like space or tab,
+   * but NOT a newline
+   */
+  function isWhitespaceExceptNewline(text, index) {
+    const code = text.charCodeAt(index);
+    return code === codeSpace || code === codeTab || code === codeReturn;
+  }
+
+  /**
+   * Check if the given character is a special whitespace character, some
+   * unicode variant
+   */
+  function isSpecialWhitespace(text, index) {
+    const code = text.charCodeAt(index);
+    return code === codeNonBreakingSpace || code >= codeEnQuad && code <= codeHairSpace || code === codeNarrowNoBreakSpace || code === codeMediumMathematicalSpace || code === codeIdeographicSpace;
+  }
+
+  /**
+   * Test whether the given character is a quote or double quote character.
+   * Also tests for special variants of quotes.
+   */
+  function isQuote(char) {
+    // the first check double quotes, since that occurs most often
+    return isDoubleQuoteLike(char) || isSingleQuoteLike(char);
+  }
+
+  /**
+   * Test whether the given character is a double quote character.
+   * Also tests for special variants of double quotes.
+   */
+  function isDoubleQuoteLike(char) {
+    return char === '"' || char === '\u201c' || char === '\u201d';
+  }
+
+  /**
+   * Test whether the given character is a double quote character.
+   * Does NOT test for special variants of double quotes.
+   */
+  function isDoubleQuote(char) {
+    return char === '"';
+  }
+
+  /**
+   * Test whether the given character is a single quote character.
+   * Also tests for special variants of single quotes.
+   */
+  function isSingleQuoteLike(char) {
+    return char === "'" || char === '\u2018' || char === '\u2019' || char === '\u0060' || char === '\u00b4';
+  }
+
+  /**
+   * Test whether the given character is a single quote character.
+   * Does NOT test for special variants of single quotes.
+   */
+  function isSingleQuote(char) {
+    return char === "'";
+  }
+
+  /**
+   * Strip last occurrence of textToStrip from text
+   */
+  function stripLastOccurrence(text, textToStrip) {
+    let stripRemainingText = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    const index = text.lastIndexOf(textToStrip);
+    return index !== -1 ? text.substring(0, index) + (stripRemainingText ? '' : text.substring(index + 1)) : text;
+  }
+  function insertBeforeLastWhitespace(text, textToInsert) {
+    let index = text.length;
+    if (!isWhitespace(text, index - 1)) {
+      // no trailing whitespaces
+      return text + textToInsert;
+    }
+    while (isWhitespace(text, index - 1)) {
+      index--;
+    }
+    return text.substring(0, index) + textToInsert + text.substring(index);
+  }
+  function removeAtIndex(text, start, count) {
+    return text.substring(0, start) + text.substring(start + count);
+  }
+
+  /**
+   * Test whether a string ends with a newline or comma character and optional whitespace
+   */
+  function endsWithCommaOrNewline(text) {
+    return /[,\n][ \t\r]*$/.test(text);
+  }
+
+  const controlCharacters = {
+    '\b': '\\b',
+    '\f': '\\f',
+    '\n': '\\n',
+    '\r': '\\r',
+    '\t': '\\t'
+  };
+
+  // map with all escape characters
+  const escapeCharacters = {
+    '"': '"',
+    '\\': '\\',
+    '/': '/',
+    b: '\b',
+    f: '\f',
+    n: '\n',
+    r: '\r',
+    t: '\t'
+    // note that \u is handled separately in parseString()
+  };
+
+  /**
+   * Repair a string containing an invalid JSON document.
+   * For example changes JavaScript notation into JSON notation.
+   *
+   * Example:
+   *
+   *     try {
+   *       const json = "{name: 'John'}"
+   *       const repaired = jsonrepair(json)
+   *       console.log(repaired)
+   *       // '{"name": "John"}'
+   *     } catch (err) {
+   *       console.error(err)
+   *     }
+   *
+   */
+  function jsonrepair(text) {
+    let i = 0; // current index in text
+    let output = ''; // generated output
+
+    parseMarkdownCodeBlock(['```', '[```', '{```']);
+    const processed = parseValue();
+    if (!processed) {
+      throwUnexpectedEnd();
+    }
+    parseMarkdownCodeBlock(['```', '```]', '```}']);
+    const processedComma = parseCharacter(',');
+    if (processedComma) {
+      parseWhitespaceAndSkipComments();
+    }
+    if (isStartOfValue(text[i]) && endsWithCommaOrNewline(output)) {
+      // start of a new value after end of the root level object: looks like
+      // newline delimited JSON -> turn into a root level array
+      if (!processedComma) {
+        // repair missing comma
+        output = insertBeforeLastWhitespace(output, ',');
+      }
+      parseNewlineDelimitedJSON();
+    } else if (processedComma) {
+      // repair: remove trailing comma
+      output = stripLastOccurrence(output, ',');
+    }
+
+    // repair redundant end quotes
+    while (text[i] === '}' || text[i] === ']') {
+      i++;
+      parseWhitespaceAndSkipComments();
+    }
+    if (i >= text.length) {
+      // reached the end of the document properly
+      return output;
+    }
+    throwUnexpectedCharacter();
+    function parseValue() {
+      parseWhitespaceAndSkipComments();
+      const processed = parseObject() || parseArray() || parseString() || parseNumber() || parseKeywords() || parseUnquotedString(false) || parseRegex();
+      parseWhitespaceAndSkipComments();
+      return processed;
+    }
+    function parseWhitespaceAndSkipComments() {
+      let skipNewline = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      const start = i;
+      let changed = parseWhitespace(skipNewline);
+      do {
+        changed = parseComment();
+        if (changed) {
+          changed = parseWhitespace(skipNewline);
+        }
+      } while (changed);
+      return i > start;
+    }
+    function parseWhitespace(skipNewline) {
+      const _isWhiteSpace = skipNewline ? isWhitespace : isWhitespaceExceptNewline;
+      let whitespace = '';
+      while (true) {
+        if (_isWhiteSpace(text, i)) {
+          whitespace += text[i];
+          i++;
+        } else if (isSpecialWhitespace(text, i)) {
+          // repair special whitespace
+          whitespace += ' ';
+          i++;
+        } else {
+          break;
+        }
+      }
+      if (whitespace.length > 0) {
+        output += whitespace;
+        return true;
+      }
+      return false;
+    }
+    function parseComment() {
+      // find a block comment '/* ... */'
+      if (text[i] === '/' && text[i + 1] === '*') {
+        // repair block comment by skipping it
+        while (i < text.length && !atEndOfBlockComment(text, i)) {
+          i++;
+        }
+        i += 2;
+        return true;
+      }
+
+      // find a line comment '// ...'
+      if (text[i] === '/' && text[i + 1] === '/') {
+        // repair line comment by skipping it
+        while (i < text.length && text[i] !== '\n') {
+          i++;
+        }
+        return true;
+      }
+      return false;
+    }
+    function parseMarkdownCodeBlock(blocks) {
+      // find and skip over a Markdown fenced code block:
+      //     ``` ... ```
+      // or
+      //     ```json ... ```
+      if (skipMarkdownCodeBlock(blocks)) {
+        if (isFunctionNameCharStart(text[i])) {
+          // strip the optional language specifier like "json"
+          while (i < text.length && isFunctionNameChar(text[i])) {
+            i++;
+          }
+        }
+        parseWhitespaceAndSkipComments();
+        return true;
+      }
+      return false;
+    }
+    function skipMarkdownCodeBlock(blocks) {
+      parseWhitespace(true);
+      for (const block of blocks) {
+        const end = i + block.length;
+        if (text.slice(i, end) === block) {
+          i = end;
+          return true;
+        }
+      }
+      return false;
+    }
+    function parseCharacter(char) {
+      if (text[i] === char) {
+        output += text[i];
+        i++;
+        return true;
+      }
+      return false;
+    }
+    function skipCharacter(char) {
+      if (text[i] === char) {
+        i++;
+        return true;
+      }
+      return false;
+    }
+    function skipEscapeCharacter() {
+      return skipCharacter('\\');
+    }
+
+    /**
+     * Skip ellipsis like "[1,2,3,...]" or "[1,2,3,...,9]" or "[...,7,8,9]"
+     * or a similar construct in objects.
+     */
+    function skipEllipsis() {
+      parseWhitespaceAndSkipComments();
+      if (text[i] === '.' && text[i + 1] === '.' && text[i + 2] === '.') {
+        // repair: remove the ellipsis (three dots) and optionally a comma
+        i += 3;
+        parseWhitespaceAndSkipComments();
+        skipCharacter(',');
+        return true;
+      }
+      return false;
+    }
+
+    /**
+     * Parse an object like '{"key": "value"}'
+     */
+    function parseObject() {
+      if (text[i] === '{') {
+        output += '{';
+        i++;
+        parseWhitespaceAndSkipComments();
+
+        // repair: skip leading comma like in {, message: "hi"}
+        if (skipCharacter(',')) {
+          parseWhitespaceAndSkipComments();
+        }
+        let initial = true;
+        while (i < text.length && text[i] !== '}') {
+          let processedComma;
+          if (!initial) {
+            processedComma = parseCharacter(',');
+            if (!processedComma) {
+              // repair missing comma
+              output = insertBeforeLastWhitespace(output, ',');
+            }
+            parseWhitespaceAndSkipComments();
+          } else {
+            processedComma = true;
+            initial = false;
+          }
+          skipEllipsis();
+          const processedKey = parseString() || parseUnquotedString(true);
+          if (!processedKey) {
+            if (text[i] === '}' || text[i] === '{' || text[i] === ']' || text[i] === '[' || text[i] === undefined) {
+              // repair trailing comma
+              output = stripLastOccurrence(output, ',');
+            } else {
+              throwObjectKeyExpected();
+            }
+            break;
+          }
+          parseWhitespaceAndSkipComments();
+          const processedColon = parseCharacter(':');
+          const truncatedText = i >= text.length;
+          if (!processedColon) {
+            if (isStartOfValue(text[i]) || truncatedText) {
+              // repair missing colon
+              output = insertBeforeLastWhitespace(output, ':');
+            } else {
+              throwColonExpected();
+            }
+          }
+          const processedValue = parseValue();
+          if (!processedValue) {
+            if (processedColon || truncatedText) {
+              // repair missing object value
+              output += 'null';
+            } else {
+              throwColonExpected();
+            }
+          }
+        }
+        if (text[i] === '}') {
+          output += '}';
+          i++;
+        } else {
+          // repair missing end bracket
+          output = insertBeforeLastWhitespace(output, '}');
+        }
+        return true;
+      }
+      return false;
+    }
+
+    /**
+     * Parse an array like '["item1", "item2", ...]'
+     */
+    function parseArray() {
+      if (text[i] === '[') {
+        output += '[';
+        i++;
+        parseWhitespaceAndSkipComments();
+
+        // repair: skip leading comma like in [,1,2,3]
+        if (skipCharacter(',')) {
+          parseWhitespaceAndSkipComments();
+        }
+        let initial = true;
+        while (i < text.length && text[i] !== ']') {
+          if (!initial) {
+            const processedComma = parseCharacter(',');
+            if (!processedComma) {
+              // repair missing comma
+              output = insertBeforeLastWhitespace(output, ',');
+            }
+          } else {
+            initial = false;
+          }
+          skipEllipsis();
+          const processedValue = parseValue();
+          if (!processedValue) {
+            // repair trailing comma
+            output = stripLastOccurrence(output, ',');
+            break;
+          }
+        }
+        if (text[i] === ']') {
+          output += ']';
+          i++;
+        } else {
+          // repair missing closing array bracket
+          output = insertBeforeLastWhitespace(output, ']');
+        }
+        return true;
+      }
+      return false;
+    }
+
+    /**
+     * Parse and repair Newline Delimited JSON (NDJSON):
+     * multiple JSON objects separated by a newline character
+     */
+    function parseNewlineDelimitedJSON() {
+      // repair NDJSON
+      let initial = true;
+      let processedValue = true;
+      while (processedValue) {
+        if (!initial) {
+          // parse optional comma, insert when missing
+          const processedComma = parseCharacter(',');
+          if (!processedComma) {
+            // repair: add missing comma
+            output = insertBeforeLastWhitespace(output, ',');
+          }
+        } else {
+          initial = false;
+        }
+        processedValue = parseValue();
+      }
+      if (!processedValue) {
+        // repair: remove trailing comma
+        output = stripLastOccurrence(output, ',');
+      }
+
+      // repair: wrap the output inside array brackets
+      output = `[\n${output}\n]`;
+    }
+
+    /**
+     * Parse a string enclosed by double quotes "...". Can contain escaped quotes
+     * Repair strings enclosed in single quotes or special quotes
+     * Repair an escaped string
+     *
+     * The function can run in two stages:
+     * - First, it assumes the string has a valid end quote
+     * - If it turns out that the string does not have a valid end quote followed
+     *   by a delimiter (which should be the case), the function runs again in a
+     *   more conservative way, stopping the string at the first next delimiter
+     *   and fixing the string by inserting a quote there, or stopping at a
+     *   stop index detected in the first iteration.
+     */
+    function parseString() {
+      let stopAtDelimiter = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      let stopAtIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : -1;
+      let skipEscapeChars = text[i] === '\\';
+      if (skipEscapeChars) {
+        // repair: remove the first escape character
+        i++;
+        skipEscapeChars = true;
+      }
+      if (isQuote(text[i])) {
+        // double quotes are correct JSON,
+        // single quotes come from JavaScript for example, we assume it will have a correct single end quote too
+        // otherwise, we will match any double-quote-like start with a double-quote-like end,
+        // or any single-quote-like start with a single-quote-like end
+        const isEndQuote = isDoubleQuote(text[i]) ? isDoubleQuote : isSingleQuote(text[i]) ? isSingleQuote : isSingleQuoteLike(text[i]) ? isSingleQuoteLike : isDoubleQuoteLike;
+        const iBefore = i;
+        const oBefore = output.length;
+        let str = '"';
+        i++;
+        while (true) {
+          if (i >= text.length) {
+            // end of text, we are missing an end quote
+
+            const iPrev = prevNonWhitespaceIndex(i - 1);
+            if (!stopAtDelimiter && isDelimiter(text.charAt(iPrev))) {
+              // if the text ends with a delimiter, like ["hello],
+              // so the missing end quote should be inserted before this delimiter
+              // retry parsing the string, stopping at the first next delimiter
+              i = iBefore;
+              output = output.substring(0, oBefore);
+              return parseString(true);
+            }
+
+            // repair missing quote
+            str = insertBeforeLastWhitespace(str, '"');
+            output += str;
+            return true;
+          }
+          if (i === stopAtIndex) {
+            // use the stop index detected in the first iteration, and repair end quote
+            str = insertBeforeLastWhitespace(str, '"');
+            output += str;
+            return true;
+          }
+          if (isEndQuote(text[i])) {
+            // end quote
+            // let us check what is before and after the quote to verify whether this is a legit end quote
+            const iQuote = i;
+            const oQuote = str.length;
+            str += '"';
+            i++;
+            output += str;
+            parseWhitespaceAndSkipComments(false);
+            if (stopAtDelimiter || i >= text.length || isDelimiter(text[i]) || isQuote(text[i]) || isDigit(text[i])) {
+              // The quote is followed by the end of the text, a delimiter,
+              // or a next value. So the quote is indeed the end of the string.
+              parseConcatenatedString();
+              return true;
+            }
+            const iPrevChar = prevNonWhitespaceIndex(iQuote - 1);
+            const prevChar = text.charAt(iPrevChar);
+            if (prevChar === ',') {
+              // A comma followed by a quote, like '{"a":"b,c,"d":"e"}'.
+              // We assume that the quote is a start quote, and that the end quote
+              // should have been located right before the comma but is missing.
+              i = iBefore;
+              output = output.substring(0, oBefore);
+              return parseString(false, iPrevChar);
+            }
+            if (isDelimiter(prevChar)) {
+              // This is not the right end quote: it is preceded by a delimiter,
+              // and NOT followed by a delimiter. So, there is an end quote missing
+              // parse the string again and then stop at the first next delimiter
+              i = iBefore;
+              output = output.substring(0, oBefore);
+              return parseString(true);
+            }
+
+            // revert to right after the quote but before any whitespace, and continue parsing the string
+            output = output.substring(0, oBefore);
+            i = iQuote + 1;
+
+            // repair unescaped quote
+            str = `${str.substring(0, oQuote)}\\${str.substring(oQuote)}`;
+          } else if (stopAtDelimiter && isUnquotedStringDelimiter(text[i])) {
+            // we're in the mode to stop the string at the first delimiter
+            // because there is an end quote missing
+
+            // test start of an url like "https://..." (this would be parsed as a comment)
+            if (text[i - 1] === ':' && regexUrlStart.test(text.substring(iBefore + 1, i + 2))) {
+              while (i < text.length && regexUrlChar.test(text[i])) {
+                str += text[i];
+                i++;
+              }
+            }
+
+            // repair missing quote
+            str = insertBeforeLastWhitespace(str, '"');
+            output += str;
+            parseConcatenatedString();
+            return true;
+          } else if (text[i] === '\\') {
+            // handle escaped content like \n or \u2605
+            const char = text.charAt(i + 1);
+            const escapeChar = escapeCharacters[char];
+            if (escapeChar !== undefined) {
+              str += text.slice(i, i + 2);
+              i += 2;
+            } else if (char === 'u') {
+              let j = 2;
+              while (j < 6 && isHex(text[i + j])) {
+                j++;
+              }
+              if (j === 6) {
+                str += text.slice(i, i + 6);
+                i += 6;
+              } else if (i + j >= text.length) {
+                // repair invalid or truncated unicode char at the end of the text
+                // by removing the unicode char and ending the string here
+                i = text.length;
+              } else {
+                throwInvalidUnicodeCharacter();
+              }
+            } else {
+              // repair invalid escape character: remove it
+              str += char;
+              i += 2;
+            }
+          } else {
+            // handle regular characters
+            const char = text.charAt(i);
+            if (char === '"' && text[i - 1] !== '\\') {
+              // repair unescaped double quote
+              str += `\\${char}`;
+              i++;
+            } else if (isControlCharacter(char)) {
+              // unescaped control character
+              str += controlCharacters[char];
+              i++;
+            } else {
+              if (!isValidStringCharacter(char)) {
+                throwInvalidCharacter(char);
+              }
+              str += char;
+              i++;
+            }
+          }
+          if (skipEscapeChars) {
+            // repair: skipped escape character (nothing to do)
+            skipEscapeCharacter();
+          }
+        }
+      }
+      return false;
+    }
+
+    /**
+     * Repair concatenated strings like "hello" + "world", change this into "helloworld"
+     */
+    function parseConcatenatedString() {
+      let processed = false;
+      parseWhitespaceAndSkipComments();
+      while (text[i] === '+') {
+        processed = true;
+        i++;
+        parseWhitespaceAndSkipComments();
+
+        // repair: remove the end quote of the first string
+        output = stripLastOccurrence(output, '"', true);
+        const start = output.length;
+        const parsedStr = parseString();
+        if (parsedStr) {
+          // repair: remove the start quote of the second string
+          output = removeAtIndex(output, start, 1);
+        } else {
+          // repair: remove the + because it is not followed by a string
+          output = insertBeforeLastWhitespace(output, '"');
+        }
+      }
+      return processed;
+    }
+
+    /**
+     * Parse a number like 2.4 or 2.4e6
+     */
+    function parseNumber() {
+      const start = i;
+      if (text[i] === '-') {
+        i++;
+        if (atEndOfNumber()) {
+          repairNumberEndingWithNumericSymbol(start);
+          return true;
+        }
+        if (!isDigit(text[i])) {
+          i = start;
+          return false;
+        }
+      }
+
+      // Note that in JSON leading zeros like "00789" are not allowed.
+      // We will allow all leading zeros here though and at the end of parseNumber
+      // check against trailing zeros and repair that if needed.
+      // Leading zeros can have meaning, so we should not clear them.
+      while (isDigit(text[i])) {
+        i++;
+      }
+      if (text[i] === '.') {
+        i++;
+        if (atEndOfNumber()) {
+          repairNumberEndingWithNumericSymbol(start);
+          return true;
+        }
+        if (!isDigit(text[i])) {
+          i = start;
+          return false;
+        }
+        while (isDigit(text[i])) {
+          i++;
+        }
+      }
+      if (text[i] === 'e' || text[i] === 'E') {
+        i++;
+        if (text[i] === '-' || text[i] === '+') {
+          i++;
+        }
+        if (atEndOfNumber()) {
+          repairNumberEndingWithNumericSymbol(start);
+          return true;
+        }
+        if (!isDigit(text[i])) {
+          i = start;
+          return false;
+        }
+        while (isDigit(text[i])) {
+          i++;
+        }
+      }
+
+      // if we're not at the end of the number by this point, allow this to be parsed as another type
+      if (!atEndOfNumber()) {
+        i = start;
+        return false;
+      }
+      if (i > start) {
+        // repair a number with leading zeros like "00789"
+        const num = text.slice(start, i);
+        const hasInvalidLeadingZero = /^0\d/.test(num);
+        output += hasInvalidLeadingZero ? `"${num}"` : num;
+        return true;
+      }
+      return false;
+    }
+
+    /**
+     * Parse keywords true, false, null
+     * Repair Python keywords True, False, None
+     */
+    function parseKeywords() {
+      return parseKeyword('true', 'true') || parseKeyword('false', 'false') || parseKeyword('null', 'null') ||
+      // repair Python keywords True, False, None
+      parseKeyword('True', 'true') || parseKeyword('False', 'false') || parseKeyword('None', 'null');
+    }
+    function parseKeyword(name, value) {
+      if (text.slice(i, i + name.length) === name) {
+        output += value;
+        i += name.length;
+        return true;
+      }
+      return false;
+    }
+
+    /**
+     * Repair an unquoted string by adding quotes around it
+     * Repair a MongoDB function call like NumberLong("2")
+     * Repair a JSONP function call like callback({...});
+     */
+    function parseUnquotedString(isKey) {
+      // note that the symbol can end with whitespaces: we stop at the next delimiter
+      // also, note that we allow strings to contain a slash / in order to support repairing regular expressions
+      const start = i;
+      if (isFunctionNameCharStart(text[i])) {
+        while (i < text.length && isFunctionNameChar(text[i])) {
+          i++;
+        }
+        let j = i;
+        while (isWhitespace(text, j)) {
+          j++;
+        }
+        if (text[j] === '(') {
+          // repair a MongoDB function call like NumberLong("2")
+          // repair a JSONP function call like callback({...});
+          i = j + 1;
+          parseValue();
+          if (text[i] === ')') {
+            // repair: skip close bracket of function call
+            i++;
+            if (text[i] === ';') {
+              // repair: skip semicolon after JSONP call
+              i++;
+            }
+          }
+          return true;
+        }
+      }
+      while (i < text.length && !isUnquotedStringDelimiter(text[i]) && !isQuote(text[i]) && (!isKey || text[i] !== ':')) {
+        i++;
+      }
+
+      // test start of an url like "https://..." (this would be parsed as a comment)
+      if (text[i - 1] === ':' && regexUrlStart.test(text.substring(start, i + 2))) {
+        while (i < text.length && regexUrlChar.test(text[i])) {
+          i++;
+        }
+      }
+      if (i > start) {
+        // repair unquoted string
+        // also, repair undefined into null
+
+        // first, go back to prevent getting trailing whitespaces in the string
+        while (isWhitespace(text, i - 1) && i > 0) {
+          i--;
+        }
+        const symbol = text.slice(start, i);
+        output += symbol === 'undefined' ? 'null' : JSON.stringify(symbol);
+        if (text[i] === '"') {
+          // we had a missing start quote, but now we encountered the end quote, so we can skip that one
+          i++;
+        }
+        return true;
+      }
+    }
+    function parseRegex() {
+      if (text[i] === '/') {
+        const start = i;
+        i++;
+        while (i < text.length && (text[i] !== '/' || text[i - 1] === '\\')) {
+          i++;
+        }
+        i++;
+        output += `"${text.substring(start, i)}"`;
+        return true;
+      }
+    }
+    function prevNonWhitespaceIndex(start) {
+      let prev = start;
+      while (prev > 0 && isWhitespace(text, prev)) {
+        prev--;
+      }
+      return prev;
+    }
+    function atEndOfNumber() {
+      return i >= text.length || isDelimiter(text[i]) || isWhitespace(text, i);
+    }
+    function repairNumberEndingWithNumericSymbol(start) {
+      // repair numbers cut off at the end
+      // this will only be called when we end after a '.', '-', or 'e' and does not
+      // change the number more than it needs to make it valid JSON
+      output += `${text.slice(start, i)}0`;
+    }
+    function throwInvalidCharacter(char) {
+      throw new JSONRepairError(`Invalid character ${JSON.stringify(char)}`, i);
+    }
+    function throwUnexpectedCharacter() {
+      throw new JSONRepairError(`Unexpected character ${JSON.stringify(text[i])}`, i);
+    }
+    function throwUnexpectedEnd() {
+      throw new JSONRepairError('Unexpected end of json string', text.length);
+    }
+    function throwObjectKeyExpected() {
+      throw new JSONRepairError('Object key expected', i);
+    }
+    function throwColonExpected() {
+      throw new JSONRepairError('Colon expected', i);
+    }
+    function throwInvalidUnicodeCharacter() {
+      const chars = text.slice(i, i + 6);
+      throw new JSONRepairError(`Invalid unicode character "${chars}"`, i);
+    }
+  }
+  function atEndOfBlockComment(text, i) {
+    return text[i] === '*' && text[i + 1] === '/';
+  }
+
+  exports.JSONRepairError = JSONRepairError;
+  exports.jsonrepair = jsonrepair;
+
+}));
+//# sourceMappingURL=jsonrepair.js.map

node_modules/jsonrepair/lib/umd/jsonrepair.min.js

@@ -0,0 +1,3 @@
+((t,n)=>{"object"==typeof exports&&"undefined"!=typeof module?n(exports):"function"==typeof define&&define.amd?define(["exports"],n):n((t="undefined"!=typeof globalThis?globalThis:t||self).JSONRepair={})})(this,function(t){class x extends Error{constructor(t,n){super(t+" at position "+n),this.position=n}}let r=32,e=10,i=9,f=13,a=160,h=8192,y=8202,O=8239,N=8287,J=12288;function S(t){return"0"<=t&&t<="9"}function j(t){return",:[]/{}()\n+".includes(t)}function k(t){return"a"<=t&&t<="z"||"A"<=t&&t<="Z"||"_"===t||"$"===t}function C(t){return"a"<=t&&t<="z"||"A"<=t&&t<="Z"||"_"===t||"$"===t||"0"<=t&&t<="9"}let m=/^(http|https|ftp|mailto|file|data|irc):\/\/$/,z=/^[A-Za-z0-9-._~:/?#@!$&'()*+;=]$/;function E(t){return",[]/{}\n+".includes(t)}function I(t){return _(t)||n.test(t)}let n=/^[[{\w-]$/;function T(t,n){t=t.charCodeAt(n);return t===r||t===e||t===i||t===f}function Z(t,n){t=t.charCodeAt(n);return t===r||t===i||t===f}function _(t){return F(t)||U(t)}function F(t){return'"'===t||"“"===t||"”"===t}function R(t){return'"'===t}function U(t){return"'"===t||"‘"===t||"’"===t||"`"===t||"´"===t}function q(t){return"'"===t}function B(t,n,r){r=2<arguments.length&&void 0!==r&&r,n=t.lastIndexOf(n);return-1!==n?t.substring(0,n)+(r?"":t.substring(n+1)):t}function D(t,n){let r=t.length;if(!T(t,r-1))return t+n;for(;T(t,r-1);)r--;return t.substring(0,r)+n+t.substring(r)}let G={"\b":"\\b","\f":"\\f","\n":"\\n","\r":"\\r","\t":"\\t"},H={'"':'"',"\\":"\\","/":"/",b:"\b",f:"\f",n:"\n",r:"\r",t:"\t"};t.JSONRepairError=x,t.jsonrepair=function(g){let d=0,v="";if(n(["```","[```","{```"]),!f())throw new x("Unexpected end of json string",g.length);n(["```","```]","```}"]);var t=u(",");if(t&&b(),I(g[d])&&/[,\n][ \t\r]*$/.test(v)){t||(v=D(v,","));{let t=!0,n=!0;for(;n;)t?t=!1:u(",")||(v=D(v,",")),n=f();v=`[
+${v=n?v:B(v,",")}
+]`}}else t&&(v=B(v,","));for(;"}"===g[d]||"]"===g[d];)d++,b();if(d>=g.length)return v;throw new x("Unexpected character "+JSON.stringify(g[d]),d);function f(){b();var t=(()=>{if("{"!==g[d])return!1;{v+="{",d++,b(),p(",")&&b();let n=!0;for(;d<g.length&&"}"!==g[d];){let t;if(n?(t=!0,n=!1):((t=u(","))||(v=D(v,",")),b()),o(),!(w()||l(!0))){"}"===g[d]||"{"===g[d]||"]"===g[d]||"["===g[d]||void 0===g[d]?v=B(v,","):(()=>{throw new x("Object key expected",d)})();break}b();var r=u(":"),e=d>=g.length,i=(r||(I(g[d])||e?v=D(v,":"):c()),f());i||(r||e?v+="null":c())}return"}"===g[d]?(v+="}",d++):v=D(v,"}"),!0}})()||(()=>{if("["!==g[d])return!1;{v+="[",d++,b(),p(",")&&b();let t=!0;for(;d<g.length&&"]"!==g[d];){t?t=!1:u(",")||(v=D(v,",")),o();var n=f();if(!n){v=B(v,",");break}}return"]"===g[d]?(v+="]",d++):v=D(v,"]"),!0}})()||w()||(()=>{var t,n,r=d;if("-"===g[d]){if(d++,i())return s(r),!0;if(!S(g[d]))return d=r,!1}for(;S(g[d]);)d++;if("."===g[d]){if(d++,i())return s(r),!0;if(!S(g[d]))return d=r,!1;for(;S(g[d]);)d++}if("e"===g[d]||"E"===g[d]){if(d++,"-"!==g[d]&&"+"!==g[d]||d++,i())return s(r),!0;if(!S(g[d]))return d=r,!1;for(;S(g[d]);)d++}if(i()){if(d>r)return t=g.slice(r,d),n=/^0\d/.test(t),v+=n?`"${t}"`:t,!0}else d=r;return!1})()||r("true","true")||r("false","false")||r("null","null")||r("True","true")||r("False","false")||r("None","null")||l(!1)||(()=>{if("/"===g[d]){var t=d;for(d++;d<g.length&&("/"!==g[d]||"\\"===g[d-1]);)d++;return d++,v+=`"${g.substring(t,d)}"`,!0}})();return b(),t}function b(t){var n=!(0<arguments.length&&void 0!==t)||t;d;let r=e(n);for(;r=(r=(()=>{if("/"===g[d]&&"*"===g[d+1]){for(;d<g.length&&!((t,n)=>"*"===t[n]&&"/"===t[n+1])(g,d);)d++;d+=2}else{if("/"!==g[d]||"/"!==g[d+1])return!1;for(;d<g.length&&"\n"!==g[d];)d++}return!0})())&&e(n););d}function e(t){var n,r,e=t?T:Z;let i="";for(;;){if(e(g,d))i+=g[d];else{if(n=g,r=d,!((n=n.charCodeAt(r))===a||n>=h&&n<=y||n===O||n===N||n===J))break;i+=" "}d++}return 0<i.length&&(v+=i,!0)}function n(t){if((t=>{e(!0);for(var n of t){var r=d+n.length;if(g.slice(d,r)===n)return d=r,1}})(t)){if(k(g[d]))for(;d<g.length&&C(g[d]);)d++;b()}}function u(t){return g[d]===t&&(v+=g[d],d++,!0)}function p(t){return g[d]===t&&(d++,!0)}function o(){b(),"."===g[d]&&"."===g[d+1]&&"."===g[d+2]&&(d+=3,b(),p(","))}function w(t,n){var r=0<arguments.length&&void 0!==t&&t,e=1<arguments.length&&void 0!==n?n:-1;let i="\\"===g[d];if(i&&(d++,i=!0),_(g[d])){var f=R(g[d])?R:q(g[d])?q:U(g[d])?U:F,u=d,o=v.length;let n='"';for(d++;;){if(d>=g.length)return l=A(d-1),!r&&j(g.charAt(l))?(d=u,v=v.substring(0,o),w(!0)):(n=D(n,'"'),v+=n,!0);if(d===e)return n=D(n,'"'),v+=n,!0;if(f(g[d])){var l=d,s=n.length;if(n+='"',d++,v+=n,b(!1),r||d>=g.length||j(g[d])||_(g[d])||S(g[d]))return $(),!0;var c=A(l-1),a=g.charAt(c);if(","===a)return d=u,v=v.substring(0,o),w(!1,c);if(j(a))return d=u,v=v.substring(0,o),w(!0);v=v.substring(0,o),d=l+1,n=n.substring(0,s)+"\\"+n.substring(s)}else{if(r&&E(g[d])){if(":"===g[d-1]&&m.test(g.substring(u+1,d+2)))for(;d<g.length&&z.test(g[d]);)n+=g[d],d++;return n=D(n,'"'),v+=n,$(),!0}if("\\"===g[d]){c=g.charAt(d+1);if(void 0!==H[c])n+=g.slice(d,d+2),d+=2;else if("u"===c){let t=2;for(;t<6&&/^[0-9A-Fa-f]$/.test(g[d+t]);)t++;if(6===t)n+=g.slice(d,d+6),d+=6;else{if(!(d+t>=g.length))throw a=void 0,a=g.slice(d,d+6),new x(`Invalid unicode character "${a}"`,d);d=g.length}}else n+=c,d+=2}else{var h,s=g.charAt(d);if('"'===s&&"\\"!==g[d-1])n+="\\"+s;else if("\n"===(h=s)||"\r"===h||"\t"===h||"\b"===h||"\f"===h)n+=G[s];else{if(!(" "<=s))throw h=void 0,h=s,new x("Invalid character "+JSON.stringify(h),d);n+=s}d++}}i&&p("\\")}}return!1}function $(){let t=!1;for(b();"+"===g[d];){t=!0,d++,b();var n=(v=B(v,'"',!0)).length,r=w();v=r?(r=v,n=n,e=1,r.substring(0,n)+r.substring(n+e)):D(v,'"')}var e;t}function r(t,n){return g.slice(d,d+t.length)===t&&(v+=n,d+=t.length,!0)}function l(t){var n=d;if(k(g[d])){for(;d<g.length&&C(g[d]);)d++;let t=d;for(;T(g,t);)t++;if("("===g[t])return d=t+1,f(),")"===g[d]&&(d++,";"===g[d])&&d++,!0}for(;d<g.length&&!E(g[d])&&!_(g[d])&&(!t||":"!==g[d]);)d++;if(":"===g[d-1]&&m.test(g.substring(n,d+2)))for(;d<g.length&&z.test(g[d]);)d++;if(d>n){for(;T(g,d-1)&&0<d;)d--;n=g.slice(n,d);return v+="undefined"===n?"null":JSON.stringify(n),'"'===g[d]&&d++,!0}}function A(t){let n=t;for(;0<n&&T(g,n);)n--;return n}function i(){return d>=g.length||j(g[d])||T(g,d)}function s(t){v+=g.slice(t,d)+"0"}function c(){throw new x("Colon expected",d)}}});

node_modules/jsonrepair/lib/umd/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}