@reliverse/relifso 1.4.0 → 1.4.1

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

@@ -0,0 +1,88 @@
+import { JSONRepairError } from "../helpers/JSONRepairError.js";
+import { jsonrepair } from "./jsonrepair.js";
+export function parseJsonc(text, options = {}) {
+  const { throws = true } = options;
+  try {
+    return JSON.parse(text);
+  } catch (_error) {
+    try {
+      const repaired = jsonrepair(text);
+      return JSON.parse(repaired);
+    } catch (_error2) {
+      if (throws) {
+        throw new JSONRepairError("Failed to parse JSONC", -1);
+      }
+      return null;
+    }
+  }
+}
+export function stringifyJsonc(value, options = {}) {
+  const { spaces = 2 } = options;
+  return JSON.stringify(value, null, spaces);
+}
+export function isValidJsonc(text) {
+  try {
+    parseJsonc(text, { throws: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+export function extractComments(text) {
+  const comments = [];
+  let line = 1;
+  let column = 0;
+  let i = 0;
+  while (i < text.length) {
+    const char = text[i];
+    if (char === "/" && text[i + 1] === "/") {
+      const startColumn = column;
+      const startLine = line;
+      let commentText = "";
+      i += 2;
+      while (i < text.length && text[i] !== "\n") {
+        commentText += text[i];
+        i++;
+      }
+      comments.push({
+        line: startLine,
+        column: startColumn,
+        text: commentText.trim(),
+        type: "line"
+      });
+    } else if (char === "/" && text[i + 1] === "*") {
+      const startColumn = column;
+      const startLine = line;
+      let commentText = "";
+      i += 2;
+      while (i < text.length - 1 && !(text[i] === "*" && text[i + 1] === "/")) {
+        if (text[i] === "\n") {
+          line++;
+          column = 0;
+        } else {
+          column++;
+        }
+        commentText += text[i];
+        i++;
+      }
+      if (i < text.length - 1) {
+        i += 2;
+      }
+      comments.push({
+        line: startLine,
+        column: startColumn,
+        text: commentText.trim(),
+        type: "block"
+      });
+    } else {
+      if (char === "\n") {
+        line++;
+        column = 0;
+      } else {
+        column++;
+      }
+      i++;
+    }
+  }
+  return comments;
+}

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

@@ -0,0 +1,17 @@
+/**
+ * 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;

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

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

@@ -0,0 +1,22 @@
+/**
+ * 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;