jsonfixerdev 1.0.2 → 1.0.3

package/lib/cjs/streaming/core.js

@@ -0,0 +1,674 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.jsonfixerCore = jsonfixerCore;
+var _InputBuffer = require("./buffer/InputBuffer.js");
+var _OutputBuffer = require("./buffer/OutputBuffer.js");
+var _JSONFixerError = require("../utils/JSONFixerError.js");
+var _stack = require("./stack.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()
+};
+function jsonfixerCore(_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 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 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 parseValue() || parseUnexpectedEnd();
+            case _stack.Caret.afterValue:
+              return parseRootEnd();
+            default:
+              return false;
+          }
+        }
+      default:
+        return false;
+    }
+  }
+  function parseValue() {
+    return parseObjectStart() || parseArrayStart() || parseString() || parseNumber() || parseKeywords() || parseRepairUnquotedString();
+  }
+  function parseObjectStart() {
+    if (parseCharacter(_stringUtils.codeOpeningBrace)) {
+      parseWhitespaceAndSkipComments();
+      if (parseCharacter(_stringUtils.codeClosingBrace)) {
+        return stack.update(_stack.Caret.afterValue);
+      }
+      return stack.push(_stack.StackType.object, _stack.Caret.beforeKey);
+    }
+    return false;
+  }
+  function parseArrayStart() {
+    if (parseCharacter(_stringUtils.codeOpeningBracket)) {
+      parseWhitespaceAndSkipComments();
+      if (parseCharacter(_stringUtils.codeClosingBracket)) {
+        return stack.update(_stack.Caret.afterValue);
+      }
+      return stack.push(_stack.StackType.array, _stack.Caret.beforeValue);
+    }
+    return false;
+  }
+  function parseRepairUnquotedString() {
+    const unquotedStringEnd = findNextDelimiter();
+    if (unquotedStringEnd !== null) {
+      const symbol = input.substring(i, unquotedStringEnd);
+      i = unquotedStringEnd;
+      if (skipCharacter(_stringUtils.codeOpenParenthesis)) {
+        // A MongoDB function call like NumberLong("2")
+        // Or a JSONP function call like callback({...});
+        // we strip the function call
+
+        return stack.push(_stack.StackType.functionCall, _stack.Caret.beforeValue);
+      }
+      output.push(symbol === 'undefined' ? 'null' : JSON.stringify(symbol));
+      if (input.charCodeAt(i) === _stringUtils.codeDoubleQuote) {
+        // 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 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.charCodeAt(i) === _stringUtils.codeColon) {
+      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(_stringUtils.codeColon)) {
+        // 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(_stringUtils.codeComma)) {
+      return stack.update(_stack.Caret.beforeKey);
+    }
+    return false;
+  }
+  function parseObjectEnd() {
+    if (parseCharacter(_stringUtils.codeClosingBrace)) {
+      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(_stringUtils.codeComma)) {
+      return stack.update(_stack.Caret.beforeValue);
+    }
+    return false;
+  }
+  function parseArrayEnd() {
+    if (parseCharacter(_stringUtils.codeClosingBracket)) {
+      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();
+    } else {
+      throwUnexpectedEnd();
+      return false; // just to make TS happy
+    }
+  }
+  function parseFunctionCallEnd() {
+    if (skipCharacter(_stringUtils.codeCloseParenthesis)) {
+      skipCharacter(_stringUtils.codeSemicolon);
+    }
+    return stack.pop();
+  }
+  function parseRootEnd() {
+    const parsedComma = parseCharacter(_stringUtils.codeComma);
+    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.charCodeAt(i) === _stringUtils.codeClosingBrace || input.charCodeAt(i) === _stringUtils.codeClosingBracket) {
+      i++;
+      parseWhitespaceAndSkipComments();
+    }
+    if (!input.isEnd(i)) {
+      throwUnexpectedCharacter();
+    }
+    return false;
+  }
+  function parseWhitespaceAndSkipComments() {
+    const start = i;
+    let changed = parseWhitespace();
+    do {
+      changed = parseComment();
+      if (changed) {
+        changed = parseWhitespace();
+      }
+    } while (changed);
+    return i > start;
+  }
+  function parseWhitespace() {
+    let whitespace = '';
+    let normal;
+    while ((normal = (0, _stringUtils.isWhitespace)(input.charCodeAt(i))) || (0, _stringUtils.isSpecialWhitespace)(input.charCodeAt(i))) {
+      if (normal) {
+        whitespace += input.charAt(i);
+      } else {
+        // repair special whitespace
+        whitespace += ' ';
+      }
+      i++;
+    }
+    if (whitespace.length > 0) {
+      output.push(whitespace);
+      return true;
+    }
+    return false;
+  }
+  function parseComment() {
+    // find a block comment '/* ... */'
+    if (input.charCodeAt(i) === _stringUtils.codeSlash && input.charCodeAt(i + 1) === _stringUtils.codeAsterisk) {
+      // repair block comment by skipping it
+      while (!input.isEnd(i) && !atEndOfBlockComment(i)) {
+        i++;
+      }
+      i += 2;
+      return true;
+    }
+
+    // find a line comment '// ...'
+    if (input.charCodeAt(i) === _stringUtils.codeSlash && input.charCodeAt(i + 1) === _stringUtils.codeSlash) {
+      // repair line comment by skipping it
+      while (!input.isEnd(i) && input.charCodeAt(i) !== _stringUtils.codeNewline) {
+        i++;
+      }
+      return true;
+    }
+    return false;
+  }
+  function parseCharacter(code) {
+    if (input.charCodeAt(i) === code) {
+      output.push(input.charAt(i));
+      i++;
+      return true;
+    }
+    return false;
+  }
+  function skipCharacter(code) {
+    if (input.charCodeAt(i) === code) {
+      i++;
+      return true;
+    }
+    return false;
+  }
+  function skipEscapeCharacter() {
+    return skipCharacter(_stringUtils.codeBackslash);
+  }
+
+  /**
+   * 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.
+   */
+  function parseString() {
+    let stopAtDelimiter = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    const iBefore = i; // we may need to revert
+
+    let skipEscapeChars = input.charCodeAt(i) === _stringUtils.codeBackslash;
+    if (skipEscapeChars) {
+      // repair: remove the first escape character
+      i++;
+      skipEscapeChars = true;
+    }
+    if ((0, _stringUtils.isQuote)(input.charCodeAt(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.charCodeAt(i)) ? _stringUtils.isDoubleQuote : (0, _stringUtils.isSingleQuote)(input.charCodeAt(i)) ? _stringUtils.isSingleQuote // eslint-disable-line indent
+      : (0, _stringUtils.isSingleQuoteLike)(input.charCodeAt(i)) // eslint-disable-line indent
+      ? _stringUtils.isSingleQuoteLike // eslint-disable-line indent
+      : _stringUtils.isDoubleQuoteLike; // eslint-disable-line indent
+
+      output.push('"');
+      i++;
+      const isEndOfString = stopAtDelimiter ? i => (0, _stringUtils.isDelimiter)(input.charAt(i)) : i => isEndQuote(input.charCodeAt(i));
+      while (!input.isEnd(i) && !isEndOfString(i)) {
+        if (input.charCodeAt(i) === _stringUtils.codeBackslash) {
+          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.charCodeAt(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 {
+          const char = input.charAt(i);
+          const code = char.charCodeAt(0);
+          if (code === _stringUtils.codeDoubleQuote && input.charCodeAt(i - 1) !== _stringUtils.codeBackslash) {
+            // repair unescaped double quote
+            output.push('\\' + char);
+            i++;
+          } else if ((0, _stringUtils.isControlCharacter)(code)) {
+            // unescaped control character
+            output.push(controlCharacters[char]);
+            i++;
+          } else {
+            if (!(0, _stringUtils.isValidStringCharacter)(code)) {
+              throwInvalidCharacter(char);
+            }
+            output.push(char);
+            i++;
+          }
+        }
+        if (skipEscapeChars) {
+          // repair: skipped escape character (nothing to do)
+          skipEscapeCharacter();
+        }
+      }
+
+      // see whether we have an end quote followed by a valid delimiter
+      const hasEndQuote = (0, _stringUtils.isQuote)(input.charCodeAt(i));
+      const valid = hasEndQuote && (input.isEnd(i + 1) || (0, _stringUtils.isDelimiter)(nextNonWhiteSpaceCharacter(i + 1)));
+      if (!valid && !stopAtDelimiter) {
+        // we're dealing with a missing quote somewhere. Let's revert parsing
+        // this string and try again, running in a more conservative mode,
+        // stopping at the first next delimiter
+        i = iBefore;
+        output.remove(iBefore);
+        return parseString(true);
+      }
+      if (hasEndQuote) {
+        output.push('"');
+        i++;
+      } else {
+        // repair missing quote
+        output.insertBeforeLastWhitespace('"');
+      }
+      parseConcatenatedString();
+      return stack.update(_stack.Caret.afterValue);
+    }
+    return false;
+  }
+
+  /**
+   * Repair concatenated strings like "hello" + "world", change this into "helloworld"
+   */
+  function parseConcatenatedString() {
+    let parsed = false;
+    parseWhitespaceAndSkipComments();
+    while (input.charCodeAt(i) === _stringUtils.codePlus) {
+      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.charCodeAt(i) === _stringUtils.codeMinus) {
+      i++;
+      if (expectDigitOrRepair(start)) {
+        return stack.update(_stack.Caret.afterValue);
+      }
+    }
+
+    // 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.charCodeAt(i))) {
+      i++;
+    }
+    if (input.charCodeAt(i) === _stringUtils.codeDot) {
+      i++;
+      if (expectDigitOrRepair(start)) {
+        return stack.update(_stack.Caret.afterValue);
+      }
+      while ((0, _stringUtils.isDigit)(input.charCodeAt(i))) {
+        i++;
+      }
+    }
+    if (input.charCodeAt(i) === _stringUtils.codeLowercaseE || input.charCodeAt(i) === _stringUtils.codeUppercaseE) {
+      i++;
+      if (input.charCodeAt(i) === _stringUtils.codeMinus || input.charCodeAt(i) === _stringUtils.codePlus) {
+        i++;
+      }
+      if (expectDigitOrRepair(start)) {
+        return stack.update(_stack.Caret.afterValue);
+      }
+      while ((0, _stringUtils.isDigit)(input.charCodeAt(i))) {
+        i++;
+      }
+    }
+    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();
+    if (end !== null) {
+      // first, go back to prevent getting trailing whitespaces in the string
+      while ((0, _stringUtils.isWhitespace)(input.charCodeAt(end - 1)) && end > i) {
+        end--;
+      }
+      const symbol = input.substring(i, end);
+      output.push(JSON.stringify(symbol));
+      i = end;
+      if (input.charCodeAt(i) === _stringUtils.codeDoubleQuote) {
+        // 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() {
+    // note that the symbol can end with whitespaces: we stop at the next delimiter
+    let j = i;
+    while (!input.isEnd(j) && !(0, _stringUtils.isDelimiter)(input.charAt(j))) {
+      j++;
+    }
+    return j > i ? j : null;
+  }
+  function nextNonWhiteSpaceCharacter(start) {
+    let i = start;
+    while ((0, _stringUtils.isWhitespace)(input.charCodeAt(i))) {
+      i++;
+    }
+    return input.charAt(i);
+  }
+  function expectDigit(start) {
+    if (!(0, _stringUtils.isDigit)(input.charCodeAt(i))) {
+      const numSoFar = input.substring(start, i);
+      throw new _JSONFixerError.JSONFixerError(`Invalid number '${numSoFar}', expecting a digit ${got()}`, i);
+    }
+  }
+  function expectDigitOrRepair(start) {
+    if (input.isEnd(i)) {
+      // 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');
+      return true;
+    } else {
+      expectDigit(start);
+      return false;
+    }
+  }
+  function throwInvalidCharacter(char) {
+    throw new _JSONFixerError.JSONFixerError('Invalid character ' + JSON.stringify(char), i);
+  }
+  function throwUnexpectedCharacter() {
+    throw new _JSONFixerError.JSONFixerError('Unexpected character ' + JSON.stringify(input.charAt(i)), i);
+  }
+  function throwUnexpectedEnd() {
+    throw new _JSONFixerError.JSONFixerError('Unexpected end of json string', i);
+  }
+  function throwObjectKeyExpected() {
+    throw new _JSONFixerError.JSONFixerError('Object key expected', i);
+  }
+  function throwColonExpected() {
+    throw new _JSONFixerError.JSONFixerError('Colon expected', i);
+  }
+  function throwInvalidUnicodeCharacter() {
+    const chars = input.substring(i, i + 6);
+    throw new _JSONFixerError.JSONFixerError(`Invalid unicode character "${chars}"`, i);
+  }
+  function got() {
+    const char = input.charAt(i);
+    return char ? `but got '${char}'` : 'but reached end of input';
+  }
+  function atEndOfBlockComment(i) {
+    return input.charAt(i) === '*' && input.charAt(i + 1) === '/';
+  }
+  return {
+    transform,
+    flush
+  };
+}
+//# sourceMappingURL=core.js.map