@reliverse/relifso 1.4.0 → 1.4.2

package/bin/utils/json/stream/core.js

@@ -0,0 +1,695 @@
+import { JSONRepairError } from "../helpers/JSONRepairError.js";
+import {
+  isControlCharacter,
+  isDelimiter,
+  isDigit,
+  isDoubleQuote,
+  isDoubleQuoteLike,
+  isFunctionNameChar,
+  isFunctionNameCharStart,
+  isHex,
+  isQuote,
+  isSingleQuote,
+  isSingleQuoteLike,
+  isSpecialWhitespace,
+  isStartOfValue,
+  isUnquotedStringDelimiter,
+  isValidStringCharacter,
+  isWhitespace,
+  isWhitespaceExceptNewline,
+  regexUrlChar,
+  regexUrlStart
+} from "../helpers/stringUtils.js";
+import { createInputBuffer } from "./buffer/InputBuffer.js";
+import { createOutputBuffer } from "./buffer/OutputBuffer.js";
+import { Caret, StackType, createStack } from "./stack.js";
+const controlCharacters = {
+  "\b": "\\b",
+  "\f": "\\f",
+  "\n": "\\n",
+  "\r": "\\r",
+  "	": "\\t"
+};
+const escapeCharacters = {
+  '"': '"',
+  "\\": "\\",
+  "/": "/",
+  b: "\b",
+  f: "\f",
+  n: "\n",
+  r: "\r",
+  t: "	"
+  // note that \u is handled separately in parseString()
+};
+export function jsonrepairCore({
+  onData,
+  bufferSize = 65536,
+  chunkSize = 65536
+}) {
+  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()) {
+    }
+    flushInputBuffer();
+  }
+  function flush() {
+    input.close();
+    while (parse()) {
+    }
+    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() || false;
+  }
+  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) === "(") {
+        k++;
+        i = k;
+        return stack.push(StackType.functionCall, Caret.beforeValue);
+      }
+    }
+    const nextDelimiter = findNextDelimiter(false, j);
+    if (nextDelimiter === null) {
+      return false;
+    }
+    j = nextDelimiter;
+    if (j !== null) {
+      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) === '"') {
+        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() {
+    output.push("null");
+    return stack.update(Caret.afterValue);
+  }
+  function parseRepairTrailingComma() {
+    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(":")) {
+        return stack.update(Caret.beforeValue);
+      }
+      const truncatedText = input.isEnd(i);
+      if (isStartOfValue(input.charAt(i)) || truncatedText) {
+        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() {
+    if (input.charAt(i) === "{") {
+      output.stripLastOccurrence(",");
+      output.insertBeforeLastWhitespace("}");
+      return stack.pop();
+    }
+    if (!input.isEnd(i) && isStartOfValue(input.charAt(i))) {
+      output.insertBeforeLastWhitespace(",");
+      return stack.update(Caret.beforeKey);
+    }
+    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() {
+    if (!input.isEnd(i) && isStartOfValue(input.charAt(i))) {
+      output.insertBeforeLastWhitespace(",");
+      return stack.update(Caret.beforeValue);
+    }
+    return false;
+  }
+  function parseRepairArrayEnd() {
+    output.insertBeforeLastWhitespace("]");
+    return stack.pop();
+  }
+  function parseRepairNdJsonEnd() {
+    if (input.isEnd(i)) {
+      output.push("\n]");
+      return stack.pop();
+    }
+    throwUnexpectedEnd();
+    return false;
+  }
+  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"))) {
+      if (!parsedComma) {
+        output.insertBeforeLastWhitespace(",");
+      }
+      output.unshift("[\n");
+      return stack.push(StackType.ndJson, Caret.beforeValue);
+    }
+    if (parsedComma) {
+      output.stripLastOccurrence(",");
+      return stack.update(Caret.afterValue);
+    }
+    while (input.charAt(i) === "}" || input.charAt(i) === "]") {
+      i++;
+      parseWhitespaceAndSkipComments();
+    }
+    if (!input.isEnd(i)) {
+      throwUnexpectedCharacter();
+    }
+    return false;
+  }
+  function parseWhitespaceAndSkipComments(skipNewline = 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)) {
+        whitespace += " ";
+        i++;
+      } else {
+        break;
+      }
+    }
+    if (whitespace.length > 0) {
+      output.push(whitespace);
+      return true;
+    }
+    return false;
+  }
+  function parseComment() {
+    if (input.charAt(i) === "/" && input.charAt(i + 1) === "*") {
+      while (!input.isEnd(i) && !atEndOfBlockComment(i)) {
+        i++;
+      }
+      i += 2;
+      return true;
+    }
+    if (input.charAt(i) === "/" && input.charAt(i + 1) === "/") {
+      while (!input.isEnd(i) && input.charAt(i) !== "\n") {
+        i++;
+      }
+      return true;
+    }
+    return false;
+  }
+  function parseMarkdownCodeBlock() {
+    if (input.substring(i, i + 3) === "```") {
+      i += 3;
+      if (isFunctionNameCharStart(input.charAt(i))) {
+        while (!input.isEnd(i) && isFunctionNameChar(input.charAt(i))) {
+          i++;
+        }
+      }
+      parseWhitespaceAndSkipComments();
+      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("\\");
+  }
+  function skipEllipsis() {
+    parseWhitespaceAndSkipComments();
+    if (input.charAt(i) === "." && input.charAt(i + 1) === "." && input.charAt(i + 2) === ".") {
+      i += 3;
+      parseWhitespaceAndSkipComments();
+      skipCharacter(",");
+      return true;
+    }
+    return false;
+  }
+  function parseString(stopAtDelimiter = false, stopAtIndex = -1) {
+    let skipEscapeChars = input.charAt(i) === "\\";
+    if (skipEscapeChars) {
+      i++;
+      skipEscapeChars = true;
+    }
+    if (isQuote(input.charAt(i))) {
+      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)) {
+          const iPrev = prevNonWhitespaceIndex(i - 1);
+          if (!stopAtDelimiter && isDelimiter(input.charAt(iPrev))) {
+            i = iBefore;
+            output.remove(oBefore);
+            return parseString(true);
+          }
+          output.insertBeforeLastWhitespace('"');
+          return stack.update(Caret.afterValue);
+        } else if (i === stopAtIndex) {
+          output.insertBeforeLastWhitespace('"');
+          return stack.update(Caret.afterValue);
+        } else if (isEndQuote(input.charAt(i))) {
+          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))) {
+            parseConcatenatedString();
+            return stack.update(Caret.afterValue);
+          }
+          const iPrevChar = prevNonWhitespaceIndex(iQuote - 1);
+          const prevChar = input.charAt(iPrevChar);
+          if (prevChar === ",") {
+            i = iBefore;
+            output.remove(oBefore);
+            return parseString(false, iPrevChar);
+          }
+          if (isDelimiter(prevChar)) {
+            i = iBefore;
+            output.remove(oBefore);
+            return parseString(true);
+          }
+          output.remove(oQuote + 1);
+          i = iQuote + 1;
+          output.insertAt(oQuote, "\\");
+        } else if (stopAtDelimiter && isUnquotedStringDelimiter(input.charAt(i))) {
+          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++;
+            }
+          }
+          output.insertBeforeLastWhitespace('"');
+          parseConcatenatedString();
+          return stack.update(Caret.afterValue);
+        } else if (input.charAt(i) === "\\") {
+          const char = input.charAt(i + 1);
+          const escapeChar = escapeCharacters[char];
+          if (escapeChar !== void 0) {
+            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)) {
+              i += j;
+            } else {
+              throwInvalidUnicodeCharacter();
+            }
+          } else {
+            output.push(char);
+            i += 2;
+          }
+        } else {
+          const char = input.charAt(i);
+          if (char === '"' && input.charAt(i - 1) !== "\\") {
+            output.push(`\\${char}`);
+            i++;
+          } else if (isControlCharacter(char)) {
+            const escaped = controlCharacters[char];
+            if (escaped === void 0) {
+              throwInvalidCharacter(char);
+            }
+            output.push(escaped);
+            i++;
+          } else {
+            if (!isValidStringCharacter(char)) {
+              throwInvalidCharacter(char);
+            }
+            output.push(char);
+            i++;
+          }
+        }
+        if (skipEscapeChars) {
+          skipEscapeCharacter();
+        }
+      }
+    }
+    return false;
+  }
+  function parseConcatenatedString() {
+    let parsed = false;
+    parseWhitespaceAndSkipComments();
+    while (input.charAt(i) === "+") {
+      parsed = true;
+      i++;
+      parseWhitespaceAndSkipComments();
+      output.stripLastOccurrence('"', true);
+      const start = output.length();
+      const parsedStr = parseString();
+      if (parsedStr) {
+        output.remove(start, start + 1);
+      } else {
+        output.insertBeforeLastWhitespace('"');
+      }
+    }
+    return parsed;
+  }
+  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;
+      }
+    }
+    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 (!atEndOfNumber()) {
+      i = start;
+      return false;
+    }
+    if (i > start) {
+      const num = input.substring(start, i);
+      const hasInvalidLeadingZero = /^0\d/.test(num);
+      output.push(hasInvalidLeadingZero ? `"${num}"` : num);
+      return stack.update(Caret.afterValue);
+    }
+    return false;
+  }
+  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) {
+      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) === '"') {
+        i++;
+      }
+      return stack.update(Caret.afterValue);
+    }
+    return false;
+  }
+  function findNextDelimiter(isKey, start) {
+    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) {
+    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(i2) {
+    return input.charAt(i2) === "*" && input.charAt(i2 + 1) === "/";
+  }
+  return {
+    transform,
+    flush
+  };
+}

package/bin/utils/json/stream/jsonl.d.ts

@@ -0,0 +1,21 @@
+import { Transform } from "node:stream";
+interface JsonlOptions {
+    chunkSize?: number;
+    reviver?: (key: string, value: unknown) => unknown;
+    replacer?: (key: string, value: unknown) => unknown | (number | string)[] | null;
+}
+/**
+ * Creates a transform stream that parses JSONL (JSON Lines) data.
+ *
+ * @param options - Parser options
+ * @returns A transform stream that emits parsed JSON objects
+ */
+export declare function createJsonlParser(options?: JsonlOptions): Transform;
+/**
+ * Creates a transform stream that writes JSONL (JSON Lines) data.
+ *
+ * @param options - Writer options
+ * @returns A transform stream that accepts objects and outputs JSONL strings
+ */
+export declare function createJsonlWriter(options?: JsonlOptions): Transform;
+export {};