@visulima/pail 3.2.2 → 4.0.0-alpha.10

package/dist/processor/message-formatter-processor.js

@@ -1,4 +1,651 @@
-import { b as build } from '../packem_shared/index-BomQ3E6J.js';
+const colorKeywords = /* @__PURE__ */ new Map([
+  ["aliceblue", "#f0f8ff"],
+  ["antiquewhite", "#faebd7"],
+  ["aqua", "#00ffff"],
+  ["aquamarine", "#7fffd4"],
+  ["azure", "#f0ffff"],
+  ["beige", "#f5f5dc"],
+  ["bisque", "#ffe4c4"],
+  ["black", "#000000"],
+  ["blanchedalmond", "#ffebcd"],
+  ["blue", "#0000ff"],
+  ["blueviolet", "#8a2be2"],
+  ["brown", "#a52a2a"],
+  ["burlywood", "#deb887"],
+  ["cadetblue", "#5f9ea0"],
+  ["chartreuse", "#7fff00"],
+  ["chocolate", "#d2691e"],
+  ["coral", "#ff7f50"],
+  ["cornflowerblue", "#6495ed"],
+  ["cornsilk", "#fff8dc"],
+  ["crimson", "#dc143c"],
+  ["cyan", "#00ffff"],
+  ["darkblue", "#00008b"],
+  ["darkcyan", "#008b8b"],
+  ["darkgoldenrod", "#b8860b"],
+  ["darkgray", "#a9a9a9"],
+  ["darkgreen", "#006400"],
+  ["darkgrey", "#a9a9a9"],
+  ["darkkhaki", "#bdb76b"],
+  ["darkmagenta", "#8b008b"],
+  ["darkolivegreen", "#556b2f"],
+  ["darkorange", "#ff8c00"],
+  ["darkorchid", "#9932cc"],
+  ["darkred", "#8b0000"],
+  ["darksalmon", "#e9967a"],
+  ["darkseagreen", "#8fbc8f"],
+  ["darkslateblue", "#483d8b"],
+  ["darkslategray", "#2f4f4f"],
+  ["darkslategrey", "#2f4f4f"],
+  ["darkturquoise", "#00ced1"],
+  ["darkviolet", "#9400d3"],
+  ["deeppink", "#ff1493"],
+  ["deepskyblue", "#00bfff"],
+  ["dimgray", "#696969"],
+  ["dimgrey", "#696969"],
+  ["dodgerblue", "#1e90ff"],
+  ["firebrick", "#b22222"],
+  ["floralwhite", "#fffaf0"],
+  ["forestgreen", "#228b22"],
+  ["fuchsia", "#ff00ff"],
+  ["gainsboro", "#dcdcdc"],
+  ["ghostwhite", "#f8f8ff"],
+  ["gold", "#ffd700"],
+  ["goldenrod", "#daa520"],
+  ["gray", "#808080"],
+  ["green", "#008000"],
+  ["greenyellow", "#adff2f"],
+  ["grey", "#808080"],
+  ["honeydew", "#f0fff0"],
+  ["hotpink", "#ff69b4"],
+  ["indianred", "#cd5c5c"],
+  ["indigo", "#4b0082"],
+  ["ivory", "#fffff0"],
+  ["khaki", "#f0e68c"],
+  ["lavender", "#e6e6fa"],
+  ["lavenderblush", "#fff0f5"],
+  ["lawngreen", "#7cfc00"],
+  ["lemonchiffon", "#fffacd"],
+  ["lightblue", "#add8e6"],
+  ["lightcoral", "#f08080"],
+  ["lightcyan", "#e0ffff"],
+  ["lightgoldenrodyellow", "#fafad2"],
+  ["lightgray", "#d3d3d3"],
+  ["lightgreen", "#90ee90"],
+  ["lightgrey", "#d3d3d3"],
+  ["lightpink", "#ffb6c1"],
+  ["lightsalmon", "#ffa07a"],
+  ["lightseagreen", "#20b2aa"],
+  ["lightskyblue", "#87cefa"],
+  ["lightslategray", "#778899"],
+  ["lightslategrey", "#778899"],
+  ["lightsteelblue", "#b0c4de"],
+  ["lightyellow", "#ffffe0"],
+  ["lime", "#00ff00"],
+  ["limegreen", "#32cd32"],
+  ["linen", "#faf0e6"],
+  ["magenta", "#ff00ff"],
+  ["maroon", "#800000"],
+  ["mediumaquamarine", "#66cdaa"],
+  ["mediumblue", "#0000cd"],
+  ["mediumorchid", "#ba55d3"],
+  ["mediumpurple", "#9370db"],
+  ["mediumseagreen", "#3cb371"],
+  ["mediumslateblue", "#7b68ee"],
+  ["mediumspringgreen", "#00fa9a"],
+  ["mediumturquoise", "#48d1cc"],
+  ["mediumvioletred", "#c71585"],
+  ["midnightblue", "#191970"],
+  ["mintcream", "#f5fffa"],
+  ["mistyrose", "#ffe4e1"],
+  ["moccasin", "#ffe4b5"],
+  ["navajowhite", "#ffdead"],
+  ["navy", "#000080"],
+  ["oldlace", "#fdf5e6"],
+  ["olive", "#808000"],
+  ["olivedrab", "#6b8e23"],
+  ["orange", "#ffa500"],
+  ["orangered", "#ff4500"],
+  ["orchid", "#da70d6"],
+  ["palegoldenrod", "#eee8aa"],
+  ["palegreen", "#98fb98"],
+  ["paleturquoise", "#afeeee"],
+  ["palevioletred", "#db7093"],
+  ["papayawhip", "#ffefd5"],
+  ["peachpuff", "#ffdab9"],
+  ["peru", "#cd853f"],
+  ["pink", "#ffc0cb"],
+  ["plum", "#dda0dd"],
+  ["powderblue", "#b0e0e6"],
+  ["purple", "#800080"],
+  ["rebeccapurple", "#663399"],
+  ["red", "#ff0000"],
+  ["rosybrown", "#bc8f8f"],
+  ["royalblue", "#4169e1"],
+  ["saddlebrown", "#8b4513"],
+  ["salmon", "#fa8072"],
+  ["sandybrown", "#f4a460"],
+  ["seagreen", "#2e8b57"],
+  ["seashell", "#fff5ee"],
+  ["sienna", "#a0522d"],
+  ["silver", "#c0c0c0"],
+  ["skyblue", "#87ceeb"],
+  ["slateblue", "#6a5acd"],
+  ["slategray", "#708090"],
+  ["slategrey", "#708090"],
+  ["snow", "#fffafa"],
+  ["springgreen", "#00ff7f"],
+  ["steelblue", "#4682b4"],
+  ["tan", "#d2b48c"],
+  ["teal", "#008080"],
+  ["thistle", "#d8bfd8"],
+  ["tomato", "#ff6347"],
+  ["turquoise", "#40e0d0"],
+  ["violet", "#ee82ee"],
+  ["wheat", "#f5deb3"],
+  ["white", "#ffffff"],
+  ["whitesmoke", "#f5f5f5"],
+  ["yellow", "#ffff00"],
+  ["yellowgreen", "#9acd32"]
+]);
+const HASH_PATTERN = /^#([\dA-F]{2})([\dA-F]{2})([\dA-F]{2})([\dA-F]{2})?$/i;
+const SMALL_HASH_PATTERN = /^#([\dA-F])([\dA-F])([\dA-F])([\dA-F])?$/i;
+const RGB_PATTERN = /^rgba?\(\s*([+-]?(?:\d+(?:\.\d+)?|\.\d+))\s*,\s*([+-]?(?:\d+(?:\.\d+)?|\.\d+))\s*,\s*([+-]?(?:\d+(?:\.\d+)?|\.\d+))\s*(,\s*([+-]?(?:\d+(?:\.\d+)?|\.\d+))\s*)?\)$/;
+const HSL_PATTERN = /^hsla?\(\s*([+-]?(?:\d+(?:\.\d+)?|\.\d+))\s*,\s*([+-]?(?:\d+(?:\.\d+)?|\.\d+))%\s*,\s*([+-]?(?:\d+(?:\.\d+)?|\.\d+))%\s*(,\s*([+-]?(?:\d+(?:\.\d+)?|\.\d+))\s*)?\)$/;
+const getDefaultCss = () => {
+  return {
+    __proto__: null,
+    backgroundColor: null,
+    color: null,
+    fontStyle: null,
+    fontWeight: null,
+    textDecorationColor: null,
+    textDecorationLine: []
+  };
+};
+const SPACE_PATTERN = /\s+/;
+const parseCssColor = (colorString) => {
+  if (colorKeywords.has(colorString)) {
+    colorString = colorKeywords.get(colorString);
+  }
+  const hashMatch = HASH_PATTERN.exec(colorString);
+  if (hashMatch) {
+    return [Number.parseInt(hashMatch[1], 16), Number.parseInt(hashMatch[2], 16), Number.parseInt(hashMatch[3], 16)];
+  }
+  const smallHashMatch = SMALL_HASH_PATTERN.exec(colorString);
+  if (smallHashMatch) {
+    return [
+      Number.parseInt(`${smallHashMatch[1]}${smallHashMatch[1]}`, 16),
+      Number.parseInt(`${smallHashMatch[2]}${smallHashMatch[2]}`, 16),
+      Number.parseInt(`${smallHashMatch[3]}${smallHashMatch[3]}`, 16)
+    ];
+  }
+  const rgbMatch = RGB_PATTERN.exec(colorString);
+  if (rgbMatch) {
+    return [
+      Math.round(Math.max(0, Math.min(255, Number(rgbMatch[1])))),
+      Math.round(Math.max(0, Math.min(255, Number(rgbMatch[2])))),
+      Math.round(Math.max(0, Math.min(255, Number(rgbMatch[3]))))
+    ];
+  }
+  const hslMatch = HSL_PATTERN.exec(colorString);
+  if (hslMatch) {
+    let h = Number(hslMatch[1]) % 360;
+    if (h < 0) {
+      h += 360;
+    }
+    const s = Math.max(0, Math.min(100, Number(hslMatch[2]))) / 100;
+    const l = Math.max(0, Math.min(100, Number(hslMatch[3]))) / 100;
+    const c = (1 - Math.abs(2 * l - 1)) * s;
+    const x = c * (1 - Math.abs(h / 60 % 2 - 1));
+    const m = l - c / 2;
+    let r_;
+    let g_;
+    let b_;
+    if (h < 60) {
+      ({ 0: r_, 1: g_, 2: b_ } = [c, x, 0]);
+    } else if (h < 120) {
+      ({ 0: r_, 1: g_, 2: b_ } = [x, c, 0]);
+    } else if (h < 180) {
+      ({ 0: r_, 1: g_, 2: b_ } = [0, c, x]);
+    } else if (h < 240) {
+      ({ 0: r_, 1: g_, 2: b_ } = [0, x, c]);
+    } else if (h < 300) {
+      ({ 0: r_, 1: g_, 2: b_ } = [x, 0, c]);
+    } else {
+      ({ 0: r_, 1: g_, 2: b_ } = [c, 0, x]);
+    }
+    return [Math.round((r_ + m) * 255), Math.round((g_ + m) * 255), Math.round((b_ + m) * 255)];
+  }
+  return null;
+};
+const colorEquals = (color1, color2) => color1?.[0] === color2?.[0] && color1?.[1] === color2?.[1] && color1?.[2] === color2?.[2];
+const parseCss = (cssString) => {
+  const css = getDefaultCss();
+  const rawEntries = [];
+  let inValue = false;
+  let currentKey = null;
+  let parenthesesDepth = 0;
+  let currentPart = "";
+  for (const c of cssString) {
+    if (c === "(") {
+      parenthesesDepth += 1;
+    } else if (parenthesesDepth > 0) {
+      if (c === ")") {
+        parenthesesDepth -= 1;
+      }
+    } else if (inValue) {
+      if (c === ";") {
+        const value = currentPart.trim();
+        if (value !== "") {
+          rawEntries.push([currentKey, value]);
+        }
+        currentKey = null;
+        currentPart = "";
+        inValue = false;
+        continue;
+      }
+    } else if (c === ":") {
+      currentKey = currentPart.trim();
+      currentPart = "";
+      inValue = true;
+      continue;
+    }
+    currentPart += c;
+  }
+  if (inValue && parenthesesDepth === 0) {
+    const value = currentPart.trim();
+    if (value !== "") {
+      rawEntries.push([currentKey, value]);
+    }
+    currentKey = null;
+    currentPart = "";
+  }
+  for (const { 0: key, 1: value } of rawEntries) {
+    switch (key) {
+      case "background-color": {
+        if (value != void 0) {
+          css.backgroundColor = value;
+        }
+        break;
+      }
+      case "color": {
+        if (value != void 0) {
+          css.color = value;
+        }
+        break;
+      }
+      case "font-style": {
+        if (["italic", "oblique", "oblique 14deg"].includes(value)) {
+          css.fontStyle = "italic";
+        }
+        break;
+      }
+      case "font-weight": {
+        if (value === "bold") {
+          css.fontWeight = value;
+        }
+        break;
+      }
+      case "text-decoration": {
+        css.textDecorationColor = null;
+        css.textDecorationLine = [];
+        const arguments_ = value.split(SPACE_PATTERN);
+        for (const argument of arguments_) {
+          const maybeColor = parseCssColor(argument);
+          if (maybeColor != void 0) {
+            css.textDecorationColor = maybeColor;
+          } else if (["line-through", "overline", "underline"].includes(argument)) {
+            css.textDecorationLine.push(argument);
+          }
+        }
+        break;
+      }
+      case "text-decoration-color": {
+        const color = parseCssColor(value);
+        if (color != void 0) {
+          css.textDecorationColor = color;
+        }
+        break;
+      }
+      case "text-decoration-line": {
+        css.textDecorationLine = [];
+        const lineTypes = value.split(SPACE_PATTERN);
+        for (const lineType of lineTypes) {
+          if (["line-through", "overline", "underline"].includes(lineType)) {
+            css.textDecorationLine.push(lineType);
+          }
+        }
+        break;
+      }
+    }
+  }
+  return css;
+};
+const cssToAnsi = (css, previousCss = null) => {
+  previousCss = previousCss ?? getDefaultCss();
+  let ansi = "";
+  if (!colorEquals(css.backgroundColor, previousCss.backgroundColor)) {
+    if (css.backgroundColor == void 0) {
+      ansi += "\x1B[49m";
+    } else {
+      switch (css.backgroundColor) {
+        case "black": {
+          ansi += "\x1B[40m";
+          break;
+        }
+        case "blue": {
+          ansi += "\x1B[44m";
+          break;
+        }
+        case "cyan": {
+          ansi += "\x1B[46m";
+          break;
+        }
+        case "green": {
+          ansi += "\x1B[42m";
+          break;
+        }
+        case "magenta": {
+          ansi += "\x1B[45m";
+          break;
+        }
+        case "red": {
+          ansi += "\x1B[41m";
+          break;
+        }
+        case "white": {
+          ansi += "\x1B[47m";
+          break;
+        }
+        case "yellow": {
+          ansi += "\x1B[43m";
+          break;
+        }
+        default: {
+          if (Array.isArray(css.backgroundColor)) {
+            const { 0: r, 1: g, 2: b } = css.backgroundColor;
+            ansi += `\x1B[48;2;${String(r)};${String(g)};${String(b)}m`;
+          } else {
+            const parsed = parseCssColor(css.backgroundColor);
+            if (parsed === null) {
+              ansi += "\x1B[49m";
+            } else {
+              const { 0: r, 1: g, 2: b } = parsed;
+              ansi += `\x1B[48;2;${String(r)};${String(g)};${String(b)}m`;
+            }
+          }
+        }
+      }
+    }
+  }
+  if (!colorEquals(css.color, previousCss.color)) {
+    if (css.color == void 0) {
+      ansi += "\x1B[39m";
+    } else {
+      switch (css.color) {
+        case "black": {
+          ansi += "\x1B[30m";
+          break;
+        }
+        case "blue": {
+          ansi += "\x1B[34m";
+          break;
+        }
+        case "cyan": {
+          ansi += "\x1B[36m";
+          break;
+        }
+        case "green": {
+          ansi += "\x1B[32m";
+          break;
+        }
+        case "magenta": {
+          ansi += "\x1B[35m";
+          break;
+        }
+        case "red": {
+          ansi += "\x1B[31m";
+          break;
+        }
+        case "white": {
+          ansi += "\x1B[37m";
+          break;
+        }
+        case "yellow": {
+          ansi += "\x1B[33m";
+          break;
+        }
+        default: {
+          if (Array.isArray(css.color)) {
+            const { 0: r, 1: g, 2: b } = css.color;
+            ansi += `\x1B[38;2;${String(r)};${String(g)};${String(b)}m`;
+          } else {
+            const parsed = parseCssColor(css.color);
+            if (parsed === null) {
+              ansi += "\x1B[39m";
+            } else {
+              const { 0: r, 1: g, 2: b } = parsed;
+              ansi += `\x1B[38;2;${String(r)};${String(g)};${String(b)}m`;
+            }
+          }
+        }
+      }
+    }
+  }
+  if (css.fontWeight !== previousCss.fontWeight) {
+    ansi += css.fontWeight === "bold" ? "\x1B[1m" : "\x1B[22m";
+  }
+  if (css.fontStyle !== previousCss.fontStyle) {
+    ansi += css.fontStyle === "italic" ? "\x1B[3m" : "\x1B[23m";
+  }
+  if (!colorEquals(css.textDecorationColor, previousCss.textDecorationColor)) {
+    if (css.textDecorationColor == void 0) {
+      ansi += "\x1B[59m";
+    } else {
+      const { 0: r, 1: g, 2: b } = css.textDecorationColor;
+      ansi += `\x1B[58;2;${String(r)};${String(g)};${String(b)}m`;
+    }
+  }
+  if (css.textDecorationLine.includes("line-through") !== previousCss.textDecorationLine.includes("line-through")) {
+    ansi += css.textDecorationLine.includes("line-through") ? "\x1B[9m" : "\x1B[29m";
+  }
+  if (css.textDecorationLine.includes("overline") !== previousCss.textDecorationLine.includes("overline")) {
+    ansi += css.textDecorationLine.includes("overline") ? "\x1B[53m" : "\x1B[55m";
+  }
+  if (css.textDecorationLine.includes("underline") !== previousCss.textDecorationLine.includes("underline")) {
+    ansi += css.textDecorationLine.includes("underline") ? "\x1B[4m" : "\x1B[24m";
+  }
+  return ansi;
+};
+const tryStringify = (o) => {
+  try {
+    return JSON.stringify(o);
+  } catch {
+    return '"[Circular]"';
+  }
+};
+const CHAR_PERCENT = "%".codePointAt(0);
+const CHAR_s = "s".codePointAt(0);
+const CHAR_d = "d".codePointAt(0);
+const CHAR_f = "f".codePointAt(0);
+const CHAR_i = "i".codePointAt(0);
+const CHAR_O = "O".codePointAt(0);
+const CHAR_o = "o".codePointAt(0);
+const CHAR_j = "j".codePointAt(0);
+const CHAR_c = "c".codePointAt(0);
+const format = (fmt, arguments_ = [], options = {}) => {
+  if (typeof fmt !== "string" && typeof fmt !== "object" || fmt === null) {
+    throw new TypeError(`fmt must be a string or object, got ${fmt === null ? "null" : typeof fmt}`);
+  }
+  const stringify = options.stringify ?? tryStringify;
+  const offset = 1;
+  if (typeof fmt === "object") {
+    const argumentsLength = arguments_.length + offset;
+    if (argumentsLength === 1) {
+      return "{}";
+    }
+    const objects = Array.from({ length: argumentsLength });
+    objects[0] = stringify(fmt);
+    for (let index = 1; index < argumentsLength; index += 1) {
+      objects[index] = stringify(arguments_[index - offset]);
+    }
+    return objects.join(" ");
+  }
+  if (arguments_.length === 0) {
+    return fmt;
+  }
+  let result = "";
+  let a = 1 - offset;
+  let lastPosition = -1;
+  let usedStyle = false;
+  let previousCss = null;
+  for (let index = 0; index < fmt.length; ) {
+    if (fmt.codePointAt(index) === CHAR_PERCENT && index + 1 < fmt.length) {
+      lastPosition = lastPosition > -1 ? lastPosition : 0;
+      const c = fmt.codePointAt(index + 1);
+      if (c === void 0) {
+        a += 1;
+        break;
+      }
+      switch (c) {
+        case CHAR_c: {
+          if (globalThis.window === void 0) {
+            const css = parseCss(arguments_[a]);
+            if (lastPosition < index) {
+              result += fmt.slice(lastPosition, index);
+            }
+            result += cssToAnsi(css, previousCss);
+            if (result !== "") {
+              usedStyle = true;
+              previousCss = css;
+            }
+          }
+          lastPosition = index + 2;
+          index += 1;
+          break;
+        }
+        case CHAR_d:
+        case CHAR_f: {
+          if (a >= arguments_.length || arguments_[a] == void 0) {
+            break;
+          }
+          if (lastPosition < index) {
+            result += fmt.slice(lastPosition, index);
+          }
+          result += Number(arguments_[a]).toString();
+          lastPosition = index + 2;
+          index += 1;
+          break;
+        }
+        case CHAR_i: {
+          if (a >= arguments_.length || arguments_[a] == void 0) {
+            break;
+          }
+          if (lastPosition < index) {
+            result += fmt.slice(lastPosition, index);
+          }
+          result += Math.floor(Number(arguments_[a])).toString();
+          lastPosition = index + 2;
+          index += 1;
+          break;
+        }
+        case CHAR_j:
+        case CHAR_O:
+        case CHAR_o: {
+          if (a >= arguments_.length || arguments_[a] === void 0) {
+            break;
+          }
+          if (lastPosition < index) {
+            result += fmt.slice(lastPosition, index);
+          }
+          const temporaryArgument = arguments_[a];
+          const type = typeof temporaryArgument;
+          if (type === "string") {
+            result += `'${temporaryArgument}'`;
+            lastPosition = index + 2;
+            break;
+          }
+          if (type === "function") {
+            result += temporaryArgument.name ? `[Function: ${temporaryArgument.name}]` : "[Function: <anonymous>]";
+            lastPosition = index + 2;
+            break;
+          }
+          result += stringify(temporaryArgument);
+          lastPosition = index + 2;
+          index += 1;
+          break;
+        }
+        case CHAR_PERCENT: {
+          if (lastPosition < index) {
+            result += fmt.slice(lastPosition, index);
+          }
+          result += "%";
+          lastPosition = index + 2;
+          index += 1;
+          a -= 1;
+          break;
+        }
+        case CHAR_s: {
+          if (a >= arguments_.length) {
+            break;
+          }
+          if (lastPosition < index) {
+            result += fmt.slice(lastPosition, index);
+          }
+          result += typeof arguments_[a] === "object" ? stringify(arguments_[a]) : String(arguments_[a]);
+          lastPosition = index + 2;
+          index += 1;
+          break;
+        }
+        default: {
+          if (typeof options.formatters?.[c] === "function") {
+            if (lastPosition < index) {
+              result += fmt.slice(lastPosition, index);
+            }
+            result += options.formatters[c](arguments_[a]);
+            lastPosition = index + 2;
+            index += 1;
+          }
+        }
+      }
+      a += 1;
+    }
+    index += 1;
+  }
+  if (lastPosition === -1) {
+    return fmt;
+  }
+  if (lastPosition < fmt.length) {
+    result += fmt.slice(lastPosition);
+  }
+  if (usedStyle) {
+    result += "\x1B[0m";
+  }
+  return result;
+};
+const build = (options = {}) => {
+  const formatters = {};
+  if (typeof options.formatters === "object") {
+    Object.entries(options.formatters).forEach(([key, formatterFunction]) => {
+      if (key.length === 0) {
+        throw new Error(`Formatter %${key} has no characters`);
+      }
+      if (key.length > 1) {
+        throw new Error(`Formatter %${key} has more than one character`);
+      }
+      if (typeof formatterFunction !== "function") {
+        throw new TypeError(`Formatter for %${key} is not a function`);
+      }
+      const c = key.codePointAt(0);
+      if (c === void 0) {
+        throw new Error(`${key}.codePointAt(0) failed to return a value, please report this issue`);
+      }
+      formatters[c] = formatterFunction;
+    });
+  }
+  return (f, arguments_ = [], formatOptions = {}) => format(f, arguments_, { ...formatOptions, formatters });
+};
 
 class MessageFormatterProcessor {
   /** Custom stringify function for object serialization */
@@ -17,7 +664,6 @@ class MessageFormatterProcessor {
    * Sets the stringify function for object serialization.
    * @param function_ The stringify function to use for serializing objects
    */
-  // eslint-disable-next-line , @typescript-eslint/no-explicit-any
   setStringify(function_) {
     this.#stringify = function_;
   }
@@ -47,16 +693,18 @@ class MessageFormatterProcessor {
    * @returns The formatted data
    * @private
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   #format(formatter, data, arguments_ = []) {
     if (typeof data === "string") {
       return formatter(data, arguments_);
     }
     if (typeof data === "object" && data !== null) {
-      for (const index in data) {
-        const value = data[index];
+      const record = data;
+      const keys = Object.keys(record);
+      for (let i = 0; i < keys.length; i += 1) {
+        const index = keys[i];
+        const value = record[index];
         if (typeof value === "string" || Array.isArray(value) || typeof value === "object") {
-          data[index] = this.#format(formatter, value, arguments_);
+          record[index] = this.#format(formatter, value, arguments_);
         }
       }
     }

package/dist/processor/opentelemetry-processor.js

@@ -14,9 +14,9 @@ class OpenTelemetryProcessor {
    * @param options Configuration options for field names and nesting
    */
   constructor(options = {}) {
-    this.#traceIdField = options.traceIdFieldName || "trace_id";
-    this.#spanIdField = options.spanIdFieldName || "span_id";
-    this.#traceFlagsField = options.traceFlagsFieldName || "trace_flags";
+    this.#traceIdField = options.traceIdFieldName ?? "trace_id";
+    this.#spanIdField = options.spanIdFieldName ?? "span_id";
+    this.#traceFlagsField = options.traceFlagsFieldName ?? "trace_flags";
     this.#traceFieldName = options.traceFieldName;
   }
   /**
@@ -44,7 +44,7 @@ class OpenTelemetryProcessor {
     const traceData = this.#traceFieldName ? {
       [this.#traceFieldName]: fields
     } : fields;
-    meta.context = [...meta.context || [], traceData];
+    meta.context = [...meta.context ?? [], traceData];
     return meta;
   }
 }