The Monitor

--- +++ @@ -1,3 +1,3 @@ import type { TSESLint } from '@typescript-eslint/utils';-export type MessageIds = 'preferIndexSignature' | 'preferIndexSignatureSuggestion' | 'preferRecord';+export type MessageIds = 'preferIndexSignature' | 'preferIndexSignatureSuggestion' | 'preferRecord' | 'preferRecordSuggestion'; export type Options = ['index-signature' | 'record'];

--- +++ @@ -19,2 +19,3 @@             preferRecord: 'A record is preferred over an index signature.',+            preferRecordSuggestion: 'Change into a record instead of an index signature.',         },@@ -30,2 +31,12 @@     create(context, [mode]) {+        // The fixers rebuild the type from the text of a few sub-nodes, so a+        // comment inside `node` but outside all of those preserved sub-nodes would+        // be dropped by the fix. Returns true when at least one such comment exists.+        function hasUnpreservedComments(node, ...preserved) {+            return context.sourceCode+                .getCommentsInside(node)+                .some(comment => preserved.every(target => target == null ||+                comment.range[0] < target.range[0] ||+                comment.range[1] > target.range[1]));+        }         function checkMembers(members, node, parentId, prefix, postfix, safeFix = true) {@@ -61,12 +72,20 @@                 messageId: 'preferRecord',-                fix: safeFix-                    ? (fixer) => {-                        const key = context.sourceCode.getText(keyType.typeAnnotation);-                        const value = context.sourceCode.getText(valueType.typeAnnotation);-                        const record = member.readonly-                            ? `Readonly<Record<${key}, ${value}>>`-                            : `Record<${key}, ${value}>`;-                        return fixer.replaceText(node, `${prefix}${record}${postfix}`);-                    }-                    : null,+                ...(0, util_1.getFixOrSuggest)({+                    fixOrSuggest: !safeFix+                        ? 'none'+                        : hasUnpreservedComments(node, keyType.typeAnnotation, valueType.typeAnnotation)+                            ? 'suggest'+                            : 'fix',+                    suggestion: {+                        messageId: 'preferRecordSuggestion',+                        fix: (fixer) => {+                            const key = context.sourceCode.getText(keyType.typeAnnotation);+                            const value = context.sourceCode.getText(valueType.typeAnnotation);+                            const record = member.readonly+                                ? `Readonly<Record<${key}, ${value}>>`+                                : `Record<${key}, ${value}>`;+                            return fixer.replaceText(node, `${prefix}${record}${postfix}`);+                        },+                    },+                }),             });@@ -95,3 +114,5 @@                         ...(0, util_1.getFixOrSuggest)({-                            fixOrSuggest: shouldFix ? 'fix' : 'suggest',+                            fixOrSuggest: shouldFix && !hasUnpreservedComments(node, params[0], params[1])+                                ? 'fix'+                                : 'suggest',                             suggestion: {@@ -148,4 +169,2 @@                     }-                    // There's no builtin Mutable<T> type, so we can't autofix it really.-                    const canFix = node.readonly !== '-';                     context.report({@@ -153,19 +172,29 @@                         messageId: 'preferRecord',-                        ...(canFix && {-                            fix: (fixer) => {-                                const keyType = context.sourceCode.getText(constraint);-                                const valueType = node.typeAnnotation-                                    ? context.sourceCode.getText(node.typeAnnotation)-                                    : 'any';-                                let recordText = `Record<${keyType}, ${valueType}>`;-                                if (node.optional === '+' || node.optional === true) {-                                    recordText = `Partial<${recordText}>`;-                                }-                                else if (node.optional === '-') {-                                    recordText = `Required<${recordText}>`;-                                }-                                if (node.readonly === '+' || node.readonly === true) {-                                    recordText = `Readonly<${recordText}>`;-                                }-                                return fixer.replaceText(node, recordText);+                        ...(0, util_1.getFixOrSuggest)({+                            // There's no builtin Mutable<T> type, so a `-readonly` mapped+                            // type can't be represented as a Record and is left untouched.+                            fixOrSuggest: node.readonly === '-'+                                ? 'none'+                                : hasUnpreservedComments(node, constraint, node.typeAnnotation)+                                    ? 'suggest'+                                    : 'fix',+                            suggestion: {+                                messageId: 'preferRecordSuggestion',+                                fix: (fixer) => {+                                    const keyType = context.sourceCode.getText(constraint);+                                    const valueType = node.typeAnnotation+                                        ? context.sourceCode.getText(node.typeAnnotation)+                                        : 'any';+                                    let recordText = `Record<${keyType}, ${valueType}>`;+                                    if (node.optional === '+' || node.optional === true) {+                                        recordText = `Partial<${recordText}>`;+                                    }+                                    else if (node.optional === '-') {+                                        recordText = `Required<${recordText}>`;+                                    }+                                    if (node.readonly === '+' || node.readonly === true) {+                                        recordText = `Readonly<${recordText}>`;+                                    }+                                    return fixer.replaceText(node, recordText);+                                },                             },

--- +++ @@ -165,7 +165,7 @@                 }-                const { value: literalBooleanInComparison } = against;+                const booleanLiteral = against.value ? 'true' : 'false';                 const negated = !comparisonType.isPositive;                 return {+                    booleanLiteral,                     expression,-                    literalBooleanInComparison,                     negated,@@ -185,3 +185,3 @@                 if (comparison.expressionIsNullableBoolean) {-                    if (comparison.literalBooleanInComparison &&+                    if (comparison.booleanLiteral === 'true' &&                         options.allowComparingNullableBooleansToTrue) {@@ -189,3 +189,3 @@                     }-                    if (!comparison.literalBooleanInComparison &&+                    if (comparison.booleanLiteral === 'false' &&                         options.allowComparingNullableBooleansToFalse) {@@ -197,3 +197,3 @@                     messageId: comparison.expressionIsNullableBoolean-                        ? comparison.literalBooleanInComparison+                        ? comparison.booleanLiteral === 'true'                             ? comparison.negated@@ -205,26 +205,32 @@                             : 'direct',-                    *fix(fixer) {-                        // 1. isUnaryNegation - parent negation-                        // 2. literalBooleanInComparison - is compared to literal boolean-                        // 3. negated - is expression negated-                        const isUnaryNegation = nodeIsUnaryNegation(node.parent);-                        const shouldNegate = comparison.negated !== comparison.literalBooleanInComparison;-                        const mutatedNode = isUnaryNegation ? node.parent : node;-                        yield fixer.replaceText(mutatedNode, context.sourceCode.getText(comparison.expression));-                        // if `isUnaryNegation === literalBooleanInComparison === !negated` is true - negate the expression-                        if (shouldNegate === isUnaryNegation) {-                            yield fixer.insertTextBefore(mutatedNode, '!');-                            // if the expression `exp` is not a strong precedence node, wrap it in parentheses-                            if (!(0, util_1.isStrongPrecedenceNode)(comparison.expression)) {-                                yield fixer.insertTextBefore(mutatedNode, '(');-                                yield fixer.insertTextAfter(mutatedNode, ')');+                    fix(fixer) {+                        const isWrappedInUnaryNegation = nodeIsUnaryNegation(node.parent);+                        const mutatedNode = isWrappedInUnaryNegation ? node.parent : node;+                        // Whether the truth table of the overall expression being replaced+                        // is negated, _ignoring the nullish cases_.+                        const isOverallNegated = booleanXor(isWrappedInUnaryNegation, comparison.negated, comparison.booleanLiteral === 'false');+                        // we'll build up the replacement text from the compared expression outwards.+                        let replacementText = context.sourceCode.getText(comparison.expression);+                        let mayNeedParentheses = !(0, util_1.isStrongPrecedenceNode)(comparison.expression);+                        // In maybeNullish === false, nullish values have the same truth table+                        // as `true`.+                        if (comparison.expressionIsNullableBoolean &&+                            comparison.booleanLiteral === 'false') {+                            if (mayNeedParentheses) {+                                replacementText = parenthesize(replacementText);                             }+                            replacementText = `${replacementText} ?? true`;+                            mayNeedParentheses = true;                         }-                        // if the expression `exp` is nullable, and we're not comparing to `true`, insert `?? true`-                        if (comparison.expressionIsNullableBoolean &&-                            !comparison.literalBooleanInComparison) {-                            // provide the default `true`-                            yield fixer.insertTextBefore(mutatedNode, '(');-                            yield fixer.insertTextAfter(mutatedNode, ' ?? true)');+                        if (isOverallNegated) {+                            if (mayNeedParentheses) {+                                replacementText = parenthesize(replacementText);+                            }+                            replacementText = `!${replacementText}`;+                            mayNeedParentheses = false;                         }+                        if (mayNeedParentheses && (0, util_1.isWeakPrecedenceParent)(mutatedNode)) {+                            replacementText = parenthesize(replacementText);+                        }+                        return fixer.replaceText(mutatedNode, replacementText);                     },@@ -261 +267,8 @@ }+function booleanXor(arg0, ...args) {+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-conversion+    return args.reduce((acc, curr) => acc !== Boolean(curr), Boolean(arg0));+}+function parenthesize(text) {+    return `(${text})`;+}

--- +++ @@ -517,2 +517,10 @@             }+            /**+             * Interpolated template literals can be widened to `string` while contextual+             * typing still accepts them, so the assertion may be required.+             * @see https://github.com/typescript-eslint/typescript-eslint/issues/12276+             */+            if (isTemplateLiteralWithExpressions(node.expression)) {+                return true;+            }             if (SKIP_PARENT_TYPES.has(node.parent.type) ||@@ -559,6 +567,25 @@                         token.value === '>'), util_1.NullThrowsReasons.MissingToken('>', 'type annotation'));-                    return fixer.removeRange([+                    // Removing the angle-bracketed type can leave a bare object+                    // literal in a position where `{` is parsed as a block (concise+                    // arrow body, or the start of an expression statement). Wrap the+                    // result in parentheses to preserve the original expression+                    // semantics.+                    const needsParens = node.expression.type === utils_1.AST_NODE_TYPES.ObjectExpression &&+                        ((node.parent.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&+                            node.parent.body === node) ||+                            node.parent.type === utils_1.AST_NODE_TYPES.ExpressionStatement) &&+                        !(0, util_1.isParenthesized)(node, context.sourceCode) &&+                        !(0, util_1.isParenthesized)(node.expression, context.sourceCode);+                    const fixes = [];+                    if (needsParens) {+                        fixes.push(fixer.insertTextBefore(node, '('));+                    }+                    fixes.push(fixer.removeRange([                         openingAngleBracket.range[0],                         closingAngleBracket.range[1],-                    ]);+                    ]));+                    if (needsParens) {+                        fixes.push(fixer.insertTextAfter(node, ')'));+                    }+                    return fixes;                 }

--- +++ @@ -41,2 +41,6 @@ export declare function isStrongPrecedenceNode(innerNode: TSESTree.Node): boolean;+/**+ * Check if a node's parent could have different precedence if the node changes.+ */+export declare function isWeakPrecedenceParent(node: TSESTree.Node): boolean; export {};

--- +++ @@ -5,2 +5,3 @@ exports.isStrongPrecedenceNode = isStrongPrecedenceNode;+exports.isWeakPrecedenceParent = isWeakPrecedenceParent; const utils_1 = require("@typescript-eslint/utils");

--- +++ @@ -2,3 +2,3 @@   "name": "@typescript-eslint/eslint-plugin",-  "version": "8.61.0",+  "version": "8.61.1",   "description": "TypeScript plugin for ESLint",@@ -54,6 +54,6 @@     "ts-api-utils": "^2.5.0",-    "@typescript-eslint/scope-manager": "8.61.0",-    "@typescript-eslint/utils": "8.61.0",-    "@typescript-eslint/type-utils": "8.61.0",-    "@typescript-eslint/visitor-keys": "8.61.0"+    "@typescript-eslint/scope-manager": "8.61.1",+    "@typescript-eslint/type-utils": "8.61.1",+    "@typescript-eslint/utils": "8.61.1",+    "@typescript-eslint/visitor-keys": "8.61.1"   },@@ -81,4 +81,4 @@     "vitest": "^4.0.18",-    "@typescript-eslint/rule-tester": "8.61.0",-    "@typescript-eslint/rule-schema-to-typescript-types": "8.61.0"+    "@typescript-eslint/rule-tester": "8.61.1",+    "@typescript-eslint/rule-schema-to-typescript-types": "8.61.1"   },@@ -87,3 +87,3 @@     "typescript": ">=4.8.4 <6.1.0",-    "@typescript-eslint/parser": "^8.61.0"+    "@typescript-eslint/parser": "^8.61.1"   },

--- +++ @@ -0,0 +1,5104 @@+/*! Axios v1.18.0 Copyright (c) 2026 Matt Zabriskie and contributors */+'use strict';++/**+ * Create a bound version of a function with a specified `this` context+ *+ * @param {Function} fn - The function to bind+ * @param {*} thisArg - The value to be passed as the `this` parameter+ * @returns {Function} A new function that will call the original function with the specified `this` context+ */+function bind(fn, thisArg) {+  return function wrap() {+    return fn.apply(thisArg, arguments);+  };+}++// utils is a library of generic helper functions non-specific to axios++const { toString } = Object.prototype;+const { getPrototypeOf } = Object;+const { iterator, toStringTag } = Symbol;++/* Creating a function that will check if an object has a property. */+const hasOwnProperty = (+  ({ hasOwnProperty }) =>+  (obj, prop) =>+    hasOwnProperty.call(obj, prop)+)(Object.prototype);++/**+ * Walk the prototype chain (excluding the shared Object.prototype) looking for+ * an own `prop`. This distinguishes genuine own/inherited members — including+ * class accessors and template prototypes — from members injected via+ * Object.prototype pollution (e.g. `Object.prototype.username = '...'`), which+ * live on Object.prototype itself and are therefore never matched.+ *+ * @param {*} thing The value whose chain to inspect+ * @param {string|symbol} prop The property key to look for+ *+ * @returns {boolean} True when `prop` is owned below Object.prototype+ */+const hasOwnInPrototypeChain = (thing, prop) => {+  let obj = thing;+  const seen = [];++  while (obj != null && obj !== Object.prototype) {+    if (seen.indexOf(obj) !== -1) {+      return false;+    }+    seen.push(obj);++    if (hasOwnProperty(obj, prop)) {+      return true;+    }+    obj = getPrototypeOf(obj);+  }+  return false;+};++/**+ * Read `obj[prop]` only when it is safe from Object.prototype pollution. Own+ * properties and members inherited from a non-Object.prototype source (a class+ * instance or template object) are honored; a value reachable only through a+ * polluted Object.prototype is ignored and `undefined` is returned.+ *+ * @param {*} obj The source object+ * @param {string|symbol} prop The property key to read+ *+ * @returns {*} The resolved value, or undefined when unsafe/absent+ */+const getSafeProp = (obj, prop) =>+  obj != null && hasOwnInPrototypeChain(obj, prop) ? obj[prop] : undefined;++const kindOf = ((cache) => (thing) => {+  const str = toString.call(thing);+  return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());+})(Object.create(null));++const kindOfTest = (type) => {+  type = type.toLowerCase();+  return (thing) => kindOf(thing) === type;+};++const typeOfTest = (type) => (thing) => typeof thing === type;++/**+ * Determine if a value is a non-null object+ *+ * @param {Object} val The value to test+ *+ * @returns {boolean} True if value is an Array, otherwise false+ */+const { isArray } = Array;++/**+ * Determine if a value is undefined+ *+ * @param {*} val The value to test+ *+ * @returns {boolean} True if the value is undefined, otherwise false+ */+const isUndefined = typeOfTest('undefined');++/**+ * Determine if a value is a Buffer+ *+ * @param {*} val The value to test+ *+ * @returns {boolean} True if value is a Buffer, otherwise false+ */+function isBuffer(val) {+  return (+    val !== null &&+    !isUndefined(val) &&+    val.constructor !== null &&+    !isUndefined(val.constructor) &&+    isFunction$1(val.constructor.isBuffer) &&+    val.constructor.isBuffer(val)+  );+}++/**+ * Determine if a value is an ArrayBuffer+ *+ * @param {*} val The value to test+ *+ * @returns {boolean} True if value is an ArrayBuffer, otherwise false+ */+const isArrayBuffer = kindOfTest('ArrayBuffer');++/**+ * Determine if a value is a view on an ArrayBuffer+ *+ * @param {*} val The value to test+ *+ * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false+ */+function isArrayBufferView(val) {+  let result;+  if (typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView) {+    result = ArrayBuffer.isView(val);+  } else {+    result = val && val.buffer && isArrayBuffer(val.buffer);+  }+  return result;+}++/**+ * Determine if a value is a String+ *+ * @param {*} val The value to test+ *+ * @returns {boolean} True if value is a String, otherwise false+ */+const isString = typeOfTest('string');++/**+ * Determine if a value is a Function+ *+ * @param {*} val The value to test+ * @returns {boolean} True if value is a Function, otherwise false+ */+const isFunction$1 = typeOfTest('function');++/**+ * Determine if a value is a Number+ *+ * @param {*} val The value to test+ *+ * @returns {boolean} True if value is a Number, otherwise false+ */+const isNumber = typeOfTest('number');++/**+ * Determine if a value is an Object+ *+ * @param {*} thing The value to test+ *+ * @returns {boolean} True if value is an Object, otherwise false+ */+const isObject = (thing) => thing !== null && typeof thing === 'object';++/**+ * Determine if a value is a Boolean+ *+ * @param {*} thing The value to test+ * @returns {boolean} True if value is a Boolean, otherwise false+ */+const isBoolean = (thing) => thing === true || thing === false;++/**+ * Determine if a value is a plain Object+ *+ * @param {*} val The value to test+ *+ * @returns {boolean} True if value is a plain Object, otherwise false+ */+const isPlainObject = (val) => {+  if (!isObject(val)) {+    return false;+  }++  const prototype = getPrototypeOf(val);+  return (+    (prototype === null ||+      prototype === Object.prototype ||+      getPrototypeOf(prototype) === null) &&+    // Treat any genuine (non-Object.prototype-polluted) Symbol.toStringTag or+    // Symbol.iterator as evidence the value is a tagged/iterable type rather+    // than a plain object, while ignoring keys injected onto Object.prototype.+    !hasOwnInPrototypeChain(val, toStringTag) &&+    !hasOwnInPrototypeChain(val, iterator)+  );+};++/**+ * Determine if a value is an empty object (safely handles Buffers)+ *+ * @param {*} val The value to test+ *+ * @returns {boolean} True if value is an empty object, otherwise false+ */+const isEmptyObject = (val) => {+  // Early return for non-objects or Buffers to prevent RangeError+  if (!isObject(val) || isBuffer(val)) {+    return false;+  }++  try {+    return Object.keys(val).length === 0 && Object.getPrototypeOf(val) === Object.prototype;+  } catch (e) {+    // Fallback for any other objects that might cause RangeError with Object.keys()+    return false;+  }+};++/**+ * Determine if a value is a Date+ *+ * @param {*} val The value to test+ *+ * @returns {boolean} True if value is a Date, otherwise false+ */+const isDate = kindOfTest('Date');++/**+ * Determine if a value is a File

--- +++ @@ -1,3 +1,10 @@-// axios v0.33.0 Copyright (c) 2026 Matt Zabriskie-var bind = function bind(fn, thisArg) {+/*! Axios v1.18.0 Copyright (c) 2026 Matt Zabriskie and contributors */+/**+ * Create a bound version of a function with a specified `this` context+ *+ * @param {Function} fn - The function to bind+ * @param {*} thisArg - The value to be passed as the `this` parameter+ * @returns {Function} A new function that will call the original function with the specified `this` context+ */+function bind(fn, thisArg) {   return function wrap() {@@ -5,3 +12,3 @@   };-};+} @@ -9,29 +16,77 @@ -var toString = Object.prototype.toString;--// eslint-disable-next-line func-names-var kindOf = (function(cache) {-  // eslint-disable-next-line func-names-  return function(thing) {-    var str = toString.call(thing);-    return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());-  };+const { toString } = Object.prototype;+const { getPrototypeOf } = Object;+const { iterator, toStringTag } = Symbol;++/* Creating a function that will check if an object has a property. */+const hasOwnProperty = (+  ({ hasOwnProperty }) =>+  (obj, prop) =>+    hasOwnProperty.call(obj, prop)+)(Object.prototype);++/**+ * Walk the prototype chain (excluding the shared Object.prototype) looking for+ * an own `prop`. This distinguishes genuine own/inherited members — including+ * class accessors and template prototypes — from members injected via+ * Object.prototype pollution (e.g. `Object.prototype.username = '...'`), which+ * live on Object.prototype itself and are therefore never matched.+ *+ * @param {*} thing The value whose chain to inspect+ * @param {string|symbol} prop The property key to look for+ *+ * @returns {boolean} True when `prop` is owned below Object.prototype+ */+const hasOwnInPrototypeChain = (thing, prop) => {+  let obj = thing;+  const seen = [];++  while (obj != null && obj !== Object.prototype) {+    if (seen.indexOf(obj) !== -1) {+      return false;+    }+    seen.push(obj);++    if (hasOwnProperty(obj, prop)) {+      return true;+    }+    obj = getPrototypeOf(obj);+  }+  return false;+};++/**+ * Read `obj[prop]` only when it is safe from Object.prototype pollution. Own+ * properties and members inherited from a non-Object.prototype source (a class+ * instance or template object) are honored; a value reachable only through a+ * polluted Object.prototype is ignored and `undefined` is returned.+ *+ * @param {*} obj The source object+ * @param {string|symbol} prop The property key to read+ *+ * @returns {*} The resolved value, or undefined when unsafe/absent+ */+const getSafeProp = (obj, prop) =>+  obj != null && hasOwnInPrototypeChain(obj, prop) ? obj[prop] : undefined;++const kindOf = ((cache) => (thing) => {+  const str = toString.call(thing);+  return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase()); })(Object.create(null)); -function kindOfTest(type) {+const kindOfTest = (type) => {   type = type.toLowerCase();-  return function isKindOf(thing) {-    return kindOf(thing) === type;-  };-}--/**- * Determine if a value is an Array+  return (thing) => kindOf(thing) === type;+};++const typeOfTest = (type) => (thing) => typeof thing === type;++/**+ * Determine if a value is a non-null object  *  * @param {Object} val The value to test+ *  * @returns {boolean} True if value is an Array, otherwise false  */-function isArray(val) {-  return Array.isArray(val);-}+const { isArray } = Array; @@ -40,8 +95,7 @@  *- * @param {Object} val The value to test+ * @param {*} val The value to test+ *  * @returns {boolean} True if the value is undefined, otherwise false  */-function isUndefined(val) {-  return typeof val === 'undefined';-}+const isUndefined = typeOfTest('undefined'); @@ -50,3 +104,4 @@  *- * @param {Object} val The value to test+ * @param {*} val The value to test+ *  * @returns {boolean} True if value is a Buffer, otherwise false@@ -59,3 +114,3 @@     !isUndefined(val.constructor) &&-    typeof val.constructor.isBuffer === 'function' &&+    isFunction$1(val.constructor.isBuffer) &&     val.constructor.isBuffer(val)@@ -67,7 +122,7 @@  *- * @function- * @param {Object} val The value to test+ * @param {*} val The value to test+ *  * @returns {boolean} True if value is an ArrayBuffer, otherwise false  */-var isArrayBuffer = kindOfTest('ArrayBuffer');+const isArrayBuffer = kindOfTest('ArrayBuffer'); @@ -76,3 +131,4 @@  *- * @param {Object} val The value to test+ * @param {*} val The value to test+ *  * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false@@ -80,3 +136,3 @@ function isArrayBufferView(val) {-  var result;+  let result;   if (typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView) {@@ -92,8 +148,15 @@  *- * @param {Object} val The value to test+ * @param {*} val The value to test+ *  * @returns {boolean} True if value is a String, otherwise false  */-function isString(val) {-  return typeof val === 'string';-}+const isString = typeOfTest('string');++/**+ * Determine if a value is a Function+ *+ * @param {*} val The value to test+ * @returns {boolean} True if value is a Function, otherwise false+ */+const isFunction$1 = typeOfTest('function'); @@ -102,8 +165,7 @@  *- * @param {Object} val The value to test+ * @param {*} val The value to test+ *  * @returns {boolean} True if value is a Number, otherwise false  */-function isNumber(val) {-  return typeof val === 'number';-}+const isNumber = typeOfTest('number'); @@ -112,8 +174,15 @@  *- * @param {Object} val The value to test+ * @param {*} thing The value to test+ *  * @returns {boolean} True if value is an Object, otherwise false  */-function isObject(val) {-  return val !== null && typeof val === 'object';-}+const isObject = (thing) => thing !== null && typeof thing === 'object';++/**+ * Determine if a value is a Boolean+ *+ * @param {*} thing The value to test+ * @returns {boolean} True if value is a Boolean, otherwise false+ */+const isBoolean = (thing) => thing === true || thing === false; @@ -122,7 +191,8 @@  *- * @param {Object} val The value to test- * @return {boolean} True if value is a plain Object, otherwise false- */-function isPlainObject(val) {-  if (kindOf(val) !== 'object') {+ * @param {*} val The value to test+ *+ * @returns {boolean} True if value is a plain Object, otherwise false+ */+const isPlainObject = (val) => {+  if (!isObject(val)) {     return false;@@ -130,23 +200,35 @@ -  var prototype = Object.getPrototypeOf(val);-  return prototype === null || prototype === Object.prototype;-}--/**- * Determine if a value is a empty Object- *- * @param {Object} val The value to test- * @return {boolean} True if value is a empty Object, otherwise false- */-function isEmptyObject(val) {-  if (!isPlainObject(val)) {+  const prototype = getPrototypeOf(val);+  return (+    (prototype === null ||+      prototype === Object.prototype ||+      getPrototypeOf(prototype) === null) &&+    // Treat any genuine (non-Object.prototype-polluted) Symbol.toStringTag or+    // Symbol.iterator as evidence the value is a tagged/iterable type rather

--- +++ @@ -0,0 +1,5906 @@+/*! Axios v1.18.0 Copyright (c) 2026 Matt Zabriskie and contributors */+'use strict';++var FormData$1 = require('form-data');+var crypto = require('crypto');+var url = require('url');+var HttpsProxyAgent = require('https-proxy-agent');+var http = require('http');+var https = require('https');+var http2 = require('http2');+var util = require('util');+var path = require('path');+var followRedirects = require('follow-redirects');+var zlib = require('zlib');+var stream = require('stream');+var events = require('events');++/**+ * Create a bound version of a function with a specified `this` context+ *+ * @param {Function} fn - The function to bind+ * @param {*} thisArg - The value to be passed as the `this` parameter+ * @returns {Function} A new function that will call the original function with the specified `this` context+ */+function bind(fn, thisArg) {+  return function wrap() {+    return fn.apply(thisArg, arguments);+  };+}++// utils is a library of generic helper functions non-specific to axios++const {+  toString+} = Object.prototype;+const {+  getPrototypeOf+} = Object;+const {+  iterator,+  toStringTag+} = Symbol;++/* Creating a function that will check if an object has a property. */+const hasOwnProperty = (({+  hasOwnProperty+}) => (obj, prop) => hasOwnProperty.call(obj, prop))(Object.prototype);++/**+ * Walk the prototype chain (excluding the shared Object.prototype) looking for+ * an own `prop`. This distinguishes genuine own/inherited members — including+ * class accessors and template prototypes — from members injected via+ * Object.prototype pollution (e.g. `Object.prototype.username = '...'`), which+ * live on Object.prototype itself and are therefore never matched.+ *+ * @param {*} thing The value whose chain to inspect+ * @param {string|symbol} prop The property key to look for+ *+ * @returns {boolean} True when `prop` is owned below Object.prototype+ */+const hasOwnInPrototypeChain = (thing, prop) => {+  let obj = thing;+  const seen = [];+  while (obj != null && obj !== Object.prototype) {+    if (seen.indexOf(obj) !== -1) {+      return false;+    }+    seen.push(obj);+    if (hasOwnProperty(obj, prop)) {+      return true;+    }+    obj = getPrototypeOf(obj);+  }+  return false;+};++/**+ * Read `obj[prop]` only when it is safe from Object.prototype pollution. Own+ * properties and members inherited from a non-Object.prototype source (a class+ * instance or template object) are honored; a value reachable only through a+ * polluted Object.prototype is ignored and `undefined` is returned.+ *+ * @param {*} obj The source object+ * @param {string|symbol} prop The property key to read+ *+ * @returns {*} The resolved value, or undefined when unsafe/absent+ */+const getSafeProp = (obj, prop) => obj != null && hasOwnInPrototypeChain(obj, prop) ? obj[prop] : undefined;+const kindOf = (cache => thing => {+  const str = toString.call(thing);+  return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());+})(Object.create(null));+const kindOfTest = type => {+  type = type.toLowerCase();+  return thing => kindOf(thing) === type;+};+const typeOfTest = type => thing => typeof thing === type;++/**+ * Determine if a value is a non-null object+ *+ * @param {Object} val The value to test+ *+ * @returns {boolean} True if value is an Array, otherwise false+ */+const {+  isArray+} = Array;++/**+ * Determine if a value is undefined+ *+ * @param {*} val The value to test+ *+ * @returns {boolean} True if the value is undefined, otherwise false+ */+const isUndefined = typeOfTest('undefined');++/**+ * Determine if a value is a Buffer+ *+ * @param {*} val The value to test+ *+ * @returns {boolean} True if value is a Buffer, otherwise false+ */+function isBuffer(val) {+  return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor) && isFunction$1(val.constructor.isBuffer) && val.constructor.isBuffer(val);+}++/**+ * Determine if a value is an ArrayBuffer+ *+ * @param {*} val The value to test+ *+ * @returns {boolean} True if value is an ArrayBuffer, otherwise false+ */+const isArrayBuffer = kindOfTest('ArrayBuffer');++/**+ * Determine if a value is a view on an ArrayBuffer+ *+ * @param {*} val The value to test+ *+ * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false+ */+function isArrayBufferView(val) {+  let result;+  if (typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView) {+    result = ArrayBuffer.isView(val);+  } else {+    result = val && val.buffer && isArrayBuffer(val.buffer);+  }+  return result;+}++/**+ * Determine if a value is a String+ *+ * @param {*} val The value to test+ *+ * @returns {boolean} True if value is a String, otherwise false+ */+const isString = typeOfTest('string');++/**+ * Determine if a value is a Function+ *+ * @param {*} val The value to test+ * @returns {boolean} True if value is a Function, otherwise false+ */+const isFunction$1 = typeOfTest('function');++/**+ * Determine if a value is a Number+ *+ * @param {*} val The value to test+ *+ * @returns {boolean} True if value is a Number, otherwise false+ */+const isNumber = typeOfTest('number');++/**+ * Determine if a value is an Object+ *+ * @param {*} thing The value to test+ *+ * @returns {boolean} True if value is an Object, otherwise false+ */+const isObject = thing => thing !== null && typeof thing === 'object';++/**+ * Determine if a value is a Boolean+ *+ * @param {*} thing The value to test+ * @returns {boolean} True if value is a Boolean, otherwise false+ */+const isBoolean = thing => thing === true || thing === false;++/**+ * Determine if a value is a plain Object+ *+ * @param {*} val The value to test+ *+ * @returns {boolean} True if value is a plain Object, otherwise false+ */+const isPlainObject = val => {+  if (!isObject(val)) {+    return false;+  }+  const prototype = getPrototypeOf(val);+  return (prototype === null || prototype === Object.prototype || getPrototypeOf(prototype) === null) &&+  // Treat any genuine (non-Object.prototype-polluted) Symbol.toStringTag or+  // Symbol.iterator as evidence the value is a tagged/iterable type rather+  // than a plain object, while ignoring keys injected onto Object.prototype.+  !hasOwnInPrototypeChain(val, toStringTag) && !hasOwnInPrototypeChain(val, iterator);+};++/**+ * Determine if a value is an empty object (safely handles Buffers)+ *+ * @param {*} val The value to test+ *+ * @returns {boolean} True if value is an empty object, otherwise false+ */+const isEmptyObject = val => {+  // Early return for non-objects or Buffers to prevent RangeError+  if (!isObject(val) || isBuffer(val)) {+    return false;+  }+  try {+    return Object.keys(val).length === 0 && Object.getPrototypeOf(val) === Object.prototype;+  } catch (e) {+    // Fallback for any other objects that might cause RangeError with Object.keys()+    return false;+  }+};++/**+ * Determine if a value is a Date+ *+ * @param {*} val The value to test+ *+ * @returns {boolean} True if value is a Date, otherwise false+ */+const isDate = kindOfTest('Date');++/**

--- +++ @@ -1,28 +1,129 @@-'use strict';--var utils = require('./../utils');-var settle = require('./../core/settle');-var buildFullPath = require('../core/buildFullPath');-var buildURL = require('./../helpers/buildURL');-var getProxyForUrl = require('proxy-from-env').getProxyForUrl;-var http = require('http');-var https = require('https');-var httpFollow = require('follow-redirects/http');-var httpsFollow = require('follow-redirects/https');-var url = require('url');-var path = require('path');-var zlib = require('zlib');-var VERSION = require('./../env/data').version;-var transitionalDefaults = require('../defaults/transitional');-var AxiosError = require('../core/AxiosError');-var CanceledError = require('../cancel/CanceledError');-var platform = require('../platform');-var fromDataURI = require('../helpers/fromDataURI');-var stream = require('stream');-var estimateDataURLDecodedBytes = require('../helpers/estimateDataURLDecodedBytes.js');-var shouldBypassProxy = require('../helpers/shouldBypassProxy');--var isHttps = /https:?/;--var supportedProtocols = platform.protocols.map(function(protocol) {+import utils from '../utils.js';+import settle from '../core/settle.js';+import buildFullPath from '../core/buildFullPath.js';+import buildURL from '../helpers/buildURL.js';+import { getProxyForUrl } from 'proxy-from-env';+import HttpsProxyAgent from 'https-proxy-agent';+import http from 'http';+import https from 'https';+import http2 from 'http2';+import util from 'util';+import { resolve as resolvePath } from 'path';+import followRedirects from 'follow-redirects';+import zlib from 'zlib';+import { VERSION } from '../env/data.js';+import transitionalDefaults from '../defaults/transitional.js';+import AxiosError from '../core/AxiosError.js';+import CanceledError from '../cancel/CanceledError.js';+import platform from '../platform/index.js';+import fromDataURI from '../helpers/fromDataURI.js';+import stream from 'stream';+import AxiosHeaders from '../core/AxiosHeaders.js';+import AxiosTransformStream from '../helpers/AxiosTransformStream.js';+import { EventEmitter } from 'events';+import formDataToStream from '../helpers/formDataToStream.js';+import readBlob from '../helpers/readBlob.js';+import ZlibHeaderTransformStream from '../helpers/ZlibHeaderTransformStream.js';+import Http2Sessions from '../helpers/Http2Sessions.js';+import callbackify from '../helpers/callbackify.js';+import shouldBypassProxy from '../helpers/shouldBypassProxy.js';+import { toByteStringHeaderObject } from '../helpers/sanitizeHeaderValue.js';+import {+  progressEventReducer,+  progressEventDecorator,+  asyncDecorator,+} from '../helpers/progressEventReducer.js';+import estimateDataURLDecodedBytes from '../helpers/estimateDataURLDecodedBytes.js';++const zlibOptions = {+  flush: zlib.constants.Z_SYNC_FLUSH,+  finishFlush: zlib.constants.Z_SYNC_FLUSH,+};++const brotliOptions = {+  flush: zlib.constants.BROTLI_OPERATION_FLUSH,+  finishFlush: zlib.constants.BROTLI_OPERATION_FLUSH,+};++const zstdOptions = {+  flush: zlib.constants.ZSTD_e_flush,+  finishFlush: zlib.constants.ZSTD_e_flush,+};++const isBrotliSupported = utils.isFunction(zlib.createBrotliDecompress);+const isZstdSupported = utils.isFunction(zlib.createZstdDecompress);+const ACCEPT_ENCODING = 'gzip, compress, deflate' + (isBrotliSupported ? ', br' : '');+const ACCEPT_ENCODING_WITH_ZSTD = ACCEPT_ENCODING + (isZstdSupported ? ', zstd' : '');++const { http: httpFollow, https: httpsFollow } = followRedirects;++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);+    }+  });+}++// Symbols used to bind a single 'error' listener to a pooled socket and track+// the request currently owning that socket across keep-alive reuse (issue #10780).+const kAxiosSocketListener = Symbol('axios.http.socketListener');+const kAxiosCurrentReq = Symbol('axios.http.currentReq');++// Tags HttpsProxyAgent instances installed by setProxy() so the redirect path+// can strip them without clobbering a user-supplied agent that happens to be+// an HttpsProxyAgent.+const kAxiosInstalledTunnel = Symbol('axios.http.installedTunnel');++// Cache of CONNECT-tunneling agents keyed by proxy config so repeat requests+// through the same proxy reuse a single agent (and its socket pool). The+// keyspace is bounded by the set of distinct proxy configs the process uses,+// so unbounded growth is not a concern in practice.+const tunnelingAgentCache = new Map();+const tunnelingAgentCacheUser = new WeakMap();++function getTunnelingAgent(agentOptions, userHttpsAgent) {+  const key =+    agentOptions.protocol ++    '//' ++    agentOptions.hostname ++    ':' ++    (agentOptions.port || '') ++    '#' ++    (agentOptions.auth || '');+  const cache = userHttpsAgent+    ? (tunnelingAgentCacheUser.get(userHttpsAgent) ||+        tunnelingAgentCacheUser.set(userHttpsAgent, new Map()).get(userHttpsAgent))+    : tunnelingAgentCache;+  let agent = cache.get(key);+  if (agent) return agent;+  // Forward the user's TLS options (custom CA, rejectUnauthorized, client cert,+  // etc.) into the tunneling agent so they apply to the origin TLS upgrade+  // performed after CONNECT. Our proxy fields take precedence on conflict.+  const merged = userHttpsAgent && userHttpsAgent.options+    ? { ...userHttpsAgent.options, ...agentOptions }+    : agentOptions;+  agent = new HttpsProxyAgent(merged);+  if (userHttpsAgent && userHttpsAgent.options) {+    const originTLSOptions = { ...userHttpsAgent.options };+    const callback = agent.callback;+    agent.callback = function axiosTunnelingAgentCallback(req, opts) {+      // HttpsProxyAgent v5 reads callback opts for the post-CONNECT origin TLS upgrade.+      return callback.call(this, req, { ...originTLSOptions, ...opts });+    };+  }+  agent[kAxiosInstalledTunnel] = true;+  cache.set(key, agent);+  return agent;+}++const supportedProtocols = platform.protocols.map((protocol) => {   return protocol + ':';@@ -30,3 +131,35 @@ -function dispatchBeforeRedirect(options) {+// Node's WHATWG URL parser returns `username` and `password` percent-encoded.+// Decode before composing the `auth` option so credentials such as+// `my%40email.com:pass` are sent as `[email protected]:pass`. Falls back to the+// original value for malformed input so a bad encoding never throws.+const decodeURIComponentSafe = (value) => {+  if (!utils.isString(value)) {+    return value;+  }++  try {+    return decodeURIComponent(value);+  } catch (error) {+    return value;+  }+};++const flushOnFinish = (stream, [throttled, flush]) => {+  stream.on('end', flush).on('error', flush);++  return throttled;+};++const http2Sessions = new Http2Sessions();++/**+ * If the proxy, auth, sensitive header, or config beforeRedirects functions are defined,+ * call them with the options object.+ *+ * @param {Object<string, any>} options - The options object that was passed to the request.+ *+ * @returns {Object<string, any>}+ */+function dispatchBeforeRedirect(options, responseDetails, requestDetails) {   if (options.beforeRedirects.proxy) {@@ -34,4 +167,10 @@   }+  if (options.beforeRedirects.auth) {+    options.beforeRedirects.auth(options);+  }+  if (options.beforeRedirects.sensitiveHeaders) {+    options.beforeRedirects.sensitiveHeaders(options, requestDetails);+  }   if (options.beforeRedirects.config) {-    options.beforeRedirects.config(options);+    options.beforeRedirects.config(options, responseDetails, requestDetails);   }@@ -39,5 +178,9 @@ -function removeProxyAuthorization(headers) {-  Object.keys(headers).forEach(function removeHeader(header) {-    if (header.toLowerCase() === 'proxy-authorization') {+function stripMatchingHeaders(headers, sensitiveSet) {+  if (!headers) {+    return;+  }++  Object.keys(headers).forEach((header) => {+    if (sensitiveSet.has(header.toLowerCase())) {       delete headers[header];@@ -47,97 +190,31 @@ -function normalizeSocketPath(socketPath) {-  if (/^\\\\[.?]\\pipe\\/i.test(socketPath)) {-    return socketPath;-  }--  return path.resolve(socketPath);+function isSameOriginRedirect(redirectOptions, requestDetails) {+  if (!requestDetails) {+    return false;+  }++  try {+    return new URL(requestDetails.url).origin === new URL(redirectOptions.href).origin;+  } catch (e) {+    // If origin comparison fails, treat the redirect as unsafe.+    return false;+  } } -function getAllowedSocketPaths(config) {-  var allowedSocketPaths = config.allowedSocketPaths;--  if (-    allowedSocketPaths === null ||-    typeof allowedSocketPaths === 'undefined'-  ) {-    return null;

