@visulima/error 5.0.2 → 5.0.4

package/dist/packem_shared/deserializeError-E0VQnnm0.js

@@ -0,0 +1,116 @@
+import { i as isPlainObject } from './index-y_UPkY2Z.js';
+import { isErrorLike, getErrorConstructor } from './addKnownErrorConstructor-s_3SsXtQ.js';
+import NonError from './NonError-D5FGLYKY.js';
+
+const defaultOptions = {
+  maxDepth: Number.POSITIVE_INFINITY
+};
+const deserializePlainObject = (object, options, depth = 0) => {
+  if (isErrorLike(object)) {
+    return reconstructError(object, options, depth);
+  }
+  if (options.maxDepth !== void 0 && depth >= options.maxDepth) {
+    return new NonError(JSON.stringify(object));
+  }
+  return new NonError(JSON.stringify(object));
+};
+const reconstructAggregateError = (Constructor, errors, message, options, depth) => {
+  const reconstructedErrors = errors.map((error_) => deserializeValue(error_, options, depth + 1));
+  return new Constructor(reconstructedErrors, message);
+};
+const reconstructError = (serialized, options, depth) => {
+  if (options.maxDepth !== void 0 && depth >= options.maxDepth) {
+    return new NonError(JSON.stringify(serialized));
+  }
+  const { cause, errors, message, name, stack, ...properties } = serialized;
+  const Constructor = getErrorConstructor(name) || Error;
+  const error = name === "AggregateError" && Array.isArray(errors) ? reconstructAggregateError(Constructor, errors, message, options, depth) : new Constructor(message);
+  if (!error.name && name) {
+    error.name = name;
+  }
+  if (message !== void 0) {
+    error.message = message;
+  }
+  if (stack) {
+    error.stack = stack;
+  }
+  restoreErrorProperties(error, properties, cause, name, options, depth);
+  if (cause !== void 0) {
+    error.cause = deserializeValue(cause, options, depth + 1);
+  }
+  makePropertiesEnumerable(error, serialized);
+  return error;
+};
+const deserializeValue = (value, options, depth) => {
+  if (isPlainObject(value)) {
+    return deserializePlainObject(value, options, depth);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => deserializeValue(item, options, depth));
+  }
+  return value;
+};
+const restoreErrorProperties = (error, properties, cause, name, options, depth) => {
+  const errorCopy = error;
+  for (const [key, value] of Object.entries(properties)) {
+    if (key === "cause" && cause !== void 0) {
+      continue;
+    } else if (key === "errors" && name === "AggregateError") {
+      continue;
+    } else {
+      errorCopy[key] = deserializeValue(value, options, depth + 1);
+    }
+  }
+};
+const makePropertiesEnumerable = (error, serialized) => {
+  const errorProperties = /* @__PURE__ */ new Set();
+  errorProperties.add("name");
+  errorProperties.add("message");
+  errorProperties.add("stack");
+  for (const key of Object.keys(serialized)) {
+    errorProperties.add(key);
+  }
+  for (const key of errorProperties) {
+    if (key in error) {
+      const descriptor = Object.getOwnPropertyDescriptor(error, key);
+      if (descriptor && !descriptor.enumerable) {
+        Object.defineProperty(error, key, {
+          ...descriptor,
+          enumerable: true
+        });
+      }
+    }
+  }
+};
+const handlePrimitive = (value) => new NonError(JSON.stringify(value));
+const handleArray = (value) => new NonError(JSON.stringify(value));
+const handlePlainObject = (value, config) => {
+  if (isErrorLike(value)) {
+    return reconstructError(value, config, 0);
+  }
+  return deserializePlainObject(value, config);
+};
+const deserialize = (value, options = {}) => {
+  const config = { ...defaultOptions, ...options };
+  if (value instanceof Error) {
+    return value;
+  }
+  if (value === null) {
+    return handlePrimitive(null);
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return handlePrimitive(value);
+  }
+  if (Array.isArray(value)) {
+    return handleArray(value);
+  }
+  if (isErrorLike(value)) {
+    return reconstructError(value, config, 0);
+  }
+  if (isPlainObject(value)) {
+    return handlePlainObject(value, config);
+  }
+  return new NonError(JSON.stringify(value));
+};
+
+export { deserialize as default };

package/dist/packem_shared/errorHintFinder-DEaeRnRW.js

