The Monitor

--- +++ @@ -1,2 +1,2 @@-/*! Axios v1.18.1 Copyright (c) 2026 Matt Zabriskie and contributors */+/*! Axios v1.19.0 Copyright (c) 2026 Matt Zabriskie and contributors */ 'use strict';@@ -296,2 +296,3 @@ const isFileList = kindOfTest('FileList');+const isSet = kindOfTest('Set'); @@ -861,8 +862,19 @@         visited.add(source);-        const target = isArray(source) ? [] : {};--        forEach(source, (value, key) => {-          const reducedValue = visit(value);-          !isUndefined(reducedValue) && (target[key] = reducedValue);-        });++        let target;++        if (isSet(source)) {+          target = [];+          for (const value of source) {+            const reducedValue = visit(value);+            !isUndefined(reducedValue) && target.push(reducedValue);+          }+        } else {+          target = isArray(source) ? [] : {};++          forEach(source, (value, key) => {+            const reducedValue = visit(value);+            !isUndefined(reducedValue) && (target[key] = reducedValue);+          });+        } @@ -1078,3 +1090,5 @@ -      if (!key || (parsed[key] && ignoreDuplicateOf[key])) {+      const hasKey = utils$1.hasOwnProp(parsed, key);++      if (!key || (hasKey && utils$1.hasOwnProp(ignoreDuplicateOf, key))) {         return;@@ -1083,3 +1097,3 @@       if (key === 'set-cookie') {-        if (parsed[key]) {+        if (hasKey) {           parsed[key].push(val);@@ -1089,3 +1103,3 @@       } else {-        parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;+        parsed[key] = hasKey ? parsed[key] + ', ' + val : val;       }@@ -1177,2 +1191,120 @@   return tokens;+}++const parameterNameRE = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;++function trimOWS(value) {+  let start = 0;+  let end = value.length;++  while (start < end) {+    const code = value.charCodeAt(start);++    if (code !== 0x09 && code !== 0x20) {+      break;+    }++    start += 1;+  }++  while (end > start) {+    const code = value.charCodeAt(end - 1);++    if (code !== 0x09 && code !== 0x20) {+      break;+    }++    end -= 1;+  }++  return start === 0 && end === value.length ? value : value.slice(start, end);+}++function decodeQuotedString(value) {+  const last = value.length - 1;++  if (last < 1 || value.charCodeAt(0) !== 0x22 || value.charCodeAt(last) !== 0x22) {+    return value;+  }++  let decoded = '';++  for (let i = 1; i < last; i++) {+    const code = value.charCodeAt(i);++    if (code === 0x22) {+      return value;+    }++    if (code === 0x5c) {+      i += 1;++      if (i >= last) {+        return value;+      }+    }++    decoded += value[i];+  }++  return decoded;+}++function parseParameters(value) {+  const parameters = Object.create(null);+  const str = String(value);+  let start = 0;+  let quoted = false;+  let escaped = false;++  function parseParameter(end) {+    const part = trimOWS(str.slice(start, end));+    const equals = part.indexOf('=');++    if (equals < 1) {+      return;+    }++    const name = trimOWS(part.slice(0, equals));++    if (!parameterNameRE.test(name)) {+      return;+    }++    const normalizedName = name.toLowerCase();++    if (+      normalizedName === '__proto__' ||+      normalizedName === 'constructor' ||+      normalizedName === 'prototype'+    ) {+      return;+    }++    const parameterValue = trimOWS(part.slice(equals + 1));+    parameters[normalizedName] = decodeQuotedString(parameterValue);+  }++  for (let i = 0; i < str.length; i++) {+    const code = str.charCodeAt(i);++    if (quoted) {+      if (escaped) {+        escaped = false;+      } else if (code === 0x5c) {+        escaped = true;+      } else if (code === 0x22) {+        quoted = false;+      }+    } else if (code === 0x22) {+      quoted = true;+    } else if (code === 0x2c || code === 0x3b) {+      parseParameter(i);+      start = i + 1;+    }+  }++  parseParameter(str.length);++  return parameters; }@@ -1430,3 +1562,4 @@   getSetCookie() {-    return this.get('set-cookie') || [];+    const value = this.get('set-cookie');+    return utils$1.isArray(value) ? value : value == null || value === false ? [] : [value];   }@@ -1439,2 +1572,6 @@     return thing instanceof this ? thing : new this(thing);+  }++  static parseParameters(value) {+    return parseParameters(value);   }@@ -1566,5 +1703,36 @@ +function stringifySafely$1(value) {+  try {+    return String(value);+  } catch (err) {+    return '';+  }+}++function aggregateErrorMessage(error) {+  const message = error.errors+    .map((entry) => {+      try {+        return entry && entry.message ? stringifySafely$1(entry.message) : stringifySafely$1(entry);+      } catch (err) {+        return '';+      }+    })+    .filter(Boolean)+    .join('; ');++  return message || error.name || 'AggregateError';+}+ class AxiosError extends Error {   static from(error, code, config, request, response, customProps) {-    const axiosError = new AxiosError(error.message, code || error.code, config, request, response);+    // `AggregateError` (thrown by Node on dual-stack/Happy-Eyeballs connection+    // failures) has an empty `message`; its detail lives in `errors[]`. Without+    // this, the wrapped error surfaces with a blank message (see #6721).+    let message = error.message;+    if (!message && utils$1.isArray(error.errors) && error.errors.length) {+      message = aggregateErrorMessage(error);+    }++    const axiosError = new AxiosError(message, code || error.code, config, request, response);     // Match native `Error` `cause` semantics: non-enumerable. The wrapped@@ -1823,5 +1991,2 @@       }-      if (typeof Buffer !== 'undefined') {-        return Buffer.from(value);-      }       throw new AxiosError('Blob is not supported. Use a Buffer instead.', AxiosError.ERR_NOT_SUPPORT);@@ -2262,8 +2427,14 @@ function parsePropPath(name) {-  // foo[x][y][z]-  // foo.x.y.z-  // foo-x-y-z-  // foo x y z+  // foo[x][y][z] -> ['foo', 'x', 'y', 'z']+  // foo.x.y.z    -> ['foo', 'x', 'y', 'z']+  // A path is split on `.` and on `[...]` groups. A segment — whether written+  // in dot notation or captured inside brackets — may contain any character+  // except `.`, `[` and `]`, so a key like `user-name` or `user name` is kept+  // literal instead of being split (#5402). `.`, `[` and `]` keep their existing+  // meaning, e.g. `foo[bar.baz]` -> ['foo', 'bar', 'baz'] and `[]` is an array push.+  // Excluding `[` from the bracket group also makes the match fail fast at the+  // next `[`, so a malformed name cannot rescan to the end of the string from+  // every unmatched `[` — parsing stays linear in the length of the name.   const path = [];-  const pattern = /\w+|\[(\w*)]/g;+  const pattern = /[^.[\]]+|\[([^.[\]]*)]/g;

--- +++ @@ -1,2 +1,2 @@-/*! Axios v1.18.1 Copyright (c) 2026 Matt Zabriskie and contributors */+/*! Axios v1.19.0 Copyright (c) 2026 Matt Zabriskie and contributors */ /**@@ -294,2 +294,3 @@ const isFileList = kindOfTest('FileList');+const isSet = kindOfTest('Set'); @@ -859,8 +860,19 @@         visited.add(source);-        const target = isArray(source) ? [] : {};--        forEach(source, (value, key) => {-          const reducedValue = visit(value);-          !isUndefined(reducedValue) && (target[key] = reducedValue);-        });++        let target;++        if (isSet(source)) {+          target = [];+          for (const value of source) {+            const reducedValue = visit(value);+            !isUndefined(reducedValue) && target.push(reducedValue);+          }+        } else {+          target = isArray(source) ? [] : {};++          forEach(source, (value, key) => {+            const reducedValue = visit(value);+            !isUndefined(reducedValue) && (target[key] = reducedValue);+          });+        } @@ -1076,3 +1088,5 @@ -      if (!key || (parsed[key] && ignoreDuplicateOf[key])) {+      const hasKey = utils$1.hasOwnProp(parsed, key);++      if (!key || (hasKey && utils$1.hasOwnProp(ignoreDuplicateOf, key))) {         return;@@ -1081,3 +1095,3 @@       if (key === 'set-cookie') {-        if (parsed[key]) {+        if (hasKey) {           parsed[key].push(val);@@ -1087,3 +1101,3 @@       } else {-        parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;+        parsed[key] = hasKey ? parsed[key] + ', ' + val : val;       }@@ -1175,2 +1189,120 @@   return tokens;+}++const parameterNameRE = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;++function trimOWS(value) {+  let start = 0;+  let end = value.length;++  while (start < end) {+    const code = value.charCodeAt(start);++    if (code !== 0x09 && code !== 0x20) {+      break;+    }++    start += 1;+  }++  while (end > start) {+    const code = value.charCodeAt(end - 1);++    if (code !== 0x09 && code !== 0x20) {+      break;+    }++    end -= 1;+  }++  return start === 0 && end === value.length ? value : value.slice(start, end);+}++function decodeQuotedString(value) {+  const last = value.length - 1;++  if (last < 1 || value.charCodeAt(0) !== 0x22 || value.charCodeAt(last) !== 0x22) {+    return value;+  }++  let decoded = '';++  for (let i = 1; i < last; i++) {+    const code = value.charCodeAt(i);++    if (code === 0x22) {+      return value;+    }++    if (code === 0x5c) {+      i += 1;++      if (i >= last) {+        return value;+      }+    }++    decoded += value[i];+  }++  return decoded;+}++function parseParameters(value) {+  const parameters = Object.create(null);+  const str = String(value);+  let start = 0;+  let quoted = false;+  let escaped = false;++  function parseParameter(end) {+    const part = trimOWS(str.slice(start, end));+    const equals = part.indexOf('=');++    if (equals < 1) {+      return;+    }++    const name = trimOWS(part.slice(0, equals));++    if (!parameterNameRE.test(name)) {+      return;+    }++    const normalizedName = name.toLowerCase();++    if (+      normalizedName === '__proto__' ||+      normalizedName === 'constructor' ||+      normalizedName === 'prototype'+    ) {+      return;+    }++    const parameterValue = trimOWS(part.slice(equals + 1));+    parameters[normalizedName] = decodeQuotedString(parameterValue);+  }++  for (let i = 0; i < str.length; i++) {+    const code = str.charCodeAt(i);++    if (quoted) {+      if (escaped) {+        escaped = false;+      } else if (code === 0x5c) {+        escaped = true;+      } else if (code === 0x22) {+        quoted = false;+      }+    } else if (code === 0x22) {+      quoted = true;+    } else if (code === 0x2c || code === 0x3b) {+      parseParameter(i);+      start = i + 1;+    }+  }++  parseParameter(str.length);++  return parameters; }@@ -1428,3 +1560,4 @@   getSetCookie() {-    return this.get('set-cookie') || [];+    const value = this.get('set-cookie');+    return utils$1.isArray(value) ? value : value == null || value === false ? [] : [value];   }@@ -1437,2 +1570,6 @@     return thing instanceof this ? thing : new this(thing);+  }++  static parseParameters(value) {+    return parseParameters(value);   }@@ -1564,5 +1701,36 @@ +function stringifySafely$1(value) {+  try {+    return String(value);+  } catch (err) {+    return '';+  }+}++function aggregateErrorMessage(error) {+  const message = error.errors+    .map((entry) => {+      try {+        return entry && entry.message ? stringifySafely$1(entry.message) : stringifySafely$1(entry);+      } catch (err) {+        return '';+      }+    })+    .filter(Boolean)+    .join('; ');++  return message || error.name || 'AggregateError';+}+ let AxiosError$1 = class AxiosError extends Error {   static from(error, code, config, request, response, customProps) {-    const axiosError = new AxiosError(error.message, code || error.code, config, request, response);+    // `AggregateError` (thrown by Node on dual-stack/Happy-Eyeballs connection+    // failures) has an empty `message`; its detail lives in `errors[]`. Without+    // this, the wrapped error surfaces with a blank message (see #6721).+    let message = error.message;+    if (!message && utils$1.isArray(error.errors) && error.errors.length) {+      message = aggregateErrorMessage(error);+    }++    const axiosError = new AxiosError(message, code || error.code, config, request, response);     // Match native `Error` `cause` semantics: non-enumerable. The wrapped@@ -1821,5 +1989,2 @@       }-      if (typeof Buffer !== 'undefined') {-        return Buffer.from(value);-      }       throw new AxiosError$1('Blob is not supported. Use a Buffer instead.', AxiosError$1.ERR_NOT_SUPPORT);@@ -2260,8 +2425,14 @@ function parsePropPath(name) {-  // foo[x][y][z]-  // foo.x.y.z-  // foo-x-y-z-  // foo x y z+  // foo[x][y][z] -> ['foo', 'x', 'y', 'z']+  // foo.x.y.z    -> ['foo', 'x', 'y', 'z']+  // A path is split on `.` and on `[...]` groups. A segment — whether written+  // in dot notation or captured inside brackets — may contain any character+  // except `.`, `[` and `]`, so a key like `user-name` or `user name` is kept+  // literal instead of being split (#5402). `.`, `[` and `]` keep their existing+  // meaning, e.g. `foo[bar.baz]` -> ['foo', 'bar', 'baz'] and `[]` is an array push.+  // Excluding `[` from the bracket group also makes the match fail fast at the+  // next `[`, so a malformed name cannot rescan to the end of the string from+  // every unmatched `[` — parsing stays linear in the length of the name.   const path = [];-  const pattern = /\w+|\[(\w*)]/g;+  const pattern = /[^.[\]]+|\[([^.[\]]*)]/g;

--- +++ @@ -1,2 +1,2 @@-/*! Axios v1.18.1 Copyright (c) 2026 Matt Zabriskie and contributors */+/*! Axios v1.19.0 Copyright (c) 2026 Matt Zabriskie and contributors */ 'use strict';@@ -297,2 +297,3 @@ const isFileList = kindOfTest('FileList');+const isSet = kindOfTest('Set'); @@ -819,7 +820,16 @@         visited.add(source);-        const target = isArray(source) ? [] : {};-        forEach(source, (value, key) => {-          const reducedValue = visit(value);-          !isUndefined(reducedValue) && (target[key] = reducedValue);-        });+        let target;+        if (isSet(source)) {+          target = [];+          for (const value of source) {+            const reducedValue = visit(value);+            !isUndefined(reducedValue) && target.push(reducedValue);+          }+        } else {+          target = isArray(source) ? [] : {};+          forEach(source, (value, key) => {+            const reducedValue = visit(value);+            !isUndefined(reducedValue) && (target[key] = reducedValue);+          });+        }         visited.delete(source);@@ -997,3 +1007,4 @@     val = line.substring(i + 1).trim();-    if (!key || parsed[key] && ignoreDuplicateOf[key]) {+    const hasKey = utils$1.hasOwnProp(parsed, key);+    if (!key || hasKey && utils$1.hasOwnProp(ignoreDuplicateOf, key)) {       return;@@ -1001,3 +1012,3 @@     if (key === 'set-cookie') {-      if (parsed[key]) {+      if (hasKey) {         parsed[key].push(val);@@ -1007,3 +1018,3 @@     } else {-      parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;+      parsed[key] = hasKey ? parsed[key] + ', ' + val : val;     }@@ -1072,2 +1083,86 @@   return tokens;+}+const parameterNameRE = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;+function trimOWS(value) {+  let start = 0;+  let end = value.length;+  while (start < end) {+    const code = value.charCodeAt(start);+    if (code !== 0x09 && code !== 0x20) {+      break;+    }+    start += 1;+  }+  while (end > start) {+    const code = value.charCodeAt(end - 1);+    if (code !== 0x09 && code !== 0x20) {+      break;+    }+    end -= 1;+  }+  return start === 0 && end === value.length ? value : value.slice(start, end);+}+function decodeQuotedString(value) {+  const last = value.length - 1;+  if (last < 1 || value.charCodeAt(0) !== 0x22 || value.charCodeAt(last) !== 0x22) {+    return value;+  }+  let decoded = '';+  for (let i = 1; i < last; i++) {+    const code = value.charCodeAt(i);+    if (code === 0x22) {+      return value;+    }+    if (code === 0x5c) {+      i += 1;+      if (i >= last) {+        return value;+      }+    }+    decoded += value[i];+  }+  return decoded;+}+function parseParameters(value) {+  const parameters = Object.create(null);+  const str = String(value);+  let start = 0;+  let quoted = false;+  let escaped = false;+  function parseParameter(end) {+    const part = trimOWS(str.slice(start, end));+    const equals = part.indexOf('=');+    if (equals < 1) {+      return;+    }+    const name = trimOWS(part.slice(0, equals));+    if (!parameterNameRE.test(name)) {+      return;+    }+    const normalizedName = name.toLowerCase();+    if (normalizedName === '__proto__' || normalizedName === 'constructor' || normalizedName === 'prototype') {+      return;+    }+    const parameterValue = trimOWS(part.slice(equals + 1));+    parameters[normalizedName] = decodeQuotedString(parameterValue);+  }+  for (let i = 0; i < str.length; i++) {+    const code = str.charCodeAt(i);+    if (quoted) {+      if (escaped) {+        escaped = false;+      } else if (code === 0x5c) {+        escaped = true;+      } else if (code === 0x22) {+        quoted = false;+      }+    } else if (code === 0x22) {+      quoted = true;+    } else if (code === 0x2c || code === 0x3b) {+      parseParameter(i);+      start = i + 1;+    }+  }+  parseParameter(str.length);+  return parameters; }@@ -1250,3 +1345,4 @@   getSetCookie() {-    return this.get('set-cookie') || [];+    const value = this.get('set-cookie');+    return utils$1.isArray(value) ? value : value == null || value === false ? [] : [value];   }@@ -1257,2 +1353,5 @@     return thing instanceof this ? thing : new this(thing);+  }+  static parseParameters(value) {+    return parseParameters(value);   }@@ -1352,5 +1451,29 @@ }+function stringifySafely$1(value) {+  try {+    return String(value);+  } catch (err) {+    return '';+  }+}+function aggregateErrorMessage(error) {+  const message = error.errors.map(entry => {+    try {+      return entry && entry.message ? stringifySafely$1(entry.message) : stringifySafely$1(entry);+    } catch (err) {+      return '';+    }+  }).filter(Boolean).join('; ');+  return message || error.name || 'AggregateError';+} class AxiosError extends Error {   static from(error, code, config, request, response, customProps) {-    const axiosError = new AxiosError(error.message, code || error.code, config, request, response);+    // `AggregateError` (thrown by Node on dual-stack/Happy-Eyeballs connection+    // failures) has an empty `message`; its detail lives in `errors[]`. Without+    // this, the wrapped error surfaces with a blank message (see #6721).+    let message = error.message;+    if (!message && utils$1.isArray(error.errors) && error.errors.length) {+      message = aggregateErrorMessage(error);+    }+    const axiosError = new AxiosError(message, code || error.code, config, request, response);     // Match native `Error` `cause` semantics: non-enumerable. The wrapped@@ -1458,2 +1581,11 @@ +var PlatformBuffer = {+  isBufferAvailable() {+    return typeof Buffer !== 'undefined';+  },+  from(value) {+    return Buffer.from(value);+  }+};+ // Default nesting limit shared with the inverse transform (formDataToJSON) so@@ -1583,4 +1715,4 @@       }-      if (typeof Buffer !== 'undefined') {-        return Buffer.from(value);+      if (PlatformBuffer && PlatformBuffer.isBufferAvailable()) {+        return PlatformBuffer.from(value);       }@@ -1964,8 +2096,14 @@ function parsePropPath(name) {-  // foo[x][y][z]-  // foo.x.y.z-  // foo-x-y-z-  // foo x y z+  // foo[x][y][z] -> ['foo', 'x', 'y', 'z']+  // foo.x.y.z    -> ['foo', 'x', 'y', 'z']+  // A path is split on `.` and on `[...]` groups. A segment — whether written+  // in dot notation or captured inside brackets — may contain any character+  // except `.`, `[` and `]`, so a key like `user-name` or `user name` is kept+  // literal instead of being split (#5402). `.`, `[` and `]` keep their existing+  // meaning, e.g. `foo[bar.baz]` -> ['foo', 'bar', 'baz'] and `[]` is an array push.+  // Excluding `[` from the bracket group also makes the match fail fast at the+  // next `[`, so a malformed name cannot rescan to the end of the string from+  // every unmatched `[` — parsing stays linear in the length of the name.   const path = [];-  const pattern = /\w+|\[(\w*)]/g;+  const pattern = /[^.[\]]+|\[([^.[\]]*)]/g;   let match;@@ -2245,3 +2383,10 @@ function combineURLs(baseURL, relativeURL) {-  return relativeURL ? baseURL.replace(/\/?\/$/, '') + '/' + relativeURL.replace(/^\/+/, '') : baseURL;+  if (!relativeURL) {+    return baseURL;+  }+  let end = baseURL.length;+  while (end > 0 && baseURL.charCodeAt(end - 1) === 47) {+    end--;+  }+  return baseURL.slice(0, end) + '/' + relativeURL.replace(/^\/+/, ''); }@@ -2260,5 +2405,35 @@ }++// Redact the parts of a URL that can carry secrets before it is embedded in an+// error message. AxiosError.toJSON() serializes `message` verbatim and errors+// are commonly logged, while the opt-in `config.redact` model only cleans+// config keys — it cannot reach the message. Redact only the genuinely+// sensitive substrings — userinfo (credentials), query parameter values and+// fragment contents — with the same REDACTED marker the config redaction uses,+// while keeping the scheme, host, path and parameter names so the offending+// request stays accurately identifiable.+function redactFragment(fragment) {+  if (!fragment) {+    return fragment;+  }+  return fragment.replace(/(^|&)([^=&]*=)?[^&]+/g, (match, separator, parameterName = '') => {+    return `${separator}${parameterName}${REDACTED}`;+  });+}+function redactSensitiveURLParts(url) {+  const redactedURL = url.replace(/^(https?:\/{0,2})[^/?#]*@/i, `$1${REDACTED}@`);

--- +++ @@ -1,9 +1,7 @@ /**- * Estimate decoded byte length of a data:// URL *without* allocating large buffers.- * - For base64: compute exact decoded size using length and padding;- *               handle %XX at the character-count level (no string allocation).- * - For non-base64: compute the exact percent-decoded UTF-8 byte length.- *- * @param {string} url- * @returns {number}+ * Estimate data: URL byte lengths *without* allocating large buffers.+ * - Fetch percent-decodes a base64 body before decoding it.+ * - Node's Buffer.from(body, 'base64') sizes its backing allocation from the+ *   raw body, including ignored characters and content after padding.+ * - Non-base64 data is percent-decoded and then encoded as UTF-8.  */@@ -17,3 +15,85 @@ -export default function estimateDataURLDecodedBytes(url) {+const hexValue = (charCode) => (charCode <= 57 ? charCode - 48 : (charCode & 0xdf) - 55);++const isBase64Char = (charCode) =>+  (charCode >= 65 && charCode <= 90) || // A-Z+  (charCode >= 97 && charCode <= 122) || // a-z+  (charCode >= 48 && charCode <= 57) || // 0-9+  charCode === 43 || // ++  charCode === 47 || // /+  charCode === 45 || // - (base64url)+  charCode === 95; // _ (base64url)++const isBase64Whitespace = (charCode) =>+  charCode === 9 || charCode === 10 || charCode === 12 || charCode === 13 || charCode === 32;++const base64Bytes = (significant) => {+  const groups = Math.floor(significant / 4);+  const remainder = significant % 4;+  return groups * 3 + (remainder === 2 ? 1 : remainder === 3 ? 2 : 0);+};++// Buffer.byteLength(body, 'base64') uses the raw string length as an allocation+// upper bound even when Buffer.from later ignores characters or stops at '='.+const estimateBase64BufferAllocation = (body) => {+  const len = body.length;+  let padding = 0;++  if (len > 0 && body.charCodeAt(len - 1) === 61 /* '=' */) {+    padding++;++    if (len > 1 && body.charCodeAt(len - 2) === 61 /* '=' */) {+      padding++;+    }+  }++  return Math.floor(((len - padding) * 3) / 4);+};++const estimatePercentDecodedBase64Bytes = (body) => {+  const len = body.length;+  let significant = 0;+  let padding = 0;+  let invalid = false;++  for (let i = 0; i < len; i++) {+    let code = body.charCodeAt(i);++    if (code === 37 /* '%' */ && isPercentEncodedByte(body, i, len)) {+      code = hexValue(body.charCodeAt(i + 1)) * 16 + hexValue(body.charCodeAt(i + 2));+      i += 2;+    }++    if (isBase64Whitespace(code)) {+      continue;+    }++    if (code === 61 /* '=' */) {+      padding++;+      continue;+    }++    if (!isBase64Char(code) || padding > 0) {+      invalid = true;+      continue;+    }++    significant++;+  }++  // Fetch rejects malformed forgiving-base64 input. Returning the raw-size+  // allocation bound keeps that invalid input from becoming a pre-check bypass.+  if (+    invalid ||+    padding > 2 ||+    (padding > 0 && (significant + padding) % 4 !== 0) ||+    significant % 4 === 1+  ) {+    return estimateBase64BufferAllocation(body);+  }++  return base64Bytes(significant);+};++const estimateDataURLBytes = (url, estimateBase64) => {   if (!url || typeof url !== 'string') return 0;@@ -29,48 +109,3 @@   if (isBase64) {-    let effectiveLen = body.length;-    const len = body.length; // cache length--    for (let i = 0; i < len; i++) {-      if (body.charCodeAt(i) === 37 /* '%' */ && i + 2 < len) {-        const a = body.charCodeAt(i + 1);-        const b = body.charCodeAt(i + 2);-        const isHex = isHexDigit(a) && isHexDigit(b);--        if (isHex) {-          effectiveLen -= 2;-          i += 2;-        }-      }-    }--    let pad = 0;-    let idx = len - 1;--    const tailIsPct3D = (j) =>-      j >= 2 &&-      body.charCodeAt(j - 2) === 37 && // '%'-      body.charCodeAt(j - 1) === 51 && // '3'-      (body.charCodeAt(j) === 68 || body.charCodeAt(j) === 100); // 'D' or 'd'--    if (idx >= 0) {-      if (body.charCodeAt(idx) === 61 /* '=' */) {-        pad++;-        idx--;-      } else if (tailIsPct3D(idx)) {-        pad++;-        idx -= 3;-      }-    }--    if (pad === 1 && idx >= 0) {-      if (body.charCodeAt(idx) === 61 /* '=' */) {-        pad++;-      } else if (tailIsPct3D(idx)) {-        pad++;-      }-    }--    const groups = Math.floor(effectiveLen / 4);-    const bytes = groups * 3 - (pad || 0);-    return bytes > 0 ? bytes : 0;+    return estimateBase64(body);   }@@ -104,2 +139,28 @@   return bytes;+};++/**+ * Estimate the percent-decoded payload size used by Fetch data: URLs.+ *+ * @param {string} url+ * @returns {number}+ */+export default function estimateDataURLDecodedBytes(url) {+  // Fetch removes URL fragments before processing a data: URL.+  const fragmentIndex = typeof url === 'string' ? url.indexOf('#') : -1;++  return estimateDataURLBytes(+    fragmentIndex === -1 ? url : url.slice(0, fragmentIndex),+    estimatePercentDecodedBase64Bytes+  ); }++/**+ * Estimate the Buffer backing allocation used by Node's raw base64 decoder.+ *+ * @param {string} url+ * @returns {number}+ */+export function estimateDataURLBufferAllocation(url) {+  return estimateDataURLBytes(url, estimateBase64BufferAllocation);+}

--- +++ @@ -4,2 +4,4 @@ export type AxiosHeaderValue = AxiosHeaders | string | string[] | number | boolean | null;++export type AxiosHeaderParameters = Record<string, string>; @@ -35,2 +37,3 @@ +  get(headerName: string, parser: typeof AxiosHeaders.parseParameters): AxiosHeaderParameters;   get(headerName: string, parser: RegExp): RegExpExecArray | null;@@ -55,2 +58,4 @@   static from(thing?: AxiosHeaders | RawAxiosHeaders | string): AxiosHeaders;++  static parseParameters(value: AxiosHeaderValue): AxiosHeaderParameters; @@ -238,2 +243,3 @@   NetworkAuthenticationRequired = 511,+  WebServerReturnsAnUnknownError = 520,   WebServerIsDown = 521,@@ -337,9 +343,9 @@ -export interface CustomParamsSerializer {-  (params: Record<string, any>, options?: ParamsSerializerOptions): string;-}--export interface ParamsSerializerOptions extends SerializerOptions {+export interface CustomParamsSerializer<P = Record<string, any>> {+  (params: P, options?: ParamsSerializerOptions<P>): string;+}++export interface ParamsSerializerOptions<P = Record<string, any>> extends SerializerOptions {   encode?: ParamEncoder;-  serialize?: CustomParamsSerializer;+  serialize?: CustomParamsSerializer<P>; }@@ -380,3 +386,3 @@ -export interface AxiosRequestConfig<D = any> {+export interface AxiosRequestConfig<D = any, P = any> {   url?: string;@@ -388,4 +394,6 @@   headers?: (RawAxiosRequestHeaders & MethodsHeaders) | AxiosHeaders;-  params?: any;-  paramsSerializer?: ParamsSerializerOptions | CustomParamsSerializer;+  params?: P;+  paramsSerializer?:+    | ParamsSerializerOptions<unknown extends P ? Record<string, any> : P>+    | CustomParamsSerializer<unknown extends P ? Record<string, any> : P>;   data?: D;@@ -457,3 +465,3 @@       >);-  withXSRFToken?: boolean | ((config: InternalAxiosRequestConfig) => boolean | undefined);+  withXSRFToken?: boolean | ((config: InternalAxiosRequestConfig<D, P>) => boolean | undefined);   parseReviver?: (this: any, key: string, value: any, context?: { source?: string }) => any;@@ -470,5 +478,5 @@ // Alias-export type RawAxiosRequestConfig<D = any> = AxiosRequestConfig<D>;--export interface InternalAxiosRequestConfig<D = any> extends AxiosRequestConfig<D> {+export type RawAxiosRequestConfig<D = any, P = any> = AxiosRequestConfig<D, P>;++export interface InternalAxiosRequestConfig<D = any, P = any> extends AxiosRequestConfig<D, P> {   headers: AxiosRequestHeaders;@@ -491,3 +499,3 @@ -export interface AxiosDefaults<D = any> extends Omit<AxiosRequestConfig<D>, 'headers'> {+export interface AxiosDefaults<D = any, P = any> extends Omit<AxiosRequestConfig<D, P>, 'headers'> {   headers: HeadersDefaults;@@ -495,3 +503,6 @@ -export interface CreateAxiosDefaults<D = any> extends Omit<AxiosRequestConfig<D>, 'headers'> {+export interface CreateAxiosDefaults<D = any, P = any> extends Omit<+  AxiosRequestConfig<D, P>,+  'headers'+> {   headers?: RawAxiosRequestHeaders | AxiosHeaders | Partial<HeadersDefaults>;@@ -499,3 +510,3 @@ -export interface AxiosResponse<T = any, D = any, H = {}> {+export interface AxiosResponse<T = any, D = any, H = {}, P = any> {   data: T;@@ -504,3 +515,3 @@   headers: (H & RawAxiosResponseHeaders) | AxiosResponseHeaders;-  config: InternalAxiosRequestConfig<D>;+  config: InternalAxiosRequestConfig<D, P>;   request?: any;@@ -508,3 +519,3 @@ -export class AxiosError<T = unknown, D = any> extends Error {+export class AxiosError<T = unknown, D = any, P = any> extends Error {   constructor(@@ -512,11 +523,11 @@     code?: string,-    config?: InternalAxiosRequestConfig<D>,+    config?: InternalAxiosRequestConfig<D, P>,     request?: any,-    response?: AxiosResponse<T, D>+    response?: AxiosResponse<T, D, {}, P>   ); -  config?: InternalAxiosRequestConfig<D>;+  config?: InternalAxiosRequestConfig<D, P>;   code?: string;   request?: any;-  response?: AxiosResponse<T, D>;+  response?: AxiosResponse<T, D, {}, P>;   isAxiosError: boolean;@@ -526,10 +537,10 @@   event?: BrowserProgressEvent;-  static from<T = unknown, D = any>(+  static from<T = unknown, D = any, P = any>(     error: Error | unknown,     code?: string,-    config?: InternalAxiosRequestConfig<D>,+    config?: InternalAxiosRequestConfig<D, P>,     request?: any,-    response?: AxiosResponse<T, D>,+    response?: AxiosResponse<T, D, {}, P>,     customProps?: object-  ): AxiosError<T, D>;+  ): AxiosError<T, D, P>;   static readonly ERR_FR_TOO_MANY_REDIRECTS = 'ERR_FR_TOO_MANY_REDIRECTS';@@ -550,4 +561,4 @@ -export class CanceledError<T> extends AxiosError<T> {-  constructor(message?: string, config?: InternalAxiosRequestConfig, request?: any);+export class CanceledError<T, D = any, P = any> extends AxiosError<T, D, P> {+  constructor(message?: string, config?: InternalAxiosRequestConfig<D, P>, request?: any);   readonly name: 'CanceledError';@@ -556,3 +567,11 @@ -export type AxiosPromise<T = any> = Promise<AxiosResponse<T>>;+declare const axiosResponseDefault: unique symbol;++type AxiosResponseDefault = typeof axiosResponseDefault;++type AxiosResponseResult<T, R, D, P> = R extends AxiosResponseDefault+  ? AxiosResponse<T, D, {}, P>+  : R;++export type AxiosPromise<T = any, D = any, P = any> = Promise<AxiosResponse<T, D, {}, P>>; @@ -630,54 +649,56 @@   getUri(config?: AxiosRequestConfig): string;-  request<T = any, R = AxiosResponse<T>, D = any>(config: AxiosRequestConfig<D>): Promise<R>;-  get<T = any, R = AxiosResponse<T>, D = any>(-    url: string,-    config?: AxiosRequestConfig<D>-  ): Promise<R>;-  delete<T = any, R = AxiosResponse<T>, D = any>(-    url: string,-    config?: AxiosRequestConfig<D>-  ): Promise<R>;-  head<T = any, R = AxiosResponse<T>, D = any>(-    url: string,-    config?: AxiosRequestConfig<D>-  ): Promise<R>;-  options<T = any, R = AxiosResponse<T>, D = any>(-    url: string,-    config?: AxiosRequestConfig<D>-  ): Promise<R>;-  post<T = any, R = AxiosResponse<T>, D = any>(+  request<T = any, R = AxiosResponseDefault, D = any, P = any>(+    config: AxiosRequestConfig<D, P>+  ): Promise<AxiosResponseResult<T, R, D, P>>;+  get<T = any, R = AxiosResponseDefault, D = any, P = any>(+    url: string,+    config?: AxiosRequestConfig<D, P>+  ): Promise<AxiosResponseResult<T, R, D, P>>;+  delete<T = any, R = AxiosResponseDefault, D = any, P = any>(+    url: string,+    config?: AxiosRequestConfig<D, P>+  ): Promise<AxiosResponseResult<T, R, D, P>>;+  head<T = any, R = AxiosResponseDefault, D = any, P = any>(+    url: string,+    config?: AxiosRequestConfig<D, P>+  ): Promise<AxiosResponseResult<T, R, D, P>>;+  options<T = any, R = AxiosResponseDefault, D = any, P = any>(+    url: string,+    config?: AxiosRequestConfig<D, P>+  ): Promise<AxiosResponseResult<T, R, D, P>>;+  post<T = any, R = AxiosResponseDefault, D = any, P = any>(     url: string,     data?: D,-    config?: AxiosRequestConfig<D>-  ): Promise<R>;-  put<T = any, R = AxiosResponse<T>, D = any>(+    config?: AxiosRequestConfig<D, P>+  ): Promise<AxiosResponseResult<T, R, D, P>>;+  put<T = any, R = AxiosResponseDefault, D = any, P = any>(     url: string,     data?: D,-    config?: AxiosRequestConfig<D>-  ): Promise<R>;-  patch<T = any, R = AxiosResponse<T>, D = any>(+    config?: AxiosRequestConfig<D, P>+  ): Promise<AxiosResponseResult<T, R, D, P>>;+  patch<T = any, R = AxiosResponseDefault, D = any, P = any>(     url: string,     data?: D,-    config?: AxiosRequestConfig<D>-  ): Promise<R>;-  postForm<T = any, R = AxiosResponse<T>, D = any>(+    config?: AxiosRequestConfig<D, P>+  ): Promise<AxiosResponseResult<T, R, D, P>>;+  postForm<T = any, R = AxiosResponseDefault, D = any, P = any>(     url: string,     data?: D,-    config?: AxiosRequestConfig<D>-  ): Promise<R>;-  putForm<T = any, R = AxiosResponse<T>, D = any>(+    config?: AxiosRequestConfig<D, P>+  ): Promise<AxiosResponseResult<T, R, D, P>>;+  putForm<T = any, R = AxiosResponseDefault, D = any, P = any>(     url: string,     data?: D,-    config?: AxiosRequestConfig<D>-  ): Promise<R>;-  patchForm<T = any, R = AxiosResponse<T>, D = any>(+    config?: AxiosRequestConfig<D, P>+  ): Promise<AxiosResponseResult<T, R, D, P>>;+  patchForm<T = any, R = AxiosResponseDefault, D = any, P = any>(     url: string,     data?: D,-    config?: AxiosRequestConfig<D>-  ): Promise<R>;-  query<T = any, R = AxiosResponse<T>, D = any>(+    config?: AxiosRequestConfig<D, P>+  ): Promise<AxiosResponseResult<T, R, D, P>>;+  query<T = any, R = AxiosResponseDefault, D = any, P = any>(     url: string,     data?: D,-    config?: AxiosRequestConfig<D>-  ): Promise<R>;+    config?: AxiosRequestConfig<D, P>+  ): Promise<AxiosResponseResult<T, R, D, P>>; }@@ -685,4 +706,9 @@ export interface AxiosInstance extends Axios {-  <T = any, R = AxiosResponse<T>, D = any>(config: AxiosRequestConfig<D>): Promise<R>;-  <T = any, R = AxiosResponse<T>, D = any>(url: string, config?: AxiosRequestConfig<D>): Promise<R>;+  <T = any, R = AxiosResponseDefault, D = any, P = any>(+    config: AxiosRequestConfig<D, P>+  ): Promise<AxiosResponseResult<T, R, D, P>>;+  <T = any, R = AxiosResponseDefault, D = any, P = any>(+    url: string,+    config?: AxiosRequestConfig<D, P>+  ): Promise<AxiosResponseResult<T, R, D, P>>; 

--- +++ @@ -21,2 +21,3 @@ import AxiosHeaders from '../core/AxiosHeaders.js';+import setFormDataHeaders from '../core/setFormDataHeaders.js'; import AxiosTransformStream from '../helpers/AxiosTransformStream.js';@@ -35,3 +36,3 @@ } from '../helpers/progressEventReducer.js';-import estimateDataURLDecodedBytes from '../helpers/estimateDataURLDecodedBytes.js';+import { estimateDataURLBufferAllocation } from '../helpers/estimateDataURLDecodedBytes.js'; @@ -56,2 +57,4 @@ const ACCEPT_ENCODING_WITH_ZSTD = ACCEPT_ENCODING + (isZstdSupported ? ', zstd' : '');+const scheduleProgress =+  typeof process !== 'undefined' && process.nextTick ? process.nextTick.bind(process) : utils.asap; @@ -60,16 +63,2 @@ const isHttps = /https:?/;-const FORM_DATA_CONTENT_HEADERS = ['content-type', 'content-length'];--function setFormDataHeaders(headers, formHeaders, policy) {-  if (policy !== 'content-only') {-    headers.set(formHeaders);-    return;-  }--  Object.entries(formHeaders).forEach(([key, val]) => {-    if (FORM_DATA_CONTENT_HEADERS.includes(key.toLowerCase())) {-      headers.set(key, val);-    }-  });-} @@ -677,3 +666,3 @@           const dataUrl = String(own('url') || fullPath || '');-          const estimated = estimateDataURLDecodedBytes(dataUrl);+          const estimated = estimateDataURLBufferAllocation(dataUrl); @@ -844,3 +833,3 @@                 contentLength,-                progressEventReducer(asyncDecorator(onUploadProgress), false, 3)+                progressEventReducer(asyncDecorator(onUploadProgress, scheduleProgress), false, 3)               )@@ -1082,3 +1071,3 @@                   responseLength,-                  progressEventReducer(asyncDecorator(onDownloadProgress), true, 3)+                  progressEventReducer(asyncDecorator(onDownloadProgress, scheduleProgress), true, 3)                 )

--- +++ @@ -211,5 +211,21 @@       try {-        newConfig = onFulfilled(newConfig);+        newConfig = onFulfilled ? onFulfilled(newConfig) : newConfig;       } catch (error) {-        onRejected.call(this, error);+        if (!onRejected) {+          promise = Promise.reject(error);+          break;+        }++        try {+          const rejectedResult = onRejected.call(this, error);++          if (utils.isThenable(rejectedResult)) {+            promise = Promise.resolve(rejectedResult).then(() =>+              dispatchRequest.call(this, newConfig)+            );+          }+        } catch (rejectedError) {+          promise = Promise.reject(rejectedError);+        }+         break;@@ -218,6 +234,8 @@ -    try {-      promise = dispatchRequest.call(this, newConfig);-    } catch (error) {-      return Promise.reject(error);+    if (!promise) {+      try {+        promise = dispatchRequest.call(this, newConfig);+      } catch (error) {+        promise = Promise.reject(error);+      }     }

--- +++ @@ -5,3 +5,3 @@ -const REDACTED = '[REDACTED ****]';+export const REDACTED = '[REDACTED ****]'; @@ -74,5 +74,36 @@ +function stringifySafely(value) {+  try {+    return String(value);+  } catch (err) {+    return '';+  }+}++function aggregateErrorMessage(error) {+  const message = error.errors+    .map((entry) => {+      try {+        return entry && entry.message ? stringifySafely(entry.message) : stringifySafely(entry);+      } catch (err) {+        return '';+      }+    })+    .filter(Boolean)+    .join('; ');++  return message || error.name || 'AggregateError';+}+ class AxiosError extends Error {   static from(error, code, config, request, response, customProps) {-    const axiosError = new AxiosError(error.message, code || error.code, config, request, response);+    // `AggregateError` (thrown by Node on dual-stack/Happy-Eyeballs connection+    // failures) has an empty `message`; its detail lives in `errors[]`. Without+    // this, the wrapped error surfaces with a blank message (see #6721).+    let message = error.message;+    if (!message && utils.isArray(error.errors) && error.errors.length) {+      message = aggregateErrorMessage(error);+    }++    const axiosError = new AxiosError(message, code || error.code, config, request, response);     // Match native `Error` `cause` semantics: non-enumerable. The wrapped

--- +++ @@ -30,2 +30,120 @@   return tokens;+}++const parameterNameRE = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;++function trimOWS(value) {+  let start = 0;+  let end = value.length;++  while (start < end) {+    const code = value.charCodeAt(start);++    if (code !== 0x09 && code !== 0x20) {+      break;+    }++    start += 1;+  }++  while (end > start) {+    const code = value.charCodeAt(end - 1);++    if (code !== 0x09 && code !== 0x20) {+      break;+    }++    end -= 1;+  }++  return start === 0 && end === value.length ? value : value.slice(start, end);+}++function decodeQuotedString(value) {+  const last = value.length - 1;++  if (last < 1 || value.charCodeAt(0) !== 0x22 || value.charCodeAt(last) !== 0x22) {+    return value;+  }++  let decoded = '';++  for (let i = 1; i < last; i++) {+    const code = value.charCodeAt(i);++    if (code === 0x22) {+      return value;+    }++    if (code === 0x5c) {+      i += 1;++      if (i >= last) {+        return value;+      }+    }++    decoded += value[i];+  }++  return decoded;+}++function parseParameters(value) {+  const parameters = Object.create(null);+  const str = String(value);+  let start = 0;+  let quoted = false;+  let escaped = false;++  function parseParameter(end) {+    const part = trimOWS(str.slice(start, end));+    const equals = part.indexOf('=');++    if (equals < 1) {+      return;+    }++    const name = trimOWS(part.slice(0, equals));++    if (!parameterNameRE.test(name)) {+      return;+    }++    const normalizedName = name.toLowerCase();++    if (+      normalizedName === '__proto__' ||+      normalizedName === 'constructor' ||+      normalizedName === 'prototype'+    ) {+      return;+    }++    const parameterValue = trimOWS(part.slice(equals + 1));+    parameters[normalizedName] = decodeQuotedString(parameterValue);+  }++  for (let i = 0; i < str.length; i++) {+    const code = str.charCodeAt(i);++    if (quoted) {+      if (escaped) {+        escaped = false;+      } else if (code === 0x5c) {+        escaped = true;+      } else if (code === 0x22) {+        quoted = false;+      }+    } else if (code === 0x22) {+      quoted = true;+    } else if (code === 0x2c || code === 0x3b) {+      parseParameter(i);+      start = i + 1;+    }+  }++  parseParameter(str.length);++  return parameters; }@@ -283,3 +401,4 @@   getSetCookie() {-    return this.get('set-cookie') || [];+    const value = this.get('set-cookie');+    return utils.isArray(value) ? value : value == null || value === false ? [] : [value];   }@@ -292,2 +411,6 @@     return thing instanceof this ? thing : new this(thing);+  }++  static parseParameters(value) {+    return parseParameters(value);   }

--- +++ @@ -2,3 +2,3 @@ -import AxiosError from './AxiosError.js';+import AxiosError, { REDACTED } from './AxiosError.js'; import isAbsoluteURL from '../helpers/isAbsoluteURL.js';@@ -21,9 +21,47 @@ +// Redact the parts of a URL that can carry secrets before it is embedded in an+// error message. AxiosError.toJSON() serializes `message` verbatim and errors+// are commonly logged, while the opt-in `config.redact` model only cleans+// config keys — it cannot reach the message. Redact only the genuinely+// sensitive substrings — userinfo (credentials), query parameter values and+// fragment contents — with the same REDACTED marker the config redaction uses,+// while keeping the scheme, host, path and parameter names so the offending+// request stays accurately identifiable.+function redactFragment(fragment) {+  if (!fragment) {+    return fragment;+  }++  return fragment.replace(/(^|&)([^=&]*=)?[^&]+/g, (match, separator, parameterName = '') => {+    return `${separator}${parameterName}${REDACTED}`;+  });+}++function redactSensitiveURLParts(url) {+  const redactedURL = url.replace(/^(https?:\/{0,2})[^/?#]*@/i, `$1${REDACTED}@`);+  const fragmentIndex = redactedURL.indexOf('#');+  const urlWithoutFragment =+    fragmentIndex === -1 ? redactedURL : redactedURL.slice(0, fragmentIndex);+  const redactedURLWithoutFragment = urlWithoutFragment.replace(+    /([?&][^=&#]*=)[^&#]*/g,+    `$1${REDACTED}`+  );++  if (fragmentIndex === -1) {+    return redactedURLWithoutFragment;+  }++  return `${redactedURLWithoutFragment}#${redactFragment(redactedURL.slice(fragmentIndex + 1))}`;+}+ function assertValidHttpProtocolURL(url, config) {-  if (typeof url === 'string' && malformedHttpProtocol.test(normalizeURLForProtocolCheck(url))) {-    throw new AxiosError(-      'Invalid URL: missing "//" after protocol',-      AxiosError.ERR_INVALID_URL,-      config-    );+  if (typeof url === 'string') {+    const normalizedURL = normalizeURLForProtocolCheck(url);+    if (malformedHttpProtocol.test(normalizedURL)) {+      throw new AxiosError(+        `Invalid URL ${JSON.stringify(redactSensitiveURLParts(normalizedURL))}: missing "//" after protocol`,+        AxiosError.ERR_INVALID_URL,+        config+      );+    }   }

--- +++ @@ -6,2 +6,13 @@ const headersToObject = (thing) => (thing instanceof AxiosHeaders ? { ...thing } : thing);++const ownEnumerableKeys = (thing) => {+  if (Object.getOwnPropertySymbols && Object.getOwnPropertyDescriptor) {+    return Object.keys(thing).concat(+      Object.getOwnPropertySymbols(thing).filter(+        (symbol) => Object.getOwnPropertyDescriptor(thing, symbol).enumerable+      )+    );+  }+  return Object.keys(thing);+}; @@ -72,3 +83,5 @@   function getMergedTransitionalOption(prop) {-    const transitional2 = utils.hasOwnProp(config2, 'transitional') ? config2.transitional : undefined;+    const transitional2 = utils.hasOwnProp(config2, 'transitional')+      ? config2.transitional+      : undefined; @@ -84,3 +97,5 @@ -    const transitional1 = utils.hasOwnProp(config1, 'transitional') ? config1.transitional : undefined;+    const transitional1 = utils.hasOwnProp(config1, 'transitional')+      ? config1.transitional+      : undefined; @@ -136,3 +151,3 @@ -  utils.forEach(Object.keys({ ...config1, ...config2 }), function computeConfigValue(prop) {+  utils.forEach(ownEnumerableKeys({ ...config1, ...config2 }), function computeConfigValue(prop) {     if (prop === '__proto__' || prop === 'constructor' || prop === 'prototype') return;

--- +++ @@ -0,0 +1,27 @@+'use strict';++const FORM_DATA_CONTENT_HEADERS = ['content-type', 'content-length'];++/**+ * Apply the headers generated by a FormData implementation to the request headers,+ * honoring the `formDataHeaderPolicy` option: with 'content-only', copy only the+ * content-* headers; otherwise merge all of them.+ *+ * @param {AxiosHeaders} headers - the request headers to mutate+ * @param {Object | null | undefined} formHeaders - headers produced by the FormData implementation+ * @param {String} [policy] - the resolved `formDataHeaderPolicy` config value+ *+ * @returns {void}+ */+export default function setFormDataHeaders(headers, formHeaders, policy) {+  if (policy !== 'content-only') {+    headers.set(formHeaders);+    return;+  }++  Object.entries(formHeaders || {}).forEach(([key, val]) => {+    if (FORM_DATA_CONTENT_HEADERS.includes(key.toLowerCase())) {+      headers.set(key, val);+    }+  });+}

--- +++ @@ -1 +1 @@-export const VERSION = "1.18.1";+export const VERSION = "1.19.0";

--- +++ @@ -64,2 +64,3 @@   NetworkAuthenticationRequired: 511,+  WebServerReturnsAnUnknownError: 520,   WebServerIsDown: 521,

--- +++ @@ -11,5 +11,13 @@ export default function combineURLs(baseURL, relativeURL) {-  return relativeURL-    ? baseURL.replace(/\/?\/$/, '') + '/' + relativeURL.replace(/^\/+/, '')-    : baseURL;+  if (!relativeURL) {+    return baseURL;+  }++  let end = baseURL.length;++  while (end > 0 && baseURL.charCodeAt(end - 1) === 47) {+    end--;+  }++  return baseURL.slice(0, end) + '/' + relativeURL.replace(/^\/+/, ''); }

--- +++ @@ -47,3 +47,14 @@ -  signals.forEach((signal) => signal.addEventListener('abort', onabort, { once: true }));+  signals.forEach((signal) => {+    if (aborted) {+      return;+    }++    if (signal.aborted) {+      onabort.call(signal);+      return;+    }++    signal.addEventListener('abort', onabort, { once: true });+  }); 

--- +++ @@ -25,8 +25,14 @@ function parsePropPath(name) {-  // foo[x][y][z]-  // foo.x.y.z-  // foo-x-y-z-  // foo x y z+  // foo[x][y][z] -> ['foo', 'x', 'y', 'z']+  // foo.x.y.z    -> ['foo', 'x', 'y', 'z']+  // A path is split on `.` and on `[...]` groups. A segment — whether written+  // in dot notation or captured inside brackets — may contain any character+  // except `.`, `[` and `]`, so a key like `user-name` or `user name` is kept+  // literal instead of being split (#5402). `.`, `[` and `]` keep their existing+  // meaning, e.g. `foo[bar.baz]` -> ['foo', 'bar', 'baz'] and `[]` is an array push.+  // Excluding `[` from the bracket group also makes the match fail fast at the+  // next `[`, so a malformed name cannot rescan to the end of the string from+  // every unmatched `[` — parsing stays linear in the length of the name.   const path = [];-  const pattern = /\w+|\[(\w*)]/g;+  const pattern = /[^.[\]]+|\[([^.[\]]*)]/g;   let match;

--- +++ @@ -52,3 +52,5 @@ -      if (!key || (parsed[key] && ignoreDuplicateOf[key])) {+      const hasKey = utils.hasOwnProp(parsed, key);++      if (!key || (hasKey && utils.hasOwnProp(ignoreDuplicateOf, key))) {         return;@@ -57,3 +59,3 @@       if (key === 'set-cookie') {-        if (parsed[key]) {+        if (hasKey) {           parsed[key].push(val);@@ -63,3 +65,3 @@       } else {-        parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;+        parsed[key] = hasKey ? parsed[key] + ', ' + val : val;       }

--- +++ @@ -14,3 +14,3 @@     const total = e.lengthComputable ? e.total : undefined;-    const loaded = total != null ? Math.min(rawLoaded, total) : rawLoaded;+    const loaded = Math.max(0, total != null ? Math.min(rawLoaded, total) : rawLoaded);     const progressBytes = Math.max(0, loaded - bytesNotified);@@ -51,4 +51,4 @@ export const asyncDecorator =-  (fn) =>+  (fn, scheduler = utils.asap) =>   (...args) =>-    utils.asap(() => fn(...args));+    scheduler(() => fn(...args));

--- +++ @@ -8,18 +8,4 @@ import AxiosHeaders from '../core/AxiosHeaders.js';+import setFormDataHeaders from '../core/setFormDataHeaders.js'; import buildURL from './buildURL.js';--const FORM_DATA_CONTENT_HEADERS = ['content-type', 'content-length'];--function setFormDataHeaders(headers, formHeaders, policy) {-  if (policy !== 'content-only') {-    headers.set(formHeaders);-    return;-  }--  Object.entries(formHeaders || {}).forEach(([key, val]) => {-    if (FORM_DATA_CONTENT_HEADERS.includes(key.toLowerCase())) {-      headers.set(key, val);-    }-  });-} 

--- +++ @@ -7,2 +7,108 @@   return parts.every((p) => /^\d+$/.test(p) && Number(p) >= 0 && Number(p) <= 255);+};++/**+ * Canonicalize an IPv4 address written in shorthand, octal, or hex form into+ * dotted-decimal. IPv6 addresses and non-IP strings are returned unchanged so+ * the existing IPv4-mapped IPv6 unmap path and the isLoopback path can still+ * see them.+ *+ * Shorthand expansion mirrors Node's URL parser: literal parts fill from the+ * left, the final part fills the remaining octets from the right with+ * zero-padding on the left.+ *   127.1     -> 127.0.0.1+ *   127.0.1   -> 127.0.0.1+ *   1.2.3     -> 1.2.0.3+ *+ * Each octet is parsed with an explicit base: 16 for `0x`/`0X` prefix, 8 for+ * zero-prefixed multi-digit all-`0-7` parts, 10 otherwise. Zero-prefixed+ * decimal-looking parts that contain `8` or `9` are rejected to match Node's+ * URL parser, and the comparison layer falls through to non-bypass if either+ * side rejects the form (fail-safe).+ *+ * Returns the input unchanged on any parse failure, out-of-range octet, or+ * unusual shape (1-part, 5+ parts) so the comparison layer fails closed.+ */+const parseIPv4Octet = (text) => {+  if (/^0[xX][0-9a-fA-F]+$/.test(text)) {+    const n = parseInt(text.slice(2), 16);+    return Number.isFinite(n) ? n : null;+  }+  if (text.length > 1 && /^0[0-7]+$/.test(text)) {+    const n = parseInt(text, 8);+    return Number.isFinite(n) ? n : null;+  }+  if (text.length > 1 && /^0[0-9]+$/.test(text)) {+    return null;+  }+  if (/^[0-9]+$/.test(text)) {+    const n = parseInt(text, 10);+    return Number.isFinite(n) ? n : null;+  }+  return null;+};++const normalizeIPAddress = (host) => {+  if (typeof host !== 'string' || !host || host.indexOf(':') !== -1) {+    return host;+  }++  let h = host;+  if (h.charAt(0) === '[' && h.charAt(h.length - 1) === ']') {+    h = h.slice(1, -1);+  }+  h = h.replace(/\.+$/, '');++  // Allowed characters for any IPv4 shape: digits, dot, 'x', 'X', hex digits.+  if (!/^[0-9.xXa-fA-F]+$/.test(h)) return host;++  const parts = h.split('.');++  // No part may be empty (e.g. "127..0.1" or "127.0.0."). Trailing dots are+  // already stripped above; this guards against the empty-middle case.+  if (parts.some((p) => p === '')) return host;++  if (parts.length === 4) {+    // Full IPv4 form: each part is an octet.+    const octets = parts.map(parseIPv4Octet);+    if (octets.some((n) => n === null || n < 0 || n > 255)) return host;+    return octets.join('.');+  }++  if (parts.length > 4) {+    return host;+  }++  // Shorthand: 1..3 parts. Node's URL parser treats a 1-part input as a 32-bit+  // integer split into octets, which has surprising semantics (e.g. "127" ->+  // "0.0.0.127"). Reject 1-part inputs to keep the helper predictable: the+  // fail-safe returns the input unchanged and the comparison layer falls+  // through to non-bypass.+  if (parts.length === 1) return host;++  // 2..3 parts: literal parts fill from the left, tail fills remaining octets+  // from the right with zero-padding.+  const literalOctets = parts.slice(0, -1);+  const tail = parts[parts.length - 1];+  const tailSlots = 4 - literalOctets.length;++  // Tail is parsed as a full IPv4 number (hex/octal/decimal) and packed+  // low-byte-right into the remaining octets, matching Node's URL parser.+  // e.g. 127.65535 (tail 0xFFFF into 3 slots) -> 127.0.255.255;+  //      127.0x00ff (tail 0xFF into 3 slots) -> 127.0.0.255;+  //      127.0.65535 (tail 0xFFFF into 2 slots) -> 127.0.255.255.+  const tailValue = parseIPv4Octet(tail);+  if (tailValue === null) return host;+  const maxTail = (1 << (8 * tailSlots)) - 1;+  if (tailValue < 0 || tailValue > maxTail) return host;++  const tailOctets = new Array(tailSlots).fill(0);+  for (let i = tailSlots - 1, v = tailValue; i >= 0; i--, v >>= 8) {+    tailOctets[i] = v & 0xff;+  }++  const literal = literalOctets.map(parseIPv4Octet);+  if (literal.some((n) => n === null || n < 0 || n > 255)) return host;++  return [...literal, ...tailOctets].join('.'); };@@ -155,3 +261,12 @@ -  return unmapIPv4MappedIPv6(hostname.replace(/\.+$/, ''));+  const trimmed = hostname.replace(/\.+$/, '');++  // IPv4 shorthand/octal/hex → dotted-decimal; helper is a no-op for inputs+  // containing ':' (IPv6 and IPv4-mapped IPv6) so we fall through to unmap.+  const ipv4 = normalizeIPAddress(trimmed);+  if (ipv4 !== trimmed) {+    return ipv4;+  }++  return unmapIPv4MappedIPv6(trimmed); };@@ -187,2 +302,6 @@ +    if (entry === '*') {+      return true;+    }+     let [entryHost, entryPort] = parseNoProxyEntry(entry);

--- +++ @@ -6,2 +6,3 @@ import PlatformFormData from '../platform/node/classes/FormData.js';+import PlatformBuffer from '../platform/node/classes/Buffer.js'; @@ -148,4 +149,4 @@       }-      if (typeof Buffer !== 'undefined') {-        return Buffer.from(value);+      if (PlatformBuffer && PlatformBuffer.isBufferAvailable()) {+        return PlatformBuffer.from(value);       }

--- +++ @@ -0,0 +1,11 @@+'use strict';++export default {+  isBufferAvailable() {+    return typeof Buffer !== 'undefined';+  },++  from(value) {+    return Buffer.from(value);+  }+};

--- +++ @@ -284,2 +284,3 @@ const isFileList = kindOfTest('FileList');+const isSet = kindOfTest('Set'); @@ -849,8 +850,19 @@         visited.add(source);-        const target = isArray(source) ? [] : {};--        forEach(source, (value, key) => {-          const reducedValue = visit(value);-          !isUndefined(reducedValue) && (target[key] = reducedValue);-        });++        let target;++        if (isSet(source)) {+          target = [];+          for (const value of source) {+            const reducedValue = visit(value);+            !isUndefined(reducedValue) && target.push(reducedValue);+          }+        } else {+          target = isArray(source) ? [] : {};++          forEach(source, (value, key) => {+            const reducedValue = visit(value);+            !isUndefined(reducedValue) && (target[key] = reducedValue);+          });+        } 

--- +++ @@ -2,3 +2,3 @@   "name": "babel-core",-  "version": "6.26.2",+  "version": "6.26.3",   "description": "Babel compiler core.",

--- +++ @@ -21,3 +21,3 @@     plugins: [-      ["flow", { all: true }],+      ["flow", { all: true, enums: true }],       "jsx",

--- +++ @@ -2,3 +2,3 @@   "name": "babel-eslint",-  "version": "10.0.3",+  "version": "10.1.0",   "description": "Custom parser for ESLint",@@ -14,5 +14,5 @@     "@babel/code-frame": "^7.0.0",-    "@babel/parser": "^7.0.0",-    "@babel/traverse": "^7.0.0",-    "@babel/types": "^7.0.0",+    "@babel/parser": "^7.7.0",+    "@babel/traverse": "^7.7.0",+    "@babel/types": "^7.7.0",     "eslint-visitor-keys": "^1.0.0",

--- +++ @@ -2,3 +2,3 @@ 	"name": "chalk",-	"version": "5.6.2",+	"version": "6.0.0", 	"description": "Terminal string styling done right",@@ -8,4 +8,6 @@ 	"type": "module",-	"main": "./source/index.js",-	"exports": "./source/index.js",+	"exports": {+		"types": "./source/index.d.ts",+		"default": "./source/index.js"+	}, 	"imports": {@@ -17,9 +19,8 @@ 	},-	"types": "./source/index.d.ts", 	"sideEffects": false, 	"engines": {-		"node": "^12.17.0 || ^14.13 || >=16.0.0"+		"node": ">=22" 	}, 	"scripts": {-		"test": "xo && c8 ava && tsd",+		"test": "xo && c8 ava && tsc --noEmit --types node source/index.d.ts", 		"bench": "matcha benchmark.js"@@ -27,4 +28,3 @@ 	"files": [-		"source",-		"!source/index.test-d.ts"+		"source" 	],@@ -53,22 +53,31 @@ 	"devDependencies": {-		"@types/node": "^16.11.10",-		"ava": "^3.15.0",-		"c8": "^7.10.0",-		"color-convert": "^2.0.1",-		"execa": "^6.0.0",-		"log-update": "^5.0.0",+		"@types/node": "^26.1.1",+		"ansi-styles": "^6.2.3",+		"ava": "^8.0.1",+		"c8": "^12.0.0",+		"color-convert": "^3.1.3",+		"execa": "^10.0.0",+		"log-update": "^8.0.0", 		"matcha": "^0.7.0",-		"tsd": "^0.19.0",-		"xo": "^0.57.0",+		"typescript": "^6.0.3",+		"xo": "^4.0.0", 		"yoctodelay": "^2.0.0" 	},-	"xo": {-		"rules": {-			"unicorn/prefer-string-slice": "off",-			"@typescript-eslint/consistent-type-imports": "off",-			"@typescript-eslint/consistent-type-exports": "off",-			"@typescript-eslint/consistent-type-definitions": "off",-			"unicorn/expiring-todo-comments": "off"+	"xo": [+		{+			"ignores": [+				"source/vendor"+			]+		},+		{+			"rules": {+				"unicorn/prefer-string-slice": "off",+				"@typescript-eslint/consistent-type-imports": "off",+				"@typescript-eslint/consistent-type-exports": "off",+				"@typescript-eslint/consistent-type-definitions": "off",+				"unicorn/expiring-todo-comments": "off",+				"no-warning-comments": "off"+			} 		}-	},+	], 	"c8": {

--- +++ @@ -1,2 +1,2 @@-// TODO: Make it this when TS suports that.+// TODO: Make it this when TS supports that. // import {ModifierName, ForegroundColor, BackgroundColor, ColorName} from '#ansi-styles';@@ -22,4 +22,8 @@ 	- `3` - Truecolor 16 million colors support.-	*/-	readonly level?: ColorSupportLevel;++	Omit this option, or pass `undefined`, to have the level detected instead.++	@throws If the value is neither `undefined` nor an integer from 0 to 3.+	*/+	readonly level?: ColorSupportLevel | undefined; }@@ -44,2 +48,4 @@ 	- `3` - Truecolor 16 million colors support.++	@throws If the assigned value is not an integer from 0 to 3. 	*/@@ -76,2 +82,4 @@ +	The value is downsampled to the 16-color palette on terminals that only support basic colors (level 1), so `chalk.ansi256(196)` becomes 91 (ANSI escape for bright red).+ 	@example@@ -112,3 +120,5 @@ 	/**-	Use a [8-bit unsigned number](https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit) to set background color.+	Use an [8-bit unsigned number](https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit) to set background color.++	The value is downsampled to the 16-color palette on terminals that only support basic colors (level 1), so `chalk.bgAnsi256(196)` becomes 101 (ANSI escape for bright red background). @@ -124,2 +134,48 @@ 	/**+	Use RGB values to set underline color.++	The underline color is only visible when an underline style is also applied.++	@example+	```+	import chalk from 'chalk';++	chalk.underlineRgb(222, 173, 237).underlineCurly('Hello, world!');+	```+	*/+	underlineRgb: (red: number, green: number, blue: number) => this;++	/**+	Use HEX value to set underline color.++	The underline color is only visible when an underline style is also applied.++	@param color - Hexadecimal value representing the desired color.++	@example+	```+	import chalk from 'chalk';++	chalk.underlineHex('#DEADED').underlineCurly('Hello, world!');+	```+	*/+	underlineHex: (color: string) => this;++	/**+	Use an [8-bit unsigned number](https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit) to set underline color.++	The underline color is only visible when an underline style is also applied.++	The value is downsampled to the first 16 palette entries on terminals that only support basic colors (level 1), so `chalk.underlineAnsi256(196)` becomes 9 (the palette index for bright red).++	@example+	```+	import chalk from 'chalk';++	chalk.underlineAnsi256(201).underlineCurly('Hello, world!');+	```+	*/+	underlineAnsi256: (index: number) => this;++	/** 	Modifier: Reset the current style.@@ -147,2 +203,22 @@ 	readonly underline: this;++	/**+	Modifier: Put a double horizontal line below the text. *(Not widely supported)*+	*/+	readonly underlineDouble: this;++	/**+	Modifier: Put a curly horizontal line below the text. *(Not widely supported)*+	*/+	readonly underlineCurly: this;++	/**+	Modifier: Put a dotted horizontal line below the text. *(Not widely supported)*+	*/+	readonly underlineDotted: this;++	/**+	Modifier: Put a dashed horizontal line below the text. *(Not widely supported)*+	*/+	readonly underlineDashed: this; @@ -184,3 +260,3 @@ -	/*+	/** 	Alias for `blackBright`.@@ -189,3 +265,3 @@ -	/*+	/** 	Alias for `blackBright`.@@ -212,3 +288,3 @@ -	/*+	/** 	Alias for `bgBlackBright`.@@ -217,3 +293,3 @@ -	/*+	/** 	Alias for `bgBlackBright`.@@ -230,2 +306,30 @@ 	readonly bgWhiteBright: this;++	readonly underlineBlack: this;+	readonly underlineRed: this;+	readonly underlineGreen: this;+	readonly underlineYellow: this;+	readonly underlineBlue: this;+	readonly underlineMagenta: this;+	readonly underlineCyan: this;+	readonly underlineWhite: this;++	/**+	Alias for `underlineBlackBright`.+	*/+	readonly underlineGray: this;++	/**+	Alias for `underlineBlackBright`.+	*/+	readonly underlineGrey: this;++	readonly underlineBlackBright: this;+	readonly underlineRedBright: this;+	readonly underlineGreenBright: this;+	readonly underlineYellowBright: this;+	readonly underlineBlueBright: this;+	readonly underlineMagentaBright: this;+	readonly underlineCyanBright: this;+	readonly underlineWhiteBright: this; }@@ -249,4 +353,12 @@ export {-	ModifierName, ForegroundColorName, BackgroundColorName, ColorName,-	modifierNames, foregroundColorNames, backgroundColorNames, colorNames,+	ModifierName,+	ForegroundColorName,+	BackgroundColorName,+	UnderlineColorName,+	ColorName,+	modifierNames,+	foregroundColorNames,+	backgroundColorNames,+	underlineColorNames,+	colorNames, // } from '#ansi-styles';@@ -301,3 +413,3 @@ */-export const modifiers: readonly Modifiers[];+export const modifiers: readonly ModifierName[]; @@ -308,3 +420,3 @@ */-export const foregroundColors: readonly ForegroundColor[];+export const foregroundColors: readonly ForegroundColorName[]; @@ -315,3 +427,3 @@ */-export const backgroundColors: readonly BackgroundColor[];+export const backgroundColors: readonly BackgroundColorName[]; @@ -322,3 +434,3 @@ */-export const colors: readonly Color[];+export const colors: readonly ColorName[]; 

--- +++ @@ -1,4 +1,2 @@-import ansiStyles from '#ansi-styles';-import supportsColor from '#supports-color';-import { // eslint-disable-line import/order+import { 	stringReplaceAll,@@ -6,2 +4,4 @@ } from './utilities.js';+import ansiStyles from '#ansi-styles';+import supportsColor from '#supports-color'; @@ -12,10 +12,3 @@ const IS_EMPTY = Symbol('IS_EMPTY');--// `supportsColor.level` → `ansiStyles.color[name]` mapping-const levelMapping = [-	'ansi',-	'ansi',-	'ansi256',-	'ansi16m',-];+const LEVEL = Symbol('LEVEL'); @@ -23,10 +16,28 @@ +const assertValidLevel = level => {+	if (!Number.isSafeInteger(level) || level < 0 || level > 3) {+		throw new Error('The `level` should be an integer from 0 to 3');+	}+};++// The level is stored under a symbol so the hot path can read it as a plain property, while `level` itself is an accessor that rejects values the rest of the code could not handle.+const levelDescriptor = {+	enumerable: true,+	get() {+		return this[LEVEL];+	},+	set(level) {+		assertValidLevel(level);+		this[LEVEL] = level;+	},+};+ const applyOptions = (object, options = {}) => {-	if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {-		throw new Error('The `level` option should be an integer from 0 to 3');-	}--	// Detect level if not set manually+	if (options.level !== undefined) {+		assertValidLevel(options.level);+	}++	// Detect level if not set manually. Written under the symbol rather than through `level`, as the prototype carrying that accessor is not installed until after this runs. 	const colorLevel = stdoutColor ? stdoutColor.level : 0;-	object.level = options.level === undefined ? colorLevel : options.level;+	object[LEVEL] = options.level === undefined ? colorLevel : options.level; };@@ -53,2 +64,3 @@ +// eslint-disable-next-line unicorn/no-top-level-side-effects -- The prototype chain must be set up at module load. Object.setPrototypeOf(createChalk.prototype, Function.prototype);@@ -73,13 +85,10 @@ -const getModelAnsi = (model, level, type, ...arguments_) => {+// Resolve a color model to one converter per `level`, so that a call only has to look up the converter for the current level instead of re-deciding the model and level every time.+const createModelConverters = (model, type) => {+	const style = ansiStyles[type];+ 	if (model === 'rgb') {-		if (level === 'ansi16m') {-			return ansiStyles[type].ansi16m(...arguments_);-		}--		if (level === 'ansi256') {-			return ansiStyles[type].ansi256(ansiStyles.rgbToAnsi256(...arguments_));-		}--		return ansiStyles[type].ansi(ansiStyles.rgbToAnsi(...arguments_));+		const ansi = (red, green, blue) => style.ansi(ansiStyles.rgbToAnsi(red, green, blue));+		const ansi256 = (red, green, blue) => style.ansi256(ansiStyles.rgbToAnsi256(red, green, blue));+		return [ansi, ansi, ansi256, style.ansi16m]; 	}@@ -87,6 +96,10 @@ 	if (model === 'hex') {-		return getModelAnsi('rgb', level, type, ...ansiStyles.hexToRgb(...arguments_));-	}--	return ansiStyles[type][model](...arguments_);+		const ansi = hex => style.ansi(ansiStyles.hexToAnsi(hex));+		const ansi256 = hex => style.ansi256(ansiStyles.hexToAnsi256(hex));+		return [ansi, ansi, ansi256, hex => style.ansi16m(...ansiStyles.hexToRgb(hex))];+	}++	// `ansi256` is already the native form, so only the 16-color levels need converting.+	const ansi = code => style.ansi(ansiStyles.ansi256ToAnsi(code));+	return [ansi, ansi, style.ansi256, style.ansi256]; };@@ -96,36 +109,43 @@ for (const model of usedModels) {-	styles[model] = {-		get() {-			const {level} = this;-			return function (...arguments_) {-				const styler = createStyler(getModelAnsi(model, levelMapping[level], 'color', ...arguments_), ansiStyles.color.close, this[STYLER]);-				return createBuilder(this, styler, this[IS_EMPTY]);-			};+	const capitalizedModel = model[0].toUpperCase() + model.slice(1);++	for (const [styleName, type] of [+		[model, 'color'],+		['bg' + capitalizedModel, 'bgColor'],+		['underline' + capitalizedModel, 'underlineColor'],+	]) {+		const {close} = ansiStyles[type];+		const converters = createModelConverters(model, type);++		styles[styleName] = {+			get() {+				// The level is read on call rather than captured here so the function can be cached on the instance instead of being reallocated on every property access.+				// `rgb` is the widest model, so naming the three parameters avoids a rest array.+				const styleFunction = function (first, second, third) {+					const open = converters[this.level](first, second, third);+					return createBuilder(this, createStyler(open, close, this[STYLER]), this[IS_EMPTY]);+				};++				Object.defineProperty(this, styleName, {value: styleFunction});+				return styleFunction;+			},+		};+	}+}++const proto = Object.defineProperties(+	() => {},+	{+		...styles,+		level: {+			enumerable: true,+			get() {+				return this[GENERATOR].level;+			},+			set(level) {+				this[GENERATOR].level = level;+			}, 		},-	};--	const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);-	styles[bgModel] = {-		get() {-			const {level} = this;-			return function (...arguments_) {-				const styler = createStyler(getModelAnsi(model, levelMapping[level], 'bgColor', ...arguments_), ansiStyles.bgColor.close, this[STYLER]);-				return createBuilder(this, styler, this[IS_EMPTY]);-			};-		},-	};-}--const proto = Object.defineProperties(() => {}, {-	...styles,-	level: {-		enumerable: true,-		get() {-			return this[GENERATOR].level;-		},-		set(level) {-			this[GENERATOR].level = level;-		},-	},-});+	},+); @@ -153,4 +173,14 @@ 	// Single argument is hot path, implicit coercion is faster than anything-	// eslint-disable-next-line no-implicit-coercion-	const builder = (...arguments_) => applyStyle(builder, (arguments_.length === 1) ? ('' + arguments_[0]) : arguments_.join(' '));+	const builder = (...arguments_) => {+		if (arguments_.length === 1) {+			// eslint-disable-next-line no-implicit-coercion+			return applyStyle(builder, '' + arguments_[0]);+		}++		if (arguments_.length === 2) {+			return applyStyle(builder, arguments_[0] + ' ' + arguments_[1]);+		}++		return applyStyle(builder, arguments_.join(' '));+	}; @@ -160,3 +190,4 @@ -	builder[GENERATOR] = self;+	// Point every builder at the root generator instead of its immediate parent, so reading the level costs one property load rather than walking a `level` getter per link of the chain.+	builder[GENERATOR] = self[GENERATOR] ?? self; 	builder[STYLER] = _styler;@@ -168,3 +199,5 @@ const applyStyle = (self, string) => {-	if (self.level <= 0 || !string) {+	// Read the level directly off the generator to skip the `level` getter dispatch on this hot path+	if (self[GENERATOR][LEVEL] <= 0 || !string) {+		// eslint-disable-next-line unicorn/no-computed-property-existence-check -- Reads the boolean value, not a property existence check. 		return self[IS_EMPTY] ? '' : string;@@ -179,3 +212,3 @@ 	const {openAll, closeAll} = styler;-	if (string.includes('\u001B')) {+	if (string.includes('\u{1B}')) { 		while (styler !== undefined) {@@ -201,3 +234,5 @@ -Object.defineProperties(createChalk.prototype, styles);+// `level` lives on the prototype rather than on each instance, so it costs nothing to construct an instance and matches how builders already expose it. It is inherited rather than own, so it does not show up in `Object.keys()`, same as for a builder.+// eslint-disable-next-line unicorn/no-top-level-side-effects -- The style getters must be installed at module load.+Object.defineProperties(createChalk.prototype, {...styles, level: levelDescriptor}); @@ -210,2 +245,3 @@ 	backgroundColorNames,+	underlineColorNames, 	colorNames,

--- +++ @@ -1,3 +1,3 @@-// TODO: When targeting Node.js 16, use `String.prototype.replaceAll`.-export function stringReplaceAll(string, substring, replacer) {+// Note: Each match is kept and `postfix` is inserted after it. `String#replaceAll(substring, substring + postfix)` does the same, but it has to scan the replacement for `$` patterns and it is several times slower on the no-match path that most calls take.+export function stringReplaceAll(string, substring, postfix) { 	let index = string.indexOf(substring);@@ -11,3 +11,3 @@ 	do {-		returnValue += string.slice(endIndex, index) + substring + replacer;+		returnValue += string.slice(endIndex, index) + substring + postfix; 		endIndex = index + substringLength;@@ -24,4 +24,4 @@ 	do {-		const gotCR = string[index - 1] === '\r';-		returnValue += string.slice(endIndex, (gotCR ? index - 1 : index)) + prefix + (gotCR ? '\r\n' : '\n') + postfix;+		const isGotCR = string[index - 1] === '\r';+		returnValue += string.slice(endIndex, (isGotCR ? index - 1 : index)) + prefix + (isGotCR ? '\r\n' : '\n') + postfix; 		endIndex = index + 1;

--- +++ @@ -1,2 +1,2 @@-export interface CSPair { // eslint-disable-line @typescript-eslint/naming-convention+export type CSPair = { // eslint-disable-line @typescript-eslint/naming-convention 	/**@@ -10,5 +10,5 @@ 	readonly close: string;-}--export interface ColorBase {+};++export type ColorBase = { 	/**@@ -23,5 +23,5 @@ 	ansi16m(red: number, green: number, blue: number): string;-}--export interface Modifier {+};++export type Modifier = { 	/**@@ -47,3 +47,3 @@ 	/**-	Make text underline. (Not widely supported)+	Put a horizontal line below the text. (Not widely supported) 	*/@@ -52,3 +52,23 @@ 	/**-	Make text overline.+	Put a double horizontal line below the text. (Not widely supported)+	*/+	readonly underlineDouble: CSPair;++	/**+	Put a curly horizontal line below the text. (Not widely supported)+	*/+	readonly underlineCurly: CSPair;++	/**+	Put a dotted horizontal line below the text. (Not widely supported)+	*/+	readonly underlineDotted: CSPair;++	/**+	Put a dashed horizontal line below the text. (Not widely supported)+	*/+	readonly underlineDashed: CSPair;++	/**+	Put a horizontal line above the text. @@ -72,5 +92,5 @@ 	readonly strikethrough: CSPair;-}--export interface ForegroundColor {+};++export type ForegroundColor = { 	readonly black: CSPair;@@ -102,5 +122,5 @@ 	readonly whiteBright: CSPair;-}--export interface BackgroundColor {+};++export type BackgroundColor = { 	readonly bgBlack: CSPair;@@ -132,5 +152,35 @@ 	readonly bgWhiteBright: CSPair;-}--export interface ConvertColor {+};++export type UnderlineColor = {+	readonly underlineBlack: CSPair;+	readonly underlineRed: CSPair;+	readonly underlineGreen: CSPair;+	readonly underlineYellow: CSPair;+	readonly underlineBlue: CSPair;+	readonly underlineCyan: CSPair;+	readonly underlineMagenta: CSPair;+	readonly underlineWhite: CSPair;++	/**+	Alias for `underlineBlackBright`.+	*/+	readonly underlineGray: CSPair;++	/**+	Alias for `underlineBlackBright`.+	*/+	readonly underlineGrey: CSPair;++	readonly underlineBlackBright: CSPair;+	readonly underlineRedBright: CSPair;+	readonly underlineGreenBright: CSPair;+	readonly underlineYellowBright: CSPair;+	readonly underlineBlueBright: CSPair;+	readonly underlineCyanBright: CSPair;+	readonly underlineMagentaBright: CSPair;+	readonly underlineWhiteBright: CSPair;+};++export type ConvertColor = { 	/**@@ -180,3 +230,3 @@ 	hexToAnsi(hex: string): number;-}+}; @@ -202,2 +252,9 @@ /**+Basic underline color names.++[More colors here.](https://github.com/chalk/chalk/blob/main/readme.md#256-and-truecolor-color-support)+*/+export type UnderlineColorName = keyof UnderlineColor;++/** Basic color names. The combination of foreground and background color names.@@ -223,3 +280,8 @@ -/*+/**+Basic underline color names.+*/+export const underlineColorNames: readonly UnderlineColorName[];++/** Basic color names. The combination of foreground and background color names.@@ -232,4 +294,5 @@ 	readonly bgColor: ColorBase & BackgroundColor;+	readonly underlineColor: ColorBase & UnderlineColor; 	readonly codes: ReadonlyMap<number, number>;-} & ForegroundColor & BackgroundColor & Modifier & ConvertColor;+} & ForegroundColor & BackgroundColor & UnderlineColor & Modifier & ConvertColor; 

--- +++ @@ -1,3 +1 @@-/* eslint-env browser */- const level = (() => {@@ -8,4 +6,4 @@ 	if (globalThis.navigator.userAgentData) {-		const brand = navigator.userAgentData.brands.find(({brand}) => brand === 'Chromium');-		if (brand && brand.version > 93) {+		const brand = globalThis.navigator.userAgentData.brands.find(({brand}) => brand === 'Chromium');+		if (brand?.version > 93) { 			return 3;@@ -14,3 +12,3 @@ -	if (/\b(Chrome|Chromium)\//.test(globalThis.navigator.userAgent)) {+	if (/\b(?:Chrome|Chromium)\//.test(globalThis.navigator.userAgent)) { 		return 1;

--- +++ @@ -32,14 +32,25 @@ +// Whether `FORCE_COLOR` names a level. Shared with the exact-level check below so that the two cannot disagree on what counts as numeric.+function hasNumericForceColor() {+	return /^\d+$/.test(env.FORCE_COLOR);+}+ function envForceColor() {-	if ('FORCE_COLOR' in env) {-		if (env.FORCE_COLOR === 'true') {-			return 1;-		}--		if (env.FORCE_COLOR === 'false') {-			return 0;-		}--		return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);-	}+	if (!('FORCE_COLOR' in env)) {+		return;+	}++	if (env.FORCE_COLOR === 'false') {+		return 0;+	}++	if (env.FORCE_COLOR === 'true' || env.FORCE_COLOR.length === 0) {+		return 1;+	}++	if (!hasNumericForceColor()) {+		return;+	}++	return Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3); }@@ -81,2 +92,7 @@ 		}+	}++	// A numeric `FORCE_COLOR` requests an exact level, while `FORCE_COLOR=true` and `FORCE_COLOR=` only enable color and let the level be detected.+	if (forceColor !== undefined && hasNumericForceColor()) {+		return forceColor; 	}@@ -126,3 +142,3 @@ 	if ('TEAMCITY_VERSION' in env) {-		return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;+		return /^(?:9\.0*[1-9]\d*\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0; 	}@@ -146,3 +162,3 @@ 	if ('TERM_PROGRAM' in env) {-		const version = Number.parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);+		const version = Number.parseInt((env.TERM_PROGRAM_VERSION || '').split('.', 1)[0], 10); @@ -160,3 +176,3 @@ -	if (/-256(color)?$/i.test(env.TERM)) {+	if (/-256(?:color)?$/i.test(env.TERM)) { 		return 2;

--- +++ @@ -64,3 +64,3 @@  * @param {Object} parser The parser to check.- * @returns {boolean} True if the parser is Espree or false if not.+ * @returns {boolean} `true` if the parser is Espree or `false` if not.  */

--- +++ @@ -120,3 +120,3 @@ 	 * @returns {void}-	 * @see http://www.graphviz.org+	 * @see https://www.graphviz.org 	 * @see http://www.webgraphviz.com

--- +++ @@ -42,3 +42,3 @@ 		 * In JavaScript, string data is stored as UTF-16, so BOM is 0xFEFF.-		 * http://www.ecma-international.org/ecma-262/6.0/#sec-unicode-format-control-characters+		 * https://262.ecma-international.org/6.0/#sec-unicode-format-control-characters 		 */

--- +++ @@ -143,6 +143,2 @@ 			if (isInstanceMethod(node)) {-				if (node.computed) {-					return true;-				}- 				if (ignoreOverrideMethods && node.override) {@@ -164,2 +160,6 @@ 					}+				}++				if (node.computed) {+					return true; 				}

--- +++ @@ -1,3 +1,3 @@ /**- * @fileoverview Counts the cyclomatic complexity of each function of the script. See http://en.wikipedia.org/wiki/Cyclomatic_complexity.+ * @fileoverview Counts the cyclomatic complexity of each function of the script. See https://en.wikipedia.org/wiki/Cyclomatic_complexity.  * Counts the number of if, conditional, for, while, try, switch/case,

--- +++ @@ -16,3 +16,3 @@  * Checks whether a string contains a line terminator as defined in- * http://www.ecma-international.org/ecma-262/5.1/#sec-7.3+ * https://262.ecma-international.org/5.1/#sec-7.3  * @param {string} str String to test.

--- +++ @@ -112,3 +112,3 @@ 		/*-		 * Inspired by http://tools.ietf.org/html/rfc3986#appendix-B, however:+		 * Inspired by https://datatracker.ietf.org/doc/html/rfc3986#appendix-B, however: 		 * - They're matching an entire string that we know is a URI

--- +++ @@ -100,7 +100,11 @@ 		const [{ ignore: ignoredLoopTypes }] = context.options;-		const loopTypesToCheck = getDifference(allLoopTypes, ignoredLoopTypes),-			loopSelector = loopTypesToCheck.join(","),-			loopsByTargetSegments = new Map(),-			loopsToReport = new Set();+		const loopTypesToCheck = getDifference(allLoopTypes, ignoredLoopTypes);+		const loopSelector = loopTypesToCheck.join(","); +		if (!loopSelector) {+			return {};+		}++		const loopsByTargetSegments = new Map();+		const loopsToReport = new Set(); 		const codePathSegments = [];

--- +++ @@ -13,2 +13,4 @@ 	isParenthesised,+	isStartOfExpressionStatement,+	needsPrecedingSemicolon, } = require("./utils/ast-utils");@@ -196,3 +198,9 @@ 		if (needsParens(node, sourceCode)) {-			yield fixer.replaceText(leftParen, "({");+			const prefix =+				isStartOfExpressionStatement(node) &&+				needsPrecedingSemicolon(sourceCode, node)+					? ";({"+					: "({";++			yield fixer.replaceText(leftParen, prefix); 			yield fixer.replaceText(rightParen, "})");

--- +++ @@ -206,3 +206,3 @@ 					.slice(1, -1)-					.replace(/\\*(\$\{|`)/gu, matched => {+					.replace(/(?<!\\)\\*(\$\{|`)/gu, matched => { 						if (matched.lastIndexOf("\\") % 2) {

--- +++ @@ -17,2 +17,4 @@ /** @typedef {import("estree").Node} ASTNode */+/** @typedef {import("eslint").Rule.Fix} Fix */+/** @typedef {import("eslint").Rule.RuleFixer} RuleFixer */ @@ -311,12 +313,11 @@ 		/**-		 * Gets the token after which new arguments should be inserted for the-		 * given argument, accounting for parentheses wrapping the argument so-		 * that insertions land outside them (e.g. `new Error(("msg"))`).-		 * @param {ASTNode} argNode The argument node.-		 * @param {ASTNode} callNode The enclosing call or new expression.-		 * @returns {Token} The token to insert after.+		 * Finds the first token that isn't followed by a closing parenthesis in a specified range.+		 * This is the token after which new arguments should be inserted.+		 * @param {Token} firstToken The first token to start searching from.+		 * @param {Token} lastToken The last token to scan up to (inclusive).+		 * @returns {Token} The first token that isn't followed by a closing parenthesis, or `lastToken` if none is found. 		 */-		function getLastArgumentToken(argNode, callNode) {-			const callLastToken = sourceCode.getLastToken(callNode);-			let token = sourceCode.getLastToken(argNode);+		function findInsertionTokenAfterParens(firstToken, lastToken) {+			const lastIndex = lastToken.range[1];+			let token = firstToken; 			let nextToken = sourceCode.getTokenAfter(token);@@ -324,4 +325,3 @@ 			while (-				nextToken &&-				nextToken !== callLastToken &&+				nextToken.range[1] <= lastIndex && 				astUtils.isClosingParenToken(nextToken)@@ -332,2 +332,57 @@ 			return token;+		}++		/**+		 * Adds arguments for a call/new expression with no arguments.+		 * Works for `new Error`, `new (Error)`, and forms that already include empty argument parentheses.+		 * @param {RuleFixer} fixer The fixer instance.+		 * @param {ASTNode & { callee: ASTNode }} throwExpression The thrown CallExpression or NewExpression node.+		 * @param {string} text The arguments to insert.+		 * @returns {Fix} The fixer operation.+		 */+		function addArgumentsToEmptyCall(fixer, throwExpression, text) {+			const callClosingParenToken =+				sourceCode.getLastToken(throwExpression);+			const lastCalleeToken = sourceCode.getLastToken(+				throwExpression.callee,+			);+			const parenToken = sourceCode.getFirstTokenBetween(+				lastCalleeToken,+				callClosingParenToken,+				astUtils.isOpeningParenToken,+			);++			if (parenToken) {+				return fixer.insertTextAfter(parenToken, text);+			}++			const insertionToken = findInsertionTokenAfterParens(+				lastCalleeToken,+				callClosingParenToken,+			);++			return fixer.insertTextAfter(insertionToken, `(${text})`);+		}++		/**+		 * Appends additional arguments after the last argument of a call/new expression,+		 * accounting for any wrapping parentheses around that argument.+		 * @param {RuleFixer} fixer The fixer instance.+		 * @param {ASTNode & { arguments: ASTNode[] }} throwExpression The thrown CallExpression or NewExpression node.+		 * @param {string} text The additional arguments to insert, including the leading comma.+		 * @returns {Fix} The fixer operation.+		 */+		function appendArguments(fixer, throwExpression, text) {+			const lastArgument = throwExpression.arguments.at(-1);+			const lastArgumentToken = sourceCode.getLastToken(lastArgument);+			const lastTokenBeforeArgListParen = sourceCode.getLastToken(+				throwExpression,+				{ skip: 1 },+			);+			const insertionToken = findInsertionTokenAfterParens(+				lastArgumentToken,+				lastTokenBeforeArgListParen,+			);++			return fixer.insertTextAfter(insertionToken, text); 		}@@ -452,26 +507,6 @@ 												// Case: `throw new AggregateError()` → insert all arguments-												const lastToken =-													sourceCode.getLastToken(-														throwExpression,-													);-												const lastCalleeToken =-													sourceCode.getLastToken(-														throwExpression.callee,-													);-												const parenToken =-													sourceCode.getFirstTokenBetween(-														lastCalleeToken,-														lastToken,-														astUtils.isOpeningParenToken,-													);--												if (parenToken) {-													return fixer.insertTextAfter(-														parenToken,-														`[], "", { cause: ${caughtError.name} }`,-													);-												}-												return fixer.insertTextAfter(-													throwExpression.callee,-													`([], "", { cause: ${caughtError.name} })`,+												return addArgumentsToEmptyCall(+													fixer,+													throwExpression,+													`[], "", { cause: ${caughtError.name} }`, 												);@@ -481,7 +516,5 @@ 												// Case: `throw new AggregateError([])` → insert message and options-												return fixer.insertTextAfter(-													getLastArgumentToken(-														errorsArg,-														throwExpression,-													),+												return appendArguments(+													fixer,+													throwExpression, 													`, "", { cause: ${caughtError.name} }`,@@ -492,7 +525,5 @@ 												// Case: `throw new AggregateError([], "")` → insert error options only-												return fixer.insertTextAfter(-													getLastArgumentToken(-														messageArg,-														throwExpression,-													),+												return appendArguments(+													fixer,+													throwExpression, 													`, { cause: ${caughtError.name} }`,@@ -513,26 +544,6 @@ 												// Case: `throw new Error()` → insert both message and options-												const lastToken =-													sourceCode.getLastToken(-														throwExpression,-													);-												const lastCalleeToken =-													sourceCode.getLastToken(-														throwExpression.callee,-													);-												const parenToken =-													sourceCode.getFirstTokenBetween(-														lastCalleeToken,-														lastToken,-														astUtils.isOpeningParenToken,-													);--												if (parenToken) {-													return fixer.insertTextAfter(-														parenToken,-														`"", { cause: ${caughtError.name} }`,-													);-												}-												return fixer.insertTextAfter(-													throwExpression.callee,-													`("", { cause: ${caughtError.name} })`,+												return addArgumentsToEmptyCall(+													fixer,+													throwExpression,+													`"", { cause: ${caughtError.name} }`, 												);@@ -541,7 +552,5 @@ 												// Case: `throw new Error("Some message")` → insert only options-												return fixer.insertTextAfter(-													getLastArgumentToken(-														messageArg,-														throwExpression,-													),+												return appendArguments(+													fixer,+													throwExpression, 													`, { cause: ${caughtError.name} }`,@@ -571,7 +580,5 @@ 												// Options slot missing, all prior args provided → append options-												return fixer.insertTextAfter(-													getLastArgumentToken(-														lastProvidedArg,-														throwExpression,-													),+												return appendArguments(+													fixer,+													throwExpression, 													`, { cause: ${caughtError.name} }`,@@ -580,27 +587,7 @@ -											// argumentPosition: 1 and no args → insert `{ cause: err }` inside parens-											const lastToken =-												sourceCode.getLastToken(-													throwExpression,-												);-											const lastCalleeToken =-												sourceCode.getLastToken(-													throwExpression.callee,-												);-											const parenToken =-												sourceCode.getFirstTokenBetween(-													lastCalleeToken,-													lastToken,-													astUtils.isOpeningParenToken,-												);--											if (parenToken) {-												return fixer.insertTextAfter(-													parenToken,-													`{ cause: ${caughtError.name} }`,-												);-											}-											return fixer.insertTextAfter(-												throwExpression.callee,-												`({ cause: ${caughtError.name} })`,+											// argumentPosition: 1 and no args → insert options inside parens+											return addArgumentsToEmptyCall(+												fixer,+												throwExpression,+												`{ cause: ${caughtError.name} }`, 											);

--- +++ @@ -222,3 +222,3 @@ 		 * Checks whether a specified node is either part of, or immediately follows a (possibly empty) directive prologue.-		 * @see {@link http://www.ecma-international.org/ecma-262/6.0/#sec-directive-prologues-and-the-use-strict-directive}+		 * @see {@link https://262.ecma-international.org/6.0/#sec-directive-prologues-and-the-use-strict-directive} 		 * @param {ASTNode} node A node to check.

--- +++ @@ -10,3 +10,3 @@  * @param {any} val the value to check- * @returns {boolean} true if so+ * @returns {boolean} `true` if so  * @private

--- +++ @@ -62,4 +62,4 @@  * @param {LintMessage} message The lint result.- * @returns {boolean} True if the lint message is an error (and thus should be- * autofixed), false otherwise.+ * @returns {boolean} `true` if the lint message is an error (and thus should be+ * autofixed), `false` otherwise.  */@@ -73,3 +73,3 @@  * @param {{ ruleId: string; severity: number; }} rule The rule id and severity.- * @returns {boolean} True if the lint rule should run, false otherwise.+ * @returns {boolean} `true` if the lint rule should run, `false` otherwise.  */

--- +++ @@ -7,2 +7,3 @@ 	type Config,+	type ConfigObject, 	defineConfig,@@ -12,2 +13,8 @@ -export { type Config, defineConfig, globalIgnores, includeIgnoreFile };+export {+	type Config,+	type ConfigObject,+	defineConfig,+	globalIgnores,+	includeIgnoreFile,+};

--- +++ @@ -2,3 +2,3 @@   "name": "eslint",-  "version": "10.7.0",+  "version": "10.8.0",   "author": "Nicholas C. Zakas <[email protected]>",@@ -131,3 +131,3 @@     "@eslint/config-array": "^0.23.5",-    "@eslint/config-helpers": "^0.6.0",+    "@eslint/config-helpers": "^0.7.0",     "@eslint/core": "^1.2.1",@@ -155,3 +155,3 @@     "json-stable-stringify-without-jsonify": "^1.0.1",-    "minimatch": "^10.2.4",+    "minimatch": "^10.2.5",     "natural-compare": "^1.4.0",@@ -207,3 +207,3 @@     "npm-license": "^0.3.3",-    "prettier": "3.9.4",+    "prettier": "3.9.5",     "progress": "^2.0.3",@@ -215,3 +215,3 @@     "typescript": "^6.0.3",-    "webpack": "^5.23.0",+    "webpack": "5.108.4",     "webpack-cli": "^4.5.0",

--- +++ @@ -50,2 +50,25 @@ +  "unicorn/template-indent"({ options }) {+    if (options.length === 0) {+      return false;+    }++    const { comments = [], tags = [] } = options[0] || {};++    return (+      Array.isArray(comments) &&+      Array.isArray(tags) &&+      !(+        comments.includes("GraphQL") ||+        comments.includes("HTML") ||+        tags.includes("css") ||+        tags.includes("graphql") ||+        tags.includes("gql") ||+        tags.includes("html") ||+        tags.includes("markdown") ||+        tags.includes("md")+      )+    );+  },+   "vue/html-self-closing"({ options }) {

--- +++ @@ -3,2 +3,4 @@ const includeDeprecated = !process.env.ESLINT_CONFIG_PRETTIER_NO_DEPRECATED;++const specialRule = 0; @@ -7,78 +9,15 @@     // The following rules can be used in some cases. See the README for more-    // information. (These are marked with `0` instead of `"off"` so that a-    // script can distinguish them.)-    "curly": 0,-    "lines-around-comment": 0,-    "max-len": 0,-    "no-confusing-arrow": 0,-    "no-mixed-operators": 0,-    "no-tabs": 0,-    "no-unexpected-multiline": 0,-    "quotes": 0,-    "@typescript-eslint/lines-around-comment": 0,-    "@typescript-eslint/quotes": 0,-    "babel/quotes": 0,-    "vue/html-self-closing": 0,-    "vue/max-len": 0,+    // information. These are marked with `0` instead of `"off"` so that a+    // script can distinguish them. Note that there are a few more of these+    // in the deprecated section below.+    "curly": specialRule,+    "no-unexpected-multiline": specialRule,+    "@typescript-eslint/lines-around-comment": specialRule,+    "@typescript-eslint/quotes": specialRule,+    "babel/quotes": specialRule,+    "unicorn/template-indent": specialRule,+    "vue/html-self-closing": specialRule,+    "vue/max-len": specialRule,      // The rest are rules that you never need to enable when using Prettier.-    "array-bracket-newline": "off",-    "array-bracket-spacing": "off",-    "array-element-newline": "off",-    "arrow-parens": "off",-    "arrow-spacing": "off",-    "block-spacing": "off",-    "brace-style": "off",-    "comma-dangle": "off",-    "comma-spacing": "off",-    "comma-style": "off",-    "computed-property-spacing": "off",-    "dot-location": "off",-    "eol-last": "off",-    "func-call-spacing": "off",-    "function-call-argument-newline": "off",-    "function-paren-newline": "off",-    "generator-star-spacing": "off",-    "implicit-arrow-linebreak": "off",-    "indent": "off",-    "jsx-quotes": "off",-    "key-spacing": "off",-    "keyword-spacing": "off",-    "linebreak-style": "off",-    "max-statements-per-line": "off",-    "multiline-ternary": "off",-    "newline-per-chained-call": "off",-    "new-parens": "off",-    "no-extra-parens": "off",-    "no-extra-semi": "off",-    "no-floating-decimal": "off",-    "no-mixed-spaces-and-tabs": "off",-    "no-multi-spaces": "off",-    "no-multiple-empty-lines": "off",-    "no-trailing-spaces": "off",-    "no-whitespace-before-property": "off",-    "nonblock-statement-body-position": "off",-    "object-curly-newline": "off",-    "object-curly-spacing": "off",-    "object-property-newline": "off",-    "one-var-declaration-per-line": "off",-    "operator-linebreak": "off",-    "padded-blocks": "off",-    "quote-props": "off",-    "rest-spread-spacing": "off",-    "semi": "off",-    "semi-spacing": "off",-    "semi-style": "off",-    "space-before-blocks": "off",-    "space-before-function-paren": "off",-    "space-in-parens": "off",-    "space-infix-ops": "off",-    "space-unary-ops": "off",-    "switch-colon-spacing": "off",-    "template-curly-spacing": "off",-    "template-tag-spacing": "off",-    "unicode-bom": "off",-    "wrap-iife": "off",-    "wrap-regex": "off",-    "yield-star-spacing": "off",     "@babel/object-curly-spacing": "off",@@ -175,5 +114,28 @@     ...(includeDeprecated && {+      // Removed in version 0.10.0.+      // https://eslint.org/docs/latest/rules/space-unary-word-ops+      "space-unary-word-ops": "off",+       // Removed in version 1.0.0.-      // https://eslint.org/docs/latest/rules/generator-star+      // https://github.com/eslint/eslint/issues/1898       "generator-star": "off",+      "no-comma-dangle": "off",+      "no-reserved-keys": "off",+      "no-space-before-semi": "off",+      "no-wrap-func": "off",+      "space-after-function-name": "off",+      "space-before-function-parentheses": "off",+      "space-in-brackets": "off",++      // Removed in version 2.0.0.+      // https://github.com/eslint/eslint/issues/5032+      "no-arrow-condition": "off",+      "space-after-keywords": "off",+      "space-before-keywords": "off",+      "space-return-throw-case": "off",++      // Deprecated since version 3.3.0.+      // https://eslint.org/docs/rules/no-spaced-func+      "no-spaced-func": "off",+       // Deprecated since version 4.0.0.@@ -181,41 +143,70 @@       "indent-legacy": "off",-      // Removed in version 2.0.0.-      // https://eslint.org/docs/latest/rules/no-arrow-condition-      "no-arrow-condition": "off",-      // Removed in version 1.0.0.-      // https://eslint.org/docs/latest/rules/no-comma-dangle-      "no-comma-dangle": "off",-      // Removed in version 1.0.0.-      // https://eslint.org/docs/latest/rules/no-reserved-keys-      "no-reserved-keys": "off",-      // Removed in version 1.0.0.-      // https://eslint.org/docs/latest/rules/no-space-before-semi-      "no-space-before-semi": "off",-      // Deprecated since version 3.3.0.-      // https://eslint.org/docs/rules/no-spaced-func-      "no-spaced-func": "off",-      // Removed in version 1.0.0.-      // https://eslint.org/docs/latest/rules/no-wrap-func-      "no-wrap-func": "off",-      // Removed in version 1.0.0.-      // https://eslint.org/docs/latest/rules/space-after-function-name-      "space-after-function-name": "off",-      // Removed in version 2.0.0.-      // https://eslint.org/docs/latest/rules/space-after-keywords-      "space-after-keywords": "off",-      // Removed in version 1.0.0.-      // https://eslint.org/docs/latest/rules/space-before-function-parentheses-      "space-before-function-parentheses": "off",-      // Removed in version 2.0.0.-      // https://eslint.org/docs/latest/rules/space-before-keywords-      "space-before-keywords": "off",-      // Removed in version 1.0.0.-      // https://eslint.org/docs/latest/rules/space-in-brackets-      "space-in-brackets": "off",-      // Removed in version 2.0.0.-      // https://eslint.org/docs/latest/rules/space-return-throw-case-      "space-return-throw-case": "off",-      // Removed in version 0.10.0.-      // https://eslint.org/docs/latest/rules/space-unary-word-ops-      "space-unary-word-ops": "off",++      // Deprecated since version 8.53.0.+      // https://eslint.org/blog/2023/10/deprecating-formatting-rules/+      "array-bracket-newline": "off",+      "array-bracket-spacing": "off",+      "array-element-newline": "off",+      "arrow-parens": "off",+      "arrow-spacing": "off",+      "block-spacing": "off",+      "brace-style": "off",+      "comma-dangle": "off",+      "comma-spacing": "off",+      "comma-style": "off",+      "computed-property-spacing": "off",+      "dot-location": "off",+      "eol-last": "off",+      "func-call-spacing": "off",+      "function-call-argument-newline": "off",+      "function-paren-newline": "off",+      "generator-star-spacing": "off",+      "implicit-arrow-linebreak": "off",+      "indent": "off",+      "jsx-quotes": "off",+      "key-spacing": "off",+      "keyword-spacing": "off",+      "linebreak-style": "off",+      "lines-around-comment": specialRule,+      "max-len": specialRule,+      "max-statements-per-line": "off",+      "multiline-ternary": "off",+      "new-parens": "off",+      "newline-per-chained-call": "off",+      "no-confusing-arrow": specialRule,+      "no-extra-parens": "off",+      "no-extra-semi": "off",+      "no-floating-decimal": "off",+      "no-mixed-operators": specialRule,+      "no-mixed-spaces-and-tabs": "off",+      "no-multi-spaces": "off",+      "no-multiple-empty-lines": "off",+      "no-tabs": specialRule,+      "no-trailing-spaces": "off",+      "no-whitespace-before-property": "off",+      "nonblock-statement-body-position": "off",+      "object-curly-newline": "off",+      "object-curly-spacing": "off",+      "object-property-newline": "off",+      "one-var-declaration-per-line": "off",+      "operator-linebreak": "off",+      "padded-blocks": "off",+      "quote-props": "off",+      "quotes": specialRule,+      "rest-spread-spacing": "off",+      "semi": "off",+      "semi-spacing": "off",+      "semi-style": "off",+      "space-before-blocks": "off",+      "space-before-function-paren": "off",+      "space-in-parens": "off",+      "space-infix-ops": "off",+      "space-unary-ops": "off",+      "switch-colon-spacing": "off",+      "template-curly-spacing": "off",+      "template-tag-spacing": "off",+      "wrap-iife": "off",+      "wrap-regex": "off",+      "yield-star-spacing": "off",+       // Deprecated since version 7.0.0.

--- +++ @@ -2,3 +2,3 @@   "name": "eslint-config-prettier",-  "version": "8.10.2",+  "version": "9.1.2",   "license": "MIT",

--- +++ @@ -0,0 +1,33 @@+import { ESLint, Linter, Rule } from 'eslint';++declare const plugin: ESLint.Plugin & {+  meta: {+    name: string;+    version: string;+  };+  configs: {+    'recommended': Linter.LegacyConfig;+    'errors': Linter.LegacyConfig;+    'warnings': Linter.LegacyConfig;+    'stage-0': Linter.LegacyConfig;+    'react': Linter.LegacyConfig;+    'react-native': Linter.LegacyConfig;+    'electron': Linter.LegacyConfig;+    'typescript': Linter.LegacyConfig;+  };+  flatConfigs: {+    'recommended': Linter.FlatConfig;+    'errors': Linter.FlatConfig;+    'warnings': Linter.FlatConfig;+    'stage-0': Linter.FlatConfig;+    'react': Linter.FlatConfig;+    'react-native': Linter.FlatConfig;+    'electron': Linter.FlatConfig;+    'typescript': Linter.FlatConfig;+  };+  rules: {+    [key: string]: Rule.RuleModule;+  };+};++export = plugin;

--- +++ @@ -47,2 +47,3 @@   'no-empty-named-blocks': require('./rules/no-empty-named-blocks'),+  'enforce-node-protocol-usage': require('./rules/enforce-node-protocol-usage'), @@ -97,6 +98,6 @@   // useful stuff for folks using various environments-  react: require('../config/flat/react'),-  'react-native': configs['react-native'],-  electron: configs.electron,-  typescript: configs.typescript };-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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  react: createFlatConfig(require('../config/flat/react'), 'react'),+  'react-native': createFlatConfig(configs['react-native'], 'react-native'),+  electron: createFlatConfig(configs.electron, 'electron'),+  typescript: createFlatConfig(configs.typescript, 'typescript') };+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/index.js"],"names":["rules","require","named","namespace","extensions","first","order","unambiguous","configs","recommended","errors","warnings","react","electron","typescript","importPlugin","meta","name","version","createFlatConfig","baseConfig","configName","plugins","flatConfigs"],"mappings":"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","file":"index.js","sourcesContent":["import { name, version } from '../package.json';\n\nexport const rules = {\n  'no-unresolved': require('./rules/no-unresolved'),\n  named: require('./rules/named'),\n  default: require('./rules/default'),\n  namespace: require('./rules/namespace'),\n  'no-namespace': require('./rules/no-namespace'),\n  export: require('./rules/export'),\n  'no-mutable-exports': require('./rules/no-mutable-exports'),\n  extensions: require('./rules/extensions'),\n  'no-restricted-paths': require('./rules/no-restricted-paths'),\n  'no-internal-modules': require('./rules/no-internal-modules'),\n  'group-exports': require('./rules/group-exports'),\n  'no-relative-packages': require('./rules/no-relative-packages'),\n  'no-relative-parent-imports': require('./rules/no-relative-parent-imports'),\n  'consistent-type-specifier-style': require('./rules/consistent-type-specifier-style'),\n\n  'no-self-import': require('./rules/no-self-import'),\n  'no-cycle': require('./rules/no-cycle'),\n  'no-named-default': require('./rules/no-named-default'),\n  'no-named-as-default': require('./rules/no-named-as-default'),\n  'no-named-as-default-member': require('./rules/no-named-as-default-member'),\n  'no-anonymous-default-export': require('./rules/no-anonymous-default-export'),\n  'no-unused-modules': require('./rules/no-unused-modules'),\n\n  'no-commonjs': require('./rules/no-commonjs'),\n  'no-amd': require('./rules/no-amd'),\n  'no-duplicates': require('./rules/no-duplicates'),\n  first: require('./rules/first'),\n  'max-dependencies': require('./rules/max-dependencies'),\n  'no-extraneous-dependencies': require('./rules/no-extraneous-dependencies'),\n  'no-absolute-path': require('./rules/no-absolute-path'),\n  'no-nodejs-modules': require('./rules/no-nodejs-modules'),\n  'no-webpack-loader-syntax': require('./rules/no-webpack-loader-syntax'),\n  order: require('./rules/order'),\n  'newline-after-import': require('./rules/newline-after-import'),\n  'prefer-default-export': require('./rules/prefer-default-export'),\n  'no-default-export': require('./rules/no-default-export'),\n  'no-named-export': require('./rules/no-named-export'),\n  'no-dynamic-require': require('./rules/no-dynamic-require'),\n  unambiguous: require('./rules/unambiguous'),\n  'no-unassigned-import': require('./rules/no-unassigned-import'),\n  'no-useless-path-segments': require('./rules/no-useless-path-segments'),\n  'dynamic-import-chunkname': require('./rules/dynamic-import-chunkname'),\n  'no-import-module-exports': require('./rules/no-import-module-exports'),\n  'no-empty-named-blocks': require('./rules/no-empty-named-blocks'),\n  'enforce-node-protocol-usage': require('./rules/enforce-node-protocol-usage'),\n\n  // export\n  'exports-last': require('./rules/exports-last'),\n\n  // metadata-based\n  'no-deprecated': require('./rules/no-deprecated'),\n\n  // deprecated aliases to rules\n  'imports-first': require('./rules/imports-first'),\n};\n\nexport const configs = {\n  recommended: require('../config/recommended'),\n\n  errors: require('../config/errors'),\n  warnings: require('../config/warnings'),\n\n  // shhhh... work in progress \"secret\" rules\n  'stage-0': require('../config/stage-0'),\n\n  // useful stuff for folks using various environments\n  react: require('../config/react'),\n  'react-native': require('../config/react-native'),\n  electron: require('../config/electron'),\n  typescript: require('../config/typescript'),\n};\n\n// Base Plugin Object\nconst importPlugin = {\n  meta: { name, version },\n  rules,\n};\n\n// Create flat configs (Only ones that declare plugins and parser options need to be different from the legacy config)\nconst createFlatConfig = (baseConfig, configName) => ({\n  ...baseConfig,\n  name: `import/${configName}`,\n  plugins: { import: importPlugin },\n});\n\nexport const flatConfigs = {\n  recommended: createFlatConfig(\n    require('../config/flat/recommended'),\n    'recommended',\n  ),\n\n  errors: createFlatConfig(require('../config/flat/errors'), 'errors'),\n  warnings: createFlatConfig(require('../config/flat/warnings'), 'warnings'),\n\n  // useful stuff for folks using various environments\n  react: createFlatConfig(require('../config/flat/react'), 'react'),\n  'react-native': createFlatConfig(configs['react-native'], 'react-native'),\n  electron: createFlatConfig(configs.electron, 'electron'),\n  typescript: createFlatConfig(configs.typescript, 'typescript'),\n};\n"]}

--- +++ @@ -0,0 +1,147 @@+'use strict';var _messages;function _defineProperty(obj, key, value) {if (key in obj) {Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true });} else {obj[key] = value;}return obj;}++var isCoreModule = require('is-core-module');var _require =+require('../docsUrl'),docsUrl = _require['default'];++var DO_PREFER_MESSAGE_ID = 'requireNodeProtocol';+var NEVER_PREFER_MESSAGE_ID = 'forbidNodeProtocol';+var messages = (_messages = {}, _defineProperty(_messages,+DO_PREFER_MESSAGE_ID, 'Prefer `node:{{moduleName}}` over `{{moduleName}}`.'), _defineProperty(_messages,+NEVER_PREFER_MESSAGE_ID, 'Prefer `{{moduleName}}` over `node:{{moduleName}}`.'), _messages);+++function replaceStringLiteral(+fixer,+node,+text,+relativeRangeStart,+relativeRangeEnd)+{+  var firstCharacterIndex = node.range[0] + 1;+  var start = Number.isInteger(relativeRangeEnd) ?+  relativeRangeStart + firstCharacterIndex :+  firstCharacterIndex;+  var end = Number.isInteger(relativeRangeEnd) ?+  relativeRangeEnd + firstCharacterIndex :+  node.range[1] - 1;++  return fixer.replaceTextRange([start, end], text);+}++function isStringLiteral(node) {+  return node && node.type === 'Literal' && typeof node.value === 'string';+}++function isStaticRequireWith1Param(node) {+  return !node.optional &&+  node.callee.type === 'Identifier' &&+  node.callee.name === 'require'+  // check for only 1 argument+  && node.arguments.length === 1 &&+  node.arguments[0] &&+  isStringLiteral(node.arguments[0]);+}++function checkAndReport(src, context) {+  // TODO use src.quasis[0].value.raw+  if (!src || src.type === 'TemplateLiteral') {return;}+  var moduleName = 'value' in src ? src.value : src.name;+  if (typeof moduleName !== 'string') {console.log(src, moduleName);}var+  settings = context.settings;+  var nodeVersion = settings && settings['import/node-version'];+  if (+  typeof nodeVersion !== 'undefined' && (++  typeof nodeVersion !== 'string' ||+  !/^[0-9]+\.[0-9]+\.[0-9]+$/.test(nodeVersion)))++  {+    throw new TypeError('`import/node-version` setting must be a string in the format "10.23.45" (a semver version, with no leading zero)');+  }++  if (context.options[0] === 'never') {+    if (!moduleName.startsWith('node:')) {return;}++    var actualModuleName = moduleName.slice(5);+    if (!isCoreModule(actualModuleName, nodeVersion || undefined)) {return;}++    context.report({+      node: src,+      message: messages[NEVER_PREFER_MESSAGE_ID],+      data: { moduleName: actualModuleName },+      /** @param {import('eslint').Rule.RuleFixer} fixer */+      fix: function () {function fix(fixer) {+          return replaceStringLiteral(fixer, src, '', 0, 5);+        }return fix;}() });++  } else if (context.options[0] === 'always') {+    if (+    moduleName.startsWith('node:') ||+    !isCoreModule(moduleName, nodeVersion || undefined) ||+    !isCoreModule('node:' + String(moduleName), nodeVersion || undefined))+    {+      return;+    }++    context.report({+      node: src,+      message: messages[DO_PREFER_MESSAGE_ID],+      data: { moduleName: moduleName },+      /** @param {import('eslint').Rule.RuleFixer} fixer */+      fix: function () {function fix(fixer) {+          return replaceStringLiteral(fixer, src, 'node:', 0, 0);+        }return fix;}() });++  } else if (typeof context.options[0] === 'undefined') {+    throw new Error('Missing option');+  } else {+    throw new Error('Unexpected option: ' + String(context.options[0]));+  }+}++/** @type {import('eslint').Rule.RuleModule} */+module.exports = {+  meta: {+    type: 'suggestion',+    docs: {+      description: 'Enforce either using, or omitting, the `node:` protocol when importing Node.js builtin modules.',+      recommended: true,+      category: 'Static analysis',+      url: docsUrl('enforce-node-protocol-usage') },++    fixable: 'code',+    schema: {+      type: 'array',+      minItems: 1,+      maxItems: 1,+      items: [+      {+        'enum': ['always', 'never'] }] },++++    messages: messages },++  create: function () {function create(context) {+      return {+        CallExpression: function () {function CallExpression(node) {+            if (!isStaticRequireWith1Param(node)) {return;}++            var arg = node.arguments[0];++            return checkAndReport(arg, context);+          }return CallExpression;}(),+        ExportNamedDeclaration: function () {function ExportNamedDeclaration(node) {+            return checkAndReport(node.source, context);+          }return ExportNamedDeclaration;}(),+        ImportDeclaration: function () {function ImportDeclaration(node) {+            return checkAndReport(node.source, context);+          }return ImportDeclaration;}(),+        ImportExpression: function () {function ImportExpression(node) {+            if (!isStringLiteral(node.source)) {return;}++            return checkAndReport(node.source, context);+          }return ImportExpression;}() };++    }return create;}() };+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/enforce-node-protocol-usage.js"],"names":["isCoreModule","require","docsUrl","DO_PREFER_MESSAGE_ID","NEVER_PREFER_MESSAGE_ID","messages","replaceStringLiteral","fixer","node","text","relativeRangeStart","relativeRangeEnd","firstCharacterIndex","range","start","Number","isInteger","end","replaceTextRange","isStringLiteral","type","value","isStaticRequireWith1Param","optional","callee","name","arguments","length","checkAndReport","src","context","moduleName","console","log","settings","nodeVersion","test","TypeError","options","startsWith","actualModuleName","slice","undefined","report","message","data","fix","Error","module","exports","meta","docs","description","recommended","category","url","fixable","schema","minItems","maxItems","items","create","CallExpression","arg","ExportNamedDeclaration","source","ImportDeclaration","ImportExpression"],"mappings":"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","file":"enforce-node-protocol-usage.js","sourcesContent":["'use strict';\n\nconst isCoreModule = require('is-core-module');\nconst { default: docsUrl } = require('../docsUrl');\n\nconst DO_PREFER_MESSAGE_ID = 'requireNodeProtocol';\nconst NEVER_PREFER_MESSAGE_ID = 'forbidNodeProtocol';\nconst messages = {\n  [DO_PREFER_MESSAGE_ID]: 'Prefer `node:{{moduleName}}` over `{{moduleName}}`.',\n  [NEVER_PREFER_MESSAGE_ID]: 'Prefer `{{moduleName}}` over `node:{{moduleName}}`.',\n};\n\nfunction replaceStringLiteral(\n  fixer,\n  node,\n  text,\n  relativeRangeStart,\n  relativeRangeEnd,\n) {\n  const firstCharacterIndex = node.range[0] + 1;\n  const start = Number.isInteger(relativeRangeEnd)\n    ? relativeRangeStart + firstCharacterIndex\n    : firstCharacterIndex;\n  const end = Number.isInteger(relativeRangeEnd)\n    ? relativeRangeEnd + firstCharacterIndex\n    : node.range[1] - 1;\n\n  return fixer.replaceTextRange([start, end], text);\n}\n\nfunction isStringLiteral(node) {\n  return node && node.type === 'Literal' && typeof node.value === 'string';\n}\n\nfunction isStaticRequireWith1Param(node) {\n  return !node.optional\n    && node.callee.type === 'Identifier'\n    && node.callee.name === 'require'\n    // check for only 1 argument\n    && node.arguments.length === 1\n    && node.arguments[0]\n    && isStringLiteral(node.arguments[0]);\n}\n\nfunction checkAndReport(src, context) {\n  // TODO use src.quasis[0].value.raw\n  if (!src || src.type === 'TemplateLiteral') { return; }\n  const moduleName = 'value' in src ? src.value : src.name;\n  if (typeof moduleName !== 'string') { console.log(src, moduleName); }\n  const { settings } = context;\n  const nodeVersion = settings && settings['import/node-version'];\n  if (\n    typeof nodeVersion !== 'undefined'\n    && (\n      typeof nodeVersion !== 'string'\n      || !(/^[0-9]+\\.[0-9]+\\.[0-9]+$/).test(nodeVersion)\n    )\n  ) {\n    throw new TypeError('`import/node-version` setting must be a string in the format \"10.23.45\" (a semver version, with no leading zero)');\n  }\n\n  if (context.options[0] === 'never') {\n    if (!moduleName.startsWith('node:')) { return; }\n\n    const actualModuleName = moduleName.slice(5);\n    if (!isCoreModule(actualModuleName, nodeVersion || undefined)) { return; }\n\n    context.report({\n      node: src,\n      message: messages[NEVER_PREFER_MESSAGE_ID],\n      data: { moduleName: actualModuleName },\n      /** @param {import('eslint').Rule.RuleFixer} fixer */\n      fix(fixer) {\n        return replaceStringLiteral(fixer, src, '', 0, 5);\n      },\n    });\n  } else if (context.options[0] === 'always') {\n    if (\n      moduleName.startsWith('node:')\n      || !isCoreModule(moduleName, nodeVersion || undefined)\n      || !isCoreModule(`node:${moduleName}`, nodeVersion || undefined)\n    ) {\n      return;\n    }\n\n    context.report({\n      node: src,\n      message: messages[DO_PREFER_MESSAGE_ID],\n      data: { moduleName },\n      /** @param {import('eslint').Rule.RuleFixer} fixer */\n      fix(fixer) {\n        return replaceStringLiteral(fixer, src, 'node:', 0, 0);\n      },\n    });\n  } else if (typeof context.options[0] === 'undefined') {\n    throw new Error('Missing option');\n  } else {\n    throw new Error(`Unexpected option: ${context.options[0]}`);\n  }\n}\n\n/** @type {import('eslint').Rule.RuleModule} */\nmodule.exports = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      description: 'Enforce either using, or omitting, the `node:` protocol when importing Node.js builtin modules.',\n      recommended: true,\n      category: 'Static analysis',\n      url: docsUrl('enforce-node-protocol-usage'),\n    },\n    fixable: 'code',\n    schema: {\n      type: 'array',\n      minItems: 1,\n      maxItems: 1,\n      items: [\n        {\n          enum: ['always', 'never'],\n        },\n      ],\n    },\n    messages,\n  },\n  create(context) {\n    return {\n      CallExpression(node) {\n        if (!isStaticRequireWith1Param(node)) { return; }\n\n        const arg = node.arguments[0];\n\n        return checkAndReport(arg, context);\n      },\n      ExportNamedDeclaration(node) {\n        return checkAndReport(node.source, context);\n      },\n      ImportDeclaration(node) {\n        return checkAndReport(node.source, context);\n      },\n      ImportExpression(node) {\n        if (!isStringLiteral(node.source)) { return; }\n\n        return checkAndReport(node.source, context);\n      },\n    };\n  },\n};\n"]}

--- +++ @@ -2,2 +2,3 @@ +var _minimatch = require('minimatch');var _minimatch2 = _interopRequireDefault(_minimatch); var _resolve = require('eslint-module-utils/resolve');var _resolve2 = _interopRequireDefault(_resolve);@@ -17,3 +18,23 @@     checkTypeImports: { type: 'boolean' },-    ignorePackages: { type: 'boolean' } } };+    ignorePackages: { type: 'boolean' },+    pathGroupOverrides: {+      type: 'array',+      items: {+        type: 'object',+        properties: {+          pattern: {+            type: 'string' },++          patternOptions: {+            type: 'object' },++          action: {+            type: 'string',+            'enum': ['enforce', 'ignore'] } },+++        additionalProperties: false,+        required: ['pattern', 'action'] } } } };++ @@ -55,2 +76,6 @@       result.checkTypeImports = obj.checkTypeImports;+    }++    if (obj.pathGroupOverrides !== undefined) {+      result.pathGroupOverrides = obj.pathGroupOverrides;     }@@ -145,2 +170,11 @@ +      function computeOverrideAction(pathGroupOverrides, path) {+        for (var i = 0, l = pathGroupOverrides.length; i < l; i++) {var _pathGroupOverrides$i =+          pathGroupOverrides[i],pattern = _pathGroupOverrides$i.pattern,patternOptions = _pathGroupOverrides$i.patternOptions,action = _pathGroupOverrides$i.action;+          if ((0, _minimatch2['default'])(path, pattern, patternOptions || { nocomment: true })) {+            return action;+          }+        }+      }+       function checkFileExtension(source, node) {@@ -151,4 +185,14 @@ +        // If not undefined, the user decided if rules are enforced on this import+        var overrideAction = computeOverrideAction(+        props.pathGroupOverrides || [],+        importPathWithQueryString);+++        if (overrideAction === 'ignore') {+          return;+        }+         // don't enforce anything on builtins-        if ((0, _importType.isBuiltIn)(importPathWithQueryString, context.settings)) {return;}+        if (!overrideAction && (0, _importType.isBuiltIn)(importPathWithQueryString, context.settings)) {return;} @@ -158,3 +202,3 @@         // Like `import Decimal from decimal.js`)-        if (isExternalRootModule(importPath)) {return;}+        if (!overrideAction && isExternalRootModule(importPath)) {return;} @@ -176,3 +220,3 @@           if (!props.checkTypeImports && (node.importKind === 'type' || node.exportKind === 'type')) {return;}-          var extensionRequired = isUseOfExtensionRequired(extension, isPackage);+          var extensionRequired = isUseOfExtensionRequired(extension, !overrideAction && isPackage);           var extensionForbidden = isUseOfExtensionForbidden(extension);@@ -197,2 +241,2 @@     }return create;}() };-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/extensions.js"],"names":["enumValues","patternProperties","type","properties","pattern","checkTypeImports","ignorePackages","buildProperties","context","result","defaultConfig","options","forEach","obj","undefined","Object","assign","module","exports","meta","docs","category","description","url","schema","anyOf","items","additionalItems","create","props","getModifier","extension","isUseOfExtensionRequired","isPackage","isUseOfExtensionForbidden","isResolvableWithoutExtension","file","path","extname","fileWithoutExtension","slice","length","resolvedFileWithoutExtension","isExternalRootModule","slashCount","split","checkFileExtension","source","node","value","importPathWithQueryString","settings","importPath","replace","resolvedPath","substring","endsWith","importKind","exportKind","extensionRequired","extensionForbidden","report","message","commonjs"],"mappings":"aAAA,4B;;AAEA,sD;AACA;AACA,kE;AACA,qC;;AAEA,IAAMA,aAAa,EAAE,QAAM,CAAC,QAAD,EAAW,gBAAX,EAA6B,OAA7B,CAAR,EAAnB;AACA,IAAMC,oBAAoB;AACxBC,QAAM,QADkB;AAExBD,qBAAmB,EAAE,MAAMD,UAAR,EAFK,EAA1B;;AAIA,IAAMG,aAAa;AACjBD,QAAM,QADW;AAEjBC,cAAY;AACVC,aAASH,iBADC;AAEVI,sBAAkB,EAAEH,MAAM,SAAR,EAFR;AAGVI,oBAAgB,EAAEJ,MAAM,SAAR,EAHN,EAFK,EAAnB;;;;AASA,SAASK,eAAT,CAAyBC,OAAzB,EAAkC;;AAEhC,MAAMC,SAAS;AACbC,mBAAe,OADF;AAEbN,aAAS,EAFI;AAGbE,oBAAgB,KAHH,EAAf;;;AAMAE,UAAQG,OAAR,CAAgBC,OAAhB,CAAwB,UAACC,GAAD,EAAS;;AAE/B;AACA,QAAI,OAAOA,GAAP,KAAe,QAAnB,EAA6B;AAC3BJ,aAAOC,aAAP,GAAuBG,GAAvB;AACA;AACD;;AAED;AACA,QAAIA,IAAIT,OAAJ,KAAgBU,SAAhB,IAA6BD,IAAIP,cAAJ,KAAuBQ,SAApD,IAAiED,IAAIR,gBAAJ,KAAyBS,SAA9F,EAAyG;AACvGC,aAAOC,MAAP,CAAcP,OAAOL,OAArB,EAA8BS,GAA9B;AACA;AACD;;AAED;AACA,QAAIA,IAAIT,OAAJ,KAAgBU,SAApB,EAA+B;AAC7BC,aAAOC,MAAP,CAAcP,OAAOL,OAArB,EAA8BS,IAAIT,OAAlC;AACD;;AAED;AACA,QAAIS,IAAIP,cAAJ,KAAuBQ,SAA3B,EAAsC;AACpCL,aAAOH,cAAP,GAAwBO,IAAIP,cAA5B;AACD;;AAED,QAAIO,IAAIR,gBAAJ,KAAyBS,SAA7B,EAAwC;AACtCL,aAAOJ,gBAAP,GAA0BQ,IAAIR,gBAA9B;AACD;AACF,GA3BD;;AA6BA,MAAII,OAAOC,aAAP,KAAyB,gBAA7B,EAA+C;AAC7CD,WAAOC,aAAP,GAAuB,QAAvB;AACAD,WAAOH,cAAP,GAAwB,IAAxB;AACD;;AAED,SAAOG,MAAP;AACD;;AAEDQ,OAAOC,OAAP,GAAiB;AACfC,QAAM;AACJjB,UAAM,YADF;AAEJkB,UAAM;AACJC,gBAAU,aADN;AAEJC,mBAAa,iEAFT;AAGJC,WAAK,0BAAQ,YAAR,CAHD,EAFF;;;AAQJC,YAAQ;AACNC,aAAO;AACL;AACEvB,cAAM,OADR;AAEEwB,eAAO,CAAC1B,UAAD,CAFT;AAGE2B,yBAAiB,KAHnB,EADK;;AAML;AACEzB,cAAM,OADR;AAEEwB,eAAO;AACL1B,kBADK;AAELG,kBAFK,CAFT;;AAMEwB,yBAAiB,KANnB,EANK;;AAcL;AACEzB,cAAM,OADR;AAEEwB,eAAO,CAACvB,UAAD,CAFT;AAGEwB,yBAAiB,KAHnB,EAdK;;AAmBL;AACEzB,cAAM,OADR;AAEEwB,eAAO,CAACzB,iBAAD,CAFT;AAGE0B,yBAAiB,KAHnB,EAnBK;;AAwBL;AACEzB,cAAM,OADR;AAEEwB,eAAO;AACL1B,kBADK;AAELC,yBAFK,CAFT;;AAME0B,yBAAiB,KANnB,EAxBK,CADD,EARJ,EADS;;;;;;AA8CfC,QA9Ce,+BA8CRpB,OA9CQ,EA8CC;;AAEd,UAAMqB,QAAQtB,gBAAgBC,OAAhB,CAAd;;AAEA,eAASsB,WAAT,CAAqBC,SAArB,EAAgC;AAC9B,eAAOF,MAAMzB,OAAN,CAAc2B,SAAd,KAA4BF,MAAMnB,aAAzC;AACD;;AAED,eAASsB,wBAAT,CAAkCD,SAAlC,EAA6CE,SAA7C,EAAwD;AACtD,eAAOH,YAAYC,SAAZ,MAA2B,QAA3B,KAAwC,CAACF,MAAMvB,cAAP,IAAyB,CAAC2B,SAAlE,CAAP;AACD;;AAED,eAASC,yBAAT,CAAmCH,SAAnC,EAA8C;AAC5C,eAAOD,YAAYC,SAAZ,MAA2B,OAAlC;AACD;;AAED,eAASI,4BAAT,CAAsCC,IAAtC,EAA4C;AAC1C,YAAML,YAAYM,kBAAKC,OAAL,CAAaF,IAAb,CAAlB;AACA,YAAMG,uBAAuBH,KAAKI,KAAL,CAAW,CAAX,EAAc,CAACT,UAAUU,MAAzB,CAA7B;AACA,YAAMC,+BAA+B,0BAAQH,oBAAR,EAA8B/B,OAA9B,CAArC;;AAEA,eAAOkC,iCAAiC,0BAAQN,IAAR,EAAc5B,OAAd,CAAxC;AACD;;AAED,eAASmC,oBAAT,CAA8BP,IAA9B,EAAoC;AAClC,YAAIA,SAAS,GAAT,IAAgBA,SAAS,IAA7B,EAAmC,CAAE,OAAO,KAAP,CAAe;AACpD,YAAMQ,aAAaR,KAAKS,KAAL,CAAW,GAAX,EAAgBJ,MAAhB,GAAyB,CAA5C;;AAEA,YAAIG,eAAe,CAAnB,EAAuB,CAAE,OAAO,IAAP,CAAc;AACvC,YAAI,0BAASR,IAAT,KAAkBQ,cAAc,CAApC,EAAuC,CAAE,OAAO,IAAP,CAAc;AACvD,eAAO,KAAP;AACD;;AAED,eAASE,kBAAT,CAA4BC,MAA5B,EAAoCC,IAApC,EAA0C;AACxC;AACA,YAAI,CAACD,MAAD,IAAW,CAACA,OAAOE,KAAvB,EAA8B,CAAE,OAAS;;AAEzC,YAAMC,4BAA4BH,OAAOE,KAAzC;;AAEA;AACA,YAAI,2BAAUC,yBAAV,EAAqC1C,QAAQ2C,QAA7C,CAAJ,EAA4D,CAAE,OAAS;;AAEvE,YAAMC,aAAaF,0BAA0BG,OAA1B,CAAkC,SAAlC,EAA6C,EAA7C,CAAnB;;AAEA;AACA;AACA,YAAIV,qBAAqBS,UAArB,CAAJ,EAAsC,CAAE,OAAS;;AAEjD,YAAME,eAAe,0BAAQF,UAAR,EAAoB5C,OAApB,CAArB;;AAEA;AACA;AACA,YAAMuB,YAAYM,kBAAKC,OAAL,CAAagB,gBAAgBF,UAA7B,EAAyCG,SAAzC,CAAmD,CAAnD,CAAlB;;AAEA;AACA,YAAMtB,YAAY;AAChBmB,kBADgB;AAEhB,kCAAQA,UAAR,EAAoB5C,OAApB,CAFgB;AAGhBA,eAHgB;AAIb,kCAAS4C,UAAT,CAJL;;AAMA,YAAI,CAACrB,SAAD,IAAc,CAACqB,WAAWI,QAAX,cAAwBzB,SAAxB,EAAnB,EAAyD;AACvD;AACA,cAAI,CAACF,MAAMxB,gBAAP,KAA4B2C,KAAKS,UAAL,KAAoB,MAApB,IAA8BT,KAAKU,UAAL,KAAoB,MAA9E,CAAJ,EAA2F,CAAE,OAAS;AACtG,cAAMC,oBAAoB3B,yBAAyBD,SAAzB,EAAoCE,SAApC,CAA1B;AACA,cAAM2B,qBAAqB1B,0BAA0BH,SAA1B,CAA3B;AACA,cAAI4B,qBAAqB,CAACC,kBAA1B,EAA8C;AAC5CpD,oBAAQqD,MAAR,CAAe;AACbb,oBAAMD,MADO;AAEbe;AAC4B/B,uCAAgBA,SAAhB,WAAgC,EAD5D,qBACsEmB,yBADtE,OAFa,EAAf;;AAKD;AACF,SAZD,MAYO,IAAInB,SAAJ,EAAe;AACpB,cAAIG,0BAA0BH,SAA1B,KAAwCI,6BAA6BiB,UAA7B,CAA5C,EAAsF;AACpF5C,oBAAQqD,MAAR,CAAe;AACbb,oBAAMD,MADO;AAEbe,qEAA8C/B,SAA9C,uBAAiEmB,yBAAjE,OAFa,EAAf;;AAID;AACF;AACF;;AAED,aAAO,gCAAcJ,kBAAd,EAAkC,EAAEiB,UAAU,IAAZ,EAAlC,CAAP;AACD,KAlIc,mBAAjB","file":"extensions.js","sourcesContent":["import path from 'path';\n\nimport resolve from 'eslint-module-utils/resolve';\nimport { isBuiltIn, isExternalModule, isScoped } from '../core/importType';\nimport moduleVisitor from 'eslint-module-utils/moduleVisitor';\nimport docsUrl from '../docsUrl';\n\nconst enumValues = { enum: ['always', 'ignorePackages', 'never'] };\nconst patternProperties = {\n  type: 'object',\n  patternProperties: { '.*': enumValues },\n};\nconst properties = {\n  type: 'object',\n  properties: {\n    pattern: patternProperties,\n    checkTypeImports: { type: 'boolean' },\n    ignorePackages: { type: 'boolean' },\n  },\n};\n\nfunction buildProperties(context) {\n\n  const result = {\n    defaultConfig: 'never',\n    pattern: {},\n    ignorePackages: false,\n  };\n\n  context.options.forEach((obj) => {\n\n    // If this is a string, set defaultConfig to its value\n    if (typeof obj === 'string') {\n      result.defaultConfig = obj;\n      return;\n    }\n\n    // If this is not the new structure, transfer all props to result.pattern\n    if (obj.pattern === undefined && obj.ignorePackages === undefined && obj.checkTypeImports === undefined) {\n      Object.assign(result.pattern, obj);\n      return;\n    }\n\n    // If pattern is provided, transfer all props\n    if (obj.pattern !== undefined) {\n      Object.assign(result.pattern, obj.pattern);\n    }\n\n    // If ignorePackages is provided, transfer it to result\n    if (obj.ignorePackages !== undefined) {\n      result.ignorePackages = obj.ignorePackages;\n    }\n\n    if (obj.checkTypeImports !== undefined) {\n      result.checkTypeImports = obj.checkTypeImports;\n    }\n  });\n\n  if (result.defaultConfig === 'ignorePackages') {\n    result.defaultConfig = 'always';\n    result.ignorePackages = true;\n  }\n\n  return result;\n}\n\nmodule.exports = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      category: 'Style guide',\n      description: 'Ensure consistent use of file extension within the import path.',\n      url: docsUrl('extensions'),\n    },\n\n    schema: {\n      anyOf: [\n        {\n          type: 'array',\n          items: [enumValues],\n          additionalItems: false,\n        },\n        {\n          type: 'array',\n          items: [\n            enumValues,\n            properties,\n          ],\n          additionalItems: false,\n        },\n        {\n          type: 'array',\n          items: [properties],\n          additionalItems: false,\n        },\n        {\n          type: 'array',\n          items: [patternProperties],\n          additionalItems: false,\n        },\n        {\n          type: 'array',\n          items: [\n            enumValues,\n            patternProperties,\n          ],\n          additionalItems: false,\n        },\n      ],\n    },\n  },\n\n  create(context) {\n\n    const props = buildProperties(context);\n\n    function getModifier(extension) {\n      return props.pattern[extension] || props.defaultConfig;\n    }\n\n    function isUseOfExtensionRequired(extension, isPackage) {\n      return getModifier(extension) === 'always' && (!props.ignorePackages || !isPackage);\n    }\n\n    function isUseOfExtensionForbidden(extension) {\n      return getModifier(extension) === 'never';\n    }\n\n    function isResolvableWithoutExtension(file) {\n      const extension = path.extname(file);\n      const fileWithoutExtension = file.slice(0, -extension.length);\n      const resolvedFileWithoutExtension = resolve(fileWithoutExtension, context);\n\n      return resolvedFileWithoutExtension === resolve(file, context);\n    }\n\n    function isExternalRootModule(file) {\n      if (file === '.' || file === '..') { return false; }\n      const slashCount = file.split('/').length - 1;\n\n      if (slashCount === 0)  { return true; }\n      if (isScoped(file) && slashCount <= 1) { return true; }\n      return false;\n    }\n\n    function checkFileExtension(source, node) {\n      // bail if the declaration doesn't have a source, e.g. \"export { foo };\", or if it's only partially typed like in an editor\n      if (!source || !source.value) { return; }\n\n      const importPathWithQueryString = source.value;\n\n      // don't enforce anything on builtins\n      if (isBuiltIn(importPathWithQueryString, context.settings)) { return; }\n\n      const importPath = importPathWithQueryString.replace(/\\?(.*)$/, '');\n\n      // don't enforce in root external packages as they may have names with `.js`.\n      // Like `import Decimal from decimal.js`)\n      if (isExternalRootModule(importPath)) { return; }\n\n      const resolvedPath = resolve(importPath, context);\n\n      // get extension from resolved path, if possible.\n      // for unresolved, use source value.\n      const extension = path.extname(resolvedPath || importPath).substring(1);\n\n      // determine if this is a module\n      const isPackage = isExternalModule(\n        importPath,\n        resolve(importPath, context),\n        context,\n      ) || isScoped(importPath);\n\n      if (!extension || !importPath.endsWith(`.${extension}`)) {\n        // ignore type-only imports and exports\n        if (!props.checkTypeImports && (node.importKind === 'type' || node.exportKind === 'type')) { return; }\n        const extensionRequired = isUseOfExtensionRequired(extension, isPackage);\n        const extensionForbidden = isUseOfExtensionForbidden(extension);\n        if (extensionRequired && !extensionForbidden) {\n          context.report({\n            node: source,\n            message:\n              `Missing file extension ${extension ? `\"${extension}\" ` : ''}for \"${importPathWithQueryString}\"`,\n          });\n        }\n      } else if (extension) {\n        if (isUseOfExtensionForbidden(extension) && isResolvableWithoutExtension(importPath)) {\n          context.report({\n            node: source,\n            message: `Unexpected use of file extension \"${extension}\" for \"${importPathWithQueryString}\"`,\n          });\n        }\n      }\n    }\n\n    return moduleVisitor(checkFileExtension, { commonjs: true });\n  },\n};\n"]}+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/extensions.js"],"names":["enumValues","patternProperties","type","properties","pattern","checkTypeImports","ignorePackages","pathGroupOverrides","items","patternOptions","action","additionalProperties","required","buildProperties","context","result","defaultConfig","options","forEach","obj","undefined","Object","assign","module","exports","meta","docs","category","description","url","schema","anyOf","additionalItems","create","props","getModifier","extension","isUseOfExtensionRequired","isPackage","isUseOfExtensionForbidden","isResolvableWithoutExtension","file","path","extname","fileWithoutExtension","slice","length","resolvedFileWithoutExtension","isExternalRootModule","slashCount","split","computeOverrideAction","i","l","nocomment","checkFileExtension","source","node","value","importPathWithQueryString","overrideAction","settings","importPath","replace","resolvedPath","substring","endsWith","importKind","exportKind","extensionRequired","extensionForbidden","report","message","commonjs"],"mappings":"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","file":"extensions.js","sourcesContent":["import path from 'path';\n\nimport minimatch from 'minimatch';\nimport resolve from 'eslint-module-utils/resolve';\nimport { isBuiltIn, isExternalModule, isScoped } from '../core/importType';\nimport moduleVisitor from 'eslint-module-utils/moduleVisitor';\nimport docsUrl from '../docsUrl';\n\nconst enumValues = { enum: ['always', 'ignorePackages', 'never'] };\nconst patternProperties = {\n  type: 'object',\n  patternProperties: { '.*': enumValues },\n};\nconst properties = {\n  type: 'object',\n  properties: {\n    pattern: patternProperties,\n    checkTypeImports: { type: 'boolean' },\n    ignorePackages: { type: 'boolean' },\n    pathGroupOverrides: {\n      type: 'array',\n      items: {\n        type: 'object',\n        properties: {\n          pattern: {\n            type: 'string',\n          },\n          patternOptions: {\n            type: 'object',\n          },\n          action: {\n            type: 'string',\n            enum: ['enforce', 'ignore'],\n          },\n        },\n        additionalProperties: false,\n        required: ['pattern', 'action'],\n      },\n    },\n  },\n};\n\nfunction buildProperties(context) {\n\n  const result = {\n    defaultConfig: 'never',\n    pattern: {},\n    ignorePackages: false,\n  };\n\n  context.options.forEach((obj) => {\n\n    // If this is a string, set defaultConfig to its value\n    if (typeof obj === 'string') {\n      result.defaultConfig = obj;\n      return;\n    }\n\n    // If this is not the new structure, transfer all props to result.pattern\n    if (obj.pattern === undefined && obj.ignorePackages === undefined && obj.checkTypeImports === undefined) {\n      Object.assign(result.pattern, obj);\n      return;\n    }\n\n    // If pattern is provided, transfer all props\n    if (obj.pattern !== undefined) {\n      Object.assign(result.pattern, obj.pattern);\n    }\n\n    // If ignorePackages is provided, transfer it to result\n    if (obj.ignorePackages !== undefined) {\n      result.ignorePackages = obj.ignorePackages;\n    }\n\n    if (obj.checkTypeImports !== undefined) {\n      result.checkTypeImports = obj.checkTypeImports;\n    }\n\n    if (obj.pathGroupOverrides !== undefined) {\n      result.pathGroupOverrides = obj.pathGroupOverrides;\n    }\n  });\n\n  if (result.defaultConfig === 'ignorePackages') {\n    result.defaultConfig = 'always';\n    result.ignorePackages = true;\n  }\n\n  return result;\n}\n\nmodule.exports = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      category: 'Style guide',\n      description: 'Ensure consistent use of file extension within the import path.',\n      url: docsUrl('extensions'),\n    },\n\n    schema: {\n      anyOf: [\n        {\n          type: 'array',\n          items: [enumValues],\n          additionalItems: false,\n        },\n        {\n          type: 'array',\n          items: [\n            enumValues,\n            properties,\n          ],\n          additionalItems: false,\n        },\n        {\n          type: 'array',\n          items: [properties],\n          additionalItems: false,\n        },\n        {\n          type: 'array',\n          items: [patternProperties],\n          additionalItems: false,\n        },\n        {\n          type: 'array',\n          items: [\n            enumValues,\n            patternProperties,\n          ],\n          additionalItems: false,\n        },\n      ],\n    },\n  },\n\n  create(context) {\n\n    const props = buildProperties(context);\n\n    function getModifier(extension) {\n      return props.pattern[extension] || props.defaultConfig;\n    }\n\n    function isUseOfExtensionRequired(extension, isPackage) {\n      return getModifier(extension) === 'always' && (!props.ignorePackages || !isPackage);\n    }\n\n    function isUseOfExtensionForbidden(extension) {\n      return getModifier(extension) === 'never';\n    }\n\n    function isResolvableWithoutExtension(file) {\n      const extension = path.extname(file);\n      const fileWithoutExtension = file.slice(0, -extension.length);\n      const resolvedFileWithoutExtension = resolve(fileWithoutExtension, context);\n\n      return resolvedFileWithoutExtension === resolve(file, context);\n    }\n\n    function isExternalRootModule(file) {\n      if (file === '.' || file === '..') { return false; }\n      const slashCount = file.split('/').length - 1;\n\n      if (slashCount === 0)  { return true; }\n      if (isScoped(file) && slashCount <= 1) { return true; }\n      return false;\n    }\n\n    function computeOverrideAction(pathGroupOverrides, path) {\n      for (let i = 0, l = pathGroupOverrides.length; i < l; i++) {\n        const { pattern, patternOptions, action } = pathGroupOverrides[i];\n        if (minimatch(path, pattern, patternOptions || { nocomment: true })) {\n          return action;\n        }\n      }\n    }\n\n    function checkFileExtension(source, node) {\n      // bail if the declaration doesn't have a source, e.g. \"export { foo };\", or if it's only partially typed like in an editor\n      if (!source || !source.value) { return; }\n\n      const importPathWithQueryString = source.value;\n\n      // If not undefined, the user decided if rules are enforced on this import\n      const overrideAction = computeOverrideAction(\n        props.pathGroupOverrides || [],\n        importPathWithQueryString,\n      );\n\n      if (overrideAction === 'ignore') {\n        return;\n      }\n\n      // don't enforce anything on builtins\n      if (!overrideAction && isBuiltIn(importPathWithQueryString, context.settings)) { return; }\n\n      const importPath = importPathWithQueryString.replace(/\\?(.*)$/, '');\n\n      // don't enforce in root external packages as they may have names with `.js`.\n      // Like `import Decimal from decimal.js`)\n      if (!overrideAction && isExternalRootModule(importPath)) { return; }\n\n      const resolvedPath = resolve(importPath, context);\n\n      // get extension from resolved path, if possible.\n      // for unresolved, use source value.\n      const extension = path.extname(resolvedPath || importPath).substring(1);\n\n      // determine if this is a module\n      const isPackage = isExternalModule(\n        importPath,\n        resolve(importPath, context),\n        context,\n      ) || isScoped(importPath);\n\n      if (!extension || !importPath.endsWith(`.${extension}`)) {\n        // ignore type-only imports and exports\n        if (!props.checkTypeImports && (node.importKind === 'type' || node.exportKind === 'type')) { return; }\n        const extensionRequired = isUseOfExtensionRequired(extension, !overrideAction && isPackage);\n        const extensionForbidden = isUseOfExtensionForbidden(extension);\n        if (extensionRequired && !extensionForbidden) {\n          context.report({\n            node: source,\n            message:\n              `Missing file extension ${extension ? `\"${extension}\" ` : ''}for \"${importPathWithQueryString}\"`,\n          });\n        }\n      } else if (extension) {\n        if (isUseOfExtensionForbidden(extension) && isResolvableWithoutExtension(importPath)) {\n          context.report({\n            node: source,\n            message: `Unexpected use of file extension \"${extension}\" for \"${importPathWithQueryString}\"`,\n          });\n        }\n      }\n    }\n\n    return moduleVisitor(checkFileExtension, { commonjs: true });\n  },\n};\n"]}

--- +++ @@ -418,3 +418,3 @@ /** Some parsers (languages without types) don't provide ImportKind */-var DEAFULT_IMPORT_KIND = 'value';+var DEFAULT_IMPORT_KIND = 'value'; var getNormalizedValue = function getNormalizedValue(node, toLowerCase) {@@ -464,4 +464,4 @@         result = multiplierImportKind * compareString(-        nodeA.node.importKind || DEAFULT_IMPORT_KIND,-        nodeB.node.importKind || DEAFULT_IMPORT_KIND);+        nodeA.node.importKind || DEFAULT_IMPORT_KIND,+        nodeB.node.importKind || DEFAULT_IMPORT_KIND); @@ -515,8 +515,13 @@ -function computeRank(context, ranks, importEntry, excludedImportTypes) {+function computeRank(context, ranks, importEntry, excludedImportTypes, isSortingTypesGroup) {   var impType = void 0;   var rank = void 0;++  var isTypeGroupInGroups = ranks.omittedTypes.indexOf('type') === -1;+  var isTypeOnlyImport = importEntry.node.importKind === 'type';+  var isExcludedFromPathRank = isTypeOnlyImport && isTypeGroupInGroups && excludedImportTypes.has('type');+   if (importEntry.type === 'import:object') {     impType = 'object';-  } else if (importEntry.node.importKind === 'type' && ranks.omittedTypes.indexOf('type') === -1) {+  } else if (isTypeOnlyImport && isTypeGroupInGroups && !isSortingTypesGroup) {     impType = 'type';@@ -525,8 +530,19 @@   }-  if (!excludedImportTypes.has(impType)) {++  if (!excludedImportTypes.has(impType) && !isExcludedFromPathRank) {     rank = computePathRank(ranks.groups, ranks.pathGroups, importEntry.value, ranks.maxPosition);   }+   if (typeof rank === 'undefined') {     rank = ranks.groups[impType];-  }++    if (typeof rank === 'undefined') {+      return -1;+    }+  }++  if (isTypeOnlyImport && isSortingTypesGroup) {+    rank = ranks.groups.type + rank / 10;+  }+   if (importEntry.type !== 'import' && !importEntry.type.startsWith('import:')) {@@ -538,6 +554,16 @@ -function registerNode(context, importEntry, ranks, imported, excludedImportTypes) {-  var rank = computeRank(context, ranks, importEntry, excludedImportTypes);+function registerNode(context, importEntry, ranks, imported, excludedImportTypes, isSortingTypesGroup) {+  var rank = computeRank(context, ranks, importEntry, excludedImportTypes, isSortingTypesGroup);   if (rank !== -1) {-    imported.push(Object.assign({}, importEntry, { rank: rank }));+    var importNode = importEntry.node;++    if (importEntry.type === 'require' && importNode.parent.parent.type === 'VariableDeclaration') {+      importNode = importNode.parent.parent;+    }++    imported.push(Object.assign({},+    importEntry, {+      rank: rank,+      isMultiline: importNode.loc.end.line !== importNode.loc.start.line }));+   }@@ -566,5 +592,7 @@ -// Creates an object with type-rank pairs.-// Example: { index: 0, sibling: 1, parent: 1, external: 1, builtin: 2, internal: 2 }-// Will throw an error if it contains a type that does not exist, or has a duplicate+/**+                                                                                                             * Creates an object with type-rank pairs.+                                                                                                             *+                                                                                                             * Example: { index: 0, sibling: 1, parent: 1, external: 1, builtin: 2, internal: 2 }+                                                                                                             */ function convertGroupsToRanks(groups) {@@ -572,8 +600,2 @@     [].concat(group).forEach(function (groupItem) {-      if (types.indexOf(groupItem) === -1) {-        throw new Error('Incorrect configuration of the rule: Unknown type `' + String(JSON.stringify(groupItem)) + '`');-      }-      if (res[groupItem] !== undefined) {-        throw new Error('Incorrect configuration of the rule: `' + String(groupItem) + '` is duplicated');-      }       res[groupItem] = index * 2;@@ -667,3 +689,3 @@ -function makeNewlinesBetweenReport(context, imported, newlinesBetweenImports, distinctGroup) {+function makeNewlinesBetweenReport(context, imported, newlinesBetweenImports_, newlinesBetweenTypeOnlyImports_, distinctGroup, isSortingTypesGroup, isConsolidatingSpaceBetweenImports) {   var getNumberOfEmptyLinesBetween = function getNumberOfEmptyLinesBetween(currentImport, previousImport) {@@ -680,21 +702,118 @@   imported.slice(1).forEach(function (currentImport) {-    var emptyLinesBetween = getNumberOfEmptyLinesBetween(currentImport, previousImport);-    var isStartOfDistinctGroup = getIsStartOfDistinctGroup(currentImport, previousImport);--    if (newlinesBetweenImports === 'always' ||-    newlinesBetweenImports === 'always-and-inside-groups') {-      if (currentImport.rank !== previousImport.rank && emptyLinesBetween === 0) {-        if (distinctGroup || !distinctGroup && isStartOfDistinctGroup) {+    var emptyLinesBetween = getNumberOfEmptyLinesBetween(+    currentImport,+    previousImport);+++    var isStartOfDistinctGroup = getIsStartOfDistinctGroup(+    currentImport,+    previousImport);+++    var isTypeOnlyImport = currentImport.node.importKind === 'type';+    var isPreviousImportTypeOnlyImport = previousImport.node.importKind === 'type';++    var isNormalImportNextToTypeOnlyImportAndRelevant = isTypeOnlyImport !== isPreviousImportTypeOnlyImport && isSortingTypesGroup;++    var isTypeOnlyImportAndRelevant = isTypeOnlyImport && isSortingTypesGroup;++    // In the special case where newlinesBetweenImports and consolidateIslands+    // want the opposite thing, consolidateIslands wins+    var newlinesBetweenImports = isSortingTypesGroup &&+    isConsolidatingSpaceBetweenImports && (+    previousImport.isMultiline || currentImport.isMultiline) &&+    newlinesBetweenImports_ === 'never' ?+    'always-and-inside-groups' :+    newlinesBetweenImports_;++    // In the special case where newlinesBetweenTypeOnlyImports and+    // consolidateIslands want the opposite thing, consolidateIslands wins+    var newlinesBetweenTypeOnlyImports = isSortingTypesGroup &&+    isConsolidatingSpaceBetweenImports && (+    isNormalImportNextToTypeOnlyImportAndRelevant ||+    previousImport.isMultiline ||+    currentImport.isMultiline) &&+    newlinesBetweenTypeOnlyImports_ === 'never' ?+    'always-and-inside-groups' :+    newlinesBetweenTypeOnlyImports_;++    var isNotIgnored = isTypeOnlyImportAndRelevant &&+    newlinesBetweenTypeOnlyImports !== 'ignore' ||+    !isTypeOnlyImportAndRelevant && newlinesBetweenImports !== 'ignore';++    if (isNotIgnored) {+      var shouldAssertNewlineBetweenGroups = (isTypeOnlyImportAndRelevant || isNormalImportNextToTypeOnlyImportAndRelevant) && (+      newlinesBetweenTypeOnlyImports === 'always' ||+      newlinesBetweenTypeOnlyImports === 'always-and-inside-groups') ||+      !isTypeOnlyImportAndRelevant && !isNormalImportNextToTypeOnlyImportAndRelevant && (+      newlinesBetweenImports === 'always' ||+      newlinesBetweenImports === 'always-and-inside-groups');++      var shouldAssertNoNewlineWithinGroup = (isTypeOnlyImportAndRelevant || isNormalImportNextToTypeOnlyImportAndRelevant) &&+      newlinesBetweenTypeOnlyImports !== 'always-and-inside-groups' ||+      !isTypeOnlyImportAndRelevant && !isNormalImportNextToTypeOnlyImportAndRelevant &&+      newlinesBetweenImports !== 'always-and-inside-groups';++      var shouldAssertNoNewlineBetweenGroup = !isSortingTypesGroup ||+      !isNormalImportNextToTypeOnlyImportAndRelevant ||+      newlinesBetweenTypeOnlyImports === 'never';++      var isTheNewlineBetweenImportsInTheSameGroup = distinctGroup && currentImport.rank === previousImport.rank ||+      !distinctGroup && !isStartOfDistinctGroup;++      // Let's try to cut down on linting errors sent to the user+      var alreadyReported = false;++      if (shouldAssertNewlineBetweenGroups) {+        if (currentImport.rank !== previousImport.rank && emptyLinesBetween === 0) {+          if (distinctGroup || isStartOfDistinctGroup) {+            alreadyReported = true;+            context.report({+              node: previousImport.node,+              message: 'There should be at least one empty line between import groups',+              fix: fixNewLineAfterImport(context, previousImport) });++          }+        } else if (emptyLinesBetween > 0 && shouldAssertNoNewlineWithinGroup) {+          if (isTheNewlineBetweenImportsInTheSameGroup) {+            alreadyReported = true;+            context.report({+              node: previousImport.node,+              message: 'There should be no empty line within import group',+              fix: removeNewLineAfterImport(context, currentImport, previousImport) });++          }+        }+      } else if (emptyLinesBetween > 0 && shouldAssertNoNewlineBetweenGroup) {+        alreadyReported = true;+        context.report({+          node: previousImport.node,+          message: 'There should be no empty line between import groups',+          fix: removeNewLineAfterImport(context, currentImport, previousImport) });++      }++      if (!alreadyReported && isConsolidatingSpaceBetweenImports) {+        if (emptyLinesBetween === 0 && currentImport.isMultiline) {           context.report({             node: previousImport.node,-            message: 'There should be at least one empty line between import groups',+            message: 'There should be at least one empty line between this import and the multi-line import that follows it',             fix: fixNewLineAfterImport(context, previousImport) }); -        }-      } else if (emptyLinesBetween > 0 &&-      newlinesBetweenImports !== 'always-and-inside-groups') {-        if (distinctGroup && currentImport.rank === previousImport.rank || !distinctGroup && !isStartOfDistinctGroup) {+        } else if (emptyLinesBetween === 0 && previousImport.isMultiline) {           context.report({             node: previousImport.node,-            message: 'There should be no empty line within import group',+            message: 'There should be at least one empty line between this multi-line import and the import that follows it',+            fix: fixNewLineAfterImport(context, previousImport) });++        } else if (+        emptyLinesBetween > 0 &&+        !previousImport.isMultiline &&+        !currentImport.isMultiline &&+        isTheNewlineBetweenImportsInTheSameGroup)+        {+          context.report({+            node: previousImport.node,+            message:+            'There should be no empty lines between this single-line import and the single-line import that follows it',             fix: removeNewLineAfterImport(context, currentImport, previousImport) });@@ -703,8 +822,2 @@       }-    } else if (emptyLinesBetween > 0) {-      context.report({-        node: previousImport.node,-        message: 'There should be no empty line between import groups',-        fix: removeNewLineAfterImport(context, currentImport, previousImport) });-     }@@ -742,3 +855,14 @@         groups: {-          type: 'array' },+          type: 'array',+          uniqueItems: true,+          items: {+            oneOf: [+            { 'enum': types },+            {+              type: 'array',+              uniqueItems: true,+              items: { 'enum': types } }] } },

--- +++ @@ -2,3 +2,3 @@   "name": "eslint-plugin-import",-  "version": "2.31.0",+  "version": "2.32.0",   "description": "Import with sanity.",@@ -8,2 +8,3 @@   "main": "lib/index.js",+  "types": "index.d.ts",   "directories": {@@ -18,3 +19,4 @@     "config",-    "memo-parser/{*.js,LICENSE,*.md}"+    "memo-parser/{*.js,LICENSE,*.md}",+    "index.d.ts"   ],@@ -33,5 +35,7 @@     "test-all": "node --require babel-register ./scripts/testAll",-    "test-examples": "npm run build && npm run test-example:legacy && npm run test-example:flat",+    "test-examples": "npm run build && npm run test-example:legacy && npm run test-example:flat && npm run test-example:v9",     "test-example:legacy": "cd examples/legacy && npm install && npm run lint",     "test-example:flat": "cd examples/flat && npm install && npm run lint",+    "test-example:v9": "cd examples/v9 && npm install && npm run lint",+    "test-types": "npx --package typescript@latest tsc --noEmit index.d.ts",     "prepublishOnly": "safe-publish-latest && npm run build",@@ -65,2 +69,3 @@     "@test-scope/some-module": "file:./tests/files/symlinked-module",+    "@types/eslint": "^8.56.12",     "@typescript-eslint/parser": "^2.23.0 || ^3.3.0 || ^4.29.3 || ^5.10.0",@@ -104,2 +109,3 @@     "sinon": "^2.4.1",+    "tmp": "^0.2.1",     "typescript": "^2.8.1 || ~3.9.5 || ~4.5.2",@@ -112,6 +118,6 @@     "@rtsao/scc": "^1.1.0",-    "array-includes": "^3.1.8",-    "array.prototype.findlastindex": "^1.2.5",-    "array.prototype.flat": "^1.3.2",-    "array.prototype.flatmap": "^1.3.2",+    "array-includes": "^3.1.9",+    "array.prototype.findlastindex": "^1.2.6",+    "array.prototype.flat": "^1.3.3",+    "array.prototype.flatmap": "^1.3.3",     "debug": "^3.2.7",@@ -119,5 +125,5 @@     "eslint-import-resolver-node": "^0.3.9",-    "eslint-module-utils": "^2.12.0",+    "eslint-module-utils": "^2.12.1",     "hasown": "^2.0.2",-    "is-core-module": "^2.15.1",+    "is-core-module": "^2.16.1",     "is-glob": "^4.0.3",@@ -126,5 +132,5 @@     "object.groupby": "^1.0.3",-    "object.values": "^1.2.0",+    "object.values": "^1.2.1",     "semver": "^6.3.1",-    "string.prototype.trimend": "^1.0.8",+    "string.prototype.trimend": "^1.0.9",     "tsconfig-paths": "^3.15.0"

--- +++ @@ -2,3 +2,3 @@ 	"name": "husky",-	"version": "9.1.6",+	"version": "9.1.7", 	"type": "module",

--- +++ @@ -1,2 +1,2 @@-'use strict';+"use strict"; @@ -9,5 +9,5 @@ -const fs = require('node:fs');-const pc = require('picocolors');-const yargsParser = require('yargs-parser');+const fs = require("node:fs");+const pc = require("picocolors");+const yargsParser = require("yargs-parser"); const {@@ -16,11 +16,11 @@   isMochaFlag,-  expectedTypeForFlag-} = require('./run-option-metadata');-const {ONE_AND_DONE_ARGS} = require('./one-and-dones');-const mocharc = require('../mocharc.json');-const {list} = require('./run-helpers');-const {loadConfig, findConfig} = require('./config');-const findUp = require('find-up');-const debug = require('debug')('mocha:cli:options');-const {isNodeFlag} = require('./node-flags');+  expectedTypeForFlag,+} = require("./run-option-metadata");+const { ONE_AND_DONE_ARGS } = require("./one-and-dones");+const mocharc = require("../mocharc.json");+const { list } = require("./run-helpers");+const { loadConfig, findConfig } = require("./config");+const findUp = require("find-up");+const debug = require("debug")("mocha:cli:options");+const { isNodeFlag } = require("./node-flags"); const {@@ -28,5 +28,5 @@   createInvalidArgumentTypeError,-  createUnsupportedError-} = require('../errors');-const {isNumeric} = require('../utils');+  createUnsupportedError,+} = require("../errors");+const { isNumeric } = require("../utils"); @@ -49,6 +49,6 @@ const YARGS_PARSER_CONFIG = {-  'combine-arrays': true,-  'short-option-groups': false,-  'dot-notation': false,-  'strip-aliased': true+  "combine-arrays": true,+  "short-option-groups": false,+  "dot-notation": false,+  "strip-aliased": true, };@@ -64,3 +64,3 @@ const configuration = Object.assign({}, YARGS_PARSER_CONFIG, {-  'camel-case-expansion': false+  "camel-case-expansion": false, });@@ -75,3 +75,3 @@  */-const globOptions = ['spec', 'ignore'];+const globOptions = ["spec", "ignore"]; const coerceOpts = Object.assign(@@ -80,5 +80,6 @@       Object.assign(acc, {-        [arg]: v => Array.from(new Set(globOptions.includes(arg) ? v : list(v)))+        [arg]: (v) =>+          Array.from(new Set(globOptions.includes(arg) ? v : list(v))),       }),-    {}+    {},   ),@@ -88,5 +89,5 @@       (acc, arg) =>-        Object.assign(acc, {[arg]: v => (Array.isArray(v) ? v.pop() : v)}),-      {}-    )+        Object.assign(acc, { [arg]: (v) => (Array.isArray(v) ? v.pop() : v) }),+      {},+    ), );@@ -103,3 +104,3 @@   .concat(types.string, types.number)-  .reduce((acc, arg) => Object.assign(acc, {[arg]: 1}), {});+  .reduce((acc, arg) => Object.assign(acc, { [arg]: 1 }), {}); @@ -116,3 +117,3 @@   allArgs,-  parsedResult+  parsedResult, ) => {@@ -122,3 +123,3 @@   const flag = allArgs.find((arg, index) => {-    const normalizedArg = arg.replace(/^--?/, '');+    const normalizedArg = arg.replace(/^--?/, "");     return (@@ -134,3 +135,3 @@       numericArg,-      expectedTypeForFlag(flag)+      expectedTypeForFlag(flag),     );@@ -138,3 +139,3 @@     throw createUnsupportedError(-      `Option ${numericArg} is unsupported by the mocha cli`+      `Option ${numericArg} is unsupported by the mocha cli`,     );@@ -158,9 +159,9 @@   // 4. we can then reapply the values after yargs-parser is done.-  const allArgs = Array.isArray(args) ? args : args.split(' ');+  const allArgs = Array.isArray(args) ? args : args.split(" ");   const nodeArgs = allArgs.reduce((acc, arg) => {-    const pair = arg.split('=');+    const pair = arg.split("=");     let flag = pair[0];     if (isNodeFlag(flag, false)) {-      flag = flag.replace(/^--?/, '');-      return acc.concat([[flag, arg.includes('=') ? pair[1] : true]]);+      flag = flag.replace(/^--?/, "");+      return acc.concat([[flag, arg.includes("=") ? pair[1] : true]]);     }@@ -179,3 +180,3 @@     number: types.number,-    boolean: types.boolean.concat(nodeArgs.map(pair => pair[0]))+    boolean: types.boolean.concat(nodeArgs.map((pair) => pair[0])),   });@@ -186,3 +187,3 @@ -  const numericPositionalArg = result.argv._.find(arg => isNumeric(arg));+  const numericPositionalArg = result.argv._.find((arg) => isNumeric(arg));   if (numericPositionalArg) {@@ -191,3 +192,3 @@       allArgs,-      result.argv+      result.argv,     );@@ -238,3 +239,3 @@     try {-      configData = fs.readFileSync(filepath, 'utf8');+      configData = fs.readFileSync(filepath, "utf8");     } catch (err) {@@ -244,7 +245,6 @@           `Unable to read ${filepath}: ${err}`,-          filepath+          filepath,         );       } else {-        debug('failed to read default package.json at %s; ignoring',-              filepath);+        debug("failed to read default package.json at %s; ignoring", filepath);         return result;@@ -255,6 +255,6 @@       if (pkg.mocha) {-        debug('`mocha` prop of package.json parsed: %O', pkg.mocha);+        debug("`mocha` prop of package.json parsed: %O", pkg.mocha);         result = pkg.mocha;       } else {-        debug('no config found in %s', filepath);+        debug("no config found in %s", filepath);       }@@ -264,3 +264,3 @@         `Unable to parse ${filepath}: ${err}`,-        filepath+        filepath,       );@@ -295,3 +295,3 @@       (acc, arg) => acc || arg in args,-      false+      false,     )@@ -301,3 +301,3 @@ -  const envConfig = parse(process.env.MOCHA_OPTIONS || '');+  const envConfig = parse(process.env.MOCHA_OPTIONS || "");   const rcConfig = loadRc(args);@@ -320,3 +320,3 @@     rcConfig || {},-    pkgConfig || {}+    pkgConfig || {},   );

--- +++ @@ -7,3 +7,3 @@ -'use strict';+"use strict"; @@ -15,9 +15,9 @@ -const serializeJavascript = require('serialize-javascript');-const workerpool = require('workerpool');-const {deserialize} = require('./serializer');-const debug = require('debug')('mocha:parallel:buffered-worker-pool');-const {createInvalidArgumentTypeError} = require('../errors');+const serializeJavascript = require("serialize-javascript");+const workerpool = require("workerpool");+const { deserialize } = require("./serializer");+const debug = require("debug")("mocha:parallel:buffered-worker-pool");+const { createInvalidArgumentTypeError } = require("../errors"); -const WORKER_PATH = require.resolve('./worker.js');+const WORKER_PATH = require.resolve("./worker.js"); @@ -38,7 +38,7 @@   // use child processes, not worker threads!-  workerType: 'process',+  workerType: "process",   // ensure the same flags sent to `node` for this `mocha` invocation are passed   // along to children-  forkOpts: {execArgv: process.execArgv},-  maxWorkers: workerpool.cpus - 1+  forkOpts: { execArgv: process.execArgv },+  maxWorkers: workerpool.cpus - 1, };@@ -57,5 +57,5 @@       1,-      typeof opts.maxWorkers === 'undefined'+      typeof opts.maxWorkers === "undefined"         ? WORKER_POOL_DEFAULT_OPTS.maxWorkers-        : opts.maxWorkers+        : opts.maxWorkers,     );@@ -66,3 +66,3 @@       debug(-        'not enough CPU cores available to run multiple jobs; avoid --parallel on this machine'+        "not enough CPU cores available to run multiple jobs; avoid --parallel on this machine",       );@@ -71,5 +71,5 @@       debug(-        '%d concurrent job(s) requested, but only %d core(s) available',+        "%d concurrent job(s) requested, but only %d core(s) available",         maxWorkers,-        workerpool.cpus+        workerpool.cpus,       );@@ -78,5 +78,5 @@     debug(-      'run(): starting worker pool of max size %d, using node args: %s',+      "run(): starting worker pool of max size %d, using node args: %s",       maxWorkers,-      process.execArgv.join(' ')+      process.execArgv.join(" "),     );@@ -84,3 +84,3 @@     let counter = 0;-    const onCreateWorker = ({forkOpts}) => {+    const onCreateWorker = ({ forkOpts }) => {       return {@@ -89,4 +89,4 @@           // adds an incremental id to all workers, which can be useful to allocate resources for each process-          env: {...process.env, MOCHA_WORKER_ID: counter++}-        }+          env: { ...process.env, MOCHA_WORKER_ID: counter++ },+        },       };@@ -98,3 +98,3 @@       maxWorkers,-      onCreateWorker+      onCreateWorker,     };@@ -111,3 +111,3 @@     /* istanbul ignore next */-    debug('terminate(): terminating with force = %s', force);+    debug("terminate(): terminating with force = %s", force);     return this._pool.terminate(force);@@ -126,7 +126,7 @@   async run(filepath, options = {}) {-    if (!filepath || typeof filepath !== 'string') {+    if (!filepath || typeof filepath !== "string") {       throw createInvalidArgumentTypeError(-        'Expected a non-empty filepath',-        'filepath',-        'string'+        "Expected a non-empty filepath",+        "filepath",+        "string",       );@@ -134,3 +134,3 @@     const serializedOptions = BufferedWorkerPool.serializeOptions(options);-    const result = await this._pool.exec('run', [filepath, serializedOptions]);+    const result = await this._pool.exec("run", [filepath, serializedOptions]);     return deserialize(result);@@ -169,3 +169,3 @@         unsafe: true, // this means we don't care about XSS-        ignoreFunction: true // do not serialize functions+        ignoreFunction: true, // do not serialize functions       });@@ -174,5 +174,5 @@       debug(-        'serializeOptions(): serialized options %O to: %s',+        "serializeOptions(): serialized options %O to: %s",         opts,-        serialized+        serialized,       );

--- +++ @@ -6,3 +6,3 @@ -'use strict';+"use strict"; @@ -15,12 +15,12 @@   createInvalidArgumentTypeError,-  createInvalidArgumentValueError-} = require('../errors');-const workerpool = require('workerpool');-const Mocha = require('../mocha');-const {handleRequires, validateLegacyPlugin} = require('../cli/run-helpers');-const d = require('debug');+  createInvalidArgumentValueError,+} = require("../errors");+const workerpool = require("workerpool");+const Mocha = require("../mocha");+const { handleRequires, validateLegacyPlugin } = require("../cli/run-helpers");+const d = require("debug"); const debug = d.debug(`mocha:parallel:worker:${process.pid}`); const isDebugEnabled = d.enabled(`mocha:parallel:worker:${process.pid}`);-const {serialize} = require('./serializer');-const {setInterval, clearInterval} = global;+const { serialize } = require("./serializer");+const { setInterval, clearInterval } = global; @@ -30,3 +30,3 @@   throw new Error(-    'This script is intended to be run as a worker (by the `workerpool` package).'+    "This script is intended to be run as a worker (by the `workerpool` package).",   );@@ -45,8 +45,8 @@  */-let bootstrap = async argv => {+let bootstrap = async (argv) => {   // globalSetup and globalTeardown do not run in workers   const plugins = await handleRequires(argv.require, {-    ignoredPlugins: ['mochaGlobalSetup', 'mochaGlobalTeardown']+    ignoredPlugins: ["mochaGlobalSetup", "mochaGlobalTeardown"],   });-  validateLegacyPlugin(argv, 'ui', Mocha.interfaces);+  validateLegacyPlugin(argv, "ui", Mocha.interfaces); @@ -54,3 +54,3 @@   bootstrap = () => {};-  debug('bootstrap(): finished with args: %O', argv);+  debug("bootstrap(): finished with args: %O", argv); };@@ -65,3 +65,3 @@  */-async function run(filepath, serializedOptions = '{}') {+async function run(filepath, serializedOptions = "{}") {   if (!filepath) {@@ -69,4 +69,4 @@       'Expected a non-empty "filepath" argument',-      'file',-      'string'+      "file",+      "string",     );@@ -74,9 +74,9 @@ -  debug('run(): running test file %s', filepath);+  debug("run(): running test file %s", filepath); -  if (typeof serializedOptions !== 'string') {+  if (typeof serializedOptions !== "string") {     throw createInvalidArgumentTypeError(-      'run() expects second parameter to be a string which was serialized by the `serialize-javascript` module',-      'serializedOptions',-      'string'+      "run() expects second parameter to be a string which was serialized by the `serialize-javascript` module",+      "serializedOptions",+      "string",     );@@ -86,8 +86,8 @@     // eslint-disable-next-line no-eval-    argv = eval('(' + serializedOptions + ')');+    argv = eval("(" + serializedOptions + ")");   } catch (err) {     throw createInvalidArgumentValueError(-      'run() was unable to deserialize the options',-      'serializedOptions',-      serializedOptions+      "run() was unable to deserialize the options",+      "serializedOptions",+      serializedOptions,     );@@ -95,3 +95,3 @@ -  const opts = Object.assign({ui: 'bdd'}, argv, {+  const opts = Object.assign({ ui: "bdd" }, argv, {     // if this was true, it would cause infinite recursion.@@ -101,3 +101,3 @@     // it's useful for a Mocha instance to know if it's running in a worker process.-    isWorker: true+    isWorker: true,   });@@ -113,3 +113,3 @@   } catch (err) {-    debug('run(): could not load file %s: %s', filepath, err);+    debug("run(): could not load file %s: %s", filepath, err);     throw err;@@ -122,9 +122,9 @@       debugInterval = setInterval(() => {-        debug('run(): still running %s...', filepath);+        debug("run(): still running %s...", filepath);       }, 5000).unref();     }-    mocha.run(result => {+    mocha.run((result) => {       // Runner adds these; if we don't remove them, we'll get a leak.-      process.removeAllListeners('uncaughtException');-      process.removeAllListeners('unhandledRejection');+      process.removeAllListeners("uncaughtException");+      process.removeAllListeners("unhandledRejection"); @@ -133,4 +133,4 @@         debug(-          'run(): completed run with %d test failures; returning to main process',-          typeof result.failures === 'number' ? result.failures : 0+          "run(): completed run with %d test failures; returning to main process",+          typeof result.failures === "number" ? result.failures : 0,         );@@ -140,3 +140,3 @@         // rejection should only happen if an error is "unrecoverable"-        debug('run(): serialization failed; rejecting: %O', err);+        debug("run(): serialization failed; rejecting: %O", err);         reject(err);@@ -150,5 +150,5 @@ // this registers the `run` function.-workerpool.worker({run});+workerpool.worker({ run }); -debug('started worker process');+debug("started worker process"); 

--- +++ @@ -1,2 +1,2 @@-'use strict';+"use strict"; @@ -9,7 +9,7 @@ -process.stdout = require('browser-stdout')({label: false});--var parseQuery = require('./lib/browser/parse-query');-var highlightTags = require('./lib/browser/highlight-tags');-var Mocha = require('./lib/mocha');+process.stdout = require("browser-stdout")({ label: false });++var parseQuery = require("./lib/browser/parse-query");+var highlightTags = require("./lib/browser/highlight-tags");+var Mocha = require("./lib/mocha"); @@ -21,3 +21,3 @@ -var mocha = new Mocha({reporter: 'html'});+var mocha = new Mocha({ reporter: "html" }); @@ -43,3 +43,3 @@ process.removeListener = function (e, fn) {-  if (e === 'uncaughtException') {+  if (e === "uncaughtException") {     if (originalOnerrorHandler) {@@ -61,3 +61,3 @@ process.listenerCount = function (name) {-  if (name === 'uncaughtException') {+  if (name === "uncaughtException") {     return uncaughtExceptionHandlers.length;@@ -72,5 +72,5 @@ process.on = function (e, fn) {-  if (e === 'uncaughtException') {+  if (e === "uncaughtException") {     global.onerror = function (msg, url, line, col, err) {-      fn(err || new Error(msg + ' (' + url + ':' + line + ':' + col + ')'));+      fn(err || new Error(msg + " (" + url + ":" + line + ":" + col + ")"));       return !mocha.options.allowUncaught;@@ -82,3 +82,3 @@ process.listeners = function (err) {-  if (err === 'uncaughtException') {+  if (err === "uncaughtException") {     return uncaughtExceptionHandlers;@@ -91,3 +91,3 @@ // Ensure that this default UI does not expose its methods to the global scope.-mocha.suite.removeAllListeners('pre-require');+mocha.suite.removeAllListeners("pre-require"); @@ -138,3 +138,3 @@   Mocha.prototype.ui.call(this, ui);-  this.suite.emit('pre-require', global, null, this);+  this.suite.emit("pre-require", global, null, this);   return this;@@ -147,4 +147,4 @@ mocha.setup = function (opts) {-  if (typeof opts === 'string') {-    opts = {ui: opts};+  if (typeof opts === "string") {+    opts = { ui: opts };   }@@ -156,3 +156,3 @@     .filter(function (opt) {-      return opt !== 'delay';+      return opt !== "delay";     })@@ -172,5 +172,5 @@   var options = mocha.options;-  mocha.globals('location');--  var query = parseQuery(global.location.search || '');+  mocha.globals("location");++  var query = parseQuery(global.location.search || "");   if (query.grep) {@@ -190,6 +190,6 @@       document &&-      document.getElementById('mocha') &&+      document.getElementById("mocha") &&       options.noHighlighting !== true     ) {-      highlightTags('code');+      highlightTags("code");     }

--- +++ @@ -1,3 +1,3 @@-'use strict';+"use strict"; -module.exports = require('./lib/mocha');+module.exports = require("./lib/mocha");

--- +++ @@ -1,2 +1,2 @@-'use strict';+"use strict"; @@ -11,4 +11,4 @@   return js-    .replace(/</g, '&lt;')-    .replace(/>/g, '&gt;')+    .replace(/</g, "&lt;")+    .replace(/>/g, "&gt;")     .replace(/\/\/(.*)/gm, '<span class="comment">//$1</span>')@@ -19,3 +19,3 @@       /\bnew[ \t]+(\w+)/gm,-      '<span class="keyword">new</span> <span class="init">$1</span>'+      '<span class="keyword">new</span> <span class="init">$1</span>',     )@@ -23,3 +23,3 @@       /\b(function|new|throw|return|var|if|else)\b/gm,-      '<span class="keyword">$1</span>'+      '<span class="keyword">$1</span>',     );@@ -34,3 +34,3 @@ module.exports = function highlightTags(name) {-  var code = document.getElementById('mocha').getElementsByTagName(name);+  var code = document.getElementById("mocha").getElementsByTagName(name);   for (var i = 0, len = code.length; i < len; ++i) {

--- +++ @@ -1,2 +1,2 @@-'use strict';+"use strict"; @@ -11,6 +11,6 @@   return qs-    .replace('?', '')-    .split('&')+    .replace("?", "")+    .split("&")     .reduce(function (obj, pair) {-      var i = pair.indexOf('=');+      var i = pair.indexOf("=");       var key = pair.slice(0, i);@@ -19,3 +19,3 @@       // Due to how the URLSearchParams API treats spaces-      obj[key] = decodeURIComponent(val.replace(/\+/g, '%20'));+      obj[key] = decodeURIComponent(val.replace(/\+/g, "%20")); 

--- +++ @@ -1,2 +1,2 @@-'use strict';+"use strict"; @@ -10,6 +10,6 @@ -const debug = require('debug')('mocha:cli:cli');-const symbols = require('log-symbols');-const yargs = require('yargs');-const path = require('node:path');+const debug = require("debug")("mocha:cli:cli");+const symbols = require("log-symbols");+const yargs = require("yargs");+const path = require("node:path"); const {@@ -18,9 +18,14 @@   loadOptions,-  YARGS_PARSER_CONFIG-} = require('./options');-const lookupFiles = require('./lookup-files');-const commands = require('./commands');-const pc = require('picocolors');-const {repository, homepage, version, discord} = require('../../package.json');-const {cwd} = require('../utils');+  YARGS_PARSER_CONFIG,+} = require("./options");+const lookupFiles = require("./lookup-files");+const commands = require("./commands");+const pc = require("picocolors");+const {+  repository,+  homepage,+  version,+  discord,+} = require("../../package.json");+const { cwd } = require("../utils"); @@ -36,6 +41,6 @@ exports.main = (argv = process.argv.slice(2), mochaArgs) => {-  debug('entered main with raw args', argv);+  debug("entered main with raw args", argv);   // ensure we can require() from current working directory-  if (typeof module.paths !== 'undefined') {-    module.paths.push(cwd(), path.resolve('node_modules'));+  if (typeof module.paths !== "undefined") {+    module.paths.push(cwd(), path.resolve("node_modules"));   }@@ -45,3 +50,3 @@   } catch (err) {-    debug('unable to set Error.stackTraceLimit = Infinity', err);+    debug("unable to set Error.stackTraceLimit = Infinity", err);   }@@ -51,3 +56,3 @@   yargs()-    .scriptName('mocha')+    .scriptName("mocha")     .command(commands.run)@@ -55,16 +60,16 @@     .updateStrings({-      'Positionals:': 'Positional Arguments',-      'Options:': 'Other Options',-      'Commands:': 'Commands'+      "Positionals:": "Positional Arguments",+      "Options:": "Other Options",+      "Commands:": "Commands",     })     .fail((msg, err, yargs) => {-      debug('caught error sometime before command handler: %O', err);+      debug("caught error sometime before command handler: %O", err);       yargs.showHelp();-      console.error(`\n${symbols.error} ${pc.red('ERROR:')} ${msg}`);+      console.error(`\n${symbols.error} ${pc.red("ERROR:")} ${msg}`);       process.exit(1);     })-    .help('help', 'Show usage information & exit')-    .alias('help', 'h')-    .version('version', 'Show version number & exit', version)-    .alias('version', 'V')+    .help("help", "Show usage information & exit")+    .alias("help", "h")+    .version("version", "Show version number & exit", version)+    .alias("version", "V")     .wrap(process.stdout.columns ? Math.min(process.stdout.columns, 80) : 80)@@ -75,3 +80,3 @@     Docs: ${pc.yellow(homepage)}-      `+      `,     )

--- +++ @@ -1,10 +1,10 @@-'use strict';+"use strict"; -const path = require('node:path');-const pc = require('picocolors');-const debug = require('debug')('mocha:cli:run:helpers');-const { minimatch } = require('minimatch');-const {NO_FILES_MATCH_PATTERN} = require('../error-constants').constants;-const lookupFiles = require('./lookup-files');-const {castArray} = require('../utils');+const path = require("node:path");+const pc = require("picocolors");+const debug = require("debug")("mocha:cli:run:helpers");+const { minimatch } = require("minimatch");+const { NO_FILES_MATCH_PATTERN } = require("../error-constants").constants;+const lookupFiles = require("./lookup-files");+const { castArray } = require("../utils"); @@ -35,3 +35,3 @@   sort,-  spec+  spec, } = {}) => {@@ -41,9 +41,9 @@       const moreSpecFiles = castArray(lookupFiles(arg, extension, recursive))-        .filter(filename =>+        .filter((filename) =>           ignore.every(-            pattern =>-              !minimatch(filename, pattern, {windowsPathsNoEscape: true})-          )+            (pattern) =>+              !minimatch(filename, pattern, { windowsPathsNoEscape: true }),+          ),         )-        .map(filename => path.resolve(filename));+        .map((filename) => path.resolve(filename));       return [...specFiles, ...moreSpecFiles];@@ -51,3 +51,3 @@       if (err.code === NO_FILES_MATCH_PATTERN) {-        unmatchedSpecFiles.push({message: err.message, pattern: err.pattern});+        unmatchedSpecFiles.push({ message: err.message, pattern: err.pattern });         return specFiles;@@ -62,3 +62,3 @@   const unmatchedFiles = [];-  fileArgs.forEach(file => {+  fileArgs.forEach((file) => {     const fileAbsolutePath = path.resolve(file);@@ -68,6 +68,6 @@     } catch (err) {-      if (err.code === 'MODULE_NOT_FOUND') {+      if (err.code === "MODULE_NOT_FOUND") {         unmatchedFiles.push({           pattern: file,-          absolutePath: fileAbsolutePath+          absolutePath: fileAbsolutePath,         });@@ -87,6 +87,6 @@   const files = [-    ...fileArgs.map(filepath => path.resolve(filepath)),-    ...specFiles+    ...fileArgs.map((filepath) => path.resolve(filepath)),+    ...specFiles,   ];-  debug('test files (in order): ', files);+  debug("test files (in order): ", files); @@ -97,5 +97,5 @@         ? `Error: No test files found: ${JSON.stringify(-            unmatchedSpecFiles[0].pattern+            unmatchedSpecFiles[0].pattern,           )}` // stringify to print escaped characters raw-        : 'Error: No test files found';+        : "Error: No test files found";     console.error(pc.red(noneFoundMsg));@@ -104,3 +104,3 @@     // print messages as a warning-    unmatchedSpecFiles.forEach(warning => {+    unmatchedSpecFiles.forEach((warning) => {       console.warn(pc.yellow(`Warning: ${warning.message}`));@@ -111,3 +111,3 @@     files,-    unmatchedFiles+    unmatchedFiles,   };

--- +++ @@ -1,2 +1,2 @@-'use strict';+"use strict"; @@ -10,5 +10,5 @@ module.exports = {-  init: require('./init'),+  init: require("./init"),   // default command-  run: require('./run'),-}+  run: require("./run"),+};

--- +++ @@ -1,2 +1,2 @@-'use strict';+"use strict"; @@ -9,8 +9,8 @@ -const fs = require('node:fs');-const path = require('node:path');-const debug = require('debug')('mocha:cli:config');-const findUp = require('find-up');-const {createUnparsableFileError} = require('../errors');-const utils = require('../utils');+const fs = require("node:fs");+const path = require("node:path");+const debug = require("debug")("mocha:cli:config");+const findUp = require("find-up");+const { createUnparsableFileError } = require("../errors");+const utils = require("../utils"); @@ -24,8 +24,8 @@ exports.CONFIG_FILES = [-  '.mocharc.cjs',-  '.mocharc.js',-  '.mocharc.yaml',-  '.mocharc.yml',-  '.mocharc.jsonc',-  '.mocharc.json'+  ".mocharc.cjs",+  ".mocharc.js",+  ".mocharc.yaml",+  ".mocharc.yml",+  ".mocharc.jsonc",+  ".mocharc.json", ];@@ -37,4 +37,5 @@ const parsers = (exports.parsers = {-  yaml: filepath => require('js-yaml').load(fs.readFileSync(filepath, 'utf8')),-  js: filepath => {+  yaml: (filepath) =>+    require("js-yaml").load(fs.readFileSync(filepath, "utf8")),+  js: (filepath) => {     let cwdFilepath;@@ -51,6 +52,6 @@   },-  json: filepath =>+  json: (filepath) =>     JSON.parse(-      require('strip-json-comments')(fs.readFileSync(filepath, 'utf8'))-    )+      require("strip-json-comments")(fs.readFileSync(filepath, "utf8")),+    ), });@@ -65,5 +66,5 @@  */-exports.loadConfig = filepath => {+exports.loadConfig = (filepath) => {   let config = {};-  debug('loadConfig: trying to parse config at %s', filepath);+  debug("loadConfig: trying to parse config at %s", filepath); @@ -71,5 +72,5 @@   try {-    if (ext === '.yml' || ext === '.yaml') {+    if (ext === ".yml" || ext === ".yaml") {       config = parsers.yaml(filepath);-    } else if (ext === '.js' || ext === '.cjs') {+    } else if (ext === ".js" || ext === ".cjs") {       config = parsers.js(filepath);@@ -81,3 +82,3 @@       `Unable to read/parse ${filepath}: ${err}`,-      filepath+      filepath,     );@@ -94,5 +95,5 @@ exports.findConfig = (cwd = utils.cwd()) => {-  const filepath = findUp.sync(exports.CONFIG_FILES, {cwd});+  const filepath = findUp.sync(exports.CONFIG_FILES, { cwd });   if (filepath) {-    debug('findConfig: found config file %s', filepath);+    debug("findConfig: found config file %s", filepath);   }

--- +++ @@ -1,3 +1,3 @@-'use strict';+"use strict"; -module.exports = require('./cli');+module.exports = require("./cli");

--- +++ @@ -1,2 +1,2 @@-'use strict';+"use strict"; @@ -9,28 +9,28 @@ -const fs = require('node:fs');-const path = require('node:path');+const fs = require("node:fs");+const path = require("node:path"); -exports.command = 'init <path>';+exports.command = "init <path>"; -exports.description = 'create a client-side Mocha setup at <path>';+exports.description = "create a client-side Mocha setup at <path>"; -exports.builder = yargs =>-  yargs.positional('path', {-    type: 'string',-    normalize: true+exports.builder = (yargs) =>+  yargs.positional("path", {+    type: "string",+    normalize: true,   }); -exports.handler = argv => {+exports.handler = (argv) => {   const destdir = argv.path;-  const srcdir = path.join(__dirname, '..', '..');-  fs.mkdirSync(destdir, {recursive: true});-  const css = fs.readFileSync(path.join(srcdir, 'mocha.css'));-  const js = fs.readFileSync(path.join(srcdir, 'mocha.js'));+  const srcdir = path.join(__dirname, "..", "..");+  fs.mkdirSync(destdir, { recursive: true });+  const css = fs.readFileSync(path.join(srcdir, "mocha.css"));+  const js = fs.readFileSync(path.join(srcdir, "mocha.js"));   const tmpl = fs.readFileSync(-    path.join(srcdir, 'lib', 'browser', 'template.html')+    path.join(srcdir, "lib", "browser", "template.html"),   );-  fs.writeFileSync(path.join(destdir, 'mocha.css'), css);-  fs.writeFileSync(path.join(destdir, 'mocha.js'), js);-  fs.writeFileSync(path.join(destdir, 'tests.spec.js'), '');-  fs.writeFileSync(path.join(destdir, 'index.html'), tmpl);+  fs.writeFileSync(path.join(destdir, "mocha.css"), css);+  fs.writeFileSync(path.join(destdir, "mocha.js"), js);+  fs.writeFileSync(path.join(destdir, "tests.spec.js"), "");+  fs.writeFileSync(path.join(destdir, "index.html"), tmpl); };