@reliverse/relifso 1.4.5 → 2.2.7

package/bin/utils/json/regular/jsonrepair.js

@@ -1,576 +0,0 @@
-import { JSONRepairError } from "../helpers/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 "../helpers/stringUtils.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 jsonrepair(text) {
-  let i = 0;
-  let output = "";
-  function charAt(index) {
-    return index < text.length ? text[index] : "";
-  }
-  parseMarkdownCodeBlock();
-  const processed = parseValue();
-  if (!processed) {
-    throwUnexpectedEnd();
-  }
-  parseMarkdownCodeBlock();
-  const processedComma = parseCharacter(",");
-  if (processedComma) {
-    parseWhitespaceAndSkipComments();
-  }
-  if (isStartOfValue(charAt(i)) && endsWithCommaOrNewline(output)) {
-    if (!processedComma) {
-      output = insertBeforeLastWhitespace(output, ",");
-    }
-    parseNewlineDelimitedJSON();
-  } else if (processedComma) {
-    output = stripLastOccurrence(output, ",");
-  }
-  while (charAt(i) === "}" || charAt(i) === "]") {
-    i++;
-    parseWhitespaceAndSkipComments();
-  }
-  if (i >= text.length) {
-    return output;
-  }
-  throwUnexpectedCharacter();
-  function parseValue() {
-    parseWhitespaceAndSkipComments();
-    const processed2 = parseObject() || parseArray() || parseString() || parseNumber() || parseKeywords() || parseUnquotedString(false) || parseRegex() || false;
-    parseWhitespaceAndSkipComments();
-    return processed2;
-  }
-  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(text, i)) {
-        whitespace += charAt(i);
-        i++;
-      } else if (isSpecialWhitespace(text, i)) {
-        whitespace += " ";
-        i++;
-      } else {
-        break;
-      }
-    }
-    if (whitespace.length > 0) {
-      output += whitespace;
-      return true;
-    }
-    return false;
-  }
-  function parseComment() {
-    if (charAt(i) === "/" && charAt(i + 1) === "*") {
-      while (i < text.length && !atEndOfBlockComment(text, i)) {
-        i++;
-      }
-      i += 2;
-      return true;
-    }
-    if (charAt(i) === "/" && charAt(i + 1) === "/") {
-      while (i < text.length && charAt(i) !== "\n") {
-        i++;
-      }
-      return true;
-    }
-    return false;
-  }
-  function parseMarkdownCodeBlock() {
-    if (text.slice(i, i + 3) === "```") {
-      i += 3;
-      if (isFunctionNameCharStart(charAt(i))) {
-        while (i < text.length && isFunctionNameChar(charAt(i))) {
-          i++;
-        }
-      }
-      parseWhitespaceAndSkipComments();
-      return true;
-    }
-    return false;
-  }
-  function parseCharacter(char) {
-    if (charAt(i) === char) {
-      output += charAt(i);
-      i++;
-      return true;
-    }
-    return false;
-  }
-  function skipCharacter(char) {
-    if (charAt(i) === char) {
-      i++;
-      return true;
-    }
-    return false;
-  }
-  function skipEscapeCharacter() {
-    return skipCharacter("\\");
-  }
-  function skipEllipsis() {
-    parseWhitespaceAndSkipComments();
-    if (charAt(i) === "." && charAt(i + 1) === "." && charAt(i + 2) === ".") {
-      i += 3;
-      parseWhitespaceAndSkipComments();
-      skipCharacter(",");
-      return true;
-    }
-    return false;
-  }
-  function parseObject() {
-    if (charAt(i) === "{") {
-      output += "{";
-      i++;
-      parseWhitespaceAndSkipComments();
-      if (skipCharacter(",")) {
-        parseWhitespaceAndSkipComments();
-      }
-      let initial = true;
-      while (i < text.length && charAt(i) !== "}") {
-        let processedComma2;
-        if (!initial) {
-          processedComma2 = parseCharacter(",");
-          if (!processedComma2) {
-            output = insertBeforeLastWhitespace(output, ",");
-          }
-          parseWhitespaceAndSkipComments();
-        } else {
-          processedComma2 = true;
-          initial = false;
-        }
-        skipEllipsis();
-        const processedKey = parseString() || parseUnquotedString(true);
-        if (!processedKey) {
-          if (charAt(i) === "}" || charAt(i) === "{" || charAt(i) === "]" || charAt(i) === "[" || charAt(i) === void 0) {
-            output = stripLastOccurrence(output, ",");
-          } else {
-            throwObjectKeyExpected();
-          }
-          break;
-        }
-        parseWhitespaceAndSkipComments();
-        const processedColon = parseCharacter(":");
-        const truncatedText = i >= text.length;
-        if (!processedColon) {
-          if (isStartOfValue(charAt(i)) || truncatedText) {
-            output = insertBeforeLastWhitespace(output, ":");
-          } else {
-            throwColonExpected();
-          }
-        }
-        const processedValue = parseValue();
-        if (!processedValue) {
-          if (processedColon || truncatedText) {
-            output += "null";
-          } else {
-            throwColonExpected();
-          }
-        }
-      }
-      if (charAt(i) === "}") {
-        output += "}";
-        i++;
-      } else {
-        output = insertBeforeLastWhitespace(output, "}");
-      }
-      return true;
-    }
-    return false;
-  }
-  function parseArray() {
-    if (charAt(i) === "[") {
-      output += "[";
-      i++;
-      parseWhitespaceAndSkipComments();
-      if (skipCharacter(",")) {
-        parseWhitespaceAndSkipComments();
-      }
-      let initial = true;
-      while (i < text.length && charAt(i) !== "]") {
-        if (!initial) {
-          const processedComma2 = parseCharacter(",");
-          if (!processedComma2) {
-            output = insertBeforeLastWhitespace(output, ",");
-          }
-        } else {
-          initial = false;
-        }
-        skipEllipsis();
-        const processedValue = parseValue();
-        if (!processedValue) {
-          output = stripLastOccurrence(output, ",");
-          break;
-        }
-      }
-      if (charAt(i) === "]") {
-        output += "]";
-        i++;
-      } else {
-        output = insertBeforeLastWhitespace(output, "]");
-      }
-      return true;
-    }
-    return false;
-  }
-  function parseNewlineDelimitedJSON() {
-    let initial = true;
-    let processedValue = true;
-    while (processedValue) {
-      if (!initial) {
-        const processedComma2 = parseCharacter(",");
-        if (!processedComma2) {
-          output = insertBeforeLastWhitespace(output, ",");
-        }
-      } else {
-        initial = false;
-      }
-      processedValue = parseValue();
-    }
-    if (!processedValue) {
-      output = stripLastOccurrence(output, ",");
-    }
-    output = `[
-${output}
-]`;
-  }
-  function parseString(stopAtDelimiter = false, stopAtIndex = -1) {
-    let skipEscapeChars = charAt(i) === "\\";
-    if (skipEscapeChars) {
-      i++;
-      skipEscapeChars = true;
-    }
-    if (isQuote(charAt(i))) {
-      const isEndQuote = isDoubleQuote(charAt(i)) ? isDoubleQuote : isSingleQuote(charAt(i)) ? isSingleQuote : isSingleQuoteLike(charAt(i)) ? isSingleQuoteLike : isDoubleQuoteLike;
-      const iBefore = i;
-      const oBefore = output.length;
-      let str = '"';
-      i++;
-      while (true) {
-        if (i >= text.length) {
-          const iPrev = prevNonWhitespaceIndex(i - 1);
-          if (!stopAtDelimiter && isDelimiter(charAt(iPrev))) {
-            i = iBefore;
-            output = output.substring(0, oBefore);
-            return parseString(true);
-          }
-          str = insertBeforeLastWhitespace(str, '"');
-          output += str;
-          return true;
-        } else if (i === stopAtIndex) {
-          str = insertBeforeLastWhitespace(str, '"');
-          output += str;
-          return true;
-        } else if (isEndQuote(charAt(i))) {
-          const iQuote = i;
-          const oQuote = str.length;
-          str += '"';
-          i++;
-          output += str;
-          parseWhitespaceAndSkipComments(false);
-          if (stopAtDelimiter || i >= text.length || isDelimiter(charAt(i)) || isQuote(charAt(i)) || isDigit(charAt(i))) {
-            parseConcatenatedString();
-            return true;
-          }
-          const iPrevChar = prevNonWhitespaceIndex(iQuote - 1);
-          const prevChar = charAt(iPrevChar);
-          if (prevChar === ",") {
-            i = iBefore;
-            output = output.substring(0, oBefore);
-            return parseString(false, iPrevChar);
-          }
-          if (isDelimiter(prevChar)) {
-            i = iBefore;
-            output = output.substring(0, oBefore);
-            return parseString(true);
-          }
-          output = output.substring(0, oBefore);
-          i = iQuote + 1;
-          str = `${str.substring(0, oQuote)}\\${str.substring(oQuote)}`;
-        } else if (stopAtDelimiter && isUnquotedStringDelimiter(charAt(i))) {
-          if (charAt(i - 1) === ":" && regexUrlStart.test(text.substring(iBefore + 1, i + 2))) {
-            while (i < text.length && regexUrlChar.test(charAt(i))) {
-              str += charAt(i);
-              i++;
-            }
-          }
-          str = insertBeforeLastWhitespace(str, '"');
-          output += str;
-          parseConcatenatedString();
-          return true;
-        } else if (charAt(i) === "\\") {
-          const char = charAt(i + 1);
-          const escapeChar = escapeCharacters[char];
-          if (escapeChar !== void 0) {
-            str += charAt(i) + char;
-            i += 2;
-          } else if (char === "u") {
-            let j = 2;
-            while (j < 6 && isHex(charAt(i + j))) {
-              j++;
-            }
-            if (j === 6) {
-              str += charAt(i) + charAt(i + 1) + charAt(i + 2) + charAt(i + 3) + charAt(i + 4) + charAt(i + 5);
-              i += 6;
-            } else if (i + j >= text.length) {
-              i = text.length;
-            } else {
-              throwInvalidUnicodeCharacter();
-            }
-          } else {
-            str += charAt(i) + char;
-            i += 2;
-          }
-        } else {
-          const char = charAt(i);
-          if (char === '"' && charAt(i - 1) !== "\\") {
-            str += `\\${char}`;
-            i++;
-          } else if (isControlCharacter(char)) {
-            str += controlCharacters[char];
-            i++;
-          } else {
-            if (!isValidStringCharacter(char)) {
-              throwInvalidCharacter(char);
-            }
-            str += char;
-            i++;
-          }
-        }
-        if (skipEscapeChars) {
-          skipEscapeCharacter();
-        }
-      }
-    }
-    return false;
-  }
-  function parseConcatenatedString() {
-    let processed2 = false;
-    parseWhitespaceAndSkipComments();
-    while (charAt(i) === "+") {
-      processed2 = true;
-      i++;
-      parseWhitespaceAndSkipComments();
-      output = stripLastOccurrence(output, '"', true);
-      const start = output.length;
-      const parsedStr = parseString();
-      if (parsedStr) {
-        output = removeAtIndex(output, start, 1);
-      } else {
-        output = insertBeforeLastWhitespace(output, '"');
-      }
-    }
-    return processed2;
-  }
-  function parseNumber() {
-    const start = i;
-    if (charAt(i) === "-") {
-      i++;
-      if (atEndOfNumber()) {
-        repairNumberEndingWithNumericSymbol(start);
-        return true;
-      }
-      if (!isDigit(charAt(i))) {
-        i = start;
-        return false;
-      }
-    }
-    while (isDigit(charAt(i))) {
-      i++;
-    }
-    if (charAt(i) === ".") {
-      i++;
-      if (atEndOfNumber()) {
-        repairNumberEndingWithNumericSymbol(start);
-        return true;
-      }
-      if (!isDigit(charAt(i))) {
-        i = start;
-        return false;
-      }
-      while (isDigit(charAt(i))) {
-        i++;
-      }
-    }
-    if (charAt(i) === "e" || charAt(i) === "E") {
-      i++;
-      if (charAt(i) === "-" || charAt(i) === "+") {
-        i++;
-      }
-      if (atEndOfNumber()) {
-        repairNumberEndingWithNumericSymbol(start);
-        return true;
-      }
-      if (!isDigit(charAt(i))) {
-        i = start;
-        return false;
-      }
-      while (isDigit(charAt(i))) {
-        i++;
-      }
-    }
-    if (!atEndOfNumber()) {
-      i = start;
-      return false;
-    }
-    if (i > start) {
-      const num = text.slice(start, i);
-      const hasInvalidLeadingZero = /^0\d/.test(num);
-      output += hasInvalidLeadingZero ? `"${num}"` : num;
-      return true;
-    }
-    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 (text.slice(i, i + name.length) === name) {
-      output += value;
-      i += name.length;
-      return true;
-    }
-    return false;
-  }
-  function parseUnquotedString(isKey) {
-    const start = i;
-    if (isFunctionNameCharStart(charAt(i))) {
-      while (i < text.length && isFunctionNameChar(charAt(i))) {
-        i++;
-      }
-      let j = i;
-      while (isWhitespace(text, j)) {
-        j++;
-      }
-      if (charAt(j) === "(") {
-        i = j + 1;
-        parseValue();
-        if (charAt(i) === ")") {
-          i++;
-          if (charAt(i) === ";") {
-            i++;
-          }
-        }
-        return true;
-      }
-    }
-    while (i < text.length && !isUnquotedStringDelimiter(charAt(i)) && !isQuote(charAt(i)) && (!isKey || charAt(i) !== ":")) {
-      i++;
-    }
-    if (charAt(i - 1) === ":" && regexUrlStart.test(text.substring(i, i + 2))) {
-      while (i < text.length && regexUrlChar.test(charAt(i))) {
-        i++;
-      }
-    }
-    if (i > start) {
-      while (isWhitespace(text, i - 1) && i > 0) {
-        i--;
-      }
-      const symbol = text.slice(start, i);
-      output += symbol === "undefined" ? "null" : JSON.stringify(symbol);
-      if (charAt(i) === '"') {
-        i++;
-      }
-      return true;
-    }
-  }
-  function parseRegex() {
-    if (charAt(i) === "/") {
-      const start = i;
-      i++;
-      while (i < text.length && (charAt(i) !== "/" || charAt(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(charAt(i)) || isWhitespace(text, i);
-  }
-  function repairNumberEndingWithNumericSymbol(start) {
-    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(charAt(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);
-  }
-  return output;
-}
-function atEndOfBlockComment(text, i) {
-  return text[i] === "*" && text[i + 1] === "/";
-}

package/bin/utils/json/regular/validate.d.ts

@@ -1,22 +0,0 @@
-/**
- * JSON Schema type definition
- */
-export interface JSONSchema {
-    type?: "string" | "number" | "boolean" | "object" | "array" | "null";
-    properties?: Record<string, JSONSchema>;
-    items?: JSONSchema;
-    required?: string[];
-    minItems?: number;
-    maxItems?: number;
-    minProperties?: number;
-    maxProperties?: number;
-}
-/**
- * Validates a JSON value against a JSON Schema.
- *
- * @param value - The value to validate
- * @param schema - The JSON Schema to validate against
- * @returns true if valid, throws JsonSchemaError if invalid
- * @throws {JsonSchemaError} If validation fails
- */
-export declare function validateJson(value: unknown, schema: JSONSchema): boolean;

package/bin/utils/json/regular/validate.js

@@ -1,52 +0,0 @@
-import { JsonSchemaError } from "../helpers/JsonSchemaError.js";
-export function validateJson(value, schema) {
-  if (schema.type) {
-    const type = typeof value;
-    if (schema.type === "array" && !Array.isArray(value)) {
-      throw new JsonSchemaError(`Expected array, got ${type}`);
-    }
-    if (schema.type === "object" && (type !== "object" || value === null || Array.isArray(value))) {
-      throw new JsonSchemaError(`Expected object, got ${type}`);
-    }
-    if (schema.type === "string" && type !== "string") {
-      throw new JsonSchemaError(`Expected string, got ${type}`);
-    }
-    if (schema.type === "number" && type !== "number") {
-      throw new JsonSchemaError(`Expected number, got ${type}`);
-    }
-    if (schema.type === "boolean" && type !== "boolean") {
-      throw new JsonSchemaError(`Expected boolean, got ${type}`);
-    }
-  }
-  if (Array.isArray(value)) {
-    if (schema.items) {
-      for (const item of value) {
-        validateJson(item, schema.items);
-      }
-    }
-    if (schema.minItems !== void 0 && value.length < schema.minItems) {
-      throw new JsonSchemaError(`Array must have at least ${schema.minItems} items`);
-    }
-    if (schema.maxItems !== void 0 && value.length > schema.maxItems) {
-      throw new JsonSchemaError(`Array must have at most ${schema.maxItems} items`);
-    }
-  }
-  if (value && typeof value === "object" && !Array.isArray(value)) {
-    if (schema.properties) {
-      for (const [key, propSchema] of Object.entries(schema.properties)) {
-        if (key in value) {
-          validateJson(value[key], propSchema);
-        } else if (schema.required?.includes(key)) {
-          throw new JsonSchemaError(`Missing required property: ${key}`);
-        }
-      }
-    }
-    if (schema.minProperties !== void 0 && Object.keys(value).length < schema.minProperties) {
-      throw new JsonSchemaError(`Object must have at least ${schema.minProperties} properties`);
-    }
-    if (schema.maxProperties !== void 0 && Object.keys(value).length > schema.maxProperties) {
-      throw new JsonSchemaError(`Object must have at most ${schema.maxProperties} properties`);
-    }
-  }
-  return true;
-}

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

@@ -1,6 +0,0 @@
-/**
- * Custom error class for JSON streaming errors.
- */
-export declare class JsonStreamError extends Error {
-    constructor(message: string);
-}

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

@@ -1,6 +0,0 @@
-export class JsonStreamError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "JsonStreamError";
-  }
-}

package/bin/utils/json/stream/buffer/InputBuffer.d.ts

@@ -1,13 +0,0 @@
-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;