@ai-sdk-tool/parser 3.2.1 → 3.3.0

package/dist/rjson.cjs

@@ -0,0 +1,697 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/rjson/index.ts
+var rjson_exports = {};
+__export(rjson_exports, {
+  parse: () => parse,
+  stringify: () => stringify,
+  transform: () => transform
+});
+module.exports = __toCommonJS(rjson_exports);
+var WHITESPACE_TEST_REGEX = /\s/;
+var WHITESPACE_REGEX = /^\s+/;
+var OBJECT_START_REGEX = /^\{/;
+var OBJECT_END_REGEX = /^\}/;
+var ARRAY_START_REGEX = /^\[/;
+var ARRAY_END_REGEX = /^\]/;
+var COMMA_REGEX = /^,/;
+var COLON_REGEX = /^:/;
+var KEYWORD_REGEX = /^(?:true|false|null)/;
+var NUMBER_REGEX = /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/;
+var STRING_DOUBLE_REGEX = /^"(?:[^"\\]|\\["bnrtf\\/]|\\u[0-9a-fA-F]{4})*"/;
+var STRING_SINGLE_REGEX = /^'((?:[^'\\]|\\['bnrtf\\/]|\\u[0-9a-fA-F]{4})*)'/;
+var COMMENT_SINGLE_REGEX = /^\/\/.*?(?:\r\n|\r|\n)/;
+var COMMENT_MULTI_REGEX = /^\/\*[\s\S]*?\*\//;
+var IDENTIFIER_REGEX = /^[$a-zA-Z0-9_\-+.*?!|&%^/#\\]+/;
+function some(array, f) {
+  let acc = false;
+  for (let i = 0; i < array.length; i += 1) {
+    const result = f(array[i], i, array);
+    acc = result === void 0 ? false : result;
+    if (acc) {
+      return acc;
+    }
+  }
+  return acc;
+}
+function makeLexer(tokenSpecs) {
+  return (contents) => {
+    const tokens = [];
+    let line = 1;
+    let remainingContents = contents;
+    function findToken() {
+      const result = some(tokenSpecs, (tokenSpec) => {
+        const m = tokenSpec.re.exec(remainingContents);
+        if (m) {
+          const raw = m[0];
+          remainingContents = remainingContents.slice(raw.length);
+          return {
+            raw,
+            matched: tokenSpec.f(m)
+            // Process the match using the spec's function
+          };
+        }
+        return;
+      });
+      return result === false ? void 0 : result;
+    }
+    while (remainingContents !== "") {
+      const matched = findToken();
+      if (!matched) {
+        const err = new SyntaxError(
+          `Unexpected character: ${remainingContents[0]}; input: ${remainingContents.substr(
+            0,
+            100
+          )}`
+        );
+        err.line = line;
+        throw err;
+      }
+      const tokenWithLine = matched.matched;
+      tokenWithLine.line = line;
+      line += matched.raw.replace(/[^\n]/g, "").length;
+      tokens.push(tokenWithLine);
+    }
+    return tokens;
+  };
+}
+function fStringSingle(m) {
+  const content = m[1].replace(
+    /([^'\\]|\\['bnrtf\\]|\\u[0-9a-fA-F]{4})/g,
+    (mm) => {
+      if (mm === '"') {
+        return '\\"';
+      }
+      if (mm === "\\'") {
+        return "'";
+      }
+      return mm;
+    }
+  );
+  const match = `"${content}"`;
+  return {
+    type: "string",
+    match,
+    // The transformed, double-quoted string representation
+    // Use JSON.parse on the transformed string to handle escape sequences correctly
+    value: JSON.parse(match)
+  };
+}
+function fStringDouble(m) {
+  return {
+    type: "string",
+    match: m[0],
+    // The raw matched string (including quotes)
+    value: JSON.parse(m[0])
+    // Use JSON.parse to handle escapes and get the value
+  };
+}
+function fIdentifier(m) {
+  const value = m[0];
+  const match = '"' + value.replace(/\\/g, "\\\\").replace(/"/g, '\\"') + // Escape backslashes and quotes
+  '"';
+  return {
+    type: "string",
+    // Treat identifiers as strings
+    value,
+    // The original identifier name
+    match
+    // The double-quoted string representation
+  };
+}
+function fComment(m) {
+  const match = m[0].replace(
+    /./g,
+    (c) => WHITESPACE_TEST_REGEX.test(c) ? c : " "
+  );
+  return {
+    type: " ",
+    // Represent comments as whitespace tokens
+    match,
+    // String containing original newlines and spaces for other chars
+    value: void 0
+    // Comments don't have a semantic value
+  };
+}
+function fNumber(m) {
+  return {
+    type: "number",
+    match: m[0],
+    // The raw matched number string
+    value: Number.parseFloat(m[0])
+    // Convert string to number
+  };
+}
+function fKeyword(m) {
+  let value;
+  switch (m[0]) {
+    case "null":
+      value = null;
+      break;
+    case "true":
+      value = true;
+      break;
+    case "false":
+      value = false;
+      break;
+    default:
+      throw new Error(`Unexpected keyword: ${m[0]}`);
+  }
+  return {
+    type: "atom",
+    // Use 'atom' type for these literals
+    match: m[0],
+    // The raw matched keyword
+    value
+    // The corresponding JavaScript value
+  };
+}
+function makeTokenSpecs(relaxed) {
+  function f(type) {
+    return (m) => {
+      return { type, match: m[0], value: void 0 };
+    };
+  }
+  let tokenSpecs = [
+    { re: WHITESPACE_REGEX, f: f(" ") },
+    // Whitespace
+    { re: OBJECT_START_REGEX, f: f("{") },
+    // Object start
+    { re: OBJECT_END_REGEX, f: f("}") },
+    // Object end
+    { re: ARRAY_START_REGEX, f: f("[") },
+    // Array start
+    { re: ARRAY_END_REGEX, f: f("]") },
+    // Array end
+    { re: COMMA_REGEX, f: f(",") },
+    // Comma separator
+    { re: COLON_REGEX, f: f(":") },
+    // Key-value separator
+    { re: KEYWORD_REGEX, f: fKeyword },
+    // Keywords
+    // Number: optional sign, digits, optional decimal part, optional exponent
+    { re: NUMBER_REGEX, f: fNumber },
+    // String: double-quoted, handles escapes
+    { re: STRING_DOUBLE_REGEX, f: fStringDouble }
+  ];
+  if (relaxed) {
+    tokenSpecs = tokenSpecs.concat([
+      // Single-quoted strings
+      {
+        re: STRING_SINGLE_REGEX,
+        f: fStringSingle
+      },
+      // Single-line comments (// ...)
+      { re: COMMENT_SINGLE_REGEX, f: fComment },
+      // Multi-line comments (/* ... */)
+      { re: COMMENT_MULTI_REGEX, f: fComment },
+      // Unquoted identifiers (treated as strings)
+      // Allows letters, numbers, _, -, +, ., *, ?, !, |, &, %, ^, /, #, \
+      { re: IDENTIFIER_REGEX, f: fIdentifier }
+      // Note: The order matters here. Identifiers are checked after keywords/numbers.
+    ]);
+  }
+  return tokenSpecs;
+}
+var lexer = makeLexer(makeTokenSpecs(true));
+var strictLexer = makeLexer(makeTokenSpecs(false));
+function previousNWSToken(tokens, index) {
+  let currentIndex = index;
+  for (; currentIndex >= 0; currentIndex -= 1) {
+    if (tokens[currentIndex].type !== " ") {
+      return currentIndex;
+    }
+  }
+  return;
+}
+function stripTrailingComma(tokens) {
+  const res = [];
+  tokens.forEach((token, index) => {
+    if (index > 0 && (token.type === "]" || token.type === "}")) {
+      const prevNWSTokenIndex = previousNWSToken(res, res.length - 1);
+      if (prevNWSTokenIndex !== void 0 && res[prevNWSTokenIndex].type === ",") {
+        const preCommaIndex = previousNWSToken(res, prevNWSTokenIndex - 1);
+        if (preCommaIndex !== void 0 && res[preCommaIndex].type !== "[" && res[preCommaIndex].type !== "{") {
+          res[prevNWSTokenIndex] = {
+            type: " ",
+            match: " ",
+            // Represent as a single space
+            value: void 0,
+            // Whitespace has no value
+            line: res[prevNWSTokenIndex].line
+            // Preserve original line number
+          };
+        }
+      }
+    }
+    res.push(token);
+  });
+  return res;
+}
+function transform(text) {
+  let tokens = lexer(text);
+  tokens = stripTrailingComma(tokens);
+  return tokens.reduce((str, token) => str + token.match, "");
+}
+function popToken(tokens, state) {
+  var _a, _b;
+  const token = tokens[state.pos];
+  state.pos += 1;
+  if (!token) {
+    const lastLine = tokens.length !== 0 ? (_b = (_a = tokens.at(-1)) == null ? void 0 : _a.line) != null ? _b : 1 : 1;
+    return { type: "eof", match: "", value: void 0, line: lastLine };
+  }
+  return token;
+}
+function strToken(token) {
+  switch (token.type) {
+    case "atom":
+    case "string":
+    case "number":
+      return `${token.type} ${token.match}`;
+    case "eof":
+      return "end-of-file";
+    default:
+      return `'${token.type}'`;
+  }
+}
+function skipColon(tokens, state) {
+  const colon = popToken(tokens, state);
+  if (colon.type !== ":") {
+    const message = `Unexpected token: ${strToken(colon)}, expected ':'`;
+    if (state.tolerant) {
+      state.warnings.push({
+        message,
+        line: colon.line
+      });
+      state.pos -= 1;
+    } else {
+      const err = new SyntaxError(message);
+      err.line = colon.line;
+      throw err;
+    }
+  }
+}
+function skipPunctuation(tokens, state, valid) {
+  const punctuation = [",", ":", "]", "}"];
+  let token = popToken(tokens, state);
+  while (true) {
+    if (valid == null ? void 0 : valid.includes(token.type)) {
+      return token;
+    }
+    if (token.type === "eof") {
+      return token;
+    }
+    if (punctuation.includes(token.type)) {
+      const message = `Unexpected token: ${strToken(
+        token
+      )}, expected '[', '{', number, string or atom`;
+      if (state.tolerant) {
+        state.warnings.push({
+          message,
+          line: token.line
+        });
+        token = popToken(tokens, state);
+      } else {
+        const err = new SyntaxError(message);
+        err.line = token.line;
+        throw err;
+      }
+    } else {
+      return token;
+    }
+  }
+}
+function raiseError(state, token, message) {
+  if (state.tolerant) {
+    state.warnings.push({
+      message,
+      line: token.line
+    });
+  } else {
+    const err = new SyntaxError(message);
+    err.line = token.line;
+    throw err;
+  }
+}
+function raiseUnexpected(state, token, expected) {
+  raiseError(
+    state,
+    token,
+    `Unexpected token: ${strToken(token)}, expected ${expected}`
+  );
+}
+function checkDuplicates(state, obj, token) {
+  const key = String(token.value);
+  if (!state.duplicate && Object.hasOwn(obj, key)) {
+    raiseError(state, token, `Duplicate key: ${key}`);
+  }
+}
+function appendPair(state, obj, key, value) {
+  const finalValue = state.reviver ? state.reviver(key, value) : value;
+  if (finalValue !== void 0) {
+    obj[key] = finalValue;
+  }
+}
+function parsePair(tokens, state, obj) {
+  let token = skipPunctuation(tokens, state, [":", "string", "number", "atom"]);
+  let value;
+  if (token.type !== "string") {
+    raiseUnexpected(state, token, "string key");
+    if (state.tolerant) {
+      switch (token.type) {
+        case ":":
+          token = {
+            type: "string",
+            value: "null",
+            match: '"null"',
+            line: token.line
+          };
+          state.pos -= 1;
+          break;
+        case "number":
+        // Use number as string key
+        case "atom":
+          token = {
+            type: "string",
+            value: String(token.value),
+            match: `"${token.value}"`,
+            line: token.line
+          };
+          break;
+        case "[":
+        // Assume missing key before an array
+        case "{":
+          state.pos -= 1;
+          value = parseAny(tokens, state);
+          checkDuplicates(state, obj, {
+            type: "string",
+            value: "null",
+            match: '"null"',
+            line: token.line
+          });
+          appendPair(state, obj, "null", value);
+          return;
+        // Finished parsing this "pair"
+        case "eof":
+          return;
+        // Cannot recover
+        default:
+          return;
+      }
+    } else {
+      return;
+    }
+  }
+  checkDuplicates(state, obj, token);
+  const key = String(token.value);
+  skipColon(tokens, state);
+  value = parseAny(tokens, state);
+  appendPair(state, obj, key, value);
+}
+function parseElement(tokens, state, arr) {
+  const key = arr.length;
+  const value = parseAny(tokens, state);
+  arr[key] = state.reviver ? state.reviver(String(key), value) : value;
+}
+function parseObject(tokens, state) {
+  const obj = {};
+  return parseMany(tokens, state, obj, {
+    skip: [":", "}"],
+    // Initially skip over colon or closing brace (for empty/tolerant cases)
+    elementParser: parsePair,
+    // Use parsePair to parse each key-value element
+    elementName: "string key",
+    // Expected element type for errors
+    endSymbol: "}"
+    // The closing token for an object
+  });
+}
+function parseArray(tokens, state) {
+  const arr = [];
+  return parseMany(tokens, state, arr, {
+    skip: ["]"],
+    // Initially skip over closing bracket (for empty/tolerant cases)
+    elementParser: parseElement,
+    // Use parseElement to parse each array item
+    elementName: "json value",
+    // Expected element type for errors
+    endSymbol: "]"
+    // The closing token for an array
+  });
+}
+function handleInvalidToken(token, state, opts, result) {
+  raiseUnexpected(state, token, `',' or '${opts.endSymbol}'`);
+  if (state.tolerant) {
+    if (token.type === "eof") {
+      return result;
+    }
+    state.pos -= 1;
+    return null;
+  }
+  return result;
+}
+function handleCommaToken(params) {
+  const { token, tokens, state, opts, result } = params;
+  const nextToken = tokens[state.pos];
+  if (state.tolerant && nextToken && nextToken.type === opts.endSymbol) {
+    raiseError(state, token, `Trailing comma before '${opts.endSymbol}'`);
+    popToken(tokens, state);
+    return result;
+  }
+  opts.elementParser(tokens, state, result);
+  return null;
+}
+function parseManyInitialElement(tokens, state, result, opts) {
+  const token = skipPunctuation(tokens, state, opts.skip);
+  if (token.type === "eof") {
+    raiseUnexpected(state, token, `'${opts.endSymbol}' or ${opts.elementName}`);
+    return result;
+  }
+  if (token.type === opts.endSymbol) {
+    return result;
+  }
+  state.pos -= 1;
+  opts.elementParser(tokens, state, result);
+  return;
+}
+function parseManyProcessToken(params) {
+  const { token, tokens, state, opts, result } = params;
+  if (token.type !== opts.endSymbol && token.type !== ",") {
+    const handledResult = handleInvalidToken(token, state, opts, result);
+    if (handledResult !== null) {
+      return handledResult;
+    }
+  }
+  if (token.type === opts.endSymbol) {
+    return result;
+  }
+  if (token.type === ",") {
+    const handledResult = handleCommaToken({
+      token,
+      tokens,
+      state,
+      opts,
+      result
+    });
+    if (handledResult !== null) {
+      return handledResult;
+    }
+    return;
+  }
+  opts.elementParser(tokens, state, result);
+  return;
+}
+function parseMany(tokens, state, result, opts) {
+  const initialResult = parseManyInitialElement(tokens, state, result, opts);
+  if (initialResult !== void 0) {
+    return initialResult;
+  }
+  while (true) {
+    const token = popToken(tokens, state);
+    const processedResult = parseManyProcessToken({
+      token,
+      tokens,
+      state,
+      opts,
+      result
+    });
+    if (processedResult !== void 0) {
+      return processedResult;
+    }
+  }
+}
+function endChecks(tokens, state, ret) {
+  if (state.pos < tokens.length) {
+    if (state.tolerant) {
+      skipPunctuation(tokens, state);
+    }
+    if (state.pos < tokens.length) {
+      raiseError(
+        state,
+        tokens[state.pos],
+        `Unexpected token: ${strToken(tokens[state.pos])}, expected end-of-input`
+      );
+    }
+  }
+  if (state.tolerant && state.warnings.length > 0) {
+    const message = state.warnings.length === 1 ? state.warnings[0].message : `${state.warnings.length} parse warnings`;
+    const err = new SyntaxError(message);
+    err.line = state.warnings[0].line;
+    err.warnings = state.warnings;
+    err.obj = ret;
+    throw err;
+  }
+}
+function parseAny(tokens, state, end = false) {
+  const token = skipPunctuation(tokens, state);
+  let ret;
+  if (token.type === "eof") {
+    if (end) {
+      raiseUnexpected(state, token, "json value");
+    }
+    raiseUnexpected(state, token, "json value");
+    return;
+  }
+  switch (token.type) {
+    case "{":
+      ret = parseObject(tokens, state);
+      break;
+    case "[":
+      ret = parseArray(tokens, state);
+      break;
+    case "string":
+    // String literal
+    case "number":
+    // Number literal
+    case "atom":
+      ret = token.value;
+      break;
+    default:
+      raiseUnexpected(state, token, "json value");
+      if (state.tolerant) {
+        ret = null;
+      } else {
+        return;
+      }
+  }
+  if (end) {
+    ret = state.reviver ? state.reviver("", ret) : ret;
+    endChecks(tokens, state, ret);
+  }
+  return ret;
+}
+function normalizeParseOptions(optsOrReviver) {
+  var _a;
+  let options = {};
+  if (typeof optsOrReviver === "function") {
+    options.reviver = optsOrReviver;
+  } else if (optsOrReviver !== null && typeof optsOrReviver === "object") {
+    options = { ...optsOrReviver };
+  } else if (optsOrReviver !== void 0) {
+    throw new TypeError(
+      "Second argument must be a reviver function or an options object."
+    );
+  }
+  if (options.relaxed === void 0) {
+    if (options.warnings === true || options.tolerant === true) {
+      options.relaxed = true;
+    } else if (options.warnings === false && options.tolerant === false) {
+      options.relaxed = false;
+    } else {
+      options.relaxed = true;
+    }
+  }
+  options.tolerant = options.tolerant || options.warnings;
+  options.duplicate = (_a = options.duplicate) != null ? _a : false;
+  return options;
+}
+function createParseState(options) {
+  var _a, _b;
+  return {
+    pos: 0,
+    reviver: options.reviver,
+    tolerant: (_a = options.tolerant) != null ? _a : false,
+    duplicate: (_b = options.duplicate) != null ? _b : false,
+    warnings: []
+  };
+}
+function parseWithCustomParser(text, options) {
+  const lexerToUse = options.relaxed ? lexer : strictLexer;
+  let tokens = lexerToUse(text);
+  if (options.relaxed) {
+    tokens = stripTrailingComma(tokens);
+  }
+  tokens = tokens.filter((token) => token.type !== " ");
+  const state = createParseState(options);
+  return parseAny(tokens, state, true);
+}
+function parseWithTransform(text, options) {
+  let tokens = lexer(text);
+  tokens = stripTrailingComma(tokens);
+  const newtext = tokens.reduce((str, token) => str + token.match, "");
+  return JSON.parse(
+    newtext,
+    options.reviver
+  );
+}
+function parse(text, optsOrReviver) {
+  const options = normalizeParseOptions(optsOrReviver);
+  if (!(options.relaxed || options.warnings || options.tolerant) && options.duplicate) {
+    return JSON.parse(
+      text,
+      options.reviver
+    );
+  }
+  if (options.warnings || options.tolerant || !options.duplicate) {
+    return parseWithCustomParser(text, options);
+  }
+  return parseWithTransform(text, options);
+}
+function stringifyPair(obj, key) {
+  return `${JSON.stringify(key)}:${stringify(obj[key])}`;
+}
+function stringify(obj) {
+  const type = typeof obj;
+  if (type === "string" || type === "number" || type === "boolean" || obj === null) {
+    return JSON.stringify(obj);
+  }
+  if (type === "undefined") {
+    return "null";
+  }
+  if (Array.isArray(obj)) {
+    const elements = obj.map(stringify).join(",");
+    return `[${elements}]`;
+  }
+  if (type === "object") {
+    const keys = Object.keys(obj);
+    keys.sort();
+    const pairs = keys.map((key) => stringifyPair(obj, key)).join(",");
+    return `{${pairs}}`;
+  }
+  return "null";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parse,
+  stringify,
+  transform
+});
+//# sourceMappingURL=rjson.cjs.map