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;

--- +++ @@ -232,3 +232,3 @@  * as override config file is not explicitly set to `false`, it will search- * upwards from the cwd for a file named `eslint.config.js`.+ * upwards from the cwd for an `eslint.config.*` file.  *

--- +++ @@ -92,3 +92,3 @@ 				default: "true",-				description: "Disable look up for eslint.config.js",+				description: "Disable look up for eslint.config.*", 			},@@ -99,3 +99,3 @@ 				description:-					"Use this configuration instead of eslint.config.js, eslint.config.mjs, or eslint.config.cjs",+					"Use this configuration instead of eslint.config.* look up", 			},

--- +++ @@ -185,2 +185,7 @@ 	);++	if (node.value === 0) {+		return !/^0+$/u.test(normalizedRawNumber.coefficient);+	}+ 	const requestedPrecision = normalizedRawNumber.coefficient.length;@@ -238,3 +243,3 @@ 			Literal(node) {-				if (node.value && isNumber(node) && losesPrecision(node)) {+				if (isNumber(node) && losesPrecision(node)) { 					context.report({

--- +++ @@ -28,3 +28,2 @@ const LOOP_PATTERN = /^(?:DoWhile|For|While)Statement$/u; // for-in/of statements don't have `test` property.-const GROUP_PATTERN = /^(?:BinaryExpression|ConditionalExpression)$/u; const SKIP_PATTERN = /^(?:ArrowFunction|Class|Function)Expression$/u;@@ -192,3 +191,15 @@ -		schema: [],+		schema: [+			{+				type: "object",+				properties: {+					checkConditionalExpressions: {+						type: "boolean",+					},+				},+				additionalProperties: false,+			},+		],++		defaultOptions: [{ checkConditionalExpressions: false }], @@ -201,2 +212,3 @@ 	create(context) {+		const [{ checkConditionalExpressions }] = context.options; 		const sourceCode = context.sourceCode;@@ -307,6 +319,10 @@ 				/*-				 * If it's inside of a group, OK if either operand is modified.-				 * So stores the group this reference belongs to.+				 * If it's inside of a group, OK if any reference in that group is+				 * modified. So stores the group this reference belongs to. 				 */-				if (GROUP_PATTERN.test(node.type)) {+				if (+					node.type === "BinaryExpression" ||+					(!checkConditionalExpressions &&+						node.type === "ConditionalExpression")+				) { 					// If this expression is dynamic, no need to check.

--- +++ @@ -375,4 +375,4 @@ 				/*-				 * JSXAttribute doesn't have any escape sequence: https://facebook.github.io/jsx/.-				 * In addition, backticks are not supported by JSX yet: https://github.com/facebook/jsx/issues/25.+				 * JSXAttribute doesn't have any escape sequence: https://react.github.io/jsx/.+				 * In addition, backticks are not supported by JSX yet: https://github.com/react/jsx/issues/25. 				 */

--- +++ @@ -223,2 +223,76 @@ +/**+ * Checks whether a given variable is referenced inside a hoisted function+ * declaration that is called before the variable's declaration.+ * @param {Variable} variable The variable to check.+ * @returns {boolean} `true` if the variable is referenced from a hoisted+ *      function called before its declaration.+ */+function hasUnsafeHoistedFunctionReference(variable) {+	const declarationNode = variable.defs[0].node;+	const declarationStart = declarationNode.range[0];++	for (const reference of variable.references) {+		if (reference.init) {+			continue;+		}++		if (reference.identifier.range[0] < declarationStart) {+			continue;+		}++		let currentScope = reference.from.variableScope;++		while (currentScope !== variable.scope) {+			if (+				currentScope.block.type === "FunctionDeclaration" &&+				currentScope.block.id+			) {+				const funcName = currentScope.block.id.name;+				const funcVariable = currentScope.upper.set.get(funcName);++				for (const funcRef of funcVariable.references) {+					const refId = funcRef.identifier;++					if (+						refId.parent.type === "CallExpression" &&+						refId.parent.callee === refId &&+						refId.range[0] < declarationStart+					) {+						return true;+					}+				}+			}++			currentScope = currentScope.upper.variableScope;+		}+	}++	return false;+}++/**+ * Checks whether a given variable is shadowed by the parameter of an enclosing+ * `catch` clause.+ *+ * Scope analysis does not report this as a redeclaration, because the catch+ * parameter and the `var` are distinct variables living in distinct scopes, so+ * neither one has more than one definition.+ *+ * Resolving the name from the scope of the declaration is enough to detect it.+ * A simple catch parameter is the only binding a `var` is allowed to shadow:+ * any other block-scoped declaration of the same name makes the `var` itself a+ * syntax error, and a function parameter shares its variable with the `var`, so+ * that case is reported by `isRedeclared` instead.+ * @param {ASTNode} node A `VariableDeclaration` node to check.+ * @param {SourceCode} sourceCode The source code object.+ * @returns {Function} The predicate function which checks whether a given+ *      variable is shadowed by a `catch` clause parameter.+ */+function isShadowedByCatchParameter(node, sourceCode) {+	return variable =>+		astUtils.getVariableByName(sourceCode.getScope(node), variable.name) !==+		variable;+}+ //------------------------------------------------------------------------------@@ -278,2 +352,3 @@ 		 * - A variable has name that is disallowed for `let` declarations.+		 * - A variable is shadowed by a `catch` clause parameter. 		 *@@ -314,2 +389,11 @@ 		 * initializer.+		 *+		 * ## A variable is shadowed by a `catch` clause parameter.+		 *+		 * A `var` declaration may reuse the name of a simple catch clause+		 * parameter, but the equivalent `let` declaration may not. Directly+		 * inside the catch block, `let` would be a syntax error. In a nested+		 * block, `let` is valid but changes behavior: the `var` assigns to the+		 * catch parameter, while the `let` introduces a separate binding and+		 * leaves the catch parameter untouched. 		 * @param {ASTNode} node A variable declaration node to check.@@ -332,3 +416,5 @@ 				variables.some(hasNameDisallowedForLetDeclarations) ||-				variables.some(hasReferenceBeforeDeclaration)+				variables.some(hasReferenceBeforeDeclaration) ||+				variables.some(hasUnsafeHoistedFunctionReference) ||+				variables.some(isShadowedByCatchParameter(node, sourceCode)) 			) {

--- +++ @@ -301,5 +301,11 @@ +			const prefix =+				astUtils.isStartOfExpressionStatement(topBinaryExpr) &&+				astUtils.needsPrecedingSemicolon(sourceCode, topBinaryExpr)+					? ";"+					: "";+ 			return fixer.replaceText( 				topBinaryExpr,-				getTemplateLiteral(topBinaryExpr, null, null),+				`${prefix}${getTemplateLiteral(topBinaryExpr, null, null)}`, 			);

--- +++ @@ -970,3 +970,3 @@ 					/**-					 * Enable [JSX](https://facebook.github.io/jsx/).+					 * Enable [JSX](https://react.github.io/jsx/). 					 *

--- +++ @@ -4042,3 +4042,12 @@ 	 */-	"no-unmodified-loop-condition": Linter.RuleEntry<[]>;+	"no-unmodified-loop-condition": Linter.RuleEntry<+		[+			Partial<{+				/**+				 * @default false+				 */+				checkConditionalExpressions: boolean;+			}>,+		]+	>; 

--- +++ @@ -4,5 +4,5 @@ 	return `-ESLint couldn't find an eslint.config.(js|mjs|cjs) file.+ESLint couldn't find an eslint.config.* file. -From ESLint v9.0.0, the default configuration file is now eslint.config.js.+From ESLint v9.0.0, the default configuration file is now eslint.config.*. If you are using a .eslintrc.* file, please follow the migration guide

--- +++ @@ -2,3 +2,3 @@   "name": "eslint",-  "version": "10.8.1",+  "version": "10.9.0",   "author": "Nicholas C. Zakas <[email protected]>",

--- +++ @@ -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":"AAAA,a;;AAEA,IAAMA,eAAeC,QAAQ,gBAAR,CAArB,C;AAC6BA,QAAQ,YAAR,C,CAAZC,O;;AAEjB,IAAMC,uBAAuB,qBAA7B;AACA,IAAMC,0BAA0B,oBAAhC;AACA,IAAMC;AACHF,oBADG,EACoB,qDADpB;AAEHC,uBAFG,EAEuB,qDAFvB,aAAN;;;AAKA,SAASE,oBAAT;AACEC,KADF;AAEEC,IAFF;AAGEC,IAHF;AAIEC,kBAJF;AAKEC,gBALF;AAME;AACA,MAAMC,sBAAsBJ,KAAKK,KAAL,CAAW,CAAX,IAAgB,CAA5C;AACA,MAAMC,QAAQC,OAAOC,SAAP,CAAiBL,gBAAjB;AACVD,uBAAqBE,mBADX;AAEVA,qBAFJ;AAGA,MAAMK,MAAMF,OAAOC,SAAP,CAAiBL,gBAAjB;AACRA,qBAAmBC,mBADX;AAERJ,OAAKK,KAAL,CAAW,CAAX,IAAgB,CAFpB;;AAIA,SAAON,MAAMW,gBAAN,CAAuB,CAACJ,KAAD,EAAQG,GAAR,CAAvB,EAAqCR,IAArC,CAAP;AACD;;AAED,SAASU,eAAT,CAAyBX,IAAzB,EAA+B;AAC7B,SAAOA,QAAQA,KAAKY,IAAL,KAAc,SAAtB,IAAmC,OAAOZ,KAAKa,KAAZ,KAAsB,QAAhE;AACD;;AAED,SAASC,yBAAT,CAAmCd,IAAnC,EAAyC;AACvC,SAAO,CAACA,KAAKe,QAAN;AACFf,OAAKgB,MAAL,CAAYJ,IAAZ,KAAqB,YADnB;AAEFZ,OAAKgB,MAAL,CAAYC,IAAZ,KAAqB;AACxB;AAHK,KAIFjB,KAAKkB,SAAL,CAAeC,MAAf,KAA0B,CAJxB;AAKFnB,OAAKkB,SAAL,CAAe,CAAf,CALE;AAMFP,kBAAgBX,KAAKkB,SAAL,CAAe,CAAf,CAAhB,CANL;AAOD;;AAED,SAASE,cAAT,CAAwBC,GAAxB,EAA6BC,OAA7B,EAAsC;AACpC;AACA,MAAI,CAACD,GAAD,IAAQA,IAAIT,IAAJ,KAAa,iBAAzB,EAA4C,CAAE,OAAS;AACvD,MAAMW,aAAa,WAAWF,GAAX,GAAiBA,IAAIR,KAArB,GAA6BQ,IAAIJ,IAApD;AACA,MAAI,OAAOM,UAAP,KAAsB,QAA1B,EAAoC,CAAEC,QAAQC,GAAR,CAAYJ,GAAZ,EAAiBE,UAAjB,EAA+B,CAJjC;AAK5BG,UAL4B,GAKfJ,OALe,CAK5BI,QAL4B;AAMpC,MAAMC,cAAcD,YAAYA,SAAS,qBAAT,CAAhC;AACA;AACE,SAAOC,WAAP,KAAuB,WAAvB;;AAEE,SAAOA,WAAP,KAAuB,QAAvB;AACG,GAAE,0BAAD,CAA6BC,IAA7B,CAAkCD,WAAlC,CAHN,CADF;;AAME;AACA,UAAM,IAAIE,SAAJ,CAAc,kHAAd,CAAN;AACD;;AAED,MAAIP,QAAQQ,OAAR,CAAgB,CAAhB,MAAuB,OAA3B,EAAoC;AAClC,QAAI,CAACP,WAAWQ,UAAX,CAAsB,OAAtB,CAAL,EAAqC,CAAE,OAAS;;AAEhD,QAAMC,mBAAmBT,WAAWU,KAAX,CAAiB,CAAjB,CAAzB;AACA,QAAI,CAACzC,aAAawC,gBAAb,EAA+BL,eAAeO,SAA9C,CAAL,EAA+D,CAAE,OAAS;;AAE1EZ,YAAQa,MAAR,CAAe;AACbnC,YAAMqB,GADO;AAEbe,eAASvC,SAASD,uBAAT,CAFI;AAGbyC,YAAM,EAAEd,YAAYS,gBAAd,EAHO;AAIb;AACAM,SALa,4BAKTvC,KALS,EAKF;AACT,iBAAOD,qBAAqBC,KAArB,EAA4BsB,GAA5B,EAAiC,EAAjC,EAAqC,CAArC,EAAwC,CAAxC,CAAP;AACD,SAPY,gBAAf;;AASD,GAfD,MAeO,IAAIC,QAAQQ,OAAR,CAAgB,CAAhB,MAAuB,QAA3B,EAAqC;AAC1C;AACEP,eAAWQ,UAAX,CAAsB,OAAtB;AACG,KAACvC,aAAa+B,UAAb,EAAyBI,eAAeO,SAAxC,CADJ;AAEG,KAAC1C,8BAAqB+B,UAArB,GAAmCI,eAAeO,SAAlD,CAHN;AAIE;AACA;AACD;;AAEDZ,YAAQa,MAAR,CAAe;AACbnC,YAAMqB,GADO;AAEbe,eAASvC,SAASF,oBAAT,CAFI;AAGb0C,YAAM,EAAEd,sBAAF,EAHO;AAIb;AACAe,SALa,4BAKTvC,KALS,EAKF;AACT,iBAAOD,qBAAqBC,KAArB,EAA4BsB,GAA5B,EAAiC,OAAjC,EAA0C,CAA1C,EAA6C,CAA7C,CAAP;AACD,SAPY,gBAAf;;AASD,GAlBM,MAkBA,IAAI,OAAOC,QAAQQ,OAAR,CAAgB,CAAhB,CAAP,KAA8B,WAAlC,EAA+C;AACpD,UAAM,IAAIS,KAAJ,CAAU,gBAAV,CAAN;AACD,GAFM,MAEA;AACL,UAAM,IAAIA,KAAJ,gCAAgCjB,QAAQQ,OAAR,CAAgB,CAAhB,CAAhC,EAAN;AACD;AACF;;AAED;AACAU,OAAOC,OAAP,GAAiB;AACfC,QAAM;AACJ9B,UAAM,YADF;AAEJ+B,UAAM;AACJC,mBAAa,iGADT;AAEJC,mBAAa,IAFT;AAGJC,gBAAU,iBAHN;AAIJC,WAAKrD,QAAQ,6BAAR,CAJD,EAFF;;AAQJsD,aAAS,MARL;AASJC,YAAQ;AACNrC,YAAM,OADA;AAENsC,gBAAU,CAFJ;AAGNC,gBAAU,CAHJ;AAINC,aAAO;AACL;AACE,gBAAM,CAAC,QAAD,EAAW,OAAX,CADR,EADK,CAJD,EATJ;;;;AAmBJvD,sBAnBI,EADS;;AAsBfwD,QAtBe,+BAsBR/B,OAtBQ,EAsBC;AACd,aAAO;AACLgC,sBADK,uCACUtD,IADV,EACgB;AACnB,gBAAI,CAACc,0BAA0Bd,IAA1B,CAAL,EAAsC,CAAE,OAAS;;AAEjD,gBAAMuD,MAAMvD,KAAKkB,SAAL,CAAe,CAAf,CAAZ;;AAEA,mBAAOE,eAAemC,GAAf,EAAoBjC,OAApB,CAAP;AACD,WAPI;AAQLkC,8BARK,+CAQkBxD,IARlB,EAQwB;AAC3B,mBAAOoB,eAAepB,KAAKyD,MAApB,EAA4BnC,OAA5B,CAAP;AACD,WAVI;AAWLoC,yBAXK,0CAWa1D,IAXb,EAWmB;AACtB,mBAAOoB,eAAepB,KAAKyD,MAApB,EAA4BnC,OAA5B,CAAP;AACD,WAbI;AAcLqC,wBAdK,yCAcY3D,IAdZ,EAckB;AACrB,gBAAI,CAACW,gBAAgBX,KAAKyD,MAArB,CAAL,EAAmC,CAAE,OAAS;;AAE9C,mBAAOrC,eAAepB,KAAKyD,MAApB,EAA4BnC,OAA5B,CAAP;AACD,WAlBI,6BAAP;;AAoBD,KA3Cc,mBAAjB","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":"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","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",

--- +++ @@ -103,2 +103,7 @@         description: "Not fail test run if tests were failed",+        group: GROUPS.RULES,+      },+      "fail-hook-affected-tests": {+        description:+          "Report tests as failed when affected by hook failures (before/beforeEach)",         group: GROUPS.RULES,

--- +++ @@ -841,2 +841,16 @@ /**+ * Reports tests as failed when they are skipped due to a hook failure.+ *+ * @public+ * @see [CLI option](../#-fail-hook-affected-tests)+ * @param {boolean} [failHookAffectedTests=true] - Whether to fail tests affected by hook failures.+ * @return {Mocha} this+ * @chainable+ */+Mocha.prototype.failHookAffectedTests = function (failHookAffectedTests) {+  this.options.failHookAffectedTests = failHookAffectedTests !== false;+  return this;+};++/**  * Fails test run if no tests encountered with exit-code 1.@@ -968,2 +982,3 @@     dryRun: options.dryRun,+    failHookAffectedTests: options.failHookAffectedTests,     failZero: options.failZero,

--- +++ @@ -100,2 +100,5 @@     debug("requireModule caught err: %O", requireErr.message);+    if (requireErr.name === "TSError") {+      throw requireErr;+    }     try {

--- +++ @@ -184,2 +184,3 @@    * @param {boolean} [opts.failZero] - Whether to fail test run if zero tests encountered.+   * @param {boolean} [opts.failHookAffectedTests] - Whether to fail all tests affected by hook failures.    */@@ -441,2 +442,69 @@   }+};++/**+ * Create an error object for a test that was skipped due to a hook failure.+ *+ * @private+ * @param {string} hookTitle - The title of the failed hook+ * @param {*} hookError - The error from the failed hook (may not be an Error object)+ * @returns {Error} The error object for the skipped test+ */+function createHookSkipError(hookTitle, hookError) {+  // Handle falsy or undefined exceptions+  if (!hookError) {+    hookError = createInvalidExceptionError(+      'Hook "' + hookTitle + '" failed with exception: ' + hookError,+      hookError,+    );+  }+  // Convert non-Error objects to Error+  else if (!isError(hookError)) {+    hookError = thrown2Error(hookError);+  }++  var errorMessage =+    'Test skipped due to failure in hook "' ++    hookTitle ++    '": ' ++    hookError.message;+  var testError = new Error(errorMessage);+  testError.stack = hookError.stack;+  return testError;+}++/**+ * Fail all tests that are affected by a hook failure.+ * This is used when the `failHookAffectedTests` option is enabled.+ *+ * @private+ * @param {Suite} suite - The suite containing the affected tests+ * @param {Error} hookError - The error from the failed hook+ * @param {string} hookTitle - The title of the failed hook+ */+Runner.prototype.failAffectedTests = function (suite, hookError, hookTitle) {+  if (!this._opts.failHookAffectedTests) {+    return;+  }++  var self = this;+  var testError = createHookSkipError(hookTitle, hookError);++  // Recursively fail all tests in this suite and its child suites+  function failTestsInSuite(s) {+    s.tests.forEach(function (test) {+      // Only fail tests that haven't been executed yet+      if (!test.state) {+        test.state = STATE_FAILED;+        self.failures++;+        self.emit(constants.EVENT_TEST_BEGIN, test);+        self.emit(constants.EVENT_TEST_FAIL, test, testError);+        self.emit(constants.EVENT_TEST_END, test);+      }+    });++    s.suites.forEach(failTestsInSuite);+  }++  failTestsInSuite(suite); };@@ -585,2 +653,24 @@         self.fail(hook, err);+        // If failHookAffectedTests is enabled, mark affected tests as failed+        if (self._opts.failHookAffectedTests) {+          if (name === HOOK_TYPE_BEFORE_ALL) {+            self.failAffectedTests(self.suite, err, hook.title);+          } else if (name === HOOK_TYPE_BEFORE_EACH) {+            // Fail the current test+            if (self.test && !self.test.state) {+              var testError = createHookSkipError(hook.title, err);++              self.test.state = STATE_FAILED;+              self.failures++;+              self.emit(constants.EVENT_TEST_BEGIN, self.test);+              self.emit(constants.EVENT_TEST_FAIL, self.test, testError);+              self.emit(constants.EVENT_TEST_END, self.test);+            }+            // Store the hook error info for remaining tests+            self._failedBeforeEachHook = {+              error: err,+              title: hook.title,+            };+          }+        }         // stop executing hooks, notify callee of hook err@@ -736,5 +826,32 @@ -  function hookErr(_, errSuite, after) {+  function hookErr(err, errSuite, after) {     // before/after Each hook for errSuite failed:     var orig = self.suite;++    // If failHookAffectedTests is enabled and this is a beforeEach failure,+    // mark remaining tests as failed+    if (+      self._opts.failHookAffectedTests &&+      !after &&+      self._failedBeforeEachHook+    ) {+      // Fail all remaining tests in the suite+      var remainingTests = tests.slice();+      remainingTests.forEach(function (t) {+        if (!t.state) {+          var testError = createHookSkipError(+            self._failedBeforeEachHook.title,+            self._failedBeforeEachHook.error,+          );++          t.state = STATE_FAILED;+          self.failures++;+          self.emit(constants.EVENT_TEST_BEGIN, t);+          self.emit(constants.EVENT_TEST_FAIL, t, testError);+          self.emit(constants.EVENT_TEST_END, t);+        }+      });+      // Clear the stored hook info+      delete self._failedBeforeEachHook;+    } 

--- +++ @@ -1,2 +1,2 @@-// [email protected] in javascript ES2018+// [email protected] in javascript ES2018 (function (global, factory) {@@ -15157,2 +15157,3 @@      * @param {boolean} [opts.failZero] - Whether to fail test run if zero tests encountered.+     * @param {boolean} [opts.failHookAffectedTests] - Whether to fail all tests affected by hook failures.      */@@ -15414,2 +15415,69 @@     }+  };++  /**+   * Create an error object for a test that was skipped due to a hook failure.+   *+   * @private+   * @param {string} hookTitle - The title of the failed hook+   * @param {*} hookError - The error from the failed hook (may not be an Error object)+   * @returns {Error} The error object for the skipped test+   */+  function createHookSkipError(hookTitle, hookError) {+    // Handle falsy or undefined exceptions+    if (!hookError) {+      hookError = createInvalidExceptionError(+        'Hook "' + hookTitle + '" failed with exception: ' + hookError,+        hookError,+      );+    }+    // Convert non-Error objects to Error+    else if (!isError(hookError)) {+      hookError = thrown2Error(hookError);+    }++    var errorMessage =+      'Test skipped due to failure in hook "' ++      hookTitle ++      '": ' ++      hookError.message;+    var testError = new Error(errorMessage);+    testError.stack = hookError.stack;+    return testError;+  }++  /**+   * Fail all tests that are affected by a hook failure.+   * This is used when the `failHookAffectedTests` option is enabled.+   *+   * @private+   * @param {Suite} suite - The suite containing the affected tests+   * @param {Error} hookError - The error from the failed hook+   * @param {string} hookTitle - The title of the failed hook+   */+  Runner.prototype.failAffectedTests = function (suite, hookError, hookTitle) {+    if (!this._opts.failHookAffectedTests) {+      return;+    }++    var self = this;+    var testError = createHookSkipError(hookTitle, hookError);++    // Recursively fail all tests in this suite and its child suites+    function failTestsInSuite(s) {+      s.tests.forEach(function (test) {+        // Only fail tests that haven't been executed yet+        if (!test.state) {+          test.state = STATE_FAILED;+          self.failures++;+          self.emit(constants$1.EVENT_TEST_BEGIN, test);+          self.emit(constants$1.EVENT_TEST_FAIL, test, testError);+          self.emit(constants$1.EVENT_TEST_END, test);+        }+      });++      s.suites.forEach(failTestsInSuite);+    }++    failTestsInSuite(suite);   };@@ -15558,2 +15626,24 @@           self.fail(hook, err);+          // If failHookAffectedTests is enabled, mark affected tests as failed+          if (self._opts.failHookAffectedTests) {+            if (name === HOOK_TYPE_BEFORE_ALL) {+              self.failAffectedTests(self.suite, err, hook.title);+            } else if (name === HOOK_TYPE_BEFORE_EACH) {+              // Fail the current test+              if (self.test && !self.test.state) {+                var testError = createHookSkipError(hook.title, err);++                self.test.state = STATE_FAILED;+                self.failures++;+                self.emit(constants$1.EVENT_TEST_BEGIN, self.test);+                self.emit(constants$1.EVENT_TEST_FAIL, self.test, testError);+                self.emit(constants$1.EVENT_TEST_END, self.test);+              }+              // Store the hook error info for remaining tests+              self._failedBeforeEachHook = {+                error: err,+                title: hook.title,+              };+            }+          }           // stop executing hooks, notify callee of hook err@@ -15709,5 +15799,32 @@ -    function hookErr(_, errSuite, after) {+    function hookErr(err, errSuite, after) {       // before/after Each hook for errSuite failed:       var orig = self.suite;++      // If failHookAffectedTests is enabled and this is a beforeEach failure,+      // mark remaining tests as failed+      if (+        self._opts.failHookAffectedTests &&+        !after &&+        self._failedBeforeEachHook+      ) {+        // Fail all remaining tests in the suite+        var remainingTests = tests.slice();+        remainingTests.forEach(function (t) {+          if (!t.state) {+            var testError = createHookSkipError(+              self._failedBeforeEachHook.title,+              self._failedBeforeEachHook.error,+            );++            t.state = STATE_FAILED;+            self.failures++;+            self.emit(constants$1.EVENT_TEST_BEGIN, t);+            self.emit(constants$1.EVENT_TEST_FAIL, t, testError);+            self.emit(constants$1.EVENT_TEST_END, t);+          }+        });+        // Clear the stored hook info+        delete self._failedBeforeEachHook;+      } @@ -20133,3 +20250,3 @@   var name = "mocha";-  var version = "11.7.6";+  var version = "11.8.0";   var homepage = "https://mochajs.org/";@@ -20984,2 +21101,16 @@   /**+   * Reports tests as failed when they are skipped due to a hook failure.+   *+   * @public+   * @see [CLI option](../#-fail-hook-affected-tests)+   * @param {boolean} [failHookAffectedTests=true] - Whether to fail tests affected by hook failures.+   * @return {Mocha} this+   * @chainable+   */+  Mocha.prototype.failHookAffectedTests = function (failHookAffectedTests) {+    this.options.failHookAffectedTests = failHookAffectedTests !== false;+    return this;+  };++  /**    * Fails test run if no tests encountered with exit-code 1.@@ -21111,2 +21242,3 @@       dryRun: options.dryRun,+      failHookAffectedTests: options.failHookAffectedTests,       failZero: options.failZero,

--- +++ @@ -2,3 +2,3 @@   "name": "mocha",-  "version": "11.7.6",+  "version": "11.8.0",   "type": "commonjs",@@ -51,3 +51,2 @@     "docs:build": "eleventy",-    "docs:build-new": "cd docs-next && npm i && npm run build-with-old",     "docs:preview": "http-server docs/_site -o",

--- +++ @@ -45,7 +45,13 @@ exports.nativeSync = wrapSync(rimraf_native_js_1.rimrafNativeSync);-exports.native = Object.assign(wrap(rimraf_native_js_1.rimrafNative), { sync: exports.nativeSync });+exports.native = Object.assign(wrap(rimraf_native_js_1.rimrafNative), {+    sync: exports.nativeSync,+}); exports.manualSync = wrapSync(rimraf_manual_js_1.rimrafManualSync);-exports.manual = Object.assign(wrap(rimraf_manual_js_1.rimrafManual), { sync: exports.manualSync });+exports.manual = Object.assign(wrap(rimraf_manual_js_1.rimrafManual), {+    sync: exports.manualSync,+}); exports.windowsSync = wrapSync(rimraf_windows_js_1.rimrafWindowsSync);-exports.windows = Object.assign(wrap(rimraf_windows_js_1.rimrafWindows), { sync: exports.windowsSync });+exports.windows = Object.assign(wrap(rimraf_windows_js_1.rimrafWindows), {+    sync: exports.windowsSync,+}); exports.posixSync = wrapSync(rimraf_posix_js_1.rimrafPosixSync);

--- +++ @@ -12,3 +12,4 @@     typeOrUndef(o.maxBackoff, 'number') &&-    (typeOrUndef(o.glob, 'boolean') || (o.glob && typeof o.glob === 'object')) &&+    (typeOrUndef(o.glob, 'boolean') ||+        (o.glob && typeof o.glob === 'object')) &&     typeOrUndef(o.filter, 'function');

--- +++ @@ -11,3 +11,4 @@                 : `type ${type} ${path}`;-        const msg = 'The "path" argument must be of type string. ' + `Received ${received}`;+        const msg = 'The "path" argument must be of type string. ' ++            `Received ${received}`;         throw Object.assign(new TypeError(msg), {

--- +++ @@ -1,3 +1,3 @@-export declare const readdirOrError: (path: string) => Promise<import("fs").Dirent<string>[] | Error>;-export declare const readdirOrErrorSync: (path: string) => import("fs").Dirent<string>[] | Error;+export declare const readdirOrError: (path: string) => Promise<import("node:fs").Dirent<string>[] | Error>;+export declare const readdirOrErrorSync: (path: string) => import("node:fs").Dirent<string>[] | Error; //# sourceMappingURL=readdir-or-error.d.ts.map

--- +++ @@ -21,4 +21,3 @@     opt?.signal?.throwIfAborted();-    return ((0, ignore_enoent_js_1.ignoreENOENTSync)(() => rimrafPosixDirSync(path, opt, (0, fs_js_1.lstatSync)(path))) ??-        true);+    return ((0, ignore_enoent_js_1.ignoreENOENTSync)(() => rimrafPosixDirSync(path, opt, (0, fs_js_1.lstatSync)(path))) ?? true); };

--- +++ @@ -1,2 +1,3 @@ import fs, { Dirent } from 'fs';+import fsPromises from 'fs/promises'; export { chmodSync, mkdirSync, renameSync, rmdirSync, rmSync, statSync, lstatSync, unlinkSync, } from 'fs';@@ -4,11 +5,11 @@ export declare const promises: {-    chmod: typeof fs.promises.chmod;-    mkdir: typeof fs.promises.mkdir;+    chmod: typeof fsPromises.chmod;+    mkdir: typeof fsPromises.mkdir;     readdir: (path: fs.PathLike) => Promise<fs.Dirent<string>[]>;-    rename: typeof fs.promises.rename;-    rm: typeof fs.promises.rm;-    rmdir: typeof fs.promises.rmdir;-    stat: typeof fs.promises.stat;-    lstat: typeof fs.promises.lstat;-    unlink: typeof fs.promises.unlink;+    rename: typeof fsPromises.rename;+    rm: typeof fsPromises.rm;+    rmdir: typeof fsPromises.rmdir;+    stat: typeof fsPromises.stat;+    lstat: typeof fsPromises.lstat;+    unlink: typeof fsPromises.unlink; };

--- +++ @@ -4,3 +4,3 @@ import { rimrafManual, rimrafManualSync } from './rimraf-manual.js';-import { rimrafMoveRemove, rimrafMoveRemoveSync } from './rimraf-move-remove.js';+import { rimrafMoveRemove, rimrafMoveRemoveSync, } from './rimraf-move-remove.js'; import { rimrafNative, rimrafNativeSync } from './rimraf-native.js';@@ -37,7 +37,13 @@ export const nativeSync = wrapSync(rimrafNativeSync);-export const native = Object.assign(wrap(rimrafNative), { sync: nativeSync });+export const native = Object.assign(wrap(rimrafNative), {+    sync: nativeSync,+}); export const manualSync = wrapSync(rimrafManualSync);-export const manual = Object.assign(wrap(rimrafManual), { sync: manualSync });+export const manual = Object.assign(wrap(rimrafManual), {+    sync: manualSync,+}); export const windowsSync = wrapSync(rimrafWindowsSync);-export const windows = Object.assign(wrap(rimrafWindows), { sync: windowsSync });+export const windows = Object.assign(wrap(rimrafWindows), {+    sync: windowsSync,+}); export const posixSync = wrapSync(rimrafPosixSync);

--- +++ @@ -9,3 +9,4 @@     typeOrUndef(o.maxBackoff, 'number') &&-    (typeOrUndef(o.glob, 'boolean') || (o.glob && typeof o.glob === 'object')) &&+    (typeOrUndef(o.glob, 'boolean') ||+        (o.glob && typeof o.glob === 'object')) &&     typeOrUndef(o.filter, 'function');

--- +++ @@ -9,3 +9,4 @@                 : `type ${type} ${path}`;-        const msg = 'The "path" argument must be of type string. ' + `Received ${received}`;+        const msg = 'The "path" argument must be of type string. ' ++            `Received ${received}`;         throw Object.assign(new TypeError(msg), {

--- +++ @@ -1,3 +1,3 @@-export declare const readdirOrError: (path: string) => Promise<import("fs").Dirent<string>[] | Error>;-export declare const readdirOrErrorSync: (path: string) => import("fs").Dirent<string>[] | Error;+export declare const readdirOrError: (path: string) => Promise<import("node:fs").Dirent<string>[] | Error>;+export declare const readdirOrErrorSync: (path: string) => import("node:fs").Dirent<string>[] | Error; //# sourceMappingURL=readdir-or-error.d.ts.map

--- +++ @@ -15,3 +15,3 @@ import { ignoreENOENT, ignoreENOENTSync } from './ignore-enoent.js';-import { lstatSync, promises, renameSync, rmdirSync, unlinkSync } from './fs.js';+import { lstatSync, promises, renameSync, rmdirSync, unlinkSync, } from './fs.js'; import { readdirOrError, readdirOrErrorSync } from './readdir-or-error.js';

--- +++ @@ -17,4 +17,3 @@     opt?.signal?.throwIfAborted();-    return (ignoreENOENTSync(() => rimrafPosixDirSync(path, opt, lstatSync(path))) ??-        true);+    return (ignoreENOENTSync(() => rimrafPosixDirSync(path, opt, lstatSync(path))) ?? true); };

--- +++ @@ -15,3 +15,3 @@ import { retryBusy, retryBusySync } from './retry-busy.js';-import { rimrafMoveRemove, rimrafMoveRemoveSync } from './rimraf-move-remove.js';+import { rimrafMoveRemove, rimrafMoveRemoveSync, } from './rimraf-move-remove.js'; import { errorCode } from './error.js';

--- +++ @@ -2,3 +2,3 @@   "name": "rimraf",-  "version": "6.1.2",+  "version": "6.1.3",   "type": "module",@@ -47,16 +47,4 @@   },-  "prettier": {-    "experimentalTernaries": true,-    "semi": false,-    "printWidth": 80,-    "tabWidth": 2,-    "useTabs": false,-    "singleQuote": true,-    "jsxSingleQuote": false,-    "bracketSameLine": true,-    "arrowParens": "avoid",-    "endOfLine": "lf"-  },   "devDependencies": {-    "@types/node": "^24.9.2",+    "@types/node": "^25.2.0",     "mkdirp": "^3.0.1",@@ -74,3 +62,3 @@   "dependencies": {-    "glob": "^13.0.0",+    "glob": "^13.0.3",     "package-json-from-dist": "^1.0.1"@@ -87,6 +75,3 @@   ],-  "module": "./dist/esm/index.js",-  "tap": {-    "coverage-map": "map.js"-  }+  "module": "./dist/esm/index.js" }

--- +++ @@ -378,3 +378,3 @@         if (!(0, transpile_module_1.isModernNodeModuleKind)(this._initialCompilerOptions.module)) {-            return this._ts.transpileModule(fileContent, {+            const result = this._ts.transpileModule(fileContent, {                 fileName,@@ -384,2 +384,4 @@             });+            const diagnostics = this._filterDiagnosticsFromTsJestDefaults(result.diagnostics);+            return diagnostics === result.diagnostics ? result : { ...result, diagnostics };         }@@ -394,2 +396,20 @@         });+    }+    /**+     * TypeScript 6 reports TS5107 when ts-jest's historical default of+     * `moduleResolution: Node10` is passed to `transpileModule`. The diagnostic+     * is an implementation detail when ts-jest injected that value, but remains+     * actionable when the user selected Node10 themselves.+     */+    _filterDiagnosticsFromTsJestDefaults(diagnostics) {+        // `Node10` was exposed as `NodeJs` (with the same value) by older supported TypeScript releases.+        const node10 = this._ts.ModuleResolutionKind.Node10 ?? 2;+        const tsMajor = Number.parseInt(this._ts.version.split('.')[0], 10);+        const hasInjectedNode10 = tsMajor >= 6 &&+            this._initialCompilerOptions.moduleResolution === undefined &&+            this._compilerOptions.moduleResolution === node10;+        if (!hasInjectedNode10 || !diagnostics?.some((diagnostic) => diagnostic.code === 5107)) {+            return diagnostics;+        }+        return diagnostics.filter((diagnostic) => diagnostic.code !== 5107);     }

--- +++ @@ -29,3 +29,13 @@     typescript(why, which) {-        return this._import(why, which);+        const compilerModule = this._import(why, which);+        const hasRequiredCompilerApi = typeof compilerModule.createLanguageService === 'function' &&+            typeof compilerModule.parseJsonConfigFileContent === 'function' &&+            typeof compilerModule.transpileModule === 'function';+        if (!hasRequiredCompilerApi) {+            throw new Error((0, messages_1.interpolate)("The TypeScript compiler \"{{module}}\" (version {{version}}) does not expose the JavaScript compiler API required by ts-jest. To use TypeScript 7 for project type-checking, install it as \"@typescript/native\" and alias \"@typescript/typescript6\" as \"typescript\" for ts-jest." /* Errors.TypeScriptCompilerApiUnavailable */, {+                module: which,+                version: compilerModule.version ?? 'unknown',+            }));+        }+        return compilerModule;     }

--- +++ @@ -2,3 +2,3 @@   "name": "ts-jest",-  "version": "29.4.11",+  "version": "29.4.12",   "main": "dist/index.js",@@ -59,3 +59,3 @@     "make-error": "^1.3.6",-    "semver": "^7.8.0",+    "semver": "^7.8.5",     "type-fest": "^4.41.0",@@ -96,4 +96,4 @@     "@eslint/compat": "^1.4.1",-    "@eslint/eslintrc": "^3.3.5",-    "@eslint/js": "^9.39.4",+    "@eslint/eslintrc": "^3.3.6",+    "@eslint/js": "^9.39.5",     "@jest/globals": "^30.4.1",@@ -109,3 +109,3 @@     "@types/micromatch": "^4.0.10",-    "@types/node": "20.19.41",+    "@types/node": "20.19.43",     "@types/semver": "^7.7.1",@@ -113,9 +113,9 @@     "@types/yargs-parser": "21.0.3",-    "@typescript-eslint/eslint-plugin": "^8.59.3",-    "@typescript-eslint/parser": "^8.59.3",+    "@typescript-eslint/eslint-plugin": "^8.64.0",+    "@typescript-eslint/parser": "^8.64.0",     "babel-jest": "^30.4.1",     "conventional-changelog-angular": "^8.3.1",-    "conventional-changelog": "^7.2.0",-    "esbuild": "~0.28.0",-    "eslint": "^9.39.4",+    "conventional-changelog": "^7.2.1",+    "esbuild": "~0.28.1",+    "eslint": "^9.39.5",     "eslint-config-prettier": "^10.1.8",@@ -127,3 +127,3 @@     "fast-glob": "^3.3.3",-    "fs-extra": "^11.3.5",+    "fs-extra": "^11.3.6",     "globals": "^16.5.0",@@ -131,5 +131,5 @@     "jest": "^30.4.2",-    "js-yaml": "^4.1.1",+    "js-yaml": "^4.3.0",     "lint-staged": "^15.5.2",-    "memfs": "^4.57.2",+    "memfs": "^4.64.0",     "prettier": "^2.8.8",@@ -138,3 +138,3 @@     "typescript": "~5.9.3",-    "typescript-eslint": "^8.59.3"+    "typescript-eslint": "^8.64.0"   },

--- +++ @@ -265,2 +265,11 @@ +var ownKeys = function(o) {+    ownKeys = Object.getOwnPropertyNames || function (o) {+        var ar = [];+        for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;+        return ar;+    };+    return ownKeys(o);+};+ export function __importStar(mod) {@@ -268,3 +277,3 @@     var result = {};-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);+    if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);     __setModuleDefault(result, mod);