@@ -0,0 +1,21 @@
+const errorHintFinder = {
+  handle: async (error) => {
+    if (error.hint === void 0 || error.hint === null) {
+      return void 0;
+    }
+    if (typeof error.hint === "string" && error.hint !== "") {
+      return { body: error.hint };
+    }
+    if (typeof error.hint === "object" && typeof error.hint.body === "string") {
+      return error.hint;
+    }
+    if (Array.isArray(error.hint)) {
+      return { body: error.hint.join("\n") };
+    }
+    return void 0;
+  },
+  name: "errorHint",
+  priority: 1
+};
+
+export { errorHintFinder as default };

package/dist/packem_shared/formatStackFrameLine-D3_6oSWZ.js

@@ -0,0 +1,24 @@
+const formatStackFrameLine = (frame) => {
+  const method = frame.methodName && frame.methodName !== "<unknown>" ? `${frame.methodName} ` : "";
+  const file = frame.file ?? "<unknown>";
+  const line = frame.line ?? 0;
+  const column = frame.column ?? 0;
+  if (method.trim()) {
+    return `    at ${method}(${file}:${line}:${column})`;
+  }
+  return `    at ${file}:${line}:${column}`;
+};
+const formatStacktrace = (frames, options) => {
+  const lines = [];
+  if (options?.header && (options.header.name || options.header.message)) {
+    const headerName = String(options.header.name || "Error");
+    const headerMessage = String(options.header.message || "");
+    lines.push(`${headerName}${headerMessage ? ": " : ""}${headerMessage}`);
+  }
+  for (const frame of frames) {
+    lines.push(formatStackFrameLine(frame));
+  }
+  return lines.join("\n");
+};
+
+export { formatStackFrameLine, formatStacktrace };

package/dist/packem_shared/getErrorCauses-DpUsmuqw.js

@@ -0,0 +1,43 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
+const {
+  inspect
+} = __cjs_getBuiltinModule("node:util");
+
+const getErrorCauses = (error) => {
+  const seen = /* @__PURE__ */ new Set();
+  const causes = [];
+  let currentError = error;
+  while (currentError) {
+    if (seen.has(currentError)) {
+      console.error(`Circular reference detected in error causes: ${inspect(error)}`);
+      break;
+    }
+    causes.push(currentError);
+    seen.add(currentError);
+    if (!currentError.cause) {
+      break;
+    }
+    currentError = currentError.cause;
+  }
+  return causes;
+};
+
+export { getErrorCauses as default };

package/dist/packem_shared/index-y_UPkY2Z.js

@@ -0,0 +1,9 @@
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
+}
+
+export { isPlainObject as i };

package/dist/packem_shared/indexToLineColumn-Bg8UW1bU.js

@@ -0,0 +1,50 @@
+const binarySearch = (element, array) => {
+  let m = 0;
+  let n = array.length - 2;
+  while (m < n) {
+    const key = m + (n - m >> 1);
+    if (element < array[key]) {
+      n = key - 1;
+    } else if (element >= array[key + 1]) {
+      m = key + 1;
+    } else {
+      m = key;
+      break;
+    }
+  }
+  return m;
+};
+const getLineStartIndexes = (string_) => (
+  // eslint-disable-next-line unicorn/no-array-reduce
+  string_.split(/\n|\r(?!\n)/).reduce(
+    (accumulator, current) => {
+      accumulator.push(accumulator.at(-1) + current.length + 1);
+      return accumulator;
+    },
+    [0]
+  )
+);
+const indexToLineColumn = (input, index, options) => {
+  const skipChecks = options?.skipChecks ?? false;
+  if (!skipChecks && (!Array.isArray(input) && typeof input !== "string" || (typeof input === "string" || Array.isArray(input)) && input.length === 0)) {
+    return { column: 0, line: 0 };
+  }
+  if (!skipChecks && (typeof index !== "number" || typeof input === "string" && index >= input.length || Array.isArray(input) && index + 1 >= input.at(-1))) {
+    return { column: 0, line: 0 };
+  }
+  if (typeof input === "string") {
+    const startIndexesOfEachLine = getLineStartIndexes(input);
+    const line2 = binarySearch(index, startIndexesOfEachLine);
+    return {
+      column: index - startIndexesOfEachLine[line2] + 1,
+      line: line2 + 1
+    };
+  }
+  const line = binarySearch(index, input);
+  return {
+    column: index - input[line] + 1,
+    line: line + 1
+  };
+};
+
+export { indexToLineColumn as default };

package/dist/packem_shared/isVisulimaError-DA7QsCxH.js