--- +++ @@ -0,0 +1,351 @@+'use strict';++import utils from '../utils.js';+import parseHeaders from '../helpers/parseHeaders.js';+import { sanitizeHeaderValue } from '../helpers/sanitizeHeaderValue.js';++const $internals = Symbol('internals');++function normalizeHeader(header) {+  return header && String(header).trim().toLowerCase();+}++function normalizeValue(value) {+  if (value === false || value == null) {+    return value;+  }++  return utils.isArray(value) ? value.map(normalizeValue) : sanitizeHeaderValue(String(value));+}++function parseTokens(str) {+  const tokens = Object.create(null);+  const tokensRE = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;+  let match;++  while ((match = tokensRE.exec(str))) {+    tokens[match[1]] = match[2];+  }++  return tokens;+}++const isValidHeaderName = (str) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim());++function matchHeaderValue(context, value, header, filter, isHeaderNameFilter) {+  if (utils.isFunction(filter)) {+    return filter.call(this, value, header);+  }++  if (isHeaderNameFilter) {+    value = header;+  }++  if (!utils.isString(value)) return;++  if (utils.isString(filter)) {+    return value.indexOf(filter) !== -1;+  }++  if (utils.isRegExp(filter)) {+    return filter.test(value);+  }+}++function formatHeader(header) {+  return header+    .trim()+    .toLowerCase()+    .replace(/([a-z\d])(\w*)/g, (w, char, str) => {+      return char.toUpperCase() + str;+    });+}++function buildAccessors(obj, header) {+  const accessorName = utils.toCamelCase(' ' + header);++  ['get', 'set', 'has'].forEach((methodName) => {+    Object.defineProperty(obj, methodName + accessorName, {+      // Null-proto descriptor so a polluted Object.prototype.get cannot turn+      // this data descriptor into an accessor descriptor on the way in.+      __proto__: null,+      value: function (arg1, arg2, arg3) {+        return this[methodName].call(this, header, arg1, arg2, arg3);+      },+      configurable: true,+    });+  });+}++class AxiosHeaders {+  constructor(headers) {+    headers && this.set(headers);+  }++  set(header, valueOrRewrite, rewrite) {+    const self = this;++    function setHeader(_value, _header, _rewrite) {+      const lHeader = normalizeHeader(_header);++      if (!lHeader) {+        return;+      }++      const key = utils.findKey(self, lHeader);++      if (+        !key ||+        self[key] === undefined ||+        _rewrite === true ||+        (_rewrite === undefined && self[key] !== false)+      ) {+        self[key || _header] = normalizeValue(_value);+      }+    }++    const setHeaders = (headers, _rewrite) =>+      utils.forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite));++    if (utils.isPlainObject(header) || header instanceof this.constructor) {+      setHeaders(header, valueOrRewrite);+    } else if (utils.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {+      setHeaders(parseHeaders(header), valueOrRewrite);+    } else if (utils.isObject(header) && utils.isSafeIterable(header)) {+      let obj = Object.create(null),+        dest,+        key;+      for (const entry of header) {+        if (!utils.isArray(entry)) {+          throw new TypeError('Object iterator must return a key-value pair');+        }++        key = entry[0];++        if (utils.hasOwnProp(obj, key)) {+          dest = obj[key];+          obj[key] = utils.isArray(dest) ? [...dest, entry[1]] : [dest, entry[1]];+        } else {+          obj[key] = entry[1];+        }+      }++      setHeaders(obj, valueOrRewrite);+    } else {+      header != null && setHeader(valueOrRewrite, header, rewrite);+    }++    return this;+  }++  get(header, parser) {+    header = normalizeHeader(header);++    if (header) {+      const key = utils.findKey(this, header);++      if (key) {+        const value = this[key];++        if (!parser) {+          return value;+        }++        if (parser === true) {+          return parseTokens(value);+        }++        if (utils.isFunction(parser)) {+          return parser.call(this, value, key);+        }++        if (utils.isRegExp(parser)) {+          return parser.exec(value);+        }++        throw new TypeError('parser must be boolean|regexp|function');+      }+    }+  }++  has(header, matcher) {+    header = normalizeHeader(header);++    if (header) {+      const key = utils.findKey(this, header);++      return !!(+        key &&+        this[key] !== undefined &&+        (!matcher || matchHeaderValue(this, this[key], key, matcher))+      );+    }++    return false;+  }++  delete(header, matcher) {+    const self = this;+    let deleted = false;++    function deleteHeader(_header) {+      _header = normalizeHeader(_header);++      if (_header) {+        const key = utils.findKey(self, _header);++        if (key && (!matcher || matchHeaderValue(self, self[key], key, matcher))) {+          delete self[key];++          deleted = true;+        }+      }+    }++    if (utils.isArray(header)) {+      header.forEach(deleteHeader);+    } else {+      deleteHeader(header);+    }++    return deleted;+  }++  clear(matcher) {+    const keys = Object.keys(this);+    let i = keys.length;+    let deleted = false;++    while (i--) {+      const key = keys[i];+      if (!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {+        delete this[key];+        deleted = true;+      }+    }++    return deleted;+  }++  normalize(format) {+    const self = this;+    const headers = {};++    utils.forEach(this, (value, header) => {+      const key = utils.findKey(headers, header);++      if (key) {+        self[key] = normalizeValue(value);+        delete self[header];+        return;+      }++      const normalized = format ? formatHeader(header) : String(header).trim();++      if (normalized !== header) {+        delete self[header];+      }

--- +++ @@ -2,13 +2,12 @@ -var utils = require('../utils');-var AxiosError = require('../core/AxiosError');+import utils from '../utils.js';+import AxiosError from '../core/AxiosError.js';+import { DEFAULT_FORM_DATA_MAX_DEPTH } from './toFormData.js'; -var MAX_FORM_DATA_TO_JSON_DEPTH = 100;+const MAX_DEPTH = DEFAULT_FORM_DATA_MAX_DEPTH; -function assertPathDepth(path) {-  var depth = path.length - 1;--  if (depth > MAX_FORM_DATA_TO_JSON_DEPTH) {+function throwIfDepthExceeded(index) {+  if (index > MAX_DEPTH) {     throw new AxiosError(-      'Maximum object depth of ' + MAX_FORM_DATA_TO_JSON_DEPTH + ' exceeded (got ' + depth + ' levels)',+      'FormData field is too deeply nested (' + index + ' levels). Max depth: ' + MAX_DEPTH,       AxiosError.ERR_FORM_DATA_DEPTH_EXCEEDED@@ -18,2 +17,9 @@ +/**+ * It takes a string like `foo[x][y][z]` and returns an array like `['foo', 'x', 'y', 'z']+ *+ * @param {string} name - The name of the property to get.+ *+ * @returns An array of strings.+ */ function parsePropPath(name) {@@ -23,13 +29,27 @@   // foo x y z-  return utils.matchAll(/\w+|\[(\w*)]/g, name).map(function(match) {-    return match[0] === '[]' ? '' : match[1] || match[0];-  });+  const path = [];+  const pattern = /\w+|\[(\w*)]/g;+  let match;++  while ((match = pattern.exec(name)) !== null) {+    throwIfDepthExceeded(path.length);+    path.push(match[0] === '[]' ? '' : match[1] || match[0]);+  }++  return path; } +/**+ * Convert an array to an object.+ *+ * @param {Array<any>} arr - The array to convert to an object.+ *+ * @returns An object with the same keys and values as the array.+ */ function arrayToObject(arr) {-  var obj = {};-  var keys = Object.keys(arr);-  var i;-  var len = keys.length;-  var key;+  const obj = {};+  const keys = Object.keys(arr);+  let i;+  const len = keys.length;+  let key;   for (i = 0; i < len; i++) {@@ -41,5 +61,14 @@ +/**+ * It takes a FormData object and returns a JavaScript object+ *+ * @param {string} formData The FormData object to convert to JSON.+ *+ * @returns {Object<string, any> | null} The converted object.+ */ function formDataToJSON(formData) {   function buildPath(path, value, target, index) {-    var name = path[index++];+    throwIfDepthExceeded(index);++    let name = path[index++]; @@ -47,4 +76,4 @@ -    var isNumericKey = Number.isFinite(+name);-    var isLast = index >= path.length;+    const isNumericKey = Number.isFinite(+name);+    const isLast = index >= path.length;     name = !name && utils.isArray(target) ? target.length : name;@@ -52,4 +81,6 @@     if (isLast) {-      if (utils.hasOwnProperty(target, name)) {-        target[name] = [target[name], value];+      if (utils.hasOwnProp(target, name)) {+        target[name] = utils.isArray(target[name])+          ? target[name].concat(value)+          : [target[name], value];       } else {@@ -61,3 +92,3 @@ -    if (!target[name] || !utils.isObject(target[name])) {+    if (!utils.hasOwnProp(target, name) || !utils.isObject(target[name])) {       target[name] = [];@@ -65,3 +96,3 @@ -    var result = buildPath(path, value, target[name], index);+    const result = buildPath(path, value, target[name], index); @@ -75,9 +106,6 @@   if (utils.isFormData(formData) && utils.isFunction(formData.entries)) {-    var obj = {};+    const obj = {}; -    utils.forEachEntry(formData, function(name, value) {-      var path = parsePropPath(name);--      assertPathDepth(path);-      buildPath(path, value, obj, 0);+    utils.forEachEntry(formData, (name, value) => {+      buildPath(parsePropPath(name), value, obj, 0);     });@@ -90,2 +118,2 @@ -module.exports = formDataToJSON;+export default formDataToJSON;

--- +++ @@ -2,7 +2,9 @@ -var AxiosError = require('../core/AxiosError');-var parseProtocol = require('./parseProtocol');-var platform = require('../platform');+import AxiosError from '../core/AxiosError.js';+import parseProtocol from './parseProtocol.js';+import platform from '../platform/index.js'; -var DATA_URL_PATTERN = /^(?:([^;]+);)?(?:[^;]+;)?(base64|),([\s\S]*)$/;+// RFC 2397: data:[<mediatype>][;base64],<data>+// mediatype = type/subtype followed by optional ;name=value parameters+const DATA_URL_PATTERN = /^([^,;]+\/[^,;]+)?((?:;[^,;=]+=[^,;]+)*)(;base64)?,([\s\S]*)$/; @@ -10,2 +12,3 @@  * Parse data uri to a Buffer or Blob+ *  * @param {String} uri@@ -14,7 +17,8 @@  * @param {?Function} options.Blob+ *  * @returns {Buffer|Blob}  */-module.exports = function fromDataURI(uri, asBlob, options) {-  var _Blob = options && options.Blob || platform.classes.Blob;-  var protocol = parseProtocol(uri);+export default function fromDataURI(uri, asBlob, options) {+  const _Blob = (options && options.Blob) || platform.classes.Blob;+  const protocol = parseProtocol(uri); @@ -27,3 +31,3 @@ -    var match = DATA_URL_PATTERN.exec(uri);+    const match = DATA_URL_PATTERN.exec(uri); @@ -33,6 +37,17 @@ -    var mime = match[1];-    var isBase64 = match[2];-    var body = match[3];-    var buffer = Buffer.from(decodeURIComponent(body), isBase64 ? 'base64' : 'utf8');+    const type = match[1];+    const params = match[2];+    const encoding = match[3] ? 'base64' : 'utf8';+    const body = match[4];++    // RFC 2397 section 3: default mediatype is text/plain;charset=US-ASCII+    // Bare `data:,` leaves mime undefined; Blob normalises that to "" per spec.+    let mime;+    if (type) {+      mime = params ? type + params : type;+    } else if (params) {+      mime = 'text/plain' + params;+    }++    const buffer = Buffer.from(decodeURIComponent(body), encoding); @@ -43,3 +58,3 @@ -      return new _Blob([buffer], {type: mime});+      return new _Blob([buffer], { type: mime });     }@@ -50,2 +65,2 @@   throw new AxiosError('Unsupported protocol ' + protocol, AxiosError.ERR_NOT_SUPPORT);-};+}

--- +++ @@ -2,5 +2,5 @@ -module.exports = function parseProtocol(url) {-  var match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url);-  return match && match[1] || '';-};+export default function parseProtocol(url) {+  const match = /^([-+\w]{1,25}):(?:\/\/)?/.exec(url);+  return (match && match[1]) || '';+}

--- +++ @@ -1,6 +1,81 @@-'use strict';--var URL = require('url').URL;--var DEFAULT_PORTS = {+const LOOPBACK_HOSTNAMES = new Set(['localhost', '0.0.0.0']);++const isIPv4Loopback = (host) => {+  const parts = host.split('.');+  if (parts.length !== 4) return false;+  if (parts[0] !== '127') return false;+  return parts.every((p) => /^\d+$/.test(p) && Number(p) >= 0 && Number(p) <= 255);+};++const isIPv6ZeroGroup = (group) => /^0{1,4}$/.test(group);++// The unspecified address (IPv4 0.0.0.0 / IPv6 ::) resolves to the local host+// for outbound connections, so treat it as loopback-equivalent for NO_PROXY+// matching. 0.0.0.0 is covered by LOOPBACK_HOSTNAMES; this handles compressed+// and full IPv6 all-zero forms so both families bypass symmetrically.+const isIPv6Unspecified = (host) => {+  if (host === '::') return true;++  const compressionIndex = host.indexOf('::');++  if (compressionIndex !== -1) {+    if (compressionIndex !== host.lastIndexOf('::')) return false;++    const left = host.slice(0, compressionIndex);+    const right = host.slice(compressionIndex + 2);+    const leftGroups = left ? left.split(':') : [];+    const rightGroups = right ? right.split(':') : [];+    const explicitGroups = leftGroups.length + rightGroups.length;++    return (+      explicitGroups < 8 &&+      leftGroups.every(isIPv6ZeroGroup) &&+      rightGroups.every(isIPv6ZeroGroup)+    );+  }++  const groups = host.split(':');+  return groups.length === 8 && groups.every(isIPv6ZeroGroup);+};++const isIPv6Loopback = (host) => {+  // Collapse all-zero groups: any form of ::1 / 0:0:...:0:1+  // First, strip any leading "::" by normalising with Set lookup of common forms,+  // then fall back to structural check.+  if (host === '::1') return true;++  // Check IPv4-mapped IPv6 loopback: ::ffff:<v4-loopback> or ::ffff:<hex-v4-loopback>+  // Node's URL parser normalises ::ffff:127.0.0.1 → ::ffff:7f00:1+  const v4MappedDotted = host.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/i);+  if (v4MappedDotted) return isIPv4Loopback(v4MappedDotted[1]);++  const v4MappedHex = host.match(/^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/i);+  if (v4MappedHex) {+    const high = parseInt(v4MappedHex[1], 16);+    // High 16 bits must start with 127 (0x7f) — i.e. 0x7f00..0x7fff+    return high >= 0x7f00 && high <= 0x7fff;+  }++  // Full-form ::1 variants: any number of zero groups followed by trailing 1+  // e.g. 0:0:0:0:0:0:0:1, 0000:...:0001+  const groups = host.split(':');+  if (groups.length === 8) {+    for (let i = 0; i < 7; i++) {+      if (!/^0+$/.test(groups[i])) return false;+    }+    return /^0*1$/.test(groups[7]);+  }++  return false;+};++const isLoopback = (host) => {+  if (!host) return false;+  if (LOOPBACK_HOSTNAMES.has(host)) return true;+  if (isIPv4Loopback(host)) return true;+  if (isIPv6Unspecified(host)) return true;+  return isIPv6Loopback(host);+};++const DEFAULT_PORTS = {   http: 80,@@ -9,18 +84,18 @@   wss: 443,-  ftp: 21-};--function parseNoProxyEntry(entry) {-  var entryHost = entry;-  var entryPort = 0;+  ftp: 21,+};++const parseNoProxyEntry = (entry) => {+  let entryHost = entry;+  let entryPort = 0;    if (entryHost.charAt(0) === '[') {-    var bracketIndex = entryHost.indexOf(']');+    const bracketIndex = entryHost.indexOf(']');      if (bracketIndex !== -1) {-      var host = entryHost.slice(1, bracketIndex);-      var rest = entryHost.slice(bracketIndex + 1);+      const host = entryHost.slice(1, bracketIndex);+      const rest = entryHost.slice(bracketIndex + 1);        if (rest.charAt(0) === ':' && /^\d+$/.test(rest.slice(1))) {-        entryPort = parseInt(rest.slice(1), 10);+        entryPort = Number.parseInt(rest.slice(1), 10);       }@@ -31,7 +106,11 @@ -  var firstColon = entryHost.indexOf(':');-  var lastColon = entryHost.lastIndexOf(':');--  if (firstColon !== -1 && firstColon === lastColon && /^\d+$/.test(entryHost.slice(lastColon + 1))) {-    entryPort = parseInt(entryHost.slice(lastColon + 1), 10);+  const firstColon = entryHost.indexOf(':');+  const lastColon = entryHost.lastIndexOf(':');++  if (+    firstColon !== -1 &&+    firstColon === lastColon &&+    /^\d+$/.test(entryHost.slice(lastColon + 1))+  ) {+    entryPort = Number.parseInt(entryHost.slice(lastColon + 1), 10);     entryHost = entryHost.slice(0, lastColon);@@ -40,57 +119,30 @@   return [entryHost, entryPort];-}--function parseIPv4Octets(hostname) {-  var octets = hostname.split('.');--  if (octets.length !== 4) {-    return null;-  }--  for (var i = 0; i < octets.length; i++) {-    if (!/^\d+$/.test(octets[i]) || Number(octets[i]) > 255) {-      return null;-    }-  }--  return octets;-}--// Recognises the canonical IPv4-mapped IPv6 forms the Node URL parser produces:-//   ::ffff:127.0.0.1   (dotted-quad tail)-//   ::ffff:7f00:1      (compressed two-group hex tail)-// Fully-expanded forms like 0:0:0:0:0:ffff:7f00:1 or single-group tails like-// ::ffff:1 are not normalised here. URL inputs are canonicalised by the parser-// before reaching this helper, but hand-crafted no_proxy entries in those-// shapes will not match an IPv4 listing.-function normalizeIPv4MappedIPv6(hostname) {-  // Match against the lowercased form so a hand-crafted no_proxy entry like-  // `[::FFFF:7F00:1]` still resolves to its IPv4 alias. Callers that route via-  // URL parsing already lowercase, but the helper stays robust on its own.-  var lower = hostname.toLowerCase();-  var dottedMatch = /^::ffff:(\d+\.\d+\.\d+\.\d+)$/.exec(lower);--  if (dottedMatch) {-    var octets = parseIPv4Octets(dottedMatch[1]);-    return octets ? octets.join('.') : hostname;-  }--  var hexMatch = /^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/.exec(lower);--  if (hexMatch) {-    var high = parseInt(hexMatch[1], 16);-    var low = parseInt(hexMatch[2], 16);--    return [-      (high >> 8) & 0xff,-      high & 0xff,-      (low >> 8) & 0xff,-      low & 0xff-    ].join('.');-  }--  return hostname;-}--function normalizeNoProxyHost(hostname) {+};++// Convert IPv4-mapped IPv6 (::ffff:0:0/96 prefix) to IPv4 dotted form so both+// sides of a NO_PROXY comparison see the same canonical address. Without this,+// `NO_PROXY=192.168.1.5` would not match a request to `http://[::ffff:192.168.1.5]/`+// (Node's URL parser normalises that to `[::ffff:c0a8:105]`), and vice-versa,+// allowing the proxy-bypass policy to be circumvented by using the alternate+// representation. Returns the input unchanged when not IPv4-mapped.+const IPV4_MAPPED_DOTTED_RE = /^(?:::|(?:0{1,4}:){1,4}:|(?:0{1,4}:){5})ffff:(\d+\.\d+\.\d+\.\d+)$/i;+const IPV4_MAPPED_HEX_RE = /^(?:::|(?:0{1,4}:){1,4}:|(?:0{1,4}:){5})ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/i;++const unmapIPv4MappedIPv6 = (host) => {+  if (typeof host !== 'string' || host.indexOf(':') === -1) return host;++  const dotted = host.match(IPV4_MAPPED_DOTTED_RE);+  if (dotted) return dotted[1];++  const hex = host.match(IPV4_MAPPED_HEX_RE);+  if (hex) {+    const high = parseInt(hex[1], 16);+    const low = parseInt(hex[2], 16);+    return `${high >> 8}.${high & 0xff}.${low >> 8}.${low & 0xff}`;+  }++  return host;+};++const normalizeNoProxyHost = (hostname) => {   if (!hostname) {@@ -103,11 +155,11 @@ -  hostname = hostname.replace(/\.+$/, '');--  return normalizeIPv4MappedIPv6(hostname);-}--function isLoopbackIPv4(hostname) {-  var octets = hostname.split('.');--  if (octets.length !== 4) {+  return unmapIPv4MappedIPv6(hostname.replace(/\.+$/, ''));+};++export default function shouldBypassProxy(location) {+  let parsed;++  try {+    parsed = new URL(location);+  } catch (_err) {     return false;@@ -115,3 +167,5 @@ -  if (octets[0] !== '127') {+  const noProxy = (process.env.no_proxy || process.env.NO_PROXY || '').toLowerCase();++  if (!noProxy) {     return false;@@ -119,69 +173,38 @@

--- +++ @@ -1,22 +1,145 @@-// TypeScript Version: 4.1-type HeaderValue = string | string[] | number | boolean;--type AxiosHeaders = Record<string, HeaderValue | Record<Method & CommonHeaders, HeaderValue>>;--type MethodsHeaders = {-  [Key in Method as Lowercase<Key>]: AxiosHeaders;+// TypeScript Version: 4.7+type StringLiteralsOrString<Literals extends string> = Literals | (string & {});++export type AxiosHeaderValue = AxiosHeaders | string | string[] | number | boolean | null;++export interface RawAxiosHeaders {+  [key: string]: AxiosHeaderValue;+}++type MethodsHeaders = Partial<+  {+    [Key in Method as Lowercase<Key>]: AxiosHeaders;+  } & { common: AxiosHeaders }+>;++type AxiosHeaderMatcher =+  | string+  | RegExp+  | ((this: AxiosHeaders, value: string, name: string) => boolean);++type AxiosHeaderParser = (this: AxiosHeaders, value: AxiosHeaderValue, header: string) => any;++export class AxiosHeaders {+  constructor(headers?: RawAxiosHeaders | AxiosHeaders | string);++  [key: string]: any;++  set(+    headerName?: string,+    value?: AxiosHeaderValue,+    rewrite?: boolean | AxiosHeaderMatcher+  ): AxiosHeaders;+  set(headers?: RawAxiosHeaders | AxiosHeaders | string, rewrite?: boolean): AxiosHeaders;++  get(headerName: string, parser: RegExp): RegExpExecArray | null;+  get(headerName: string, matcher?: true | AxiosHeaderParser): AxiosHeaderValue;++  has(header: string, matcher?: AxiosHeaderMatcher): boolean;++  delete(header: string | string[], matcher?: AxiosHeaderMatcher): boolean;++  clear(matcher?: AxiosHeaderMatcher): boolean;++  normalize(format: boolean): AxiosHeaders;++  concat(+    ...targets: Array<AxiosHeaders | RawAxiosHeaders | string | undefined | null>+  ): AxiosHeaders;++  toJSON(asStrings: true): Record<string, string>;+  toJSON(asStrings?: false): Record<string, string | string[]>;+  toJSON(asStrings?: boolean): Record<string, string | string[]>;++  static from(thing?: AxiosHeaders | RawAxiosHeaders | string): AxiosHeaders;++  static accessor(header: string | string[]): AxiosHeaders;++  static concat(+    ...targets: Array<AxiosHeaders | RawAxiosHeaders | string | undefined | null>+  ): AxiosHeaders;++  setContentType(value: ContentType, rewrite?: boolean | AxiosHeaderMatcher): AxiosHeaders;+  getContentType(parser?: RegExp): RegExpExecArray | null;+  getContentType(matcher?: AxiosHeaderMatcher): AxiosHeaderValue;+  hasContentType(matcher?: AxiosHeaderMatcher): boolean;++  setContentLength(value: AxiosHeaderValue, rewrite?: boolean | AxiosHeaderMatcher): AxiosHeaders;+  getContentLength(parser?: RegExp): RegExpExecArray | null;+  getContentLength(matcher?: AxiosHeaderMatcher): AxiosHeaderValue;+  hasContentLength(matcher?: AxiosHeaderMatcher): boolean;++  setAccept(value: AxiosHeaderValue, rewrite?: boolean | AxiosHeaderMatcher): AxiosHeaders;+  getAccept(parser?: RegExp): RegExpExecArray | null;+  getAccept(matcher?: AxiosHeaderMatcher): AxiosHeaderValue;+  hasAccept(matcher?: AxiosHeaderMatcher): boolean;++  setUserAgent(value: AxiosHeaderValue, rewrite?: boolean | AxiosHeaderMatcher): AxiosHeaders;+  getUserAgent(parser?: RegExp): RegExpExecArray | null;+  getUserAgent(matcher?: AxiosHeaderMatcher): AxiosHeaderValue;+  hasUserAgent(matcher?: AxiosHeaderMatcher): boolean;++  setContentEncoding(value: AxiosHeaderValue, rewrite?: boolean | AxiosHeaderMatcher): AxiosHeaders;+  getContentEncoding(parser?: RegExp): RegExpExecArray | null;+  getContentEncoding(matcher?: AxiosHeaderMatcher): AxiosHeaderValue;+  hasContentEncoding(matcher?: AxiosHeaderMatcher): boolean;++  setAuthorization(value: AxiosHeaderValue, rewrite?: boolean | AxiosHeaderMatcher): AxiosHeaders;+  getAuthorization(parser?: RegExp): RegExpExecArray | null;+  getAuthorization(matcher?: AxiosHeaderMatcher): AxiosHeaderValue;+  hasAuthorization(matcher?: AxiosHeaderMatcher): boolean;++  getSetCookie(): string[];++  [Symbol.iterator](): IterableIterator<[string, AxiosHeaderValue]>;+}++type CommonRequestHeadersList =+  | 'Accept'+  | 'Content-Length'+  | 'User-Agent'+  | 'Content-Encoding'+  | 'Authorization'+  | 'Location';++type ContentType =+  | AxiosHeaderValue+  | 'text/html'+  | 'text/plain'+  | 'multipart/form-data'+  | 'application/json'+  | 'application/x-www-form-urlencoded'+  | 'application/octet-stream';++export type RawAxiosRequestHeaders = Partial<+  RawAxiosHeaders & {+    [Key in CommonRequestHeadersList]: AxiosHeaderValue;+  } & {+    'Content-Type': ContentType;+  }+>;++export type AxiosRequestHeaders = RawAxiosRequestHeaders & AxiosHeaders;++type CommonResponseHeadersList =+  | 'Server'+  | 'Content-Type'+  | 'Content-Length'+  | 'Cache-Control'+  | 'Content-Encoding';++type CommonResponseHeaderKey = CommonResponseHeadersList | Lowercase<CommonResponseHeadersList>;++type RawCommonResponseHeaders = {+  [Key in CommonResponseHeaderKey]: AxiosHeaderValue;+} & {+  'set-cookie': string[]; }; -interface CommonHeaders  {-  common: AxiosHeaders;-}--export type AxiosRequestHeaders = Partial<AxiosHeaders & MethodsHeaders & CommonHeaders>;--export type AxiosResponseHeaders = Partial<Record<string, string>> & {-  "set-cookie"?: string[]-};+export type RawAxiosResponseHeaders = Partial<RawAxiosHeaders & RawCommonResponseHeaders>;++export type AxiosResponseHeaders = RawAxiosResponseHeaders & AxiosHeaders;  export interface AxiosRequestTransformer {-  (data: any, headers: AxiosRequestHeaders): any;+  (this: InternalAxiosRequestConfig, data: any, headers: AxiosRequestHeaders): any; }@@ -24,3 +147,8 @@ export interface AxiosResponseTransformer {-  (data: any, headers?: AxiosResponseHeaders, status?: number): any;+  (+    this: InternalAxiosRequestConfig,+    data: any,+    headers: AxiosResponseHeaders,+    status?: number+  ): any; }@@ -28,3 +156,3 @@ export interface AxiosAdapter {-  (config: AxiosRequestConfig): AxiosPromise;+  (config: InternalAxiosRequestConfig): AxiosPromise; }@@ -39,6 +167,3 @@   port: number;-  auth?: {-    username: string;-    password: string;-  };+  auth?: AxiosBasicCredentials;   protocol?: string;@@ -46,13 +171,82 @@ -export type Method =-  | 'get' | 'GET'-  | 'delete' | 'DELETE'-  | 'head' | 'HEAD'-  | 'options' | 'OPTIONS'-  | 'post' | 'POST'-  | 'put' | 'PUT'-  | 'patch' | 'PATCH'-  | 'purge' | 'PURGE'-  | 'link' | 'LINK'-  | 'unlink' | 'UNLINK';+export enum HttpStatusCode {+  Continue = 100,+  SwitchingProtocols = 101,+  Processing = 102,+  EarlyHints = 103,+  Ok = 200,+  Created = 201,+  Accepted = 202,+  NonAuthoritativeInformation = 203,+  NoContent = 204,+  ResetContent = 205,+  PartialContent = 206,+  MultiStatus = 207,+  AlreadyReported = 208,+  ImUsed = 226,+  MultipleChoices = 300,+  MovedPermanently = 301,+  Found = 302,+  SeeOther = 303,+  NotModified = 304,+  UseProxy = 305,+  Unused = 306,+  TemporaryRedirect = 307,+  PermanentRedirect = 308,+  BadRequest = 400,+  Unauthorized = 401,+  PaymentRequired = 402,+  Forbidden = 403,+  NotFound = 404,+  MethodNotAllowed = 405,+  NotAcceptable = 406,+  ProxyAuthenticationRequired = 407,+  RequestTimeout = 408,+  Conflict = 409,+  Gone = 410,+  LengthRequired = 411,+  PreconditionFailed = 412,+  PayloadTooLarge = 413,+  UriTooLong = 414,+  UnsupportedMediaType = 415,+  RangeNotSatisfiable = 416,+  ExpectationFailed = 417,+  ImATeapot = 418,+  MisdirectedRequest = 421,+  UnprocessableEntity = 422,+  Locked = 423,+  FailedDependency = 424,+  TooEarly = 425,+  UpgradeRequired = 426,

--- +++ @@ -1 +1,45 @@-module.exports = require('./lib/axios');+import axios from './lib/axios.js';++// This module is intended to unwrap Axios default export as named.+// Keep top-level export same with static properties+// so that it can keep same with es module or cjs+const {+  Axios,+  AxiosError,+  CanceledError,+  isCancel,+  CancelToken,+  VERSION,+  all,+  Cancel,+  isAxiosError,+  spread,+  toFormData,+  AxiosHeaders,+  HttpStatusCode,+  formToJSON,+  getAdapter,+  mergeConfig,+  create,+} = axios;++export {+  axios as default,+  create,+  Axios,+  AxiosError,+  CanceledError,+  isCancel,+  CancelToken,+  VERSION,+  all,+  Cancel,+  isAxiosError,+  spread,+  toFormData,+  AxiosHeaders,+  HttpStatusCode,+  formToJSON,+  getAdapter,+  mergeConfig,+};

--- +++ @@ -0,0 +1,132 @@+import utils from '../utils.js';+import httpAdapter from './http.js';+import xhrAdapter from './xhr.js';+import * as fetchAdapter from './fetch.js';+import AxiosError from '../core/AxiosError.js';++/**+ * Known adapters mapping.+ * Provides environment-specific adapters for Axios:+ * - `http` for Node.js+ * - `xhr` for browsers+ * - `fetch` for fetch API-based requests+ *+ * @type {Object<string, Function|Object>}+ */+const knownAdapters = {+  http: httpAdapter,+  xhr: xhrAdapter,+  fetch: {+    get: fetchAdapter.getFetch,+  },+};++// Assign adapter names for easier debugging and identification+utils.forEach(knownAdapters, (fn, value) => {+  if (fn) {+    try {+      // Null-proto descriptors so a polluted Object.prototype.get cannot turn+      // these data descriptors into accessor descriptors on the way in.+      Object.defineProperty(fn, 'name', { __proto__: null, value });+    } catch (e) {+      // eslint-disable-next-line no-empty+    }+    Object.defineProperty(fn, 'adapterName', { __proto__: null, value });+  }+});++/**+ * Render a rejection reason string for unknown or unsupported adapters+ *+ * @param {string} reason+ * @returns {string}+ */+const renderReason = (reason) => `- ${reason}`;++/**+ * Check if the adapter is resolved (function, null, or false)+ *+ * @param {Function|null|false} adapter+ * @returns {boolean}+ */+const isResolvedHandle = (adapter) =>+  utils.isFunction(adapter) || adapter === null || adapter === false;++/**+ * Get the first suitable adapter from the provided list.+ * Tries each adapter in order until a supported one is found.+ * Throws an AxiosError if no adapter is suitable.+ *+ * @param {Array<string|Function>|string|Function} adapters - Adapter(s) by name or function.+ * @param {Object} config - Axios request configuration+ * @throws {AxiosError} If no suitable adapter is available+ * @returns {Function} The resolved adapter function+ */+function getAdapter(adapters, config) {+  adapters = utils.isArray(adapters) ? adapters : [adapters];++  const { length } = adapters;+  let nameOrAdapter;+  let adapter;++  const rejectedReasons = {};++  for (let i = 0; i < length; i++) {+    nameOrAdapter = adapters[i];+    let id;++    adapter = nameOrAdapter;++    if (!isResolvedHandle(nameOrAdapter)) {+      adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];++      if (adapter === undefined) {+        throw new AxiosError(`Unknown adapter '${id}'`);+      }+    }++    if (adapter && (utils.isFunction(adapter) || (adapter = adapter.get(config)))) {+      break;+    }++    rejectedReasons[id || '#' + i] = adapter;+  }++  if (!adapter) {+    const reasons = Object.entries(rejectedReasons).map(+      ([id, state]) =>+        `adapter ${id} ` ++        (state === false ? 'is not supported by the environment' : 'is not available in the build')+    );++    let s = length+      ? reasons.length > 1+        ? 'since :\n' + reasons.map(renderReason).join('\n')+        : ' ' + renderReason(reasons[0])+      : 'as no adapter specified';++    throw new AxiosError(+      `There is no suitable adapter to dispatch the request ` + s,+      'ERR_NOT_SUPPORT'+    );+  }++  return adapter;+}++/**+ * Exports Axios adapters and utility to resolve an adapter+ */+export default {+  /**+   * Resolve an adapter from a list of adapter names or functions.+   * @type {Function}+   */+  getAdapter,++  /**+   * Exposes all known adapters+   * @type {Object<string, Function|Object>}+   */+  adapters: knownAdapters,+};

--- +++ @@ -0,0 +1,628 @@+import platform from '../platform/index.js';+import utils from '../utils.js';+import AxiosError from '../core/AxiosError.js';+import composeSignals from '../helpers/composeSignals.js';+import { trackStream } from '../helpers/trackStream.js';+import AxiosHeaders from '../core/AxiosHeaders.js';+import {+  progressEventReducer,+  progressEventDecorator,+  asyncDecorator,+} from '../helpers/progressEventReducer.js';+import resolveConfig from '../helpers/resolveConfig.js';+import settle from '../core/settle.js';+import estimateDataURLDecodedBytes from '../helpers/estimateDataURLDecodedBytes.js';+import { VERSION } from '../env/data.js';+import { toByteStringHeaderObject } from '../helpers/sanitizeHeaderValue.js';++const DEFAULT_CHUNK_SIZE = 64 * 1024;++const { isFunction } = utils;++/**+ * Encode a UTF-8 string to a Latin-1 byte string for use with btoa().+ * This is a modern replacement for the deprecated unescape(encodeURIComponent(str)) pattern.+ *+ * @param {string} str The string to encode+ *+ * @returns {string} UTF-8 bytes as a Latin-1 string+ */+const encodeUTF8 = (str) =>+  encodeURIComponent(str).replace(/%([0-9A-F]{2})/gi, (_, hex) =>+    String.fromCharCode(parseInt(hex, 16))+  );++// Node's WHATWG URL parser returns `username` and `password` percent-encoded.+// Decode before composing the `auth` option so credentials such as+// `my%40email.com:pass` are sent as `[email protected]:pass`. Falls back to the+// original value for malformed input so a bad encoding never throws.+const decodeURIComponentSafe = (value) => {+  if (!utils.isString(value)) {+    return value;+  }++  try {+    return decodeURIComponent(value);+  } catch (error) {+    return value;+  }+};++const test = (fn, ...args) => {+  try {+    return !!fn(...args);+  } catch (e) {+    return false;+  }+};++const maybeWithAuthCredentials = (url) => {+  const protocolIndex = url.indexOf('://');+  let urlToCheck = url;+  if (protocolIndex !== -1) {+    urlToCheck = urlToCheck.slice(protocolIndex + 3);+  }+  return urlToCheck.includes('@') || urlToCheck.includes(':');+};++const factory = (env) => {+  const globalObject =+    utils.global !== undefined && utils.global !== null+      ? utils.global+      : globalThis;+  const { ReadableStream, TextEncoder } = globalObject;++  env = utils.merge.call(+    {+      skipUndefined: true,+    },+    {+      Request: globalObject.Request,+      Response: globalObject.Response,+    },+    env+  );++  const { fetch: envFetch, Request, Response } = env;+  const isFetchSupported = envFetch ? isFunction(envFetch) : typeof fetch === 'function';+  const isRequestSupported = isFunction(Request);+  const isResponseSupported = isFunction(Response);++  if (!isFetchSupported) {+    return false;+  }++  const isReadableStreamSupported = isFetchSupported && isFunction(ReadableStream);++  const encodeText =+    isFetchSupported &&+    (typeof TextEncoder === 'function'+      ? (+          (encoder) => (str) =>+            encoder.encode(str)+        )(new TextEncoder())+      : async (str) => new Uint8Array(await new Request(str).arrayBuffer()));++  const supportsRequestStream =+    isRequestSupported &&+    isReadableStreamSupported &&+    test(() => {+      let duplexAccessed = false;++      const request = new Request(platform.origin, {+        body: new ReadableStream(),+        method: 'POST',+        get duplex() {+          duplexAccessed = true;+          return 'half';+        },+      });++      const hasContentType = request.headers.has('Content-Type');++      if (request.body != null) {+        request.body.cancel();+      }++      return duplexAccessed && !hasContentType;+    });++  const supportsResponseStream =+    isResponseSupported &&+    isReadableStreamSupported &&+    test(() => utils.isReadableStream(new Response('').body));++  const resolvers = {+    stream: supportsResponseStream && ((res) => res.body),+  };++  isFetchSupported &&+    (() => {+      ['text', 'arrayBuffer', 'blob', 'formData', 'stream'].forEach((type) => {+        !resolvers[type] &&+          (resolvers[type] = (res, config) => {+            let method = res && res[type];++            if (method) {+              return method.call(res);+            }++            throw new AxiosError(+              `Response type '${type}' is not supported`,+              AxiosError.ERR_NOT_SUPPORT,+              config+            );+          });+      });+    })();++  const getBodyLength = async (body) => {+    if (body == null) {+      return 0;+    }++    if (utils.isBlob(body)) {+      return body.size;+    }++    if (utils.isSpecCompliantForm(body)) {+      const _request = new Request(platform.origin, {+        method: 'POST',+        body,+      });+      return (await _request.arrayBuffer()).byteLength;+    }++    if (utils.isArrayBufferView(body) || utils.isArrayBuffer(body)) {+      return body.byteLength;+    }++    if (utils.isURLSearchParams(body)) {+      body = body + '';+    }++    if (utils.isString(body)) {+      return (await encodeText(body)).byteLength;+    }+  };++  const resolveBodyLength = async (headers, body) => {+    const length = utils.toFiniteNumber(headers.getContentLength());++    return length == null ? getBodyLength(body) : length;+  };++  return async (config) => {+    let {+      url,+      method,+      data,+      signal,+      cancelToken,+      timeout,+      onDownloadProgress,+      onUploadProgress,+      responseType,+      headers,+      withCredentials = 'same-origin',+      fetchOptions,+      maxContentLength,+      maxBodyLength,+    } = resolveConfig(config);++    const hasMaxContentLength = utils.isNumber(maxContentLength) && maxContentLength > -1;+    const hasMaxBodyLength = utils.isNumber(maxBodyLength) && maxBodyLength > -1;+    const own = (key) => (utils.hasOwnProp(config, key) ? config[key] : undefined);++    let _fetch = envFetch || fetch;++    responseType = responseType ? (responseType + '').toLowerCase() : 'text';++    let composedSignal = composeSignals(+      [signal, cancelToken && cancelToken.toAbortSignal()],+      timeout+    );++    let request = null;++    const unsubscribe =+      composedSignal &&+      composedSignal.unsubscribe &&+      (() => {+        composedSignal.unsubscribe();+      });++    let requestContentLength;++    // AxiosError we raise while the request body is being streamed. Captured+    // by identity so the catch block can surface it directly, regardless of+    // how the runtime wraps the resulting fetch rejection (undici exposes it+    // as `err.cause`; some browsers drop the original error entirely).+    let pendingBodyError = null;++    const maxBodyLengthError = () =>+      new AxiosError(+        'Request body larger than maxBodyLength limit',+        AxiosError.ERR_BAD_REQUEST,+        config,

--- +++ @@ -1,259 +1,43 @@-'use strict';--var utils = require('./../utils');-var settle = require('./../core/settle');-var cookies = require('./../helpers/cookies');-var buildURL = require('./../helpers/buildURL');-var buildFullPath = require('../core/buildFullPath');-var parseHeaders = require('./../helpers/parseHeaders');-var isURLSameOrigin = require('./../helpers/isURLSameOrigin');-var transitionalDefaults = require('../defaults/transitional');-var AxiosError = require('../core/AxiosError');-var CanceledError = require('../cancel/CanceledError');-var parseProtocol = require('../helpers/parseProtocol');-var platform = require('../platform');--module.exports = function xhrAdapter(config) {-  return new Promise(function dispatchXhrRequest(resolve, reject) {-    var requestData = config.data;-    var requestHeaders = config.headers;-    var responseType = config.responseType;-    // Guard against prototype pollution: only honor own properties.-    var withXSRFToken = utils.hasOwnProperty(config, 'withXSRFToken')-      ? config.withXSRFToken-      : undefined;-    var onCanceled;-    function done() {-      if (config.cancelToken) {-        config.cancelToken.unsubscribe(onCanceled);-      }--      if (config.signal) {-        config.signal.removeEventListener('abort', onCanceled);-      }-    }--    if (utils.isFormData(requestData) && utils.isStandardBrowserEnv()) {-      delete requestHeaders['Content-Type']; // Let the browser set it-    }--    var request = new XMLHttpRequest();--    // HTTP basic authentication-    var configAuth = utils.hasOwnProperty(config, 'auth') ? config.auth : undefined;-    if (configAuth) {-      var username = utils.hasOwnProperty(configAuth, 'username') ? configAuth.username || '' : '';-      var password = utils.hasOwnProperty(configAuth, 'password') && configAuth.password-        ? unescape(encodeURIComponent(configAuth.password))-        : '';-      requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);-    }--    var fullPath = buildFullPath(-      config.baseURL,-      config.url,-      config.allowAbsoluteUrls-    );--    request.open(-      config.method.toUpperCase(),-      buildURL(-        fullPath,-        config.params,-        utils.hasOwnProperty(config, 'paramsSerializer') ? config.paramsSerializer : undefined-      ),-      true-    );--    // Set the request timeout in MS-    request.timeout = config.timeout;--    function onloadend() {-      if (!request) {-        return;-      }-      // Prepare the response-      var responseHeaders =-        'getAllResponseHeaders' in request-          ? parseHeaders(request.getAllResponseHeaders())-          : null;-      var responseData =-        !responseType || responseType === 'text' || responseType === 'json'-          ? request.responseText-          : request.response;-      var response = {-        data: responseData,-        status: request.status,-        statusText: request.statusText,-        headers: responseHeaders,-        config: config,-        request: request-      };--      settle(-        function _resolve(value) {-          resolve(value);-          done();-        },-        function _reject(err) {-          reject(err);-          done();-        },-        response-      );--      // Clean up request-      request = null;-    }--    if ('onloadend' in request) {-      // Use onloadend if available-      request.onloadend = onloadend;-    } else {-      // Listen for ready state to emulate onloadend-      request.onreadystatechange = function handleLoad() {-        if (!request || request.readyState !== 4) {-          return;-        }--        // The request errored out and we didn't get a response, this will be-        // handled by onerror instead-        // With one exception: request that using file: protocol, most browsers-        // will return status as 0 even though it's a successful request-        if (-          request.status === 0 &&-          !(request.responseURL && request.responseURL.indexOf('file:') === 0)-        ) {-          return;-        }-        // readystate handler is calling before onerror or ontimeout handlers,-        // so we should call onloadend on the next 'tick'-        setTimeout(onloadend);-      };-    }--    // Handle browser request cancellation (as opposed to a manual cancellation)-    request.onabort = function handleAbort() {-      if (!request) {-        return;-      }--      reject(-        new AxiosError(-          'Request aborted',-          AxiosError.ECONNABORTED,-          config,-          request-        )-      );--      // Clean up request-      request = null;-    };--    // Handle low level network errors-    request.onerror = function handleError() {-      // Real errors are hidden from us by the browser-      // onerror should only fire if it's a network error-      reject(-        new AxiosError(-          'Network Error',-          AxiosError.ERR_NETWORK,-          config,-          request-        )-      );--      // Clean up request-      request = null;-    };--    // Handle timeout-    request.ontimeout = function handleTimeout() {-      var timeoutErrorMessage = config.timeout-        ? 'timeout of ' + config.timeout + 'ms exceeded'-        : 'timeout exceeded';-      var transitional = config.transitional || transitionalDefaults;-      if (config.timeoutErrorMessage) {-        timeoutErrorMessage = config.timeoutErrorMessage;-      }-      reject(-        new AxiosError(-          timeoutErrorMessage,-          transitional.clarifyTimeoutError-            ? AxiosError.ETIMEDOUT-            : AxiosError.ECONNABORTED,-          config,-          request-        )-      );--      // Clean up request-      request = null;-    };--    // Add xsrf header-    // This is only done if running in a standard browser environment.-    // Specifically not if we're in a web worker, or react-native.-    if (utils.isStandardBrowserEnv()) {-      // Add xsrf header-      if (utils.isFunction(withXSRFToken)) {-        withXSRFToken = withXSRFToken(config);-      }-      // Strict boolean check: only `true` short-circuits the same-origin guard.-      if (-        withXSRFToken === true ||-        (withXSRFToken !== false && isURLSameOrigin(fullPath))-      ) {-        // Add xsrf header-        var xsrfValue =-          config.xsrfHeaderName &&-          config.xsrfCookieName &&-          cookies.read(config.xsrfCookieName);-        if (xsrfValue) {-          requestHeaders[config.xsrfHeaderName] = xsrfValue;-        }-      }-    }--    // Add headers to the request-    if ('setRequestHeader' in request) {-      utils.forEach(requestHeaders, function setRequestHeader(val, key) {-        if (-          typeof requestData === 'undefined' &&-          key.toLowerCase() === 'content-type'-        ) {-          // Remove Content-Type if data is undefined-          delete requestHeaders[key];-        } else {-          // Otherwise add header to the request-          request.setRequestHeader(key, val);-        }-      });-    }--    // Add withCredentials to request if needed-    if (!utils.isUndefined(config.withCredentials)) {-      request.withCredentials = !!config.withCredentials;-    }--    // Add responseType to request if needed-    if (responseType && responseType !== 'json') {-      request.responseType = config.responseType;-    }--    // Handle progress if needed-    if (typeof config.onDownloadProgress === 'function') {-      request.addEventListener('progress', config.onDownloadProgress);

--- +++ @@ -2,8 +2,20 @@ -var utils = require('./utils');-var bind = require('./helpers/bind');-var Axios = require('./core/Axios');-var mergeConfig = require('./core/mergeConfig');-var defaults = require('./defaults');-var formDataToJSON = require('./helpers/formDataToJSON');+import utils from './utils.js';+import bind from './helpers/bind.js';+import Axios from './core/Axios.js';+import mergeConfig from './core/mergeConfig.js';+import defaults from './defaults/index.js';+import formDataToJSON from './helpers/formDataToJSON.js';+import CanceledError from './cancel/CanceledError.js';+import CancelToken from './cancel/CancelToken.js';+import isCancel from './cancel/isCancel.js';+import { VERSION } from './env/data.js';+import toFormData from './helpers/toFormData.js';+import AxiosError from './core/AxiosError.js';+import spread from './helpers/spread.js';+import isAxiosError from './helpers/isAxiosError.js';+import AxiosHeaders from './core/AxiosHeaders.js';+import adapters from './adapters/adapters.js';+import HttpStatusCode from './helpers/HttpStatusCode.js';+ /**@@ -12,13 +24,14 @@  * @param {Object} defaultConfig The default config for the instance- * @return {Axios} A new instance of Axios+ *+ * @returns {Axios} A new instance of Axios  */ function createInstance(defaultConfig) {-  var context = new Axios(defaultConfig);-  var instance = bind(Axios.prototype.request, context);+  const context = new Axios(defaultConfig);+  const instance = bind(Axios.prototype.request, context);    // Copy axios.prototype to instance-  utils.extend(instance, Axios.prototype, context);+  utils.extend(instance, Axios.prototype, context, { allOwnKeys: true });    // Copy context to instance-  utils.extend(instance, context);+  utils.extend(instance, context, null, { allOwnKeys: true }); @@ -33,3 +46,3 @@ // Create the default instance to be exported-var axios = createInstance(defaults);+const axios = createInstance(defaults); @@ -39,10 +52,10 @@ // Expose Cancel & CancelToken-axios.CanceledError = require('./cancel/CanceledError');-axios.CancelToken = require('./cancel/CancelToken');-axios.isCancel = require('./cancel/isCancel');-axios.VERSION = require('./env/data').version;-axios.toFormData = require('./helpers/toFormData');+axios.CanceledError = CanceledError;+axios.CancelToken = CancelToken;+axios.isCancel = isCancel;+axios.VERSION = VERSION;+axios.toFormData = toFormData;  // Expose AxiosError class-axios.AxiosError = require('../lib/core/AxiosError');+axios.AxiosError = AxiosError; @@ -55,14 +68,22 @@ };-axios.spread = require('./helpers/spread');++axios.spread = spread;  // Expose isAxiosError-axios.isAxiosError = require('./helpers/isAxiosError');+axios.isAxiosError = isAxiosError; -axios.formToJSON = function(thing) {-  return formDataToJSON(utils.isHTMLForm(thing) ? new FormData(thing) : thing);-};+// Expose mergeConfig+axios.mergeConfig = mergeConfig; -module.exports = axios;+axios.AxiosHeaders = AxiosHeaders; -// Allow use of default import syntax in TypeScript-module.exports.default = axios;+axios.formToJSON = (thing) => formDataToJSON(utils.isHTMLForm(thing) ? new FormData(thing) : thing);++axios.getAdapter = adapters.getAdapter;++axios.HttpStatusCode = HttpStatusCode;++axios.default = axios;++// this module should only have a default export+export default axios;

--- +++ @@ -2,3 +2,3 @@ -var CanceledError = require('./CanceledError');+import CanceledError from './CanceledError.js'; @@ -7,49 +7,75 @@  *- * @class  * @param {Function} executor The executor function.+ *+ * @returns {CancelToken}  */-function CancelToken(executor) {-  if (typeof executor !== 'function') {-    throw new TypeError('executor must be a function.');+class CancelToken {+  constructor(executor) {+    if (typeof executor !== 'function') {+      throw new TypeError('executor must be a function.');+    }++    let resolvePromise;++    this.promise = new Promise(function promiseExecutor(resolve) {+      resolvePromise = resolve;+    });++    const token = this;++    // eslint-disable-next-line func-names+    this.promise.then((cancel) => {+      if (!token._listeners) return;++      let i = token._listeners.length;++      while (i-- > 0) {+        token._listeners[i](cancel);+      }+      token._listeners = null;+    });++    // eslint-disable-next-line func-names+    this.promise.then = (onfulfilled) => {+      let _resolve;+      // eslint-disable-next-line func-names+      const promise = new Promise((resolve) => {+        token.subscribe(resolve);+        _resolve = resolve;+      }).then(onfulfilled);++      promise.cancel = function reject() {+        token.unsubscribe(_resolve);+      };++      return promise;+    };++    executor(function cancel(message, config, request) {+      if (token.reason) {+        // Cancellation has already been requested+        return;+      }++      token.reason = new CanceledError(message, config, request);+      resolvePromise(token.reason);+    });   } -  var resolvePromise;+  /**+   * Throws a `CanceledError` if cancellation has been requested.+   */+  throwIfRequested() {+    if (this.reason) {+      throw this.reason;+    }+  } -  this.promise = new Promise(function promiseExecutor(resolve) {-    resolvePromise = resolve;-  });+  /**+   * Subscribe to the cancel signal+   */ -  var token = this;--  // eslint-disable-next-line func-names-  this.promise.then(function(cancel) {-    if (!token._listeners) return;--    var i = token._listeners.length;--    while (i-- > 0) {-      token._listeners[i](cancel);-    }-    token._listeners = null;-  });--  // eslint-disable-next-line func-names-  this.promise.then = function(onfulfilled) {-    var _resolve;-    // eslint-disable-next-line func-names-    var promise = new Promise(function(resolve) {-      token.subscribe(resolve);-      _resolve = resolve;-    }).then(onfulfilled);--    promise.cancel = function reject() {-      token.unsubscribe(_resolve);-    };--    return promise;-  };--  executor(function cancel(message, config, request) {-    if (token.reason) {-      // Cancellation has already been requested+  subscribe(listener) {+    if (this.reason) {+      listener(this.reason);       return;@@ -57,62 +83,53 @@ -    token.reason = new CanceledError(message, config, request);-    resolvePromise(token.reason);-  });+    if (this._listeners) {+      this._listeners.push(listener);+    } else {+      this._listeners = [listener];+    }+  }++  /**+   * Unsubscribe from the cancel signal+   */++  unsubscribe(listener) {+    if (!this._listeners) {+      return;+    }+    const index = this._listeners.indexOf(listener);+    if (index !== -1) {+      this._listeners.splice(index, 1);+    }+  }++  toAbortSignal() {+    const controller = new AbortController();++    const abort = (err) => {+      controller.abort(err);+    };++    this.subscribe(abort);++    controller.signal.unsubscribe = () => this.unsubscribe(abort);++    return controller.signal;+  }++  /**+   * Returns an object that contains a new `CancelToken` and a function that, when called,+   * cancels the `CancelToken`.+   */+  static source() {+    let cancel;+    const token = new CancelToken(function executor(c) {+      cancel = c;+    });+    return {+      token,+      cancel,+    };+  } } -/**- * Throws a `CanceledError` if cancellation has been requested.- */-CancelToken.prototype.throwIfRequested = function throwIfRequested() {-  if (this.reason) {-    throw this.reason;-  }-};--/**- * Subscribe to the cancel signal- */--CancelToken.prototype.subscribe = function subscribe(listener) {-  if (this.reason) {-    listener(this.reason);-    return;-  }--  if (this._listeners) {-    this._listeners.push(listener);-  } else {-    this._listeners = [listener];-  }-};--/**- * Unsubscribe from the cancel signal- */--CancelToken.prototype.unsubscribe = function unsubscribe(listener) {-  if (!this._listeners) {-    return;-  }-  var index = this._listeners.indexOf(listener);-  if (index !== -1) {-    this._listeners.splice(index, 1);-  }-};--/**- * Returns an object that contains a new `CancelToken` and a function that, when called,- * cancels the `CancelToken`.- */-CancelToken.source = function source() {-  var cancel;-  var token = new CancelToken(function executor(c) {-    cancel = c;-  });-  return {-    token: token,-    cancel: cancel-  };-};--module.exports = CancelToken;+export default CancelToken;

--- +++ @@ -2,23 +2,21 @@ -var AxiosError = require('../core/AxiosError');-var utils = require('../utils');+import AxiosError from '../core/AxiosError.js'; -/**- * A `CanceledError` is an object that is thrown when an operation is canceled.- *- * @class- * @param {string=} message The message.- * @param {Object=} config The config.- * @param {Object=} request The request.- */-function CanceledError(message, config, request) {-  // eslint-disable-next-line no-eq-null,eqeqeq-  AxiosError.call(this, message == null ? 'canceled' : message, AxiosError.ERR_CANCELED, config, request);-  this.name = 'CanceledError';+class CanceledError extends AxiosError {+  /**+   * A `CanceledError` is an object that is thrown when an operation is canceled.+   *+   * @param {string=} message The message.+   * @param {Object=} config The config.+   * @param {Object=} request The request.+   *+   * @returns {CanceledError} The created error.+   */+  constructor(message, config, request) {+    super(message == null ? 'canceled' : message, AxiosError.ERR_CANCELED, config, request);+    this.name = 'CanceledError';+    this.__CANCEL__ = true;+  } } -utils.inherits(CanceledError, AxiosError, {-  __CANCEL__: true-});--module.exports = CanceledError;+export default CanceledError;

--- +++ @@ -2,4 +2,4 @@ -module.exports = function isCancel(value) {+export default function isCancel(value) {   return !!(value && value.__CANCEL__);-};+}

--- +++ @@ -2,11 +2,14 @@ -var utils = require('./../utils');-var buildURL = require('../helpers/buildURL');-var InterceptorManager = require('./InterceptorManager');-var dispatchRequest = require('./dispatchRequest');-var mergeConfig = require('./mergeConfig');-var buildFullPath = require('./buildFullPath');-var validator = require('../helpers/validator');--var validators = validator.validators;+import utils from '../utils.js';+import buildURL from '../helpers/buildURL.js';+import InterceptorManager from './InterceptorManager.js';+import dispatchRequest from './dispatchRequest.js';+import mergeConfig from './mergeConfig.js';+import buildFullPath from './buildFullPath.js';+import validator from '../helpers/validator.js';+import AxiosHeaders from './AxiosHeaders.js';+import transitionalDefaults from '../defaults/transitional.js';++const validators = validator.validators;+ /**@@ -15,128 +18,224 @@  * @param {Object} instanceConfig The default config for the instance+ *+ * @return {Axios} A new instance of Axios  */-function Axios(instanceConfig) {-  this.defaults = instanceConfig;-  this.interceptors = {-    request: new InterceptorManager(),-    response: new InterceptorManager()-  };+class Axios {+  constructor(instanceConfig) {+    this.defaults = instanceConfig || {};+    this.interceptors = {+      request: new InterceptorManager(),+      response: new InterceptorManager(),+    };+  }++  /**+   * Dispatch a request+   *+   * @param {String|Object} configOrUrl The config specific for this request (merged with this.defaults)+   * @param {?Object} config+   *+   * @returns {Promise} The Promise to be fulfilled+   */+  async request(configOrUrl, config) {+    try {+      return await this._request(configOrUrl, config);+    } catch (err) {+      if (err instanceof Error) {+        let dummy = {};++        Error.captureStackTrace ? Error.captureStackTrace(dummy) : (dummy = new Error());++        // slice off the Error: ... line+        const stack = (() => {+          if (!dummy.stack) {+            return '';+          }++          const firstNewlineIndex = dummy.stack.indexOf('\n');++          return firstNewlineIndex === -1 ? '' : dummy.stack.slice(firstNewlineIndex + 1);+        })();+        try {+          if (!err.stack) {+            err.stack = stack;+            // match without the 2 top stack lines+          } else if (stack) {+            const firstNewlineIndex = stack.indexOf('\n');+            const secondNewlineIndex =+              firstNewlineIndex === -1 ? -1 : stack.indexOf('\n', firstNewlineIndex + 1);+            const stackWithoutTwoTopLines =+              secondNewlineIndex === -1 ? '' : stack.slice(secondNewlineIndex + 1);++            if (!String(err.stack).endsWith(stackWithoutTwoTopLines)) {+              err.stack += '\n' + stack;+            }+          }+        } catch (e) {+          // ignore the case where "stack" is an un-writable property+        }+      }++      throw err;+    }+  }++  _request(configOrUrl, config) {+    /*eslint no-param-reassign:0*/+    // Allow for axios('example/url'[, config]) a la fetch API+    if (typeof configOrUrl === 'string') {+      config = config || {};+      config.url = configOrUrl;+    } else {+      config = configOrUrl || {};+    }++    config = mergeConfig(this.defaults, config);++    const { transitional, paramsSerializer, headers } = config;++    if (transitional !== undefined) {+      validator.assertOptions(+        transitional,+        {+          silentJSONParsing: validators.transitional(validators.boolean),+          forcedJSONParsing: validators.transitional(validators.boolean),+          clarifyTimeoutError: validators.transitional(validators.boolean),+          legacyInterceptorReqResOrdering: validators.transitional(validators.boolean),+          advertiseZstdAcceptEncoding: validators.transitional(validators.boolean),+          validateStatusUndefinedResolves: validators.transitional(validators.boolean),+        },+        false+      );+    }++    if (paramsSerializer != null) {+      if (utils.isFunction(paramsSerializer)) {+        config.paramsSerializer = {+          serialize: paramsSerializer,+        };+      } else {+        validator.assertOptions(+          paramsSerializer,+          {+            encode: validators.function,+            serialize: validators.function,+          },+          true+        );+      }+    }++    // Set config.allowAbsoluteUrls+    if (config.allowAbsoluteUrls !== undefined) {+      // do nothing+    } else if (this.defaults.allowAbsoluteUrls !== undefined) {+      config.allowAbsoluteUrls = this.defaults.allowAbsoluteUrls;+    } else {+      config.allowAbsoluteUrls = true;+    }++    validator.assertOptions(+      config,+      {+        baseUrl: validators.spelling('baseURL'),+        withXsrfToken: validators.spelling('withXSRFToken'),+      },+      true+    );++    // Set config.method+    config.method = (config.method || this.defaults.method || 'get').toLowerCase();++    // Flatten headers+    let contextHeaders = headers && utils.merge(headers.common, headers[config.method]);++    headers &&+      utils.forEach(['delete', 'get', 'head', 'post', 'put', 'patch', 'query', 'common'], (method) => {+        delete headers[method];+      });++    config.headers = AxiosHeaders.concat(contextHeaders, headers);++    // filter out skipped interceptors+    const requestInterceptorChain = [];+    let synchronousRequestInterceptors = true;+    this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {+      if (typeof interceptor.runWhen === 'function' && interceptor.runWhen(config) === false) {+        return;+      }++      synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;++      const transitional = config.transitional || transitionalDefaults;+      const legacyInterceptorReqResOrdering =+        transitional && transitional.legacyInterceptorReqResOrdering;++      if (legacyInterceptorReqResOrdering) {+        requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);+      } else {+        requestInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);+      }+    });++    const responseInterceptorChain = [];+    this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {+      responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);+    });++    let promise;+    let i = 0;+    let len;++    if (!synchronousRequestInterceptors) {+      const chain = [dispatchRequest.bind(this), undefined];+      chain.unshift(...requestInterceptorChain);+      chain.push(...responseInterceptorChain);+      len = chain.length;++      promise = Promise.resolve(config);++      while (i < len) {+        promise = promise.then(chain[i++], chain[i++]);+      }++      return promise;+    }++    len = requestInterceptorChain.length;++    let newConfig = config;++    while (i < len) {+      const onFulfilled = requestInterceptorChain[i++];+      const onRejected = requestInterceptorChain[i++];+      try {+        newConfig = onFulfilled(newConfig);+      } catch (error) {+        onRejected.call(this, error);+        break;+      }+    }++    try {+      promise = dispatchRequest.call(this, newConfig);+    } catch (error) {+      return Promise.reject(error);+    }++    i = 0;+    len = responseInterceptorChain.length;++    while (i < len) {+      promise = promise.then(responseInterceptorChain[i++], responseInterceptorChain[i++]);+    }++    return promise;+  }+

--- +++ @@ -2,108 +2,139 @@ -var utils = require('../utils');-var DEFAULT_REDACT_KEYS = require('../helpers/defaultRedactKeys');+import utils from '../utils.js';+import AxiosHeaders from './AxiosHeaders.js'; -var REDACTED_VALUE = '[REDACTED ****]';+const REDACTED = '[REDACTED ****]'; -function makeValueDescriptor(value) {-  var descriptor = Object.create(null);-  descriptor.value = value;-  return descriptor;+function hasOwnOrPrototypeToJSON(source) {+  if (utils.hasOwnProp(source, 'toJSON')) {+    return true;+  }++  let prototype = Object.getPrototypeOf(source);++  while (prototype && prototype !== Object.prototype) {+    if (utils.hasOwnProp(prototype, 'toJSON')) {+      return true;+    }++    prototype = Object.getPrototypeOf(prototype);+  }++  return false; } -function getRedactKeys(config) {-  // An empty array is treated as "no override" so an upstream `redact: []` cannot-  // silently disable redaction. To opt out, pass non-string values or unset keys.-  var override = config && utils.isArray(config.redact) && config.redact.length ? config.redact : null;-  var redact = override || DEFAULT_REDACT_KEYS;-  var keys = {};+// Build a plain-object snapshot of `config` and replace the value of any key+// (case-insensitive) listed in `redactKeys` with REDACTED. Walks through arrays+// and AxiosHeaders, and short-circuits on circular references.+function redactConfig(config, redactKeys) {+  const lowerKeys = new Set(redactKeys.map((k) => String(k).toLowerCase()));+  const seen = []; -  utils.forEach(redact, function eachRedactKey(key) {-    if (typeof key === 'string') {-      keys[key.toLowerCase()] = true;+  const visit = (source) => {+    if (source === null || typeof source !== 'object') return source;+    if (utils.isBuffer(source)) return source;+    if (seen.indexOf(source) !== -1) return undefined;++    if (source instanceof AxiosHeaders) {+      source = source.toJSON();     }-  }); -  return keys;+    seen.push(source);++    let result;+    if (utils.isArray(source)) {+      result = [];+      source.forEach((v, i) => {+        const reducedValue = visit(v);+        if (!utils.isUndefined(reducedValue)) {+          result[i] = reducedValue;+        }+      });+    } else {+      if (!utils.isPlainObject(source) && hasOwnOrPrototypeToJSON(source)) {+        seen.pop();+        return source;+      }++      result = Object.create(null);+      for (const [key, value] of Object.entries(source)) {+        const reducedValue = lowerKeys.has(key.toLowerCase()) ? REDACTED : visit(value);+        if (!utils.isUndefined(reducedValue)) {+          result[key] = reducedValue;+        }+      }+    }++    seen.pop();+    return result;+  };++  return visit(config); } -function shouldRedact(key, keys) {-  return typeof key === 'string' && keys[key.toLowerCase()];-}+class AxiosError extends Error {+  static from(error, code, config, request, response, customProps) {+    const axiosError = new AxiosError(error.message, code || error.code, config, request, response);+    axiosError.cause = error;+    axiosError.name = error.name; -var CIRCULAR_VALUE = '[Circular]';+    // Preserve status from the original error if not already set from response+    if (error.status != null && axiosError.status == null) {+      axiosError.status = error.status;+    } -function serializeConfigValue(value, keys, key, seen) {-  var result;--  if (shouldRedact(key, keys)) {-    return REDACTED_VALUE;+    customProps && Object.assign(axiosError, customProps);+    return axiosError;   } -  if (utils.isArray(value)) {-    if (seen.indexOf(value) !== -1) {-      return CIRCULAR_VALUE;+  /**+   * Create an Error with the specified message, config, error code, request and response.+   *+   * @param {string} message The error message.+   * @param {string} [code] The error code (for example, 'ECONNABORTED').+   * @param {Object} [config] The config.+   * @param {Object} [request] The request.+   * @param {Object} [response] The response.+   *+   * @returns {Error} The created error.+   */+  constructor(message, code, config, request, response) {+    super(message);++    // Make message enumerable to maintain backward compatibility+    // The native Error constructor sets message as non-enumerable,+    // but axios < v1.13.3 had it as enumerable+    Object.defineProperty(this, 'message', {+      // Null-proto descriptor so a polluted Object.prototype.get cannot turn+      // this data descriptor into an accessor descriptor on the way in.+      __proto__: null,+      value: message,+      enumerable: true,+      writable: true,+      configurable: true,+    });++    this.name = 'AxiosError';+    this.isAxiosError = true;+    code && (this.code = code);+    config && (this.config = config);+    request && (this.request = request);+    if (response) {+      this.response = response;+      this.status = response.status;     }-    seen.push(value);-    result = [];-    utils.forEach(value, function eachArrayValue(item, index) {-      result[index] = serializeConfigValue(item, keys, index, seen);-    });-    seen.pop();-    return result;   } -  if (utils.isPlainObject(value)) {-    if (seen.indexOf(value) !== -1) {-      return CIRCULAR_VALUE;-    }-    seen.push(value);-    result = {};-    utils.forEach(value, function eachObjectValue(item, itemKey) {-      result[itemKey] = serializeConfigValue(item, keys, itemKey, seen);-    });-    seen.pop();-    return result;-  }+  toJSON() {+    // Opt-in redaction: when the request config carries a `redact` array, the+    // value of any matching key (case-insensitive, at any depth) is replaced+    // with REDACTED in the serialized snapshot. Undefined or empty leaves the+    // existing serialization behavior unchanged.+    const config = this.config;+    const redactKeys = config && utils.hasOwnProp(config, 'redact') ? config.redact : undefined;+    const serializedConfig =+      utils.isArray(redactKeys) && redactKeys.length > 0+        ? redactConfig(config, redactKeys)+        : utils.toJSONObject(config); -  return value;-}--function serializeConfig(config) {-  if (!config) {-    return config;-  }--  return serializeConfigValue(config, getRedactKeys(config), undefined, []);-}--/**- * Create an Error with the specified message, config, error code, request and response.- *- * @param {string} message The error message.- * @param {string} [code] The error code (for example, 'ECONNABORTED').- * @param {Object} [config] The config.- * @param {Object} [request] The request.- * @param {Object} [response] The response.- * @returns {Error} The created error.- */-function AxiosError(message, code, config, request, response) {-  Error.call(this);--  if (Error.captureStackTrace) {-    Error.captureStackTrace(this, this.constructor);-  } else {-    this.stack = (new Error()).stack;-  }--  this.message = message;-  this.name = 'AxiosError';-  code && (this.code = code);-  config && (this.config = config);-  request && (this.request = request);-  response && (this.response = response);-}--utils.inherits(AxiosError, Error, {-  toJSON: function toJSON() {     return {@@ -121,53 +152,25 @@       // Axios-      config: serializeConfig(this.config),+      config: serializedConfig,       code: this.code,-      status: this.response && this.response.status ? this.response.status : null+      status: this.status,     };   }-});+} -var prototype = AxiosError.prototype;-var descriptors = Object.create(null);+// This can be changed to static properties as soon as the parser options in .eslint.cjs are updated.+AxiosError.ERR_BAD_OPTION_VALUE = 'ERR_BAD_OPTION_VALUE';+AxiosError.ERR_BAD_OPTION = 'ERR_BAD_OPTION';+AxiosError.ECONNABORTED = 'ECONNABORTED';+AxiosError.ETIMEDOUT = 'ETIMEDOUT';

--- +++ @@ -2,62 +2,71 @@ -var utils = require('./../utils');+import utils from '../utils.js'; -function InterceptorManager() {-  this.handlers = [];+class InterceptorManager {+  constructor() {+    this.handlers = [];+  }++  /**+   * Add a new interceptor to the stack+   *+   * @param {Function} fulfilled The function to handle `then` for a `Promise`+   * @param {Function} rejected The function to handle `reject` for a `Promise`+   * @param {Object} options The options for the interceptor, synchronous and runWhen+   *+   * @return {Number} An ID used to remove interceptor later+   */+  use(fulfilled, rejected, options) {+    this.handlers.push({+      fulfilled,+      rejected,+      synchronous: options ? options.synchronous : false,+      runWhen: options ? options.runWhen : null,+    });+    return this.handlers.length - 1;+  }++  /**+   * Remove an interceptor from the stack+   *+   * @param {Number} id The ID that was returned by `use`+   *+   * @returns {void}+   */+  eject(id) {+    if (this.handlers[id]) {+      this.handlers[id] = null;+    }+  }++  /**+   * Clear all interceptors from the stack+   *+   * @returns {void}+   */+  clear() {+    if (this.handlers) {+      this.handlers = [];+    }+  }++  /**+   * Iterate over all the registered interceptors+   *+   * This method is particularly useful for skipping over any+   * interceptors that may have become `null` calling `eject`.+   *+   * @param {Function} fn The function to call for each interceptor+   *+   * @returns {void}+   */+  forEach(fn) {+    utils.forEach(this.handlers, function forEachHandler(h) {+      if (h !== null) {+        fn(h);+      }+    });+  } } -/**- * Add a new interceptor to the stack- *- * @param {Function} fulfilled The function to handle `then` for a `Promise`- * @param {Function} rejected The function to handle `reject` for a `Promise`- *- * @return {Number} An ID used to remove interceptor later- */-InterceptorManager.prototype.use = function use(fulfilled, rejected, options) {-  this.handlers.push({-    fulfilled: fulfilled,-    rejected: rejected,-    synchronous: options ? options.synchronous : false,-    runWhen: options ? options.runWhen : null-  });-  return this.handlers.length - 1;-};--/**- * Remove an interceptor from the stack- *- * @param {Number} id The ID that was returned by `use`- */-InterceptorManager.prototype.eject = function eject(id) {-  if (this.handlers[id]) {-    this.handlers[id] = null;-  }-};--/**- * Clear all interceptors from the stack- */-InterceptorManager.prototype.clear = function clear() {-  if (this.handlers) {-    this.handlers = [];-  }-};--/**- * Iterate over all the registered interceptors- *- * This method is particularly useful for skipping over any- * interceptors that may have become `null` calling `eject`.- *- * @param {Function} fn The function to call for each interceptor- */-InterceptorManager.prototype.forEach = function forEach(fn) {-  utils.forEach(this.handlers, function forEachHandler(h) {-    if (h !== null) {-      fn(h);-    }-  });-};--module.exports = InterceptorManager;+export default InterceptorManager;

--- +++ @@ -2,4 +2,30 @@ -var isAbsoluteURL = require('../helpers/isAbsoluteURL');-var combineURLs = require('../helpers/combineURLs');+import AxiosError from './AxiosError.js';+import isAbsoluteURL from '../helpers/isAbsoluteURL.js';+import combineURLs from '../helpers/combineURLs.js';++const malformedHttpProtocol = /^https?:(?!\/\/)/i;+const httpProtocolControlCharacters = /[\t\n\r]/g;++function stripLeadingC0ControlOrSpace(url) {+  let i = 0;+  while (i < url.length && url.charCodeAt(i) <= 0x20) {+    i++;+  }+  return url.slice(i);+}++function normalizeURLForProtocolCheck(url) {+  return stripLeadingC0ControlOrSpace(url).replace(httpProtocolControlCharacters, '');+}++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+    );+  }+} @@ -12,3 +38,2 @@  * @param {string} requestedURL Absolute or relative URL to combine- * @param {boolean} allowAbsoluteUrls Set to true to allow absolute URLs  *@@ -16,5 +41,7 @@  */-module.exports = function buildFullPath(baseURL, requestedURL, allowAbsoluteUrls) {-  var isRelativeURL = !isAbsoluteURL(requestedURL);-  if (baseURL && (isRelativeURL || allowAbsoluteUrls === false)) {+export default function buildFullPath(baseURL, requestedURL, allowAbsoluteUrls, config) {+  assertValidHttpProtocolURL(requestedURL, config);+  let isRelativeUrl = !isAbsoluteURL(requestedURL);+  if (baseURL && (isRelativeUrl || allowAbsoluteUrls === false)) {+    assertValidHttpProtocolURL(baseURL, config);     return combineURLs(baseURL, requestedURL);@@ -22,2 +49,2 @@   return requestedURL;-};+}

--- +++ @@ -2,9 +2,8 @@ -var utils = require('./../utils');-var transformData = require('./transformData');-var isCancel = require('../cancel/isCancel');-var defaults = require('../defaults');-var CanceledError = require('../cancel/CanceledError');-var normalizeHeaderName = require('../helpers/normalizeHeaderName');-var sanitizeHeaderValue = require('../helpers/sanitizeHeaderValue');+import transformData from './transformData.js';+import isCancel from '../cancel/isCancel.js';+import defaults from '../defaults/index.js';+import CanceledError from '../cancel/CanceledError.js';+import AxiosHeaders from '../core/AxiosHeaders.js';+import adapters from '../adapters/adapters.js'; @@ -12,2 +11,6 @@  * Throws a `CanceledError` if cancellation has been requested.+ *+ * @param {Object} config The config that is to be used for the request+ *+ * @returns {void}  */@@ -19,3 +22,3 @@   if (config.signal && config.signal.aborted) {-    throw new CanceledError();+    throw new CanceledError(null, config);   }@@ -27,78 +30,60 @@  * @param {object} config The config that is to be used for the request+ *  * @returns {Promise} The Promise to be fulfilled  */-module.exports = function dispatchRequest(config) {+export default function dispatchRequest(config) {   throwIfCancellationRequested(config); -  // Ensure headers exist-  config.headers = config.headers || {};+  config.headers = AxiosHeaders.from(config.headers);    // Transform request data-  config.data = transformData.call(-    config,-    config.data,-    config.headers,-    null,-    config.transformRequest-  );+  config.data = transformData.call(config, config.transformRequest); -  normalizeHeaderName(config.headers, 'Accept');-  normalizeHeaderName(config.headers, 'Content-Type');+  if (['post', 'put', 'patch'].indexOf(config.method) !== -1) {+    config.headers.setContentType('application/x-www-form-urlencoded', false);+  } -  // Flatten headers-  var commonHeaders = utils.hasOwnProperty(config.headers, 'common') && config.headers.common-    ? config.headers.common-    : {};-  var methodHeaders = config.method &&-    utils.hasOwnProperty(config.headers, config.method) &&-    config.headers[config.method]-    ? config.headers[config.method]-    : {};+  const adapter = adapters.getAdapter(config.adapter || defaults.adapter, config); -  config.headers = utils.merge(commonHeaders, methodHeaders, config.headers);+  return adapter(config).then(+    function onAdapterResolution(response) {+      throwIfCancellationRequested(config); -  utils.forEach(-    ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],-    function cleanHeaderConfig(method) {-      delete config.headers[method];+      // Expose the current response on config so that transformResponse can+      // attach it to any AxiosError it throws (e.g. on JSON parse failure).+      // We clean it up afterwards to avoid polluting the config object.+      config.response = response;+      try {+        response.data = transformData.call(config, config.transformResponse, response);+      } finally {+        delete config.response;+      }++      response.headers = AxiosHeaders.from(response.headers);++      return response;+    },+    function onAdapterRejection(reason) {+      if (!isCancel(reason)) {+        throwIfCancellationRequested(config);++        // Transform response data+        if (reason && reason.response) {+          config.response = reason.response;+          try {+            reason.response.data = transformData.call(+              config,+              config.transformResponse,+              reason.response+            );+          } finally {+            delete config.response;+          }+          reason.response.headers = AxiosHeaders.from(reason.response.headers);+        }+      }++      return Promise.reject(reason);     }   );--  utils.forEach(config.headers, function sanitizeHeaderConfigValue(value, header) {-    config.headers[header] = sanitizeHeaderValue(value);-  });--  var adapter = config.adapter || defaults.adapter;--  return adapter(config).then(function onAdapterResolution(response) {-    throwIfCancellationRequested(config);--    // Transform response data-    response.data = transformData.call(-      config,-      response.data,-      response.headers,-      response.status,-      config.transformResponse-    );--    return response;-  }, function onAdapterRejection(reason) {-    if (!isCancel(reason)) {-      throwIfCancellationRequested(config);--      // Transform response data-      if (reason && reason.response) {-        reason.response.data = transformData.call(-          config,-          reason.response.data,-          reason.response.headers,-          reason.response.status,-          config.transformResponse-        );-      }-    }--    return Promise.reject(reason);-  });-};+}

--- +++ @@ -2,3 +2,6 @@ -var utils = require('../utils');+import utils from '../utils.js';+import AxiosHeaders from './AxiosHeaders.js';++const headersToObject = (thing) => (thing instanceof AxiosHeaders ? { ...thing } : thing); @@ -10,24 +13,27 @@  * @param {Object} config2+ *  * @returns {Object} New object resulting from merging config2 to config1  */-module.exports = function mergeConfig(config1, config2) {+export default function mergeConfig(config1, config2) {   // eslint-disable-next-line no-param-reassign   config2 = config2 || {};-  // Use a null-prototype object so a polluted Object.prototype cannot leak-  // values (e.g. transport, adapter) into the returned config via inheritance.-  var config = Object.create(null); -  function getOwn(source, prop) {-    return utils.hasOwnProperty(source, prop) ? source[prop] : undefined;-  }+  // Use a null-prototype object so that downstream reads such as `config.auth`+  // or `config.baseURL` cannot inherit polluted values from Object.prototype.+  // `hasOwnProperty` is restored as a non-enumerable own slot to preserve+  // ergonomics for user code that relies on it.+  const config = Object.create(null);+  Object.defineProperty(config, 'hasOwnProperty', {+    // Null-proto descriptor so a polluted Object.prototype.get cannot turn+    // this data descriptor into an accessor descriptor on the way in.+    __proto__: null,+    value: Object.prototype.hasOwnProperty,+    enumerable: false,+    writable: true,+    configurable: true,+  }); -  function hasOwn(source, prop) {-    return utils.hasOwnProperty(source, prop);-  }--  function getMergedValue(target, source) {+  function getMergedValue(target, source, prop, caseless) {     if (utils.isPlainObject(target) && utils.isPlainObject(source)) {-      return utils.merge(target, source);-    } else if (utils.isEmptyObject(source)) {-      return utils.merge({}, target);+      return utils.merge.call({ caseless }, target, source);     } else if (utils.isPlainObject(source)) {@@ -40,8 +46,7 @@ -  // eslint-disable-next-line consistent-return-  function mergeDeepProperties(prop) {-    if (hasOwn(config2, prop) && !utils.isUndefined(config2[prop])) {-      return getMergedValue(getOwn(config1, prop), config2[prop]);-    } else if (hasOwn(config1, prop) && !utils.isUndefined(config1[prop])) {-      return getMergedValue(undefined, config1[prop]);+  function mergeDeepProperties(a, b, prop, caseless) {+    if (!utils.isUndefined(b)) {+      return getMergedValue(a, b, prop, caseless);+    } else if (!utils.isUndefined(a)) {+      return getMergedValue(undefined, a, prop, caseless);     }@@ -50,5 +55,5 @@   // eslint-disable-next-line consistent-return-  function valueFromConfig2(prop) {-    if (hasOwn(config2, prop) && !utils.isUndefined(config2[prop])) {-      return getMergedValue(undefined, config2[prop]);+  function valueFromConfig2(a, b) {+    if (!utils.isUndefined(b)) {+      return getMergedValue(undefined, b);     }@@ -57,7 +62,7 @@   // eslint-disable-next-line consistent-return-  function defaultToConfig2(prop) {-    if (hasOwn(config2, prop) && !utils.isUndefined(config2[prop])) {-      return getMergedValue(undefined, config2[prop]);-    } else if (hasOwn(config1, prop) && !utils.isUndefined(config1[prop])) {-      return getMergedValue(undefined, config1[prop]);+  function defaultToConfig2(a, b) {+    if (!utils.isUndefined(b)) {+      return getMergedValue(undefined, b);+    } else if (!utils.isUndefined(a)) {+      return getMergedValue(undefined, a);     }@@ -65,8 +70,30 @@ +  function getMergedTransitionalOption(prop) {+    const transitional2 = utils.hasOwnProp(config2, 'transitional') ? config2.transitional : undefined;++    if (!utils.isUndefined(transitional2)) {+      if (utils.isPlainObject(transitional2)) {+        if (utils.hasOwnProp(transitional2, prop)) {+          return transitional2[prop];+        }+      } else {+        return undefined;+      }+    }++    const transitional1 = utils.hasOwnProp(config1, 'transitional') ? config1.transitional : undefined;++    if (utils.isPlainObject(transitional1) && utils.hasOwnProp(transitional1, prop)) {+      return transitional1[prop];+    }++    return undefined;+  }+   // eslint-disable-next-line consistent-return-  function mergeDirectKeys(prop) {-    if (hasOwn(config2, prop)) {-      return getMergedValue(getOwn(config1, prop), config2[prop]);-    } else if (hasOwn(config1, prop)) {-      return getMergedValue(undefined, config1[prop]);+  function mergeDirectKeys(a, b, prop) {+    if (utils.hasOwnProp(config2, prop)) {+      return getMergedValue(a, b);+    } else if (utils.hasOwnProp(config1, prop)) {+      return getMergedValue(undefined, a);     }@@ -74,40 +101,42 @@ -  var mergeMap = {-    'url': valueFromConfig2,-    'method': valueFromConfig2,-    'data': valueFromConfig2,-    'baseURL': defaultToConfig2,-    'transformRequest': defaultToConfig2,-    'transformResponse': defaultToConfig2,-    'paramsSerializer': defaultToConfig2,-    'timeout': defaultToConfig2,-    'timeoutMessage': defaultToConfig2,-    'withCredentials': defaultToConfig2,-    'withXSRFToken': defaultToConfig2,-    'adapter': defaultToConfig2,-    'responseType': defaultToConfig2,-    'xsrfCookieName': defaultToConfig2,-    'xsrfHeaderName': defaultToConfig2,-    'onUploadProgress': defaultToConfig2,-    'onDownloadProgress': defaultToConfig2,-    'decompress': defaultToConfig2,-    'maxContentLength': defaultToConfig2,-    'maxBodyLength': defaultToConfig2,-    'beforeRedirect': defaultToConfig2,-    'transport': defaultToConfig2,-    'httpAgent': defaultToConfig2,-    'httpsAgent': defaultToConfig2,-    'cancelToken': defaultToConfig2,-    'socketPath': defaultToConfig2,-    'allowedSocketPaths': defaultToConfig2,-    'responseEncoding': defaultToConfig2,-    'validateStatus': mergeDirectKeys+  const mergeMap = {+    url: valueFromConfig2,+    method: valueFromConfig2,+    data: valueFromConfig2,+    baseURL: defaultToConfig2,+    transformRequest: defaultToConfig2,+    transformResponse: defaultToConfig2,+    paramsSerializer: defaultToConfig2,+    timeout: defaultToConfig2,+    timeoutMessage: defaultToConfig2,+    withCredentials: defaultToConfig2,+    withXSRFToken: defaultToConfig2,+    adapter: defaultToConfig2,+    responseType: defaultToConfig2,+    xsrfCookieName: defaultToConfig2,+    xsrfHeaderName: defaultToConfig2,+    onUploadProgress: defaultToConfig2,+    onDownloadProgress: defaultToConfig2,+    decompress: defaultToConfig2,+    maxContentLength: defaultToConfig2,+    maxBodyLength: defaultToConfig2,+    beforeRedirect: defaultToConfig2,+    transport: defaultToConfig2,+    httpAgent: defaultToConfig2,+    httpsAgent: defaultToConfig2,+    cancelToken: defaultToConfig2,+    socketPath: defaultToConfig2,+    allowedSocketPaths: defaultToConfig2,+    responseEncoding: defaultToConfig2,+    validateStatus: mergeDirectKeys,+    headers: (a, b, prop) =>+      mergeDeepProperties(headersToObject(a), headersToObject(b), prop, true),   }; -  utils.forEach(Object.keys(config1).concat(Object.keys(config2)), function computeConfigValue(prop) {-    if (prop === '__proto__' || prop === 'constructor' || prop === 'prototype') {-      return;-    }-    var merge = utils.hasOwnProperty(mergeMap, prop) ? mergeMap[prop] : mergeDeepProperties;-    var configValue = merge(prop);+  utils.forEach(Object.keys({ ...config1, ...config2 }), function computeConfigValue(prop) {+    if (prop === '__proto__' || prop === 'constructor' || prop === 'prototype') return;+    const merge = utils.hasOwnProp(mergeMap, prop) ? mergeMap[prop] : mergeDeepProperties;+    const a = utils.hasOwnProp(config1, prop) ? config1[prop] : undefined;+    const b = utils.hasOwnProp(config2, prop) ? config2[prop] : undefined;+    const configValue = merge(a, b, prop);     (utils.isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue);@@ -115,3 +144,15 @@ +  if (+    utils.hasOwnProp(config2, 'validateStatus') &&+    utils.isUndefined(config2.validateStatus) &&+    getMergedTransitionalOption('validateStatusUndefinedResolves') === false+  ) {+    if (utils.hasOwnProp(config1, 'validateStatus')) {+      config.validateStatus = getMergedValue(undefined, config1.validateStatus);+    } else {+      delete config.validateStatus;+    }+  }+   return config;-};+}

--- +++ @@ -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",

--- +++ @@ -12,2 +12,3 @@ const { upperCaseFirst } = require("../shared/string-utils");+const { isAnySegmentReachable } = require("./utils/code-path-utils"); @@ -16,17 +17,2 @@ //--------------------------------------------------------------------------------/**- * Checks all segments in a set and returns true if all are unreachable.- * @param {Set<CodePathSegment>} segments The segments to check.- * @returns {boolean} True if all segments are unreachable; false otherwise.- */-function areAllSegmentsUnreachable(segments) {-	for (const segment of segments) {-		if (segment.reachable) {-			return false;-		}-	}--	return true;-} @@ -102,3 +88,3 @@ 				!funcInfo.hasReturnValue ||-				areAllSegmentsUnreachable(funcInfo.currentSegments) ||+				!isAnySegmentReachable(funcInfo.currentSegments) || 				astUtils.isES5Constructor(node) ||

--- +++ @@ -12,2 +12,3 @@ const astUtils = require("./utils/ast-utils");+const { isAnySegmentReachable } = require("./utils/code-path-utils"); @@ -18,17 +19,2 @@ const TARGET_NODE_TYPE = /^(?:Arrow)?FunctionExpression$/u;--/**- * Checks all segments in a set and returns true if any are reachable.- * @param {Set<CodePathSegment>} segments The segments to check.- * @returns {boolean} True if any segment is reachable; false otherwise.- */-function isAnySegmentReachable(segments) {-	for (const segment of segments) {-		if (segment.reachable) {-			return true;-		}-	}--	return false;-} 

--- +++ @@ -56,2 +56,4 @@ 	create(context) {+		const sourceCode = context.sourceCode;+ 		//--------------------------------------------------------------------------@@ -104,2 +106,3 @@ 					node,+					loc: sourceCode.getFirstToken(node).loc, 					messageId: "tooDeeply",@@ -119,2 +122,14 @@ +		/**+		 * Checks whether a node is an else-if statement.+		 * @param {ASTNode} node node to evaluate+		 * @returns {boolean} Whether the node is an else-if statement+		 */+		function isElseIf(node) {+			return (+				node.parent.type === "IfStatement" &&+				node.parent.alternate === node+			);+		}+ 		//--------------------------------------------------------------------------@@ -131,3 +146,3 @@ 			IfStatement(node) {-				if (node.parent.type !== "IfStatement") {+				if (!isElseIf(node)) { 					pushBlock(node);@@ -144,3 +159,7 @@ -			"IfStatement:exit": popBlock,+			"IfStatement:exit"(node) {+				if (!isElseIf(node)) {+					popBlock();+				}+			}, 			"SwitchStatement:exit": popBlock,

--- +++ @@ -224,2 +224,3 @@ 					node,+					loc: astUtils.getFunctionHeadLoc(funcNode, sourceCode), 					messageId: "exceed",

--- +++ @@ -6,2 +6,8 @@ "use strict";++//------------------------------------------------------------------------------+// Requirements+//------------------------------------------------------------------------------++const astUtils = require("./utils/ast-utils"); @@ -55,2 +61,4 @@ 	create(context) {+		const sourceCode = context.sourceCode;+ 		//--------------------------------------------------------------------------@@ -92,3 +100,8 @@ -				context.report({ node, messageId: "exceed", data: opts });+				context.report({+					node,+					loc: astUtils.getFunctionHeadLoc(node, sourceCode),+					messageId: "exceed",+					data: opts,+				}); 			}@@ -98,2 +111,3 @@ 		 * Pops the call stack.+		 * @param {ASTNode} node The node to check. 		 * @returns {void}@@ -101,4 +115,6 @@ 		 */-		function popStack() {-			callbackStack.pop();+		function popStack(node) {+			if (callbackStack.at(-1) === node) {+				callbackStack.pop();+			} 		}

--- +++ @@ -110,2 +110,3 @@ 					node,+					loc: astUtils.getFunctionHeadLoc(node, context.sourceCode), 					messageId: "exceed",

--- +++ @@ -11,2 +11,3 @@ const { directivesPattern } = require("../shared/directives");+const { isAnySegmentReachable } = require("./utils/code-path-utils"); @@ -17,17 +18,2 @@ const DEFAULT_FALLTHROUGH_COMMENT = /falls?\s?through/iu;--/**- * Checks all segments in a set and returns true if any are reachable.- * @param {Set<CodePathSegment>} segments The segments to check.- * @returns {boolean} True if any segment is reachable; false otherwise.- */-function isAnySegmentReachable(segments) {-	for (const segment of segments) {-		if (segment.reachable) {-			return true;-		}-	}--	return false;-} 

--- +++ @@ -6,2 +6,4 @@ "use strict";++const { isAnySegmentReachable } = require("./utils/code-path-utils"); @@ -18,17 +20,2 @@ ];--/**- * Checks all segments in a set and returns true if any are reachable.- * @param {Set<CodePathSegment>} segments The segments to check.- * @returns {boolean} True if any segment is reachable; false otherwise.- */-function isAnySegmentReachable(segments) {-	for (const segment of segments) {-		if (segment.reachable) {-			return true;-		}-	}--	return false;-} 

--- +++ @@ -5,2 +5,8 @@ "use strict";++//------------------------------------------------------------------------------+// Requirements+//------------------------------------------------------------------------------++const { isAnySegmentReachable } = require("./utils/code-path-utils"); @@ -23,17 +29,2 @@ 	return Boolean(node.init);-}--/**- * Checks all segments in a set and returns true if all are unreachable.- * @param {Set<CodePathSegment>} segments The segments to check.- * @returns {boolean} True if all segments are unreachable; false otherwise.- */-function areAllSegmentsUnreachable(segments) {-	for (const segment of segments) {-		if (segment.reachable) {-			return false;-		}-	}--	return true; }@@ -156,3 +147,3 @@ 				(node.type === "PropertyDefinition" ||-					areAllSegmentsUnreachable(currentCodePathSegments))+					!isAnySegmentReachable(currentCodePathSegments)) 			) {

--- +++ @@ -12,2 +12,3 @@ 	FixTracker = require("./utils/fix-tracker");+const { isAnySegmentReachable } = require("./utils/code-path-utils"); @@ -55,17 +56,2 @@ 		) {-			return true;-		}-	}--	return false;-}--/**- * Checks all segments in a set and returns true if any are reachable.- * @param {Set<CodePathSegment>} segments The segments to check.- * @returns {boolean} True if any segment is reachable; false otherwise.- */-function isAnySegmentReachable(segments) {-	for (const segment of segments) {-		if (segment.reachable) { 			return true;

--- +++ @@ -30,5 +30,11 @@ 	create(context) {+		const sourceCode = context.sourceCode;+ 		return { 			WithStatement(node) {-				context.report({ node, messageId: "unexpectedWith" });+				context.report({+					node,+					loc: sourceCode.getFirstToken(node).loc,+					messageId: "unexpectedWith",+				}); 			},

--- +++ @@ -0,0 +1,22 @@+/**+ * @fileoverview Code path related utilities.+ */++"use strict";++/**+ * Checks all segments in a set and returns true if any are reachable.+ * @param {Set<CodePathSegment>} segments The segments to check.+ * @returns {boolean} `true` if any segment is reachable; `false` otherwise.+ */+function isAnySegmentReachable(segments) {+	for (const segment of segments) {+		if (segment.reachable) {+			return true;+		}+	}++	return false;+}++module.exports = { isAnySegmentReachable };

--- +++ @@ -2,3 +2,3 @@   "name": "eslint",-  "version": "10.4.1",+  "version": "10.5.0",   "author": "Nicholas C. Zakas <[email protected]>",@@ -80,4 +80,11 @@     "test:pnpm": "cd tests/pnpm && node check.js && pnpm install && pnpm exec tsc",-    "test:types": "tsc -p tests/lib/types/tsconfig.json"-  },+    "test:types": "tsc -p tests/lib/types/tsconfig.json && npm run test:types --workspaces --if-present",+    "test:types:5.3": "npx -p [email protected] -y -- tsc -p tsconfig.types-legacy.json",+    "test:types:5.x": "npx -p [email protected] -y -- tsc -p tsconfig.types.json",+    "test:types:7.x": "npx -p @typescript/native-preview@latest -y -- tsgo -p tsconfig.types.json",+    "test:types:all": "npm run test:types && npm run test:types:5.3 && npm run test:types:5.x && npm run test:types:7.x"+  },+  "workspaces": [+    "packages/*"+  ],   "gitHooks": {@@ -153,3 +160,3 @@   "devDependencies": {-    "@arethetypeswrong/cli": "^0.18.0",+    "@arethetypeswrong/cli": "^0.18.3",     "@babel/core": "^7.4.3",@@ -158,3 +165,3 @@     "@eslint/eslintrc": "^3.3.5",-    "@eslint/json": "^1.2.0",+    "@eslint/json": "^2.0.0",     "@types/esquery": "^1.5.4",@@ -230,7 +237,2 @@     "node": "^20.19.0 || ^22.13.0 || >=24"-  },-  "overrides": {-    "@arethetypeswrong/core": {-      "fflate": "0.8.2"-    }   }

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

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

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

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

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

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

--- +++ @@ -2,2 +2,3 @@ +var _minimatch = require('minimatch');var _minimatch2 = _interopRequireDefault(_minimatch); var _resolve = require('eslint-module-utils/resolve');var _resolve2 = _interopRequireDefault(_resolve);@@ -17,3 +18,23 @@     checkTypeImports: { type: 'boolean' },-    ignorePackages: { type: 'boolean' } } };+    ignorePackages: { type: 'boolean' },+    pathGroupOverrides: {+      type: 'array',+      items: {+        type: 'object',+        properties: {+          pattern: {+            type: 'string' },++          patternOptions: {+            type: 'object' },++          action: {+            type: 'string',+            'enum': ['enforce', 'ignore'] } },+++        additionalProperties: false,+        required: ['pattern', 'action'] } } } };++ @@ -55,2 +76,6 @@       result.checkTypeImports = obj.checkTypeImports;+    }++    if (obj.pathGroupOverrides !== undefined) {+      result.pathGroupOverrides = obj.pathGroupOverrides;     }@@ -145,2 +170,11 @@ +      function computeOverrideAction(pathGroupOverrides, path) {+        for (var i = 0, l = pathGroupOverrides.length; i < l; i++) {var _pathGroupOverrides$i =+          pathGroupOverrides[i],pattern = _pathGroupOverrides$i.pattern,patternOptions = _pathGroupOverrides$i.patternOptions,action = _pathGroupOverrides$i.action;+          if ((0, _minimatch2['default'])(path, pattern, patternOptions || { nocomment: true })) {+            return action;+          }+        }+      }+       function checkFileExtension(source, node) {@@ -151,4 +185,14 @@ +        // If not undefined, the user decided if rules are enforced on this import+        var overrideAction = computeOverrideAction(+        props.pathGroupOverrides || [],+        importPathWithQueryString);+++        if (overrideAction === 'ignore') {+          return;+        }+         // don't enforce anything on builtins-        if ((0, _importType.isBuiltIn)(importPathWithQueryString, context.settings)) {return;}+        if (!overrideAction && (0, _importType.isBuiltIn)(importPathWithQueryString, context.settings)) {return;} @@ -158,3 +202,3 @@         // Like `import Decimal from decimal.js`)-        if (isExternalRootModule(importPath)) {return;}+        if (!overrideAction && isExternalRootModule(importPath)) {return;} @@ -176,3 +220,3 @@           if (!props.checkTypeImports && (node.importKind === 'type' || node.exportKind === 'type')) {return;}-          var extensionRequired = isUseOfExtensionRequired(extension, isPackage);+          var extensionRequired = isUseOfExtensionRequired(extension, !overrideAction && isPackage);           var extensionForbidden = isUseOfExtensionForbidden(extension);@@ -197,2 +241,2 @@     }return create;}() };-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/extensions.js"],"names":["enumValues","patternProperties","type","properties","pattern","checkTypeImports","ignorePackages","buildProperties","context","result","defaultConfig","options","forEach","obj","undefined","Object","assign","module","exports","meta","docs","category","description","url","schema","anyOf","items","additionalItems","create","props","getModifier","extension","isUseOfExtensionRequired","isPackage","isUseOfExtensionForbidden","isResolvableWithoutExtension","file","path","extname","fileWithoutExtension","slice","length","resolvedFileWithoutExtension","isExternalRootModule","slashCount","split","checkFileExtension","source","node","value","importPathWithQueryString","settings","importPath","replace","resolvedPath","substring","endsWith","importKind","exportKind","extensionRequired","extensionForbidden","report","message","commonjs"],"mappings":"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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 } }] } },