@@ -0,0 +1,34 @@
+const isVisulimaError = (error) => error instanceof Error && error.type === "VisulimaError";
+class VisulimaError extends Error {
+  loc;
+  title;
+  /**
+   * A message that explains to the user how they can fix the error.
+   */
+  hint;
+  type = "VisulimaError";
+  constructor({ cause, hint, location, message, name, stack, title }) {
+    super(message, {
+      cause
+    });
+    this.title = title;
+    this.name = name;
+    this.stack = stack ?? this.stack;
+    this.loc = location;
+    this.hint = hint;
+  }
+  setLocation(location) {
+    this.loc = location;
+  }
+  setName(name) {
+    this.name = name;
+  }
+  setMessage(message) {
+    this.message = message;
+  }
+  setHint(hint) {
+    this.hint = hint;
+  }
+}
+
+export { VisulimaError, isVisulimaError };

package/dist/packem_shared/parseStacktrace-oQvk7wYp.js

@@ -0,0 +1,273 @@
+const debugLog = (message, ...arguments_) => {
+  if (process.env.DEBUG && String(process.env.DEBUG) === "true") {
+    console.debug(`error:parse-stacktrace: ${message}`, ...arguments_);
+  }
+};
+const UNKNOWN_FUNCTION = "<unknown>";
+const CHROMIUM_REGEX = /^.*?\s*at\s(?:(.+?\)(?:\s\[.+\])?|\(?.*?)\s?\((?:address\sat\s)?)?(?:async\s)?((?:<anonymous>|[-a-z]+:|.*bundle|\/)?.*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i;
+const CHROMIUM_EVAL_REGEX = /\((\S+)\),\s(<[^>]+>)?:(\d+)?:(\d+)?\)?/;
+const CHROMIUM_MAPPED = /(.*?):(\d+):(\d+)(\s<-\s(.+):(\d+):(\d+))?/;
+const WINDOWS_EVAL_REGEX = /(eval)\sat\s(<anonymous>)\s\((.*)\)?:(\d+)?:(\d+)\),\s*(<anonymous>)?:(\d+)?:(\d+)/;
+const NODE_REGEX = /^\s*in\s(?:([^\\/]+(?:\s\[as\s\S+\])?)\s\(?)?\(at?\s?(.*?):(\d+)(?::(\d+))?\)?\s*$/;
+const NODE_NESTED_REGEX = /in\s(.*)\s\(at\s(.+)\)\sat/;
+const REACT_ANDROID_NATIVE_REGEX = /^(?:.*@)?(.*):(\d+):(\d+)$/;
+const GECKO_REGEX = /^\s*(.*?)(?:\((.*?)\))?(?:^|@)?((?:[-a-z]+)?:\/.*?|\[native code\]|[^@]*(?:bundle|\d+\.js)|\/[\w\-. \/=]+)(?::(\d+))?(?::(\d+))?\s*$/i;
+const GECKO_EVAL_REGEX = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i;
+const FIREFOX_REGEX = /(\S[^\s[]*\[.*\]|.*?)@(.*):(\d+):(\d+)/;
+const WEBPACK_ERROR_REGEXP = /\(error: (.*)\)/;
+const extractSafariExtensionDetails = (methodName, url) => {
+  const isSafariExtension = methodName.includes("safari-extension");
+  const isSafariWebExtension = methodName.includes("safari-web-extension");
+  return isSafariExtension || isSafariWebExtension ? [
+    methodName.includes("@") ? methodName.split("@")[0] : UNKNOWN_FUNCTION,
+    isSafariExtension ? `safari-extension:${url}` : `safari-web-extension:${url}`
+  ] : [methodName, url];
+};
+const parseMapped = (trace, maybeMapped) => {
+  const match = CHROMIUM_MAPPED.exec(maybeMapped);
+  if (match) {
+    trace.file = match[1];
+    trace.line = +match[2];
+    trace.column = +match[3];
+  }
+};
+const parseNode = (line) => {
+  const nestedNode = NODE_NESTED_REGEX.exec(line);
+  if (nestedNode) {
+    debugLog(`parse nested node error stack line: "${line}"`, `found: ${JSON.stringify(nestedNode)}`);
+    const split = nestedNode[2].split(":");
+    return {
+      column: split[2] ? +split[2] : void 0,
+      file: split[0],
+      line: split[1] ? +split[1] : void 0,
+      methodName: nestedNode[1] || UNKNOWN_FUNCTION,
+      raw: line,
+      type: void 0
+    };
+  }
+  const node = NODE_REGEX.exec(line);
+  if (node) {
+    debugLog(`parse node error stack line: "${line}"`, `found: ${JSON.stringify(node)}`);
+    const trace = {
+      column: node[4] ? +node[4] : void 0,
+      file: node[2] ? node[2].replace(/at\s/, "") : void 0,
+      line: node[3] ? +node[3] : void 0,
+      methodName: node[1] || UNKNOWN_FUNCTION,
+      raw: line,
+      type: line.startsWith("internal") ? "internal" : void 0
+    };
+    parseMapped(trace, `${node[2]}:${node[3]}:${node[4]}`);
+    return trace;
+  }
+  return void 0;
+};
+const parseChromium = (line) => {
+  const parts = CHROMIUM_REGEX.exec(line);
+  if (parts) {
+    debugLog(`parse chrome error stack line: "${line}"`, `found: ${JSON.stringify(parts)}`);
+    const isNative = parts[2]?.startsWith("native");
+    const isEval = parts[2]?.startsWith("eval") || parts[1]?.startsWith("eval");
+    let evalOrigin;
+    let windowsParts;
+    if (isEval) {
+      const subMatch = CHROMIUM_EVAL_REGEX.exec(line);
+      if (subMatch) {
+        const split = /^(\S+):(\d+):(\d+)$|^(\S+):(\d+)$/.exec(subMatch[1]);
+        if (split) {
+          parts[2] = split[4] ?? split[1];
+          parts[3] = split[5] ?? split[2];
+          parts[4] = split[3];
+        } else if (subMatch[2]) {
+          parts[2] = subMatch[1];
+        }
+        if (subMatch[2]) {
+          evalOrigin = {
+            column: subMatch[4] ? +subMatch[4] : void 0,
+            file: subMatch[2],
+            line: subMatch[3] ? +subMatch[3] : void 0,
+            methodName: "eval",
+            raw: line,
+            type: "eval"
+          };
+        }
+      } else {
+        const windowsSubMatch = WINDOWS_EVAL_REGEX.exec(line);
+        if (windowsSubMatch) {
+          windowsParts = {
+            column: windowsSubMatch[5] ? +windowsSubMatch[5] : void 0,
+            file: windowsSubMatch[3],
+            line: windowsSubMatch[4] ? +windowsSubMatch[4] : void 0
+          };
+          evalOrigin = {
+            column: windowsSubMatch[8] ? +windowsSubMatch[8] : void 0,
+            file: windowsSubMatch[2],
+            line: windowsSubMatch[7] ? +windowsSubMatch[7] : void 0,
+            methodName: "eval",
+            raw: windowsSubMatch[0],
+            type: "eval"
+          };
+        }
+      }
+    }
+    const [methodName, file] = extractSafariExtensionDetails(
+      // Normalize IE's 'Anonymous function'
+      parts[1] ? parts[1].replace(/^Anonymous function$/, "<anonymous>") : UNKNOWN_FUNCTION,
+      parts[2]
+    );
+    const trace = {
+      column: parts[4] ? +parts[4] : void 0,
+      evalOrigin,
+      file,
+      line: parts[3] ? +parts[3] : void 0,
+      methodName,
+      raw: line,
+      // eslint-disable-next-line sonarjs/no-nested-conditional
+      type: isEval ? "eval" : isNative ? "native" : void 0
+    };
+    if (windowsParts) {
+      trace.column = windowsParts.column;
+      trace.file = windowsParts.file;
+      trace.line = windowsParts.line;
+    } else {
+      parseMapped(trace, `${file}:${parts[3]}:${parts[4]}`);
+    }
+    return trace;
+  }
+  return void 0;
+};
+const parseGecko = (line, topFrameMeta) => {
+  const parts = GECKO_REGEX.exec(line);
+  if (parts) {
+    debugLog(`parse gecko error stack line: "${line}"`, `found: ${JSON.stringify(parts)}`);
+    const isEval = parts[3]?.includes(" > eval");
+    const subMatch = isEval && parts[3] && GECKO_EVAL_REGEX.exec(parts[3]);
+    let evalOrigin;
+    if (isEval && subMatch) {
+      parts[3] = subMatch[1];
+      evalOrigin = {
+        column: parts[5] ? +parts[5] : void 0,
+        file: parts[3],
+        line: parts[4] ? +parts[4] : void 0,
+        methodName: "eval",
+        raw: line,
+        type: "eval"
+      };
+      parts[4] = subMatch[2];
+    }
+    const [methodName, file] = extractSafariExtensionDetails(
+      // Normalize IE's 'Anonymous function'
+      parts[1] ? parts[1].replace(/^Anonymous function$/, "<anonymous>") : UNKNOWN_FUNCTION,
+      parts[3]
+    );
+    let column;
+    if ((topFrameMeta?.type === "safari" || !isEval && topFrameMeta?.type === "firefox") && topFrameMeta.column) {
+      column = topFrameMeta.column;
+    } else if (!isEval && parts[5]) {
+      column = +parts[5];
+    }
+    let lineNumber;
+    if ((topFrameMeta?.type === "safari" || !isEval && topFrameMeta?.type === "firefox") && topFrameMeta.line) {
+      lineNumber = topFrameMeta.line;
+    } else if (parts[4]) {
+      lineNumber = +parts[4];
+    }
+    return {
+      column,
+      evalOrigin,
+      file,
+      line: lineNumber,
+      methodName,
+      raw: line,
+      // eslint-disable-next-line sonarjs/no-nested-conditional
+      type: isEval ? "eval" : file.includes("[native code]") ? "native" : void 0
+    };
+  }
+  return void 0;
+};
+const parseFirefox = (line, topFrameMeta) => {
+  const parts = FIREFOX_REGEX.exec(line);
+  const isEval = parts ? parts[2].includes(" > eval") : false;
+  if (!isEval && parts) {
+    debugLog(`parse firefox error stack line: "${line}"`, `found: ${JSON.stringify(parts)}`);
+    return {
+      column: parts[4] ? +parts[4] : topFrameMeta?.column ?? void 0,
+      file: parts[2],
+      line: parts[3] ? +parts[3] : topFrameMeta?.line ?? void 0,
+      methodName: parts[1] || UNKNOWN_FUNCTION,
+      raw: line,
+      type: void 0
+    };
+  }
+  return void 0;
+};
+const parseReactAndroidNative = (line) => {
+  const parts = REACT_ANDROID_NATIVE_REGEX.exec(line);
+  if (parts) {
+    debugLog(`parse react android native error stack line: "${line}"`, `found: ${JSON.stringify(parts)}`);
+    return {
+      column: parts[3] ? +parts[3] : void 0,
+      file: parts[1],
+      line: parts[2] ? +parts[2] : void 0,
+      methodName: UNKNOWN_FUNCTION,
+      raw: line,
+      type: void 0
+    };
+  }
+  return void 0;
+};
+const parseStacktrace = (error, { filter, frameLimit = 50 } = {}) => {
+  let lines = (error.stacktrace ?? error.stack ?? "").split("\n").map((line) => {
+    const cleanedLine = WEBPACK_ERROR_REGEXP.test(line) ? line.replace(WEBPACK_ERROR_REGEXP, "$1") : line;
+    return cleanedLine.replace(/^\s+|\s+$/g, "");
+  }).filter((line) => !/\S*(?:Error: |AggregateError:)/.test(line) && line !== "eval code");
+  if (filter) {
+    lines = lines.filter((element) => filter(element));
+  }
+  lines = lines.slice(0, frameLimit);
+  return lines.reduce((stack, line, currentIndex) => {
+    if (!line) {
+      return stack;
+    }
+    if (line.length > 1024) {
+      return stack;
+    }
+    let parseResult;
+    if (/^\s*in\s.*/.test(line)) {
+      parseResult = parseNode(line);
+    } else if (/^.*?\s*at\s.*/.test(line)) {
+      parseResult = parseChromium(line);
+    } else if (/^.*?\s*@.*|\[native code\]/.test(line)) {
+      let topFrameMeta;
+      if (currentIndex === 0) {
+        if (error.columnNumber || error.lineNumber) {
+          topFrameMeta = {
+            // @ts-expect-error columnNumber and columnNumber property only exists on Firefox
+            column: error.columnNumber,
+            // @ts-expect-error columnNumber and lineNumber property only exists on Firefox
+            line: error.lineNumber,
+            type: "firefox"
+          };
+        } else if (error.line || error.column) {
+          topFrameMeta = {
+            // @ts-expect-error column property only exists on safari
+            column: error.column,
+            // @ts-expect-error line property only exists on safari
+            line: error.line,
+            type: "safari"
+          };
+        }
+      }
+      parseResult = parseFirefox(line, topFrameMeta) || parseGecko(line, topFrameMeta);
+    } else {
+      parseResult = parseReactAndroidNative(line);
+    }
+    if (parseResult) {
+      stack.push(parseResult);
+    } else {
+      debugLog(`parse error stack line: "${line}"`, "not parser found");
+    }
+    return stack;
+  }, []);
+};
+
+export { parseStacktrace as default };