@putout/bundle 3.10.0 → 3.11.0

package/bundle/putout.js

@@ -1,3 +1,6 @@
+import 'node:process';
+import require$$1$1 from 'node:module';
+
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
 function getDefaultExportFromCjs (x) {
@@ -2640,7 +2643,7 @@ function formatValue(ctx, value, recurseTimes) {
   // Check that value is an object with an inspect function on it
   if (ctx.customInspect &&
       value &&
-      isFunction$3(value.inspect) &&
+      isFunction$4(value.inspect) &&
       // Filter out the util module, it's inspect function is special
       value.inspect !== inspect &&
       // Also filter out any prototype objects using the circular check.
@@ -2675,7 +2678,7 @@ function formatValue(ctx, value, recurseTimes) {
 
   // Some type of object without properties can be shortcutted.
   if (keys.length === 0) {
-    if (isFunction$3(value)) {
+    if (isFunction$4(value)) {
       var name = value.name ? ': ' + value.name : '';
       return ctx.stylize('[Function' + name + ']', 'special');
     }
@@ -2699,7 +2702,7 @@ function formatValue(ctx, value, recurseTimes) {
   }
 
   // Make functions say that they are functions
-  if (isFunction$3(value)) {
+  if (isFunction$4(value)) {
     var n = value.name ? ': ' + value.name : '';
     base = ' [Function' + n + ']';
   }
@@ -2921,7 +2924,7 @@ function isError(e) {
       (objectToString$1(e) === '[object Error]' || e instanceof Error);
 }
 
-function isFunction$3(arg) {
+function isFunction$4(arg) {
   return typeof arg === 'function';
 }
 
@@ -3092,7 +3095,7 @@ var _polyfillNode_util = {
   log: log$6,
   isBuffer: isBuffer,
   isPrimitive: isPrimitive$1,
-  isFunction: isFunction$3,
+  isFunction: isFunction$4,
   isError: isError,
   isDate: isDate,
   isObject: isObject$5,
@@ -3128,7 +3131,7 @@ var _polyfillNode_util$1 = /*#__PURE__*/Object.freeze({
 	isBuffer: isBuffer,
 	isDate: isDate,
 	isError: isError,
-	isFunction: isFunction$3,
+	isFunction: isFunction$4,
 	isNull: isNull$1,
 	isNullOrUndefined: isNullOrUndefined,
 	isNumber: isNumber$3,
@@ -3543,10 +3546,10 @@ var __toESM = function(mod, isNodeMode, target) {
     // file that has been converted to a CommonJS file using a Babel-
     // compatible transform (i.e. "__esModule" has not been set), then set
     // "default" to the CommonJS "module.exports" for node compatibility.
-    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+    __defProp(target, "default", {
         value: mod,
         enumerable: true
-    }) : target, mod);
+    }) , mod);
 };
 var __toCommonJS = function(mod) {
     return __copyProps(__defProp({}, "__esModule", {
@@ -7685,7 +7688,7 @@ __export(lib_exports, {
         return declaredPredicate;
     },
     Decorator: function() {
-        return decorator;
+        return decorator$1;
     },
     Directive: function() {
         return directive;
@@ -9593,7 +9596,7 @@ __export(lib_exports, {
         return declaredPredicate;
     },
     decorator: function() {
-        return decorator;
+        return decorator$1;
     },
     directive: function() {
         return directive;
@@ -9791,7 +9794,7 @@ __export(lib_exports, {
         return isAssignmentExpression;
     },
     isAssignmentPattern: function() {
-        return isAssignmentPattern$1;
+        return isAssignmentPattern$2;
     },
     isAwaitExpression: function() {
         return isAwaitExpression$1;
@@ -9836,7 +9839,7 @@ __export(lib_exports, {
         return isBreakStatement;
     },
     isCallExpression: function() {
-        return isCallExpression$3;
+        return isCallExpression$4;
     },
     isCatchClause: function() {
         return isCatchClause;
@@ -10046,7 +10049,7 @@ __export(lib_exports, {
         return isForXStatement;
     },
     isFunction: function() {
-        return isFunction$2;
+        return isFunction$3;
     },
     isFunctionDeclaration: function() {
         return isFunctionDeclaration$1;
@@ -10067,7 +10070,7 @@ __export(lib_exports, {
         return isGenericTypeAnnotation;
     },
     isIdentifier: function() {
-        return isIdentifier$a;
+        return isIdentifier$c;
     },
     isIfStatement: function() {
         return isIfStatement$2;
@@ -10187,7 +10190,7 @@ __export(lib_exports, {
         return isLoop;
     },
     isMemberExpression: function() {
-        return isMemberExpression$5;
+        return isMemberExpression$6;
     },
     isMetaProperty: function() {
         return isMetaProperty;
@@ -10244,7 +10247,7 @@ __export(lib_exports, {
         return isNumericLiteral;
     },
     isObjectExpression: function() {
-        return isObjectExpression$4;
+        return isObjectExpression$5;
     },
     isObjectMember: function() {
         return isObjectMember;
@@ -10364,7 +10367,7 @@ __export(lib_exports, {
         return isSpecifierDefault;
     },
     isSpreadElement: function() {
-        return isSpreadElement$3;
+        return isSpreadElement$4;
     },
     isSpreadProperty: function() {
         return isSpreadProperty;
@@ -10379,7 +10382,7 @@ __export(lib_exports, {
         return isStaticBlock;
     },
     isStringLiteral: function() {
-        return isStringLiteral$7;
+        return isStringLiteral$9;
     },
     isStringLiteralTypeAnnotation: function() {
         return isStringLiteralTypeAnnotation;
@@ -10613,7 +10616,7 @@ __export(lib_exports, {
         return isTemplateElement$4;
     },
     isTemplateLiteral: function() {
-        return isTemplateLiteral$3;
+        return isTemplateLiteral$4;
     },
     isTerminatorless: function() {
         return isTerminatorless;
@@ -11501,7 +11504,7 @@ __export(lib_exports, {
         return yieldExpression;
     }
 });
-var import_to_fast_properties = __toESM(require_to_fast_properties(), 1);
+var import_to_fast_properties = __toESM(require_to_fast_properties());
 // node_modules/@babel/helper-validator-identifier/lib/index.js
 var nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽͿΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙՠ-ֈא-תׯ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࡠ-ࡪࡰ-ࢇࢉ-ࢎࢠ-ࣉऄ-हऽॐक़-ॡॱ-ঀঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱৼਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡૹଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-హఽౘ-ౚౝౠౡಀಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽೝೞೠೡೱೲഄ-ഌഎ-ഐഒ-ഺഽൎൔ-ൖൟ-ൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄຆ-ຊຌ-ຣລວ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛸᜀ-ᜑᜟ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡸᢀ-ᢨᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭌᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᲀ-ᲈᲐ-ᲺᲽ-Ჿᳩ-ᳬᳮ-ᳳᳵᳶᳺᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕ℘-ℝℤΩℨK-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞ々-〇〡-〩〱-〵〸-〼ぁ-ゖ゛-ゟァ-ヺー-ヿㄅ-ㄯㄱ-ㆎㆠ-ㆿㇰ-ㇿ㐀-䶿一-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚝꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-ꟊꟐꟑꟓꟕ-ꟙꟲ-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꣽꣾꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꩾ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭩꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ";
 var nonASCIIidentifierChars = "‌‍\xb7̀-ͯ·҃-֑҇-ׇֽֿׁׂׅׄؐ-ًؚ-٩ٰۖ-ۜ۟-۪ۤۧۨ-ۭ۰-۹ܑܰ-݊ަ-ް߀-߉߫-߽߳ࠖ-࠙ࠛ-ࠣࠥ-ࠧࠩ-࡙࠭-࡛࢘-࢟࣊-ࣣ࣡-ःऺ-़ा-ॏ॑-ॗॢॣ०-९ঁ-ঃ়া-ৄেৈো-্ৗৢৣ০-৯৾ਁ-ਃ਼ਾ-ੂੇੈੋ-੍ੑ੦-ੱੵઁ-ઃ઼ા-ૅે-ૉો-્ૢૣ૦-૯ૺ-૿ଁ-ଃ଼ା-ୄେୈୋ-୍୕-ୗୢୣ୦-୯ஂா-ூெ-ைொ-்ௗ௦-௯ఀ-ఄ఼ా-ౄె-ైొ-్ౕౖౢౣ౦-౯ಁ-ಃ಼ಾ-ೄೆ-ೈೊ-್ೕೖೢೣ೦-೯ೳഀ-ഃ഻഼ാ-ൄെ-ൈൊ-്ൗൢൣ൦-൯ඁ-ඃ්ා-ුූෘ-ෟ෦-෯ෲෳัิ-ฺ็-๎๐-๙ັິ-ຼ່-໎໐-໙༘༙༠-༩༹༵༷༾༿ཱ-྄྆྇ྍ-ྗྙ-ྼ࿆ါ-ှ၀-၉ၖ-ၙၞ-ၠၢ-ၤၧ-ၭၱ-ၴႂ-ႍႏ-ႝ፝-፟፩-፱ᜒ-᜕ᜲ-᜴ᝒᝓᝲᝳ឴-៓៝០-៩᠋-᠍᠏-᠙ᢩᤠ-ᤫᤰ-᤻᥆-᥏᧐-᧚ᨗ-ᨛᩕ-ᩞ᩠-᩿᩼-᪉᪐-᪙᪰-᪽ᪿ-ᫎᬀ-ᬄ᬴-᭄᭐-᭙᭫-᭳ᮀ-ᮂᮡ-ᮭ᮰-᮹᯦-᯳ᰤ-᰷᱀-᱉᱐-᱙᳐-᳔᳒-᳨᳭᳴᳷-᳹᷀-᷿‌‍‿⁀⁔⃐-⃥⃜⃡-⃰⳯-⵿⳱ⷠ-〪ⷿ-゙゚〯・꘠-꘩꙯ꙴ-꙽ꚞꚟ꛰꛱ꠂ꠆ꠋꠣ-ꠧ꠬ꢀꢁꢴ-ꣅ꣐-꣙꣠-꣱ꣿ-꤉ꤦ-꤭ꥇ-꥓ꦀ-ꦃ꦳-꧀꧐-꧙ꧥ꧰-꧹ꨩ-ꨶꩃꩌꩍ꩐-꩙ꩻ-ꩽꪰꪲ-ꪴꪷꪸꪾ꪿꫁ꫫ-ꫯꫵ꫶ꯣ-ꯪ꯬꯭꯰-꯹ﬞ︀-️︠-︯︳︴﹍-﹏０-９＿･";
@@ -12485,38 +12488,6 @@ function isKeyword(word) {
 var _isDigit = function isDigit(code2) {
     return code2 >= 48 && code2 <= 57;
 };
-var forbiddenNumericSeparatorSiblings = {
-    decBinOct: /* @__PURE__ */ new Set([
-        46,
-        66,
-        69,
-        79,
-        95,
-        98,
-        101,
-        111
-    ]),
-    hex: /* @__PURE__ */ new Set([
-        46,
-        88,
-        95,
-        120
-    ])
-};
-var isAllowedNumericSeparatorSibling = {
-    bin: function(ch) {
-        return ch === 48 || ch === 49;
-    },
-    oct: function(ch) {
-        return ch >= 48 && ch <= 55;
-    },
-    dec: function(ch) {
-        return ch >= 48 && ch <= 57;
-    },
-    hex: function(ch) {
-        return ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102;
-    }
-};
 function readStringContents(type, input, pos, lineStart, curLine, errors) {
     var initialPos = pos;
     var initialLineStart = lineStart;
@@ -12556,7 +12527,7 @@ function readStringContents(type, input, pos, lineStart, curLine, errors) {
             ++curLine;
             lineStart = pos;
         } else if (ch === 10 || ch === 13) {
-            if (type === "template") {
+            {
                 out += input.slice(chunkStart, pos) + "\n";
                 ++pos;
                 if (ch === 13 && input.charCodeAt(pos) === 10) {
@@ -12564,8 +12535,6 @@ function readStringContents(type, input, pos, lineStart, curLine, errors) {
                 }
                 ++curLine;
                 chunkStart = lineStart = pos;
-            } else {
-                errors.unterminated(initialPos, initialLineStart, initialCurLine);
             }
         } else {
             ++pos;
@@ -12580,10 +12549,9 @@ function readStringContents(type, input, pos, lineStart, curLine, errors) {
     };
 }
 function isStringEnd(type, ch, input, pos) {
-    if (type === "template") {
+    {
         return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;
     }
-    return ch === (type === "double" ? 34 : 39);
 }
 function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {
     var throwOnInvalid = !inTemplate;
@@ -12636,10 +12604,8 @@ function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {
             return res("");
         case 56:
         case 57:
-            if (inTemplate) {
+            {
                 return res(null);
-            } else {
-                errors.strictNumericEscape(pos - 1, lineStart, curLine);
             }
         default:
             if (ch >= 48 && ch <= 55) {
@@ -12654,10 +12620,8 @@ function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {
                 pos += octalStr.length - 1;
                 var next = input.charCodeAt(pos);
                 if (octalStr !== "0" || next === 56 || next === 57) {
-                    if (inTemplate) {
+                    {
                         return res(null);
-                    } else {
-                        errors.strictNumericEscape(startPos, lineStart, curLine);
                     }
                 }
                 return res(String.fromCharCode(octal));
@@ -12671,9 +12635,7 @@ function readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInval
     var ref;
     ref = readInt(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid), n2 = ref.n, pos = ref.pos;
     if (n2 === null) {
-        if (throwOnInvalid) {
-            errors.invalidEscapeSequence(initialPos, lineStart, curLine);
-        } else {
+        {
             pos = initialPos - 1;
         }
     }
@@ -12684,31 +12646,20 @@ function readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInval
 }
 function readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
     var start = pos;
-    var forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;
-    var isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin;
     var invalid = false;
     var total = 0;
     for(var i = 0, e = len == null ? Infinity : len; i < e; ++i){
         var code2 = input.charCodeAt(pos);
         var val = void 0;
         if (code2 === 95 && allowNumSeparator !== "bail") {
-            var prev = input.charCodeAt(pos - 1);
-            var next = input.charCodeAt(pos + 1);
-            if (!allowNumSeparator) {
-                if (bailOnError) return {
-                    n: null,
-                    pos: pos
-                };
-                errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine);
-            } else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) {
-                if (bailOnError) return {
+            input.charCodeAt(pos - 1);
+            input.charCodeAt(pos + 1);
+            {
+                return {
                     n: null,
                     pos: pos
                 };
-                errors.unexpectedNumericSeparator(pos, lineStart, curLine);
             }
-            ++pos;
-            continue;
         }
         if (code2 >= 97) {
             val = code2 - 97 + 10;
@@ -12757,9 +12708,7 @@ function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) {
         ref = readHexChar(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors), code2 = ref.code, pos = ref.pos;
         ++pos;
         if (code2 !== null && code2 > 1114111) {
-            if (throwOnInvalid) {
-                errors.invalidCodePoint(pos, lineStart, curLine);
-            } else {
+            {
                 return {
                     code: null,
                     pos: pos
@@ -12875,7 +12824,7 @@ function isBreakStatement(node, opts) {
     if (node.type !== "BreakStatement") return false;
     return opts == null || shallowEqual(node, opts);
 }
-function isCallExpression$3(node, opts) {
+function isCallExpression$4(node, opts) {
     if (!node) return false;
     if (node.type !== "CallExpression") return false;
     return opts == null || shallowEqual(node, opts);
@@ -12940,7 +12889,7 @@ function isFunctionExpression$1(node, opts) {
     if (node.type !== "FunctionExpression") return false;
     return opts == null || shallowEqual(node, opts);
 }
-function isIdentifier$a(node, opts) {
+function isIdentifier$c(node, opts) {
     if (!node) return false;
     if (node.type !== "Identifier") return false;
     return opts == null || shallowEqual(node, opts);
@@ -12955,7 +12904,7 @@ function isLabeledStatement$1(node, opts) {
     if (node.type !== "LabeledStatement") return false;
     return opts == null || shallowEqual(node, opts);
 }
-function isStringLiteral$7(node, opts) {
+function isStringLiteral$9(node, opts) {
     if (!node) return false;
     if (node.type !== "StringLiteral") return false;
     return opts == null || shallowEqual(node, opts);
@@ -12985,7 +12934,7 @@ function isLogicalExpression(node, opts) {
     if (node.type !== "LogicalExpression") return false;
     return opts == null || shallowEqual(node, opts);
 }
-function isMemberExpression$5(node, opts) {
+function isMemberExpression$6(node, opts) {
     if (!node) return false;
     if (node.type !== "MemberExpression") return false;
     return opts == null || shallowEqual(node, opts);
@@ -13000,7 +12949,7 @@ function isProgram$4(node, opts) {
     if (node.type !== "Program") return false;
     return opts == null || shallowEqual(node, opts);
 }
-function isObjectExpression$4(node, opts) {
+function isObjectExpression$5(node, opts) {
     if (!node) return false;
     if (node.type !== "ObjectExpression") return false;
     return opts == null || shallowEqual(node, opts);
@@ -13090,7 +13039,7 @@ function isWithStatement(node, opts) {
     if (node.type !== "WithStatement") return false;
     return opts == null || shallowEqual(node, opts);
 }
-function isAssignmentPattern$1(node, opts) {
+function isAssignmentPattern$2(node, opts) {
     if (!node) return false;
     if (node.type !== "AssignmentPattern") return false;
     return opts == null || shallowEqual(node, opts);
@@ -13185,7 +13134,7 @@ function isObjectPattern$3(node, opts) {
     if (node.type !== "ObjectPattern") return false;
     return opts == null || shallowEqual(node, opts);
 }
-function isSpreadElement$3(node, opts) {
+function isSpreadElement$4(node, opts) {
     if (!node) return false;
     if (node.type !== "SpreadElement") return false;
     return opts == null || shallowEqual(node, opts);
@@ -13205,7 +13154,7 @@ function isTemplateElement$4(node, opts) {
     if (node.type !== "TemplateElement") return false;
     return opts == null || shallowEqual(node, opts);
 }
-function isTemplateLiteral$3(node, opts) {
+function isTemplateLiteral$4(node, opts) {
     if (!node) return false;
     if (node.type !== "TemplateLiteral") return false;
     return opts == null || shallowEqual(node, opts);
@@ -14512,7 +14461,7 @@ function isForXStatement(node, opts) {
     }
     return opts == null || shallowEqual(node, opts);
 }
-function isFunction$2(node, opts) {
+function isFunction$3(node, opts) {
     if (!node) return false;
     switch(node.type){
         case "FunctionDeclaration":
@@ -15248,11 +15197,11 @@ function isModuleDeclaration(node, opts) {
     return isImportOrExportDeclaration(node, opts);
 }
 function matchesPattern$1(member, match, allowPartial) {
-    if (!isMemberExpression$5(member)) return false;
+    if (!isMemberExpression$6(member)) return false;
     var parts = Array.isArray(match) ? match : match.split(".");
     var nodes2 = [];
     var node;
-    for(node = member; isMemberExpression$5(node); node = node.object){
+    for(node = member; isMemberExpression$6(node); node = node.object){
         nodes2.push(node.property);
     }
     nodes2.push(node);
@@ -15261,9 +15210,9 @@ function matchesPattern$1(member, match, allowPartial) {
     for(var i = 0, j = nodes2.length - 1; i < parts.length; i++, j--){
         var node2 = nodes2[j];
         var value1 = void 0;
-        if (isIdentifier$a(node2)) {
+        if (isIdentifier$c(node2)) {
             value1 = node2.name;
-        } else if (isStringLiteral$7(node2)) {
+        } else if (isStringLiteral$9(node2)) {
             value1 = node2.value;
         } else if (isThisExpression(node2)) {
             value1 = "this";
@@ -21671,7 +21620,7 @@ function importAttribute$1(key, value1) {
         value: value1
     });
 }
-function decorator(expression2) {
+function decorator$1(expression2) {
     return validateNode({
         type: "Decorator",
         expression: expression2
@@ -23205,7 +23154,7 @@ function createTypeAnnotationBasedOnTypeof(type) {
     throw new Error("Invalid typeof value: " + type);
 }
 function getQualifiedName$1(node) {
-    return isIdentifier$a(node) ? node.name : "".concat(node.id.name, ".").concat(getQualifiedName$1(node.qualification));
+    return isIdentifier$c(node) ? node.name : "".concat(node.id.name, ".").concat(getQualifiedName$1(node.qualification));
 }
 function removeTypeDuplicates$1(nodesIn) {
     var nodes2 = Array.from(nodesIn);
@@ -23307,7 +23256,7 @@ function createFlowUnionType(types2) {
     }
 }
 function getQualifiedName(node) {
-    return isIdentifier$a(node) ? node.name : "".concat(node.right.name, ".").concat(getQualifiedName(node.left));
+    return isIdentifier$c(node) ? node.name : "".concat(node.right.name, ".").concat(getQualifiedName(node.left));
 }
 function removeTypeDuplicates(nodesIn) {
     var nodes2 = Array.from(nodesIn);
@@ -23440,7 +23389,7 @@ function cloneNodeInternal(node) {
     var newNode = {
         type: node.type
     };
-    if (isIdentifier$a(node)) {
+    if (isIdentifier$c(node)) {
         newNode.name = node.name;
         if (hasOwn(node, "optional") && typeof node.optional === "boolean") {
             newNode.optional = node.optional;
@@ -23639,7 +23588,7 @@ function toBlock(node, parent) {
         blockNodes = [];
     } else {
         if (!isStatement$5(node)) {
-            if (isFunction$2(parent)) {
+            if (isFunction$3(parent)) {
                 node = returnStatement$1(node);
             } else {
                 node = expressionStatement$1(node);
@@ -23696,7 +23645,7 @@ function toBindingIdentifierName(name) {
 }
 function toComputedKey(node) {
     var key = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : node.key || node.property;
-    if (!node.computed && isIdentifier$a(key)) key = stringLiteral(key.name);
+    if (!node.computed && isIdentifier$c(key)) key = stringLiteral(key.name);
     return key;
 }
 function toExpression$1(node) {
@@ -23708,7 +23657,7 @@ function toExpression$1(node) {
     }
     if (isClass(node)) {
         node.type = "ClassExpression";
-    } else if (isFunction$2(node)) {
+    } else if (isFunction$3(node)) {
         node.type = "FunctionExpression";
     }
     if (!isExpression$2(node)) {
@@ -23852,9 +23801,9 @@ function toKeyAlias(node) {
     var alias;
     if (node.kind === "method") {
         return toKeyAlias.increment() + "";
-    } else if (isIdentifier$a(key)) {
+    } else if (isIdentifier$c(key)) {
         alias = key.name;
-    } else if (isStringLiteral$7(key)) {
+    } else if (isStringLiteral$9(key)) {
         alias = JSON.stringify(key.value);
     } else {
         alias = JSON.stringify(removePropertiesDeep(cloneNode(key)));
@@ -23884,7 +23833,7 @@ function toStatement$1(node, ignore) {
     if (isClass(node)) {
         mustHaveId = true;
         newType = "ClassDeclaration";
-    } else if (isFunction$2(node)) {
+    } else if (isFunction$3(node)) {
         mustHaveId = true;
         newType = "FunctionDeclaration";
     } else if (isAssignmentExpression(node)) {
@@ -24078,7 +24027,7 @@ function getBindingIdentifiers(node, duplicates, outerOnly, newBindingsOnly) {
             continue;
         }
         var keys = getBindingIdentifiers.keys[id.type];
-        if (isIdentifier$a(id)) {
+        if (isIdentifier$c(id)) {
             if (duplicates) {
                 var _ids = ids[id.name] = ids[id.name] || [];
                 _ids.push(id);
@@ -24320,7 +24269,7 @@ function isBlockScoped(node) {
 }
 function isImmutable(node) {
     if (isType(node.type, "Immutable")) return true;
-    if (isIdentifier$a(node)) {
+    if (isIdentifier$c(node)) {
         if (node.name === "undefined") {
             return true;
         } else {
@@ -24500,16 +24449,16 @@ function isReferenced(node, parent, grandparent) {
     return true;
 }
 function isScope(node, parent) {
-    if (isBlockStatement$4(node) && (isFunction$2(parent) || isCatchClause(parent))) {
+    if (isBlockStatement$4(node) && (isFunction$3(parent) || isCatchClause(parent))) {
         return false;
     }
-    if (isPattern(node) && (isFunction$2(parent) || isCatchClause(parent))) {
+    if (isPattern(node) && (isFunction$3(parent) || isCatchClause(parent))) {
         return true;
     }
     return isScopable(node);
 }
 function isSpecifierDefault(specifier) {
-    return isImportDefaultSpecifier$1(specifier) || isIdentifier$a(specifier.imported || specifier.exported, {
+    return isImportDefaultSpecifier$1(specifier) || isIdentifier$c(specifier.imported || specifier.exported, {
         name: "default"
     });
 }
@@ -25483,7 +25432,7 @@ var TokContext = function TokContext(token, preserveSpace) {
     this.token = token;
     this.preserveSpace = !!preserveSpace;
 };
-var types$s = {
+var types$u = {
     brace: new TokContext("{"),
     j_oTag: new TokContext("<tag"),
     j_cTag: new TokContext("</tag"),
@@ -27639,7 +27588,7 @@ var State$2 = /*#__PURE__*/ function() {
         __publicField(this, "lastTokEndLoc", null);
         __publicField(this, "lastTokStartLoc", null);
         __publicField(this, "context", [
-            types$s.brace
+            types$u.brace
         ]);
         __publicField(this, "firstInvalidTemplateEscapePos", null);
         __publicField(this, "strictErrors", /* @__PURE__ */ new Map());
@@ -32250,7 +32199,7 @@ var flow$1 = function(superClass) {
                         if (!jsx2.error) return jsx2.node;
                         var context = this.state.context;
                         var currentContext = context[context.length - 1];
-                        if (currentContext === types$s.j_oTag || currentContext === types$s.j_expr) {
+                        if (currentContext === types$u.j_oTag || currentContext === types$u.j_expr) {
                             context.pop();
                         }
                     }
@@ -33467,9 +33416,9 @@ var jsx$3 = function(superClass) {
                     switch(this.state.type){
                         case 5:
                             node = this.startNode();
-                            this.setContext(types$s.brace);
+                            this.setContext(types$u.brace);
                             this.next();
-                            node = this.jsxParseExpressionContainer(node, types$s.j_oTag);
+                            node = this.jsxParseExpressionContainer(node, types$u.j_oTag);
                             if (node.expression.type === "JSXEmptyExpression") {
                                 this.raise(JsxErrors.AttributeIsEmpty, node);
                             }
@@ -33494,7 +33443,7 @@ var jsx$3 = function(superClass) {
                 value: function jsxParseSpreadChild(node) {
                     this.next();
                     node.expression = this.parseExpression();
-                    this.setContext(types$s.j_expr);
+                    this.setContext(types$u.j_expr);
                     this.state.canStartJSXElement = true;
                     this.expect(8);
                     return this.finishNode(node, "JSXSpreadChild");
@@ -33526,11 +33475,11 @@ var jsx$3 = function(superClass) {
                 value: function jsxParseAttribute() {
                     var node = this.startNode();
                     if (this.match(5)) {
-                        this.setContext(types$s.brace);
+                        this.setContext(types$u.brace);
                         this.next();
                         this.expect(21);
                         node.argument = this.parseMaybeAssignAllowIn();
-                        this.setContext(types$s.j_oTag);
+                        this.setContext(types$u.j_oTag);
                         this.state.canStartJSXElement = true;
                         this.expect(8);
                         return this.finishNode(node, "JSXSpreadAttribute");
@@ -33601,12 +33550,12 @@ var jsx$3 = function(superClass) {
                                 case 5:
                                     {
                                         var node2 = this.startNode();
-                                        this.setContext(types$s.brace);
+                                        this.setContext(types$u.brace);
                                         this.next();
                                         if (this.match(21)) {
                                             children.push(this.jsxParseSpreadChild(node2));
                                         } else {
-                                            children.push(this.jsxParseExpressionContainer(node2, types$s.j_expr));
+                                            children.push(this.jsxParseExpressionContainer(node2, types$u.j_expr));
                                         }
                                         break;
                                     }
@@ -33683,11 +33632,11 @@ var jsx$3 = function(superClass) {
                 key: "getTokenFromCode",
                 value: function getTokenFromCode(code2) {
                     var context = this.curContext();
-                    if (context === types$s.j_expr) {
+                    if (context === types$u.j_expr) {
                         this.jsxReadToken();
                         return;
                     }
-                    if (context === types$s.j_oTag || context === types$s.j_cTag) {
+                    if (context === types$u.j_oTag || context === types$u.j_cTag) {
                         if (isIdentifierStart2(code2)) {
                             this.jsxReadWord();
                             return;
@@ -33697,7 +33646,7 @@ var jsx$3 = function(superClass) {
                             this.finishToken(143);
                             return;
                         }
-                        if ((code2 === 34 || code2 === 39) && context === types$s.j_oTag) {
+                        if ((code2 === 34 || code2 === 39) && context === types$u.j_oTag) {
                             this.jsxReadString(code2);
                             return;
                         }
@@ -33715,17 +33664,17 @@ var jsx$3 = function(superClass) {
                 value: function updateContext(prevType) {
                     var _this_state = this.state, context = _this_state.context, type = _this_state.type;
                     if (type === 56 && prevType === 142) {
-                        context.splice(-2, 2, types$s.j_cTag);
+                        context.splice(-2, 2, types$u.j_cTag);
                         this.state.canStartJSXElement = false;
                     } else if (type === 142) {
-                        context.push(types$s.j_oTag);
+                        context.push(types$u.j_oTag);
                     } else if (type === 143) {
                         var out = context[context.length - 1];
-                        if (out === types$s.j_oTag && prevType === 56 || out === types$s.j_cTag) {
+                        if (out === types$u.j_oTag && prevType === 56 || out === types$u.j_cTag) {
                             context.pop();
-                            this.state.canStartJSXElement = context[context.length - 1] === types$s.j_expr;
+                            this.state.canStartJSXElement = context[context.length - 1] === types$u.j_expr;
                         } else {
-                            this.setContext(types$s.j_expr);
+                            this.setContext(types$u.j_expr);
                             this.state.canStartJSXElement = true;
                         }
                     } else {
@@ -36218,7 +36167,7 @@ var typescript$3 = function(superClass) {
                     });
                     if (node.params.length === 0) {
                         this.raise(TSErrors.EmptyTypeArguments, node);
-                    } else if (!this.state.inType && this.curContext() === types$s.brace) {
+                    } else if (!this.state.inType && this.curContext() === types$u.brace) {
                         this.reScan_lt_gt();
                     }
                     this.expect(48);
@@ -37026,7 +36975,7 @@ var typescript$3 = function(superClass) {
                         if (!jsx2.error) return jsx2.node;
                         var context = this.state.context;
                         var currentContext = context[context.length - 1];
-                        if (currentContext === types$s.j_oTag || currentContext === types$s.j_expr) {
+                        if (currentContext === types$u.j_oTag || currentContext === types$u.j_expr) {
                             context.pop();
                         }
                     }
@@ -42727,8 +42676,8 @@ function getParserClass(pluginsFromOptions) {
     return cls;
 }
 // node_modules/@babel/highlight/lib/index.js
-var import_js_tokens = __toESM(require_js_tokens(), 1);
-var import_picocolors = __toESM(require_picocolors(), 1);
+var import_js_tokens = __toESM(require_js_tokens());
+var import_picocolors = __toESM(require_picocolors());
 var colors = typeof browser$1$1 === "object" && (browser$1$1.env.FORCE_COLOR === "0" || browser$1$1.env.FORCE_COLOR === "false") ? (0, import_picocolors.createColors)(false) : import_picocolors.default;
 var compose = function(f, g) {
     return function(v) {
@@ -43026,7 +42975,7 @@ function highlight(code2) {
     }
 }
 // node_modules/@babel/code-frame/lib/index.js
-var import_picocolors2 = __toESM(require_picocolors(), 1);
+var import_picocolors2 = __toESM(require_picocolors());
 var colors2 = typeof browser$1$1 === "object" && (browser$1$1.env.FORCE_COLOR === "0" || browser$1$1.env.FORCE_COLOR === "false") ? (0, import_picocolors2.createColors)(false) : import_picocolors2.default;
 var compose2 = function(f, g) {
     return function(v) {
@@ -44253,7 +44202,7 @@ function addSegmentInternal(skipable, map, genLine, genColumn, source, sourceLin
     var line = getLine(mappings, genLine);
     var index3 = getColumnIndex(line, genColumn);
     if (!source) {
-        if (skipable && skipSourceless(line, index3)) return;
+        if (skipSourceless(line, index3)) return;
         return insert$1(line, index3, [
             genColumn
         ]);
@@ -44261,7 +44210,7 @@ function addSegmentInternal(skipable, map, genLine, genColumn, source, sourceLin
     var sourcesIndex = put(sources, source);
     var namesIndex = name ? put(names, name) : NO_NAME;
     if (sourcesIndex === sourcesContent.length) sourcesContent[sourcesIndex] = content !== null && content !== void 0 ? content : null;
-    if (skipable && skipSource(line, index3, sourcesIndex, sourceLine, sourceColumn, namesIndex)) {
+    if (skipSource(line, index3, sourcesIndex, sourceLine, sourceColumn, namesIndex)) {
         return;
     }
     return insert$1(line, index3, name ? [
@@ -44324,7 +44273,7 @@ function addMappingInternal(skipable, map, mapping) {
     return addSegmentInternal(skipable, map, generated.line - 1, generated.column, source, original.line - 1, original.column, name, content);
 }
 // node_modules/@babel/generator/lib/index.js
-var import_jsesc = __toESM(require_jsesc(), 1);
+var import_jsesc = __toESM(require_jsesc());
 var SourceMap = /*#__PURE__*/ function() {
     function SourceMap(opts, code2) {
         _class_call_check(this, SourceMap);
@@ -45500,7 +45449,7 @@ function _shouldPrintDecoratorsBeforeExport(node) {
     }
     return typeof node.start === "number" && node.start === node.declaration.start;
 }
-function Decorator(node) {
+function Decorator$1(node) {
     this.tokenChar(64);
     var expression2 = node.expression;
     if (shouldParenthesizeDecoratorExpression(expression2)) {
@@ -46609,7 +46558,7 @@ function NumericLiteral(node) {
         this.number(raw, value1);
     }
 }
-function StringLiteral$4(node) {
+function StringLiteral$5(node) {
     var raw = this.getPossibleRaw(node);
     if (!this.format.minified && raw !== void 0) {
         this.token(raw);
@@ -48079,7 +48028,7 @@ var generatorFunctions = /* @__PURE__ */ Object.freeze({
     DeclareTypeAlias: DeclareTypeAlias,
     DeclareVariable: DeclareVariable,
     DeclaredPredicate: DeclaredPredicate,
-    Decorator: Decorator,
+    Decorator: Decorator$1,
     Directive: Directive$1,
     DirectiveLiteral: DirectiveLiteral$1,
     DoExpression: DoExpression,
@@ -48185,8 +48134,8 @@ var generatorFunctions = /* @__PURE__ */ Object.freeze({
     SequenceExpression: SequenceExpression$2,
     SpreadElement: RestElement$1,
     StaticBlock: StaticBlock$1,
-    StringLiteral: StringLiteral$4,
-    StringLiteralTypeAnnotation: StringLiteral$4,
+    StringLiteral: StringLiteral$5,
+    StringLiteralTypeAnnotation: StringLiteral$5,
     StringTypeAnnotation: StringTypeAnnotation,
     Super: Super,
     SwitchCase: SwitchCase,
@@ -49189,7 +49138,7 @@ function generate$6(ast) {
     return printer.generate(ast);
 }
 // node_modules/@babel/traverse/lib/index.js
-var import_debug = __toESM(require_src(), 1);
+var import_debug = __toESM(require_src());
 // node_modules/@babel/helper-split-export-declaration/lib/index.js
 var cloneNode3 = lib_exports.cloneNode, exportNamedDeclaration2 = lib_exports.exportNamedDeclaration, exportSpecifier2 = lib_exports.exportSpecifier, identifier3 = lib_exports.identifier, variableDeclaration2 = lib_exports.variableDeclaration, variableDeclarator2 = lib_exports.variableDeclarator;
 function splitExportDeclaration(exportDeclaration) {
@@ -49287,7 +49236,7 @@ var visitor = {
     }
 };
 // node_modules/@babel/traverse/lib/index.js
-var import_globals = __toESM(require_globals2(), 1);
+var import_globals = __toESM(require_globals2());
 // node_modules/@babel/helper-hoist-variables/lib/index.js
 var assignmentExpression2 = lib_exports.assignmentExpression, expressionStatement3 = lib_exports.expressionStatement, identifier4 = lib_exports.identifier;
 var visitor2 = {
@@ -51274,7 +51223,7 @@ var _Scope = /*#__PURE__*/ function() {
                 } else if (isCallExpression$12(node)) {
                     return matchesPattern$1$1(node.callee, "Symbol.for") && !this.hasBinding("Symbol", {
                         noGlobals: true
-                    }) && node.arguments.length === 1 && isStringLiteral$7(node.arguments[0]);
+                    }) && node.arguments.length === 1 && isStringLiteral$9(node.arguments[0]);
                 } else {
                     return isPureish2(node);
                 }
@@ -56317,7 +56266,7 @@ var main = {};
 
 var fork = {exports: {}};
 
-var types$r = {exports: {}};
+var types$t = {exports: {}};
 
 var shared = {};
 
@@ -56417,12 +56366,12 @@ function requireShared () {
 	return shared;
 }
 
-types$r.exports;
+types$t.exports;
 
 var hasRequiredTypes;
 
 function requireTypes () {
-	if (hasRequiredTypes) return types$r.exports;
+	if (hasRequiredTypes) return types$t.exports;
 	hasRequiredTypes = 1;
 	(function (module, exports) {
 		Object.defineProperty(exports, "__esModule", { value: true });
@@ -57214,8 +57163,8 @@ function requireTypes () {
 		exports.default = typesPlugin;
 		(0, shared_1.maybeSetModuleExports)(function () { return module; });
 		
-	} (types$r, types$r.exports));
-	return types$r.exports;
+	} (types$t, types$t.exports));
+	return types$t.exports;
 }
 
 var pathVisitor = {exports: {}};
@@ -76557,9 +76506,9 @@ var fullstore$3 = (value) => {
     };
 };
 
-var types$q = {};
+var types$s = {};
 
-types$q.TYPES = {
+types$s.TYPES = {
     TOKEN: 'Token',
     NEWLINE: 'Newline',
     LINEBREAK: 'Linebreak',
@@ -76579,16 +76528,19 @@ var arrowFunctionExpression = {};
 
 var is$3 = {};
 
+const {types: types$r} = bundle;
 const {
-    isStringLiteral: isStringLiteral$6,
-    isIdentifier: isIdentifier$9,
+    isStringLiteral: isStringLiteral$8,
+    isSpreadElement: isSpreadElement$3,
+    isIdentifier: isIdentifier$b,
     isIfStatement: isIfStatement$1,
     isStatement: isStatement$4,
     isForOfStatement,
     isVariableDeclaration: isVariableDeclaration$1,
-    isMemberExpression: isMemberExpression$4,
+    isMemberExpression: isMemberExpression$5,
     isArrayExpression: isArrayExpression$4,
-} = bundle.types;
+    isObjectExpression: isObjectExpression$4,
+} = types$r;
 
 const isParentProgram$1 = (path) => path.parentPath?.isProgram();
 const isParentBlock$3 = (path) => path.parentPath.isBlockStatement();
@@ -76610,6 +76562,9 @@ const isPrev$1 = (path) => {
 const isNextParent$5 = (path) => isNext$r(path.parentPath);
 const isLast$d = (path) => isParentProgram$1(path) && !isNext$r(path);
 
+is$3.isNextObject = (a) => a.getNextSibling().isObjectExpression();
+is$3.isPrevObject = (a) => a.getPrevSibling().isObjectExpression();
+
 is$3.isFirst = (path) => path.node === path.parentPath.node.body?.[0];
 is$3.isPrevBody = (path) => path.getPrevSibling().isBlockStatement();
 is$3.isNext = isNext$r;
@@ -76624,9 +76579,10 @@ is$3.isIndented = (path = {}) => {
     const {parentPath, node} = path;
     return node.loc?.start.column !== parentPath.node.loc.start.column;
 };
-is$3.isCoupleLines = isCoupleLines$a;
 
-function isCoupleLines$a(path) {
+is$3.isCoupleLines = isCoupleLines$b;
+
+function isCoupleLines$b(path) {
     const start = path.node?.loc?.start?.line;
     const end = path.node?.loc?.end?.line;
     
@@ -76636,16 +76592,27 @@ function isCoupleLines$a(path) {
 is$3.exists = (a) => a.node;
 is$3.isStringAndIdentifier = isStringAndIdentifier$2;
 function isStringAndIdentifier$2([a, b]) {
-    return isStringLiteral$6(a) && isIdentifier$9(b);
+    return isStringLiteral$8(a) && isIdentifier$b(b);
 }
 
+is$3.isSimpleAndEmptyObject = ([a, b]) => {
+    if (!isIdentifier$b(a) && !isSpreadElement$3(a) && !isArrayExpression$4(a))
+        return false;
+    
+    if (!isObjectExpression$4(b))
+        return false;
+    
+    return b.node.properties.length;
+};
+
 is$3.isIdentifierAndIdentifier = ([a, b]) => {
-    return isIdentifier$9(a) && isIdentifier$9(b);
+    return isIdentifier$b(a) && isIdentifier$b(b);
 };
-is$3.isStringAndMember = ([a, b]) => isStringLiteral$6(a) && isMemberExpression$4(b);
-is$3.isIdentifierAndString = ([a, b]) => isIdentifier$9(a) && isStringLiteral$6(b);
+
+is$3.isStringAndMember = ([a, b]) => isStringLiteral$8(a) && isMemberExpression$5(b);
+is$3.isIdentifierAndString = ([a, b]) => isIdentifier$b(a) && isStringLiteral$8(b);
 is$3.isStringAndArray = ([a, b]) => {
-    if (!isStringLiteral$6(a))
+    if (!isStringLiteral$8(a))
         return false;
     
     if (!isArrayExpression$4(b))
@@ -76689,7 +76656,18 @@ is$3.satisfy = (conditions) => (path) => {
     return false;
 };
 
-is$3.hasTrailingComment = (path) => path.node?.trailingComments?.length;
+const parseNode$2 = (path) => path.node || path;
+
+is$3.hasCoupleTrailingComments = (path) => {
+    const node = parseNode$2(path);
+    return node?.trailingComments?.length > 1;
+};
+
+is$3.hasTrailingComment = (path) => {
+    const node = parseNode$2(path);
+    return node.trailingComments?.length;
+};
+
 is$3.hasLeadingComment = (path) => path.node?.leadingComments?.length;
 
 is$3.noTrailingComment = (path) => !path.node.trailingComments?.length;
@@ -76741,7 +76719,7 @@ maybeInsideFn$1.maybeInsideFn = (insideFn, {print, indent}) => {
     indent.dec();
 };
 
-const {types: types$p} = bundle;
+const {types: types$q} = bundle;
 const {
     hasTrailingComment: hasTrailingComment$3,
     satisfy: satisfy$4,
@@ -76757,7 +76735,7 @@ const {
     isClassProperty,
     isTSPropertySignature,
     isSpreadElement: isSpreadElement$2,
-} = types$p;
+} = types$q;
 
 const isProperty = satisfy$4([
     isObjectProperty$1,
@@ -76767,6 +76745,8 @@ const isProperty = satisfy$4([
     isSpreadElement$2,
 ]);
 
+const hasDecorators = ({parentPath}) => parentPath.node.decorators?.length;
+
 function isCommentOfPrevious(path) {
     const [comment] = path.node.leadingComments;
     const {line} = comment.loc.start;
@@ -76803,6 +76783,9 @@ parseLeadingComments$4.parseLeadingComments = (path, {print, maybe, indent}, sem
     if (!leadingComments?.length)
         return;
     
+    if (hasDecorators(path))
+        return;
+    
     const looksLikeSwitchCase = path.isSwitchCase();
     
     if (!looksLikeSwitchCase && hasTrailingComment$3(path.getPrevSibling()))
@@ -76862,16 +76845,16 @@ var parseTrailingComments$2 = {};
 
 const {
     isDecorator,
-    isMemberExpression: isMemberExpression$3,
+    isMemberExpression: isMemberExpression$4,
 } = bundle.types;
 
 const {
     isLast: isLast$c,
-    isCoupleLines: isCoupleLines$9,
+    isCoupleLines: isCoupleLines$a,
     isNext: isNext$q,
 } = is$3;
 
-const hasBody = (path) => path.node.body;
+const hasBody$1 = (path) => path.node.body;
 
 const isFnParam = (path) => {
     const {parentPath} = path;
@@ -76893,7 +76876,7 @@ const isTrailingIsLeading = (path) => path.node.trailingComments === path.getNex
 const isNewlineAfter = (path) => {
     const {parentPath} = path;
     
-    if (isMemberExpression$3(parentPath))
+    if (isMemberExpression$4(parentPath))
         return false;
     
     return !isLast$c(path) && !isDecorator(path);
@@ -76914,7 +76897,7 @@ function isCommentOnNextLine(path) {
     if (isTrailingIsLeading(path))
         return false;
     
-    if (trailingComments.length > 1)
+    if (path.isThrowStatement())
         return false;
     
     const [comment] = trailingComments;
@@ -76922,10 +76905,13 @@ function isCommentOnNextLine(path) {
     
     const next = path.getNextSibling();
     
-    if (line < next.node?.loc.start.line)
+    if (next.node && line < next.node.loc.start.line)
         return false;
     
-    return line === loc.start.line + 1;
+    const isNextLine = line === loc.start.line + 1;
+    const isNextLineAfterNewline = line === loc.start.line + 2;
+    
+    return isNextLine || isNextLineAfterNewline;
 }
 
 parseTrailingComments$2.parseTrailingComments = (path, {write, maybe}, semantics) => {
@@ -76951,7 +76937,7 @@ parseTrailingComments$2.parseTrailingComments = (path, {write, maybe}, semantics
             maybe.write.space(sameLine);
             maybe.indent(!sameLine && !commentOnNextLine);
             
-            if (hasBody(path)) {
+            if (hasBody$1(path)) {
                 maybe.write.breakline(!isNext$q(path));
                 maybe.write.breakline(!n);
             }
@@ -76966,7 +76952,7 @@ parseTrailingComments$2.parseTrailingComments = (path, {write, maybe}, semantics
             maybe.write.space(sameLine);
             maybe.indent(!sameLine);
             write(`/*${value}*/`);
-            maybe.write.newline(!sameLine || !isFnParam(path) && isCoupleLines$9(path.parentPath));
+            maybe.write.newline(!sameLine || !isFnParam(path) && isCoupleLines$a(path.parentPath));
         }
     }
 };
@@ -77635,15 +77621,17 @@ maybeDeclare$6.maybeDeclare = (visit) => (path, printer, semantics) => {
     visit(path, printer, semantics);
 };
 
+const {isFunction: isFunction$2} = bundle.types;
 const {isNext: isNext$l} = is$3;
 const {markAfter: markAfter$8} = mark;
 
-//const {maybeDecorators} = require('../../maybe-get');
 const {maybeDeclare: maybeDeclare$5} = maybeDeclare$6;
 const {parseComments: parseComments$4} = comment;
 const {maybeDecorators: maybeDecorators$2} = maybeDecorators$4;
 
 const isInsideExport = ({parentPath}) => parentPath.isExportDeclaration();
+const isFunctionLike = (path) => isFunction$2(path.parentPath.parentPath);
+const hasBody = ({node}) => node.body.body.length;
 
 const classVisitor = maybeDecorators$2((path, printer, semantics) => {
     const {id, abstract} = path.node;
@@ -77705,6 +77693,9 @@ _class.ClassDeclaration = {
         classVisitor(path, printer, semantics);
     }),
     afterIf(path) {
+        if (isFunctionLike(path))
+            return true;
+        
         if (!isNext$l(path))
             return false;
         
@@ -77713,7 +77704,7 @@ _class.ClassDeclaration = {
     after(path, {write}) {
         write.newline();
         
-        if (path.node.body.body.length) {
+        if (!isFunctionLike(path) && hasBody(path)) {
             write.newline();
             markAfter$8(path);
         }
@@ -77853,7 +77844,7 @@ newExpression.NewExpression = {
 var objectExpression = {};
 
 const {
-    isCoupleLines: isCoupleLines$8,
+    isCoupleLines: isCoupleLines$9,
     isForOf: isForOf$3,
     isIf,
     noTrailingComment: noTrailingComment$3,
@@ -77865,6 +77856,7 @@ const {
 
 const {parseComments: parseComments$3} = comment;
 const {likeChain} = memberExpressions$1;
+const {isStringLiteral: isStringLiteral$7} = bundle.types;
 
 const isBodyOfArrow = (path) => path.parentPath.node.body === path.node;
 const isLogical = (path) => path.get('argument').isLogicalExpression();
@@ -77883,6 +77875,25 @@ const isMemberExpressionCallee = ({parentPath}) => {
     return likeChain(callee);
 };
 
+const isInsideCall = ({parentPath}) => parentPath.isCallExpression();
+
+function isInsideNestedArrayCall({parentPath}) {
+    if (!parentPath.isArrayExpression())
+        return false;
+    
+    if (!parentPath.parentPath.isArrayExpression())
+        return false;
+    
+    return isInsideCall(parentPath.parentPath);
+}
+
+function isInsideNestedTuple({parentPath}) {
+    const {elements} = parentPath.parentPath.node;
+    const [first] = elements;
+    
+    return isStringLiteral$7(first);
+}
+
 objectExpression.ObjectExpression = (path, printer, semantics) => {
     const {trailingComma} = semantics;
     const {
@@ -77891,7 +77902,9 @@ objectExpression.ObjectExpression = (path, printer, semantics) => {
         indent,
     } = printer;
     
-    indent.inc();
+    const insideNestedArrayCall = isInsideNestedArrayCall(path);
+    
+    maybe.indent.inc(!insideNestedArrayCall);
     
     const properties = path.get('properties');
     const {length} = properties;
@@ -77905,7 +77918,8 @@ objectExpression.ObjectExpression = (path, printer, semantics) => {
     
     const n = properties.length - 1;
     
-    maybe.indent.inc(isMemberExpressionCallee(path));
+    const memberCallee = isMemberExpressionCallee(path);
+    maybe.indent.inc(memberCallee);
     
     for (const [index, property] of properties.entries()) {
         if (property.isSpreadElement()) {
@@ -77925,13 +77939,10 @@ objectExpression.ObjectExpression = (path, printer, semantics) => {
         }
         
         maybe.indent(manyLines && noLeadingComment(property));
+        print(property);
         
-        if (property.isObjectMethod()) {
-            print(property);
+        if (property.isObjectMethod())
             continue;
-        }
-        
-        print(property);
         
         if (noTrailingComment$3(property) && !hasNextLeadingComment(property)) {
             maybe.print.newline(manyLines);
@@ -77939,12 +77950,19 @@ objectExpression.ObjectExpression = (path, printer, semantics) => {
         }
     }
     
-    indent.dec();
-    maybe.indent(manyLines);
+    if (!insideNestedArrayCall) {
+        indent.dec();
+        maybe.indent(manyLines);
+    } else if (isInsideNestedTuple(path)) {
+        indent.dec();
+        indent();
+        indent.inc();
+    }
+    
     print('}');
     maybe.print(parens, ')');
     
-    maybe.indent.dec(isMemberExpressionCallee(path));
+    maybe.indent.dec(memberCallee);
 };
 
 const hasNextLeadingComment = (path) => {
@@ -77962,7 +77980,7 @@ const notLastArgInsideCall = (path) => {
     if (!parentPath.isCallExpression())
         return false;
     
-    if (isCoupleLines$8(path))
+    if (isCoupleLines$9(path))
         return false;
     
     return path !== parentPath
@@ -77978,7 +77996,7 @@ function isOneLine$1(path) {
     const {length} = path.get('properties');
     
     if (!length)
-        return true;
+        return ONE_LINE$2;
     
     if (notLastArgInsideCall(path))
         return ONE_LINE$2;
@@ -77989,7 +78007,7 @@ function isOneLine$1(path) {
     if (isIf(path))
         return ONE_LINE$2;
     
-    if (isCoupleLines$8(path))
+    if (isCoupleLines$9(path))
         return MANY_LINES;
     
     return !isValue(path);
@@ -78007,16 +78025,16 @@ var objectProperty = {};
 var concatanate$1 = {};
 
 const {
-    isStringLiteral: isStringLiteral$5,
-    isTemplateLiteral: isTemplateLiteral$2,
+    isStringLiteral: isStringLiteral$6,
+    isTemplateLiteral: isTemplateLiteral$3,
     isBinaryExpression,
 } = bundle.types;
 
 const isStringLike = (a) => {
-    if (isStringLiteral$5(a))
+    if (isStringLiteral$6(a))
         return true;
     
-    return isTemplateLiteral$2(a);
+    return isTemplateLiteral$3(a);
 };
 
 concatanate$1.isConcatenation = (path) => {
@@ -78095,9 +78113,9 @@ wrongShortand.wrongShorthand = ({computed, isAssign, keyPath, valuePath}) => {
     return !computed && !isAssign && keyPath.node.name !== valuePath.node.name;
 };
 
-var maxPropertiesInOneLine = {};
+var moreThenMaxPropertiesInOneLine$1 = {};
 
-maxPropertiesInOneLine.checkMaxPropertiesInOneLine = (path, {maxPropertiesInOneLine}) => {
+moreThenMaxPropertiesInOneLine$1.moreThenMaxPropertiesInOneLine = (path, {maxPropertiesInOneLine}) => {
     const {parentPath} = path;
     
     if (parentPath.isObjectProperty())
@@ -78129,8 +78147,43 @@ function maybePrintTypeAnnotation$3(path, printer) {
     }
 }
 
+var moreThenMaxPropertiesLengthInOneLine$1 = {};
+
 const {
-    isIdentifier: isIdentifier$8,
+    isAssignmentPattern: isAssignmentPattern$1,
+    isIdentifier: isIdentifier$a,
+} = bundle.types;
+
+moreThenMaxPropertiesLengthInOneLine$1.moreThenMaxPropertiesLengthInOneLine = (path, {maxPropertiesLengthInOneLine}) => {
+    const {properties} = path.node;
+    
+    for (const {key, value} of properties) {
+        if (isAssignmentPattern$1(value)) {
+            const {left, right} = value;
+            
+            if (!isIdentifier$a(left) || !isIdentifier$a(right))
+                continue;
+            
+            const length = left.name.length + right.name.length;
+            
+            if (length >= maxPropertiesLengthInOneLine)
+                return true;
+        }
+        
+        if (!isIdentifier$a(key))
+            continue;
+        
+        const {name} = key;
+        
+        if (name.length >= maxPropertiesLengthInOneLine)
+            return true;
+    }
+    
+    return false;
+};
+
+const {
+    isIdentifier: isIdentifier$9,
     isObjectPattern: isObjectPattern$2,
     isAssignmentPattern,
 } = bundle.types;
@@ -78139,22 +78192,41 @@ const {wrongShorthand} = wrongShortand;
 
 const {
     isForOf: isForOf$2,
-    isCoupleLines: isCoupleLines$7,
+    isCoupleLines: isCoupleLines$8,
     exists: exists$9,
 } = is$3;
 
-const {checkMaxPropertiesInOneLine} = maxPropertiesInOneLine;
+const {moreThenMaxPropertiesInOneLine} = moreThenMaxPropertiesInOneLine$1;
+
 const {maybeTypeAnnotation: maybeTypeAnnotation$3} = maybeTypeAnnotation$4;
+const {moreThenMaxPropertiesLengthInOneLine} = moreThenMaxPropertiesLengthInOneLine$1;
 
 const isTwoLevelsDeep = ({parentPath}) => parentPath.parentPath.parentPath.isObjectProperty();
-
 const isOneParentProperty = ({parentPath}) => parentPath.parentPath.node.properties?.length === 1;
 
+function isIndent(path) {
+    return !path.parentPath.isArrayPattern();
+}
+
+const isCoupleProperties = ({path, valuePath, property}) => {
+    if (!isCoupleLines$8(valuePath))
+        return false;
+    
+    if (exists$9(property.getPrevSibling()))
+        return false;
+    
+    return !path.parentPath.isObjectProperty();
+};
+
 objectPattern.ObjectPattern = {
-    print: maybeTypeAnnotation$3((path, {indent, print, maybe}, semantics) => {
-        const {maxPropertiesInOneLine} = semantics;
+    print: maybeTypeAnnotation$3((path, {print, maybe, indent}, semantics) => {
+        const shouldIndent = isIndent(path);
+        const {
+            maxPropertiesInOneLine,
+            maxPropertiesLengthInOneLine,
+        } = semantics;
         
-        indent.inc();
+        maybe.indent.inc(shouldIndent);
         print('{');
         
         const properties = path.get('properties');
@@ -78162,6 +78234,7 @@ objectPattern.ObjectPattern = {
         
         const is = shouldAddNewline(path, {
             maxPropertiesInOneLine,
+            maxPropertiesLengthInOneLine,
         });
         
         const hasObject = n && hasObjectPattern(properties);
@@ -78183,7 +78256,11 @@ objectPattern.ObjectPattern = {
             const isAssign = valuePath.isAssignmentPattern();
             
             const {shorthand, computed} = property.node;
-            const couple = isCoupleLines$7(valuePath) && !exists$9(property.getPrevSibling()) && !path.parentPath.isObjectProperty();
+            const couple = isCoupleProperties({
+                path,
+                property,
+                valuePath,
+            });
             
             maybe.indent(is);
             maybe.print.breakline(couple);
@@ -78203,7 +78280,7 @@ objectPattern.ObjectPattern = {
                 maybe.print.newline(couple);
             }
             
-            if (is || hasObject) {
+            if (is || hasObject && !isAssign) {
                 print(',');
                 print.newline();
                 
@@ -78218,6 +78295,7 @@ objectPattern.ObjectPattern = {
         
         indent.dec();
         maybe.indent(is);
+        maybe.indent.inc(!shouldIndent);
         print('}');
     }),
     afterIf(path) {
@@ -78238,7 +78316,7 @@ function checkLength(properties) {
     for (const prop of properties) {
         const {value} = prop.node;
         
-        if (!isIdentifier$8(value))
+        if (!isIdentifier$9(value))
             continue;
         
         if (value.name.length > 4)
@@ -78271,23 +78349,48 @@ function hasObjectPattern(properties) {
 const ONE_LINE$1 = false;
 const COUPLE_LINES = true;
 
-function shouldAddNewline(path, {maxPropertiesInOneLine}) {
+function shouldAddNewline(path, semantics) {
     const {parentPath} = path;
     const properties = path.get('properties');
     const n = properties.length - 1;
     
-    if (checkMaxPropertiesInOneLine(path, {maxPropertiesInOneLine}))
+    const {
+        maxPropertiesInOneLine,
+        maxPropertiesLengthInOneLine,
+    } = semantics;
+    
+    const moreLength = moreThenMaxPropertiesLengthInOneLine(path, {
+        maxPropertiesLengthInOneLine,
+    });
+    
+    const moreCount = moreThenMaxPropertiesInOneLine(path, {
+        maxPropertiesInOneLine,
+    });
+    
+    const fnParam = isFunctionParam(path);
+    
+    if (moreCount && !moreLength)
         return ONE_LINE$1;
     
-    if (!isForOf$2(path) && !path.parentPath.isFunction() && n && checkLength(properties))
+    if (!fnParam && n && !isForOf$2(path) && checkLength(properties))
         return COUPLE_LINES;
     
-    if (hasAssign(properties))
+    if (!fnParam && hasAssign(properties))
         return COUPLE_LINES;
     
     return parentPath.isObjectProperty();
 }
 
+function isFunctionParam({parentPath}) {
+    if (parentPath.isFunction())
+        return true;
+    
+    if (!parentPath.isAssignmentPattern())
+        return false;
+    
+    return parentPath.parentPath.isFunction();
+}
+
 var classProperty = {};
 
 const {exists: exists$8} = is$3;
@@ -78361,6 +78464,7 @@ parens.maybeParenClose = (path, {maybe}) => {
 
 const {isObjectPattern: isObjectPattern$1} = bundle.types;
 const {isParens: isParens$2} = parens;
+const {isCoupleLines: isCoupleLines$7} = is$3;
 
 assignmentExpression.AssignmentExpression = {
     condition: (path) => {
@@ -78377,8 +78481,9 @@ assignmentExpression.AssignmentExpression = {
     before(path, {write}) {
         write('(');
     },
-    print(path, {print}) {
+    print(path, {print, maybe}) {
         const {operator} = path.node;
+        maybe.print.breakline(isPrevCoupleLines(path));
         
         print('__left');
         print.space();
@@ -78391,6 +78496,22 @@ assignmentExpression.AssignmentExpression = {
     },
 };
 
+const isPrevCoupleLines = (path) => {
+    const {parentPath} = path;
+    const prev = parentPath.getPrevSibling();
+    
+    if (!prev.node)
+        return false;
+    
+    const currentStart = path.node?.loc?.start.line;
+    const prevEnd = prev.node?.loc?.end.line;
+    
+    if (!isCoupleLines$7(prev))
+        return false;
+    
+    return currentStart - prevEnd < 2;
+};
+
 var arrayExpression = {};
 
 var newline = {};
@@ -78399,11 +78520,11 @@ var operate = {};
 
 var getBinding$2 = {};
 
-const {types: types$o} = bundle;
+const {types: types$p} = bundle;
 const {
-    isIdentifier: isIdentifier$7,
-    isMemberExpression: isMemberExpression$2,
-} = types$o;
+    isIdentifier: isIdentifier$8,
+    isMemberExpression: isMemberExpression$3,
+} = types$p;
 
 const isString$a = (a) => typeof a === 'string';
 
@@ -78419,10 +78540,10 @@ const parseName$1 = (node) => {
     if (isString$a(node))
         return node;
     
-    if (isIdentifier$7(node))
+    if (isIdentifier$8(node))
         return node.name;
     
-    if (isMemberExpression$2(node))
+    if (isMemberExpression$3(node))
         return parseName$1(node.object);
     
     return '';
@@ -78430,22 +78551,22 @@ const parseName$1 = (node) => {
 
 var isSimple$2 = {};
 
-const {types: types$n} = bundle;
+const {types: types$o} = bundle;
 const {
     isOptionalMemberExpression,
-    isMemberExpression: isMemberExpression$1,
-    isIdentifier: isIdentifier$6,
+    isMemberExpression: isMemberExpression$2,
+    isIdentifier: isIdentifier$7,
     isLiteral: isLiteral$4,
-} = types$n;
+} = types$o;
 
 isSimple$2.isSimple = (a) => {
     if (isLiteral$4(a))
         return true;
     
-    if (isIdentifier$6(a))
+    if (isIdentifier$7(a))
         return true;
     
-    if (isMemberExpression$1(a))
+    if (isMemberExpression$2(a))
         return true;
     
     return isOptionalMemberExpression(a);
@@ -78453,33 +78574,33 @@ isSimple$2.isSimple = (a) => {
 
 var extract$6 = {};
 
-const {types: types$m} = bundle;
+const {types: types$n} = bundle;
 const {
     isArrayExpression: isArrayExpression$3,
     isLiteral: isLiteral$3,
-    isIdentifier: isIdentifier$5,
-    isMemberExpression,
+    isIdentifier: isIdentifier$6,
+    isMemberExpression: isMemberExpression$1,
     isTemplateElement: isTemplateElement$3,
     isRegExpLiteral: isRegExpLiteral$1,
     isClassMethod,
-    isTemplateLiteral: isTemplateLiteral$1,
+    isTemplateLiteral: isTemplateLiteral$2,
     isJSXText: isJSXText$2,
     isJSXAttribute: isJSXAttribute$1,
     isTSTypeReference: isTSTypeReference$2,
-} = types$m;
+} = types$n;
 
 extract$6.extract = extract$5;
 
 function extract$5(node) {
     node = node.node || node;
     
-    if (isIdentifier$5(node))
+    if (isIdentifier$6(node))
         return node.name;
     
     if (isRegExpLiteral$1(node))
         return node.pattern;
     
-    if (isTemplateLiteral$1(node))
+    if (isTemplateLiteral$2(node))
         return extract$5(node.quasis[0]);
     
     if (isLiteral$3(node))
@@ -78488,7 +78609,7 @@ function extract$5(node) {
     if (isTemplateElement$3(node))
         return node.value.raw;
     
-    if (isMemberExpression(node))
+    if (isMemberExpression$1(node))
         return `${extract$5(node.object)}.${extract$5(node.property)}`;
     
     if (isArrayExpression$3(node))
@@ -78804,19 +78925,23 @@ setLiteralValue$2.setLiteralValue = (path, newValue) => {
 
 var properties = {};
 
-var traverseProperties$3 = {};
-
-const {traverse: traverse$b, types: types$l} = bundle;
+var traverseProperties$4 = {};
 
+const {traverse: traverse$b, types: types$m} = bundle;
 const {extract: extract$3} = extract$6;
-const {isObjectExpression: isObjectExpression$3} = types$l;
+
+const {
+    isObjectExpression: isObjectExpression$3,
+    isCallExpression: isCallExpression$3,
+} = types$m;
+
 const nodeOrPath = (path) => path.node || path;
 
 function getNode(path) {
     if (!isObjectExpression$3(path))
         return nodeOrPath(path);
     
-    if (path.parentPath)
+    if (isCallExpression$3(path.parentPath))
         return path.parentPath.node;
     
     return {
@@ -78825,7 +78950,7 @@ function getNode(path) {
     };
 }
 
-traverseProperties$3.traverseProperties = (path, name, {firstLevel = false} = {}) => {
+traverseProperties$4.traverseProperties = (path, name, {firstLevel = false} = {}) => {
     const collector = [];
     const node = getNode(path);
     
@@ -78861,9 +78986,9 @@ const collect = ({name, collector}) => (path) => {
 };
 
 const {extract: extract$2} = extract$6;
-const {traverseProperties: traverseProperties$2} = traverseProperties$3;
+const {traverseProperties: traverseProperties$3} = traverseProperties$4;
 
-properties.traverseProperties = traverseProperties$2;
+properties.traverseProperties = traverseProperties$3;
 
 properties.getProperties = (path, names) => {
     const result = {};
@@ -78900,7 +79025,7 @@ properties.getProperty = (path, name) => {
     return null;
 };
 
-const {types: types$k} = bundle;
+const {types: types$l} = bundle;
 
 const {getBinding, getBindingPath} = getBinding$2;
 const {isSimple: isSimple$1} = isSimple$2;
@@ -78915,7 +79040,7 @@ const {setLiteralValue: setLiteralValue$1} = setLiteralValue$2;
 const {
     getProperty: getProperty$3,
     getProperties,
-    traverseProperties: traverseProperties$1,
+    traverseProperties: traverseProperties$2,
 } = properties;
 
 const {
@@ -78928,7 +79053,7 @@ const {
     isExpression: isExpression$1,
     isStatement: isStatement$3,
     BlockStatement: BlockStatement$1,
-} = types$k;
+} = types$l;
 
 const {assign: assign$d} = Object;
 
@@ -78946,7 +79071,7 @@ operate.setLiteralValue = setLiteralValue$1;
 
 operate.getProperty = getProperty$3;
 operate.getProperties = getProperties;
-operate.traverseProperties = traverseProperties$1;
+operate.traverseProperties = traverseProperties$2;
 
 function toExpression(el) {
     const {type} = el;
@@ -79014,7 +79139,11 @@ operate.insertAfter = (path, node) => {
     if (node.trailingComments)
         delete node.trailingComments;
     
-    path.insertAfter(node);
+    if (isStatement$3(path) && !isStatement$3(node))
+        path.insertAfter(ExpressionStatement$3(node));
+    else
+        path.insertAfter(node);
+    
     path.node.comments = comments;
 };
 
@@ -79087,7 +79216,7 @@ const {
     isAwaitExpression,
     isBooleanLiteral: isBooleanLiteral$1,
     isNullLiteral,
-    isStringLiteral: isStringLiteral$4,
+    isStringLiteral: isStringLiteral$5,
     isSpreadElement: isSpreadElement$1,
 } = bundle.types;
 
@@ -79098,6 +79227,7 @@ const {
     isCoupleLines: isCoupleLines$6,
     isStringAndArray: isStringAndArray$1,
     isIdentifierAndIdentifier: isIdentifierAndIdentifier$1,
+    isSimpleAndEmptyObject: isSimpleAndEmptyObject$1,
 } = is$3;
 
 const {round: round$1} = Math;
@@ -79119,6 +79249,7 @@ const isSimpleAndCall = ([a, b]) => {
 };
 
 const isBooleanAndSimple = ([a, b]) => isBooleanLiteral$1(a) && isSimple(b);
+const isBooleanAndObject = ([a, b]) => isBooleanLiteral$1(a) && isObjectExpression$2(b);
 const isNullAndSimple = ([a, b]) => isNullLiteral(a) && isSimple(b);
 const isSimpleAndObject = ([a, b]) => isSimple(a) && isObjectExpression$2(b);
 const ONE_LINE = false;
@@ -79137,6 +79268,9 @@ newline.isMultiLine = (path, {elements, maxElementsInOneLine}) => {
     if (elements.length > 3 && !isObjectExpression$2(elements[0]))
         return MULTI_LINE;
     
+    if (isSimpleAndEmptyObject$1(elements))
+        return MULTI_LINE;
+    
     if (isOneSimple(path))
         return ONE_LINE;
     
@@ -79202,7 +79336,7 @@ newline.isMultiLine = (path, {elements, maxElementsInOneLine}) => {
 
 const isForOf$1 = ({parentPath}) => parentPath.isForOfStatement();
 
-const isStringAndString = ([a, b]) => isStringLiteral$4(a) && isStringLiteral$4(b);
+const isStringAndString = ([a, b]) => isStringLiteral$5(a) && isStringLiteral$5(b);
 
 const isShortTwoSimplesInsideCall = (path, short) => {
     const {node, parentPath} = path;
@@ -79214,7 +79348,7 @@ const isShortTwoSimplesInsideCall = (path, short) => {
     if (!parentPath.isCallExpression())
         return false;
     
-    if (!isStringLiteral$4(a) || !isStringLiteral$4(b))
+    if (!isStringLiteral$5(a) || !isStringLiteral$5(b))
         return false;
     
     return length < short;
@@ -79233,7 +79367,7 @@ const isTwoSimplesInsideObjectProperty = (path) => {
     if (!parentPath.isObjectProperty())
         return false;
     
-    if (!isStringLiteral$4(a) || !isStringLiteral$4(b))
+    if (!isStringLiteral$5(a) || !isStringLiteral$5(b))
         return false;
     
     return !isCoupleLines$6(path);
@@ -79331,6 +79465,9 @@ function isIncreaseIndent$1(path) {
     if (!elements.length)
         return false;
     
+    if (isBooleanAndObject(elements))
+        return true;
+    
     if (isInsideCallLoop(path))
         return false;
     
@@ -79354,7 +79491,7 @@ const isStringAndObject = (elements) => {
     const first = elements.at(0);
     const last = elements.at(-1);
     
-    return isStringLiteral$4(first) && isObjectExpression$2(last);
+    return isStringLiteral$5(first) && isObjectExpression$2(last);
 };
 
 newline.isCurrentNewLine = (path) => {
@@ -79366,13 +79503,13 @@ newline.isCurrentNewLine = (path) => {
 
 var indent = {};
 
-const {types: types$j} = bundle;
+const {types: types$k} = bundle;
 const {isIndented} = is$3;
 
 const {
-    isStringLiteral: isStringLiteral$3,
+    isStringLiteral: isStringLiteral$4,
     isArrayExpression: isArrayExpression$1,
-} = types$j;
+} = types$k;
 
 const isInsideArray$1 = (path) => path.parentPath.isArrayExpression();
 
@@ -79408,18 +79545,41 @@ function isArrayInsideArray$1(path) {
 const isTwoLongStrings = ([a, b]) => {
     const LONG_STRING = 20;
     
-    if (!isStringLiteral$3(a) || !isStringLiteral$3(b))
+    if (!isStringLiteral$4(a) || !isStringLiteral$4(b))
         return false;
     
     return a.node.value.length > LONG_STRING;
 };
 
-const {types: types$i} = bundle;
+var isObjectAfterSimple$1 = {};
+
+const {isNextObject: isNextObject$1, isPrevObject} = is$3;
+
+const SIMPLE_TYPES = [
+    'ArrayExpression',
+    'ObjectExpression',
+    'SpreadElement',
+    'CallExpression',
+    'Identifier',
+];
+
+isObjectAfterSimple$1.isObjectAfterSimple = (a) => {
+    const {type} = a;
+    
+    if (!isNextObject$1(a) || isPrevObject(a))
+        return false;
+    
+    return SIMPLE_TYPES.includes(type);
+};
+
+const {types: types$j} = bundle;
 const {
     isCoupleLines: isCoupleLines$5,
     isStringAndIdentifier,
     isIdentifierAndIdentifier,
     isStringAndArray,
+    isSimpleAndEmptyObject,
+    isNextObject,
 } = is$3;
 
 const {
@@ -79434,18 +79594,56 @@ const {
     isArrayIndented,
 } = indent;
 
+const {isObjectAfterSimple} = isObjectAfterSimple$1;
+
 const {
     isObjectExpression: isObjectExpression$1,
     isSpreadElement,
-    isStringLiteral: isStringLiteral$2,
-} = types$i;
+    isStringLiteral: isStringLiteral$3,
+    isIdentifier: isIdentifier$5,
+} = types$j;
 
-const isNextString = (path) => isStringLiteral$2(path.getNextSibling());
-const isPrevString = (path) => isStringLiteral$2(path.getPrevSibling());
+const isNextString = (path) => isStringLiteral$3(path.getNextSibling());
+const isPrevString = (path) => isStringLiteral$3(path.getPrevSibling());
 const isAroundStrings = (path) => isNextString(path) || isPrevString(path);
-const isNextObject = (a) => a.getNextSibling().isObjectExpression();
-const isPrevObject = (a) => a.getPrevSibling().isObjectExpression();
-const isObjectAfterSpread = (a) => isSpreadElement(a) && isNextObject(a) && !isPrevObject(a);
+
+const isSpreadBeforeObject = (a) => {
+    if (!a.isObjectExpression())
+        return false;
+    
+    const prev = a.getPrevSibling();
+    
+    if (!prev.isSpreadElement())
+        return false;
+    
+    if (prev.getPrevSibling().isObjectExpression())
+        return false;
+    
+    return prev
+        .get('argument')
+        .isCallExpression();
+};
+
+const isNextSimple = (a) => {
+    const next = a.getNextSibling();
+    
+    if (next.isSpreadElement())
+        return true;
+    
+    return next.isIdentifier();
+};
+
+const isNextSimpleBetweenObjects = (a) => {
+    const next = a.getNextSibling();
+    const is = next.isSpreadElement() || next.isIdentifier();
+    
+    if (!is)
+        return true;
+    
+    return next
+        .getNextSibling()
+        .isObjectExpression();
+};
 
 const isInsideOneElementArray = ({parentPath}) => parentPath.node.elements.length === 1;
 
@@ -79495,18 +79693,24 @@ arrayExpression.ArrayExpression = {
         
         for (const [index, element] of elements.entries()) {
             const is = isNewLine && isCurrentNewLine(element);
+            
+            if (isSimpleAfterObject(element))
+                print.newline();
+            
             maybe.indent(is);
             print(element);
             
             if (index < n || trailingComma)
                 maybe.print(is, ',');
             
-            maybe.print.newline(is && !isNextObject(element));
-            maybe.print.space(isObjectAfterSpread(element));
+            maybe.print.newline((is || isSpreadBeforeObject(element)) && !isNextObject(element));
+            maybe.print.space(is && isObjectAfterSimple(element));
             
             if (!is && index < n) {
                 print(',');
-                print.space();
+                
+                if (isNextSimpleBetweenObjects(element) || !(element.isObjectExpression() && isNextSimple(element)))
+                    print.space();
             }
         }
         
@@ -79526,6 +79730,11 @@ arrayExpression.ArrayExpression = {
             maybe.indent(elements.length && isNewLine);
         }
         
+        if (isSimpleAndEmptyObject(elements) && !isSpreadElement(elements.at(-1))) {
+            print(',');
+            print.breakline();
+        }
+        
         print(']');
     },
     afterIf(path) {
@@ -79550,6 +79759,19 @@ arrayExpression.ArrayExpression = {
     },
 };
 
+function isSimpleAfterObject(path) {
+    if (!isSpreadElement(path) && !isIdentifier$5(path))
+        return;
+    
+    const prev = path.getPrevSibling();
+    const next = path.getNextSibling();
+    
+    if (next.isObjectExpression())
+        return false;
+    
+    return prev.isObjectExpression();
+}
+
 var arrayPattern = {};
 
 const {maybeTypeAnnotation: maybeTypeAnnotation$2} = maybeTypeAnnotation$4;
@@ -80111,11 +80333,31 @@ expressionStatement.ExpressionStatement = {
         if (hasTrailingComment$1(path) && !isCoupleLines$4(path))
             return;
         
+        if (isTopParentLast(path))
+            return;
+        
         print.newline();
         maybe.markAfter(store(), path);
     },
 };
 
+function isTopParentLast({parentPath}) {
+    if (!parentPath.isIfStatement())
+        return false;
+    
+    const nextParent = parentPath.parentPath;
+    
+    if (!nextParent.isIfStatement())
+        return false;
+    
+    const nextNext = nextParent.parentPath;
+    
+    if (!nextNext.isIfStatement())
+        return false;
+    
+    return isLast$a(nextNext);
+}
+
 function isNotLastBody(path) {
     return path.parentPath.get('body') === path;
 }
@@ -80236,7 +80478,6 @@ variableDeclaration.VariableDeclaration = {
             write.newline();
             wasNewline = true;
         } else if (isParentSwitchCase(path)) {
-            //write.breakline();
             write.newline();
         }
         
@@ -80391,6 +80632,7 @@ ifStatement.IfStatement = {
         const alternate = path.get('alternate');
         const isConsequentBlock = consequent.isBlockStatement();
         const isVar = consequent.isVariableDeclaration();
+        consequent.isReturnStatement();
         
         if (isConsequentBlock) {
             print.space();
@@ -80414,7 +80656,12 @@ ifStatement.IfStatement = {
             write.space();
             traverse(alternate);
         } else if (alternate.isIfStatement()) {
-            write(' else ');
+            if (alternate.get('consequent').isBlockStatement())
+                write.space();
+            else
+                indent();
+            
+            write('else ');
             traverse(alternate);
         } else if (exists$6(alternate)) {
             maybe.write.newline(isVar);
@@ -80427,6 +80674,9 @@ ifStatement.IfStatement = {
             indent.dec();
         }
         
+        if (!isNext$i(path) && !consequent.isBlockStatement())
+            return;
+        
         if (path === partOfAlternate && isInside(path))
             print.newline();
     },
@@ -80738,6 +80988,8 @@ const {maybeSpaceAfterKeyword} = maybeSpaceAfterKeyword$1;
 
 const isBodyLength = ({parentPath}) => parentPath.node?.body?.length > 2;
 
+const isInsideIfWithElse = ({parentPath}) => parentPath.isIfStatement() && parentPath.node.alternate;
+
 returnStatement.ReturnStatement = {
     beforeIf(path) {
         return !hasPrevNewline(path) && isBodyLength(path) || isPrevBody(path);
@@ -80765,6 +81017,9 @@ returnStatement.ReturnStatement = {
         print(';');
     },
     afterIf: (path) => {
+        if (isInsideIfWithElse(path))
+            return true;
+        
         if (isLast$6(path))
             return false;
         
@@ -80993,11 +81248,18 @@ const {
 
 importDeclaration.ImportAttribute = ImportAttribute;
 importDeclaration.ImportDeclaration = {
-    print(path, {print, maybe, write, traverse, indent}, options) {
+    print(path, printer, semantics) {
+        const {
+            print,
+            maybe,
+            write,
+            traverse,
+            indent,
+        } = printer;
+        
         const {phase} = path.node;
         const isType = path.node.importKind === 'type';
         const specifiers = path.get('specifiers');
-        const {maxSpecifiersInOneLine} = options;
         
         indent();
         write('import');
@@ -81026,6 +81288,7 @@ importDeclaration.ImportDeclaration = {
             traverse(spec.get('local'));
         }
         
+        const maxSpecifiersInOneLine = parseMaxSpecifiers(imports, semantics);
         const importsCount = imports.length - 1;
         
         for (const [index, spec] of imports.entries()) {
@@ -81037,7 +81300,7 @@ importDeclaration.ImportDeclaration = {
             indent.inc();
             
             maybe.write(!wasSpecifier, '{');
-            maybe.write.breakline(importsCount > maxSpecifiersInOneLine);
+            maybe.write.breakline(importsCount >= maxSpecifiersInOneLine);
             
             wasSpecifier = true;
             write(imported.name);
@@ -81047,18 +81310,18 @@ importDeclaration.ImportDeclaration = {
                 write(spec.node.local.name);
             }
             
-            if (importsCount <= maxSpecifiersInOneLine && notLast) {
+            if (importsCount < maxSpecifiersInOneLine && notLast) {
                 maybe.write(n, ',');
                 maybe.write.space(n);
             }
             
-            if (importsCount > maxSpecifiersInOneLine) {
+            if (importsCount >= maxSpecifiersInOneLine) {
                 maybe.write(n, ',');
                 
                 const last = index === n;
-                const penult = index === n - 1;
+                const penulty = index === n - 1;
                 
-                maybe.write.newline(penult && defaults.length);
+                maybe.write.newline(penulty && defaults.length);
                 maybe.write.newline(last);
             }
             
@@ -81091,6 +81354,23 @@ importDeclaration.ImportDeclaration = {
     },
 };
 
+function parseMaxSpecifiers(imports, semantics) {
+    const {
+        maxSpecifiersInOneLine,
+        maxPropertiesLengthInOneLine,
+    } = semantics;
+    
+    for (const {node} of imports) {
+        if (node.imported.name !== node.local.name)
+            return 1;
+        
+        if (node.imported.name.length >= maxPropertiesLengthInOneLine)
+            return 1;
+    }
+    
+    return maxSpecifiersInOneLine;
+}
+
 var exportDeclaration = {};
 
 const {
@@ -81431,6 +81711,7 @@ var program = {};
 
 const {parseComments: parseComments$1} = comment;
 const {getDirectives} = getDirectives$2;
+const {hasCoupleTrailingComments} = is$3;
 
 program.Program = (path, printer, semantics) => {
     const {body} = path.node;
@@ -81457,6 +81738,9 @@ program.Program = (path, printer, semantics) => {
     if (directives.length && !body.length)
         return;
     
+    if (body.length && hasCoupleTrailingComments(body.at(-1)))
+        return;
+    
     write.endOfFile();
 };
 
@@ -81587,9 +81871,26 @@ identifier.Identifier = maybeParens$2(maybeTypeAnnotation((path, printer) => {
     maybe.write(optional, '?');
 }));
 
+var decorator = {};
+
+const {isMemberExpression} = bundle.types;
+
+decorator.Decorator = (path, {print, maybe}) => {
+    const {expression} = path.node;
+    const isMember = isMemberExpression(expression);
+    
+    print('@');
+    
+    maybe.print(isMember, '(');
+    print('__expression');
+    maybe.print(isMember, ')');
+};
+
 const {TemplateLiteral} = templateLiteral;
 const {Identifier: Identifier$2} = identifier;
 
+const {Decorator} = decorator;
+
 const maybeEncode = (value, {encodeDoubleQuote, encodeSingleQuote}) => {
     if (encodeSingleQuote && !value.includes('\\'))
         return value.replaceAll(`'`, `\\'`);
@@ -81602,14 +81903,11 @@ const maybeEncode = (value, {encodeDoubleQuote, encodeSingleQuote}) => {
 
 var literals$1 = {
     Identifier: Identifier$2,
+    Decorator,
     TemplateLiteral,
     BigIntLiteral(path, {write}) {
         write(path.node.raw);
     },
-    Decorator(path, {print}) {
-        print('@');
-        print('__expression');
-    },
     NumericLiteral(path, {write}) {
         const {
             raw,
@@ -81711,8 +82009,13 @@ const {
 const {markAfter} = mark;
 const {maybeDeclare: maybeDeclare$3} = maybeDeclare$6;
 const isNextType = (a) => a.getNextSibling().isTSTypeAliasDeclaration();
+const isNextExport = (a) => a.getNextSibling().isExportDeclaration();
 
 tsTypeAliasDeclaration.TSTypeAliasDeclaration = {
+    beforeIf: (path) => !path.parentPath.isExportDeclaration(),
+    before: (path, {indent}) => {
+        indent();
+    },
     print: maybeDeclare$3((path, {print, maybe, store}) => {
         const typeAnnotation = path.get('typeAnnotation');
         const isConditional = typeAnnotation.isTSConditionalType();
@@ -81742,7 +82045,8 @@ tsTypeAliasDeclaration.TSTypeAliasDeclaration = {
         
         return !isNextType(path);
     },
-    after(path, {print}) {
+    after(path, {print, maybe}) {
+        maybe.indent(isNextExport(path));
         print.newline();
         markAfter(path);
     },
@@ -81750,8 +82054,8 @@ tsTypeAliasDeclaration.TSTypeAliasDeclaration = {
 
 var tsMappedType = {};
 
-const {types: types$h} = bundle;
-const {isTSConditionalType} = types$h;
+const {types: types$i} = bundle;
+const {isTSConditionalType} = types$i;
 
 tsMappedType.TSMappedType = (path, {print, indent, maybe}) => {
     const {
@@ -82639,6 +82943,9 @@ var jsxOpeningElement = {};
 const {isCoupleLines: isCoupleLines$1} = is$3;
 
 const isNotJSX = ({parentPath}) => {
+    if (parentPath.parentPath.isCallExpression())
+        return false;
+    
     if (parentPath.parentPath.isJSXElement())
         return false;
     
@@ -82841,7 +83148,7 @@ function snakeCase(str) {
 }
 
 const {stringify: stringify$8} = JSON;
-const {TYPES: TYPES$2} = types$q;
+const {TYPES: TYPES$2} = types$s;
 const toSnakeCase = justSnakeCase;
 
 const {codeFrameColumns: codeFrameColumns$1} = bundle;
@@ -82951,6 +83258,7 @@ function initSemantics(semantics = {}) {
     return {
         comments: true,
         maxPropertiesInOneLine: 2,
+        maxPropertiesLengthInOneLine: 15,
         maxSpecifiersInOneLine: 2,
         maxElementsInOneLine: 5,
         maxVariablesInOneLine: 4,
@@ -82966,7 +83274,7 @@ const {round} = Math;
 const fullstore$2 = fullstore$3;
 const isObject$4 = (a) => a && typeof a === 'object';
 const babelTraverse$2 = bundle.traverse;
-const {TYPES: TYPES$1} = types$q;
+const {TYPES: TYPES$1} = types$s;
 const baseVisitors = visitors$1;
 
 const {
@@ -83334,6 +83642,7 @@ json.toJS = (source, name = __json) => {
 };
 
 json.fromJS = (source, name = __json) => {
+    source = maybeNewline$1(source);
     const shortName = cut$1(name);
     
     source = source.slice(source.indexOf(shortName));
@@ -83859,7 +84168,7 @@ var getAst = (node) => {
     return ast;
 };
 
-const {traverse: traverse$a, types: types$g} = bundle;
+const {traverse: traverse$a, types: types$h} = bundle;
 
 const traverseObjectExpression = traverseObjectExpression$1;
 const setClassMethod = setClassMethod$1;
@@ -83886,7 +84195,7 @@ const getAST = getAst;
 const {
     isObjectExpression,
     isExportDeclaration,
-} = types$g;
+} = types$h;
 
 var estreeToBabel = (node) => {
     const ast = getAST(node);
@@ -91299,14 +91608,16 @@ const clean = (a) => a.filter(Boolean);
 const initBabel = once$6(() => bundle);
 const {assign: assign$8} = Object;
 
-// There is a difference in options naming for babel and recast// recast -> sourceFileName// babel, putout: sourceFilename
-babel$1.parse = function babelParse(source, {sourceFilename, isTS, isJSX = true, isFlow = getFlow(source)}) {
+// There is a difference in options naming for babel and recast
+// recast -> sourceFileName
+// babel, putout: sourceFilename
+babel$1.parse = function babelParse(source, {sourceFilename, isTS, isJSX = true, isFlow = getFlow(source), isRecovery}) {
     const {parse} = initBabel();
-    
     const parserOptions = {
         sourceType: 'module',
         tokens: true,
         ...options,
+        errorRecovery: isRecovery,
         plugins: clean([
             ...plugins,
             ...getBabelLangExts({
@@ -101282,10 +101593,10 @@ var tenko_prod = /*#__PURE__*/Object.freeze({
 	toktypeToString: toktypeToString
 });
 
-var require$$1$1 = /*@__PURE__*/getAugmentedNamespace(tenko_prod);
+var require$$1 = /*@__PURE__*/getAugmentedNamespace(tenko_prod);
 
 const once$3 = onceExports;
-const initTenko = once$3(() => require$$1$1);
+const initTenko = once$3(() => require$$1);
 
 tenko$1.parse = (source) => {
     const {Tenko} = initTenko();
@@ -104016,7 +104327,7 @@ function isAbsolute(path) {
 }
 
 // posix version
-function join$2() {
+function join$3() {
   var paths = Array.prototype.slice.call(arguments, 0);
   return normalize(filter$1(paths, function(p, index) {
     if (typeof p !== 'string') {
@@ -104101,17 +104412,17 @@ function basename$3(path, ext) {
 }
 
 
-function extname(path) {
+function extname$1(path) {
   return splitPath(path)[3];
 }
 var _polyfillNode_path = {
-  extname: extname,
+  extname: extname$1,
   basename: basename$3,
   dirname: dirname$1,
   sep: sep,
   delimiter: delimiter,
   relative: relative$1,
-  join: join$2,
+  join: join$3,
   isAbsolute: isAbsolute,
   normalize: normalize,
   resolve: resolve
@@ -104140,9 +104451,9 @@ var _polyfillNode_path$1 = /*#__PURE__*/Object.freeze({
 	default: _polyfillNode_path,
 	delimiter: delimiter,
 	dirname: dirname$1,
-	extname: extname,
+	extname: extname$1,
 	isAbsolute: isAbsolute,
-	join: join$2,
+	join: join$3,
 	normalize: normalize,
 	relative: relative$1,
 	resolve: resolve,
@@ -109132,7 +109443,7 @@ function requireDist () {
 
 		function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
-		function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+		function _interopRequireWildcard(obj, nodeInterop) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
 		const DEFAULTS = {
 		  flow: 'detect'
@@ -109216,20 +109527,35 @@ var tryCatch$5 = (fn, ...args) => {
 
 const tryCatch$4 = tryCatch$5;
 
-var secondChance$1 = (fn, source, a, b) => {
+var secondChance$1 = (fn, source, messages, args) => {
+    const [a, ...others] = args;
     const [errorA, resultA] = tryCatch$4(fn, source, a);
     
     if (!errorA)
         return resultA;
     
-    const [errorB, resultB] = tryCatch$4(fn, source, b);
+    if (checkError(errorA, messages))
+        throw errorA;
     
-    if (!errorB)
-        return resultB;
+    for (const b of others) {
+        const [errorB, resultB] = tryCatch$4(fn, source, b);
+        
+        if (!errorB)
+            return resultB;
+    }
     
     throw errorA;
 };
 
+function checkError(error, messages) {
+    for (const message of messages) {
+        if (error.message.includes(message))
+            return true;
+    }
+    
+    return false;
+}
+
 const acorn = acorn$2;
 const babel = babel$1;
 const espree = espree$2;
@@ -109239,6 +109565,10 @@ const hermes = hermes$1;
 const secondChance = secondChance$1;
 const isObject$3 = (a) => typeof a === 'object';
 
+const MESSAGES = [
+    'has already been declared',
+];
+
 var customParser$1 = (source, parser, {isTS, isFlow, isJSX}) => {
     const options = {
         parser,
@@ -109247,18 +109577,30 @@ var customParser$1 = (source, parser, {isTS, isFlow, isJSX}) => {
         isJSX,
     };
     
-    return secondChance(customParse, source, options, {
+    const optionsB = {
         ...options,
         isJSX: false,
-    });
+    };
+    
+    const optionsC = {
+        ...options,
+        isRecovery: true,
+    };
+    
+    return secondChance(customParse, source, MESSAGES, [
+        options,
+        optionsB,
+        optionsC,
+    ]);
 };
 
-function customParse(source, {parser, isTS, isFlow, isJSX}) {
+function customParse(source, {parser, isTS, isFlow, isJSX, isRecovery}) {
     if (parser === 'babel')
         return babel.parse(source, {
             isTS,
             isFlow,
             isJSX,
+            isRecovery,
         });
     
     if (isObject$3(parser))
@@ -109285,11 +109627,11 @@ function customParse(source, {parser, isTS, isFlow, isJSX}) {
     return commonjsRequire(parser).parse(source);
 }
 
-const {types: types$f} = bundle;
+const {types: types$g} = bundle;
 const {
-    StringLiteral: StringLiteral$3,
+    StringLiteral: StringLiteral$4,
     ExpressionStatement,
-} = types$f;
+} = types$g;
 
 const {assign: assign$7} = Object;
 
@@ -109304,7 +109646,7 @@ var moveOutDirectives$1 = (ast) => {
     for (const directive of directives) {
         const {leadingComments} = directive;
         const {value} = directive.value;
-        const expression = assign$7(ExpressionStatement(StringLiteral$3(value)), {
+        const expression = assign$7(ExpressionStatement(StringLiteral$4(value)), {
             leadingComments,
         });
         
@@ -109617,16 +109959,7 @@ var lib$1 = {};
 
 var load$1 = {};
 
-var _polyfillNode_module = {};
-
-var _polyfillNode_module$1 = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	default: _polyfillNode_module
-});
-
-var require$$1 = /*@__PURE__*/getAugmentedNamespace(_polyfillNode_module$1);
-
-const {createRequire} = require$$1;
+const {createRequire} = require$$1$1;
 
 const tryCatch$3 = tryCatch$5;
 const once$1 = onceExports;
@@ -110067,7 +110400,7 @@ isEnabled$4.isEnabled = (name, rules) => {
     }
     
     for (const {rule, state} of rules) {
-        if (RegExp(`^${rule}`).test(name))
+        if (RegExp(`^${rule}/`).test(name))
             return state;
     }
     
@@ -111464,7 +111797,7 @@ function getStore(plugin, {fix, rule, shebang, msg, options}) {
 
 mergeVisitors$1.default;
 
-const {traverse: babelTraverse$1, types: types$e} = bundle;
+const {traverse: babelTraverse$1, types: types$f} = bundle;
 
 const {generate: generate$1} = parser$6;
 const {merge: merge$1} = babelTraverse$1.visitors;
@@ -111483,7 +111816,7 @@ var superFind$1 = function superFind({rule, find, ast, options, template}) {
             template,
         }),
         generate: generate$1,
-        types: types$e,
+        types: types$f,
         push,
         options,
     });
@@ -111669,7 +112002,7 @@ function check$5(selector) {
 var is$2 = {};
 
 const {template: template$8} = parser$6;
-const {types: types$d} = bundle;
+const {types: types$e} = bundle;
 const {
     isBlockStatement: isBlockStatement$1,
     isBooleanLiteral,
@@ -111685,7 +112018,7 @@ const {
     isJSXIdentifier,
     isJSXAttribute,
     isTSTypeReference: isTSTypeReference$1,
-} = types$d;
+} = types$e;
 
 const isStr$1 = (a) => typeof a === 'string';
 
@@ -111986,7 +112319,7 @@ is$2.isInsideTypeReference = (path) => path.isIdentifier() && path.parentPath?.i
 
 const jessy = jessy$1;
 const nessy = nessy$1;
-const {traverse: traverse$7, types: types$c} = bundle;
+const {traverse: traverse$7, types: types$d} = bundle;
 const {template: template$7} = parser$6;
 
 const {replaceWith: replaceWith$3, extract} = operate;
@@ -112006,9 +112339,9 @@ const {
     isStatement: isStatement$1,
     isJSXElement,
     isLiteral: isLiteral$1,
-    isTemplateLiteral,
+    isTemplateLiteral: isTemplateLiteral$1,
     TemplateElement,
-} = types$c;
+} = types$d;
 
 const {extractExpression: extractExpression$1} = template$7;
 
@@ -112118,7 +112451,7 @@ function setValues$2({waysTo, values, path}) {
             if (isStatement$1(values[name]))
                 way = way.replace(/\.expression$/, '');
             
-            if (isLiteral$1(values[name]) && isTemplateLiteral(node)) {
+            if (isLiteral$1(values[name]) && isTemplateLiteral$1(node)) {
                 const {value} = values[name];
                 
                 const element = TemplateElement({
@@ -112187,14 +112520,14 @@ function parseValue(a) {
 
 var logExports = log$4.exports;
 
-const {types: types$b} = bundle;
+const {types: types$c} = bundle;
 const {
     isIdentifier: isIdentifier$1,
     isLiteral,
-    isStringLiteral: isStringLiteral$1,
+    isStringLiteral: isStringLiteral$2,
     isTemplateElement: isTemplateElement$1,
     isTSTypeReference,
-} = types$b;
+} = types$c;
 
 const parseName = (node) => {
     node = node[0] || node;
@@ -112216,7 +112549,7 @@ const parseName = (node) => {
 var link$1 = ({add, value, nodeValue, templateStore}) => {
     const name = parseName(value);
     
-    if (isStringLiteral$1(value) && !isStringLiteral$1(nodeValue))
+    if (isStringLiteral$2(value) && !isStringLiteral$2(nodeValue))
         return false;
     
     if (!templateStore[name]) {
@@ -112259,13 +112592,13 @@ const {
     isLinkedRegExp: isLinkedRegExp$1,
 } = is$2;
 
-const {types: types$a} = bundle;
+const {types: types$b} = bundle;
 const {
     isClassBody,
     isBlock,
     isJSXText,
     isTemplateElement,
-} = types$a;
+} = types$b;
 
 const isEmptyBlock = (a) => isBlock(a) && !a.body.length;
 const isPrimitive = (a) => typeof a !== 'object' || a === null;
@@ -112372,7 +112705,7 @@ function compareJSXTexts(node, template) {
 
 var topLevelComparators = {};
 
-const {types: types$9} = bundle;
+const {types: types$a} = bundle;
 const {
     isEqualBody,
     isEqualAnyObject,
@@ -112385,8 +112718,8 @@ const {
 
 const {
     isIdentifier,
-    isStringLiteral,
-} = types$9;
+    isStringLiteral: isStringLiteral$1,
+} = types$a;
 
 const comparators = [
     isEqualAnyObject,
@@ -112418,7 +112751,7 @@ function isLinkedAndIdentifier(node, templateNode) {
 }
 
 function isLinkedAndStringLiteral(node, templateNode) {
-    return isStringLiteral(node) && isLinkedNode(templateNode);
+    return isStringLiteral$1(node) && isLinkedNode(templateNode);
 }
 
 const {template: template$6} = parser$6;
@@ -112536,7 +112869,7 @@ compare$5.compareAll = (path, templateNodes, options) => {
 };
 
 // @babel/template creates empty array directives// extra duplicate value
-const ignore$2 = [
+const ignore$3 = [
     'loc',
     'start',
     'end',
@@ -112568,7 +112901,7 @@ function superCompareIterate(node, template) {
             return false;
         
         for (const key of keys$2(template)) {
-            if (ignore$2.includes(key))
+            if (ignore$3.includes(key))
                 continue;
             
             const nodeValue = extractExpression(node[key]);
@@ -112641,8 +112974,8 @@ function findKey(path, parent) {
 
 const wraptile = wraptile$1;
 const findPath = findPath$1;
-const {types: types$8} = bundle;
-const {isProgram: isProgram$2} = types$8;
+const {types: types$9} = bundle;
+const {isProgram: isProgram$2} = types$9;
 const name = '__putout_runner_replace';
 const hasWatermark = (watermark) => (path) => path.node?.[name]?.has(watermark);
 
@@ -112707,7 +113040,7 @@ var watermarkExports = watermark$1.exports;
 
 const {template: template$5, print: print$2} = parser$6;
 const {remove, replaceWith: replaceWith$2} = operate;
-const {types: types$7} = bundle;
+const {types: types$8} = bundle;
 
 const {
     compare: compare$3,
@@ -112724,7 +113057,7 @@ const {
     isExpression,
     isStatement,
     isExpressionStatement,
-} = types$7;
+} = types$8;
 
 const PRINT_OPTIONS = {
     printer: ['putout', {
@@ -112965,11 +113298,11 @@ const {
     setModuleType,
 } = record;
 
-const {types: types$6} = bundle;
+const {types: types$7} = bundle;
 const {
     isImportDeclaration,
     isVariableDeclaration,
-} = types$6;
+} = types$7;
 
 const {keys} = Object;
 const isString$3 = (a) => typeof a === 'string';
@@ -113224,14 +113557,14 @@ function deinit() {
     assign$2(maybeFS$1, defaultFS);
 }
 
-const {join: join$1, basename: basename$1} = require$$0$2;
+const {join: join$2, basename: basename$1} = require$$0$2;
 const tryCatch$1 = tryCatch$5;
-const {types: types$5} = bundle;
+const {types: types$6} = bundle;
 
 const {
     setLiteralValue,
     getProperty: getProperty$2,
-    traverseProperties,
+    traverseProperties: traverseProperties$1,
 } = operate;
 
 const maybeFS = maybeFs;
@@ -113260,10 +113593,10 @@ const fromBase64 = (content) => {
 const {
     ObjectExpression: ObjectExpression$1,
     ArrayExpression: ArrayExpression$2,
-    StringLiteral: StringLiteral$2,
+    StringLiteral: StringLiteral$3,
     ObjectProperty: ObjectProperty$2,
     isProgram: isProgram$1,
-} = types$5;
+} = types$6;
 
 const getRegExp = (wildcard) => {
     const escaped = wildcard
@@ -113291,7 +113624,7 @@ function findFile$5(node, name) {
     const filePaths = [];
     const names = maybeArray$1(name);
     
-    for (const filenamePath of traverseProperties(node, 'filename')) {
+    for (const filenamePath of traverseProperties$1(node, 'filename')) {
         const {value} = filenamePath.node.value;
         const base = basename$1(value);
         
@@ -113376,7 +113709,7 @@ filesystem.moveFile = (filePath, dirPath) => {
         .split('/')
         .pop();
     
-    const newFilename = join$1(dirname, basename);
+    const newFilename = join$2(dirname, basename);
     
     maybeRemoveFile(dirPath, newFilename);
     
@@ -113395,7 +113728,7 @@ filesystem.copyFile = (filePath, dirPath) => {
         .split('/')
         .pop();
     
-    const newFilename = join$1(dirname, basename);
+    const newFilename = join$2(dirname, basename);
     const [hasContent, content] = getFileContent(filePath);
     
     const copiedFile = ObjectExpression$1([
@@ -113421,7 +113754,8 @@ function maybeRemoveFile(dirPath, filename) {
     }
     
     const dirPathFiles = getProperty$2(dirPath, 'files');
-    const [fileToOverwrite] = findFile$5(dirPathFiles, filename);
+    const name = join$2(getFilename$4(dirPath), basename$1(filename));
+    const [fileToOverwrite] = findFile$5(dirPathFiles, name);
     
     if (!fileToOverwrite)
         return;
@@ -113429,19 +113763,19 @@ function maybeRemoveFile(dirPath, filename) {
     fileToOverwrite.remove();
 }
 
-const createTypeProperty = (type) => ObjectProperty$2(StringLiteral$2('type'), StringLiteral$2(type));
+const createTypeProperty = (type) => ObjectProperty$2(StringLiteral$3('type'), StringLiteral$3(type));
 
 filesystem.createTypeProperty = createTypeProperty;
 
-const createFilesProperty = (files) => ObjectProperty$2(StringLiteral$2('files'), ArrayExpression$2(files));
+const createFilesProperty = (files) => ObjectProperty$2(StringLiteral$3('files'), ArrayExpression$2(files));
 
 filesystem.createFilesProperty = createFilesProperty;
 
-const createFilenameProperty = (filename) => ObjectProperty$2(StringLiteral$2('filename'), StringLiteral$2(filename));
+const createFilenameProperty = (filename) => ObjectProperty$2(StringLiteral$3('filename'), StringLiteral$3(filename));
 
 filesystem.createFilenameProperty = createFilenameProperty;
 
-const createContentProperty = (content) => ObjectProperty$2(StringLiteral$2('content'), StringLiteral$2(content));
+const createContentProperty = (content) => ObjectProperty$2(StringLiteral$3('content'), StringLiteral$3(content));
 
 filesystem.createContentProperty = createContentProperty;
 
@@ -113450,7 +113784,7 @@ filesystem.createFile = (dirPath, name, content) => {
     
     const dirPathFiles = getFiles$1(dirPath);
     const parentFilename = getFilename$4(dirPath);
-    const filename = join$1(parentFilename, name);
+    const filename = join$2(parentFilename, name);
     
     const typeProperty = createTypeProperty('file');
     const filenameProperty = createFilenameProperty(filename);
@@ -113480,7 +113814,7 @@ function getFiles$1(dirPath) {
 filesystem.createDirectory = (dirPath, name) => {
     const dirPathFiles = getFiles$1(dirPath);
     const parentFilename = getFilename$4(dirPath);
-    const filename = join$1(parentFilename, name);
+    const filename = join$2(parentFilename, name);
     
     const typeProperty = createTypeProperty('directory');
     const filesProperty = createFilesProperty([]);
@@ -113551,7 +113885,7 @@ filesystem.start = maybeFS.start;
 
 var convertSimpleFilesystemToFilesystem = {};
 
-const {types: types$4} = bundle;
+const {types: types$5} = bundle;
 const {basename, dirname} = require$$0$2;
 const {
     createDirectory,
@@ -113565,11 +113899,13 @@ const {replaceWith: replaceWith$1, getProperty: getProperty$1} = operate;
 
 const {
     ObjectExpression,
-    isArrayExpression,
     ArrayExpression: ArrayExpression$1,
-    StringLiteral: StringLiteral$1,
+    StringLiteral: StringLiteral$2,
     ObjectProperty: ObjectProperty$1,
-} = types$4;
+    isArrayExpression,
+    isStringLiteral,
+    isTemplateLiteral,
+} = types$5;
 
 convertSimpleFilesystemToFilesystem.report = () => `Convert Simple Filesystem to Filesystem`;
 
@@ -113577,24 +113913,34 @@ const isDirectory = (a) => a.endsWith('/');
 const getType = (a) => {
     const type = isDirectory(a) ? 'directory' : 'file';
     
-    return ObjectProperty$1(StringLiteral$1('type'), StringLiteral$1(type));
+    return ObjectProperty$1(StringLiteral$2('type'), StringLiteral$2(type));
 };
 
 const createFilename = (filename) => {
-    return ObjectProperty$1(StringLiteral$1('filename'), StringLiteral$1(filename));
+    return ObjectProperty$1(StringLiteral$2('filename'), StringLiteral$2(filename));
 };
 
 const getFiles = (a) => {
     if (isDirectory(a))
-        return ObjectProperty$1(StringLiteral$1('files'), ArrayExpression$1([]));
+        return ObjectProperty$1(StringLiteral$2('files'), ArrayExpression$1([]));
     
     return null;
 };
 
 const getContent = (a) => {
-    return ObjectProperty$1(StringLiteral$1('content'), StringLiteral$1(a));
+    return ObjectProperty$1(StringLiteral$2('content'), StringLiteral$2(a));
 };
 
+function parseContent(node, path) {
+    if (isStringLiteral(node))
+        return node.value;
+    
+    if (isTemplateLiteral(node))
+        return btoa(node.quasis[0].value.raw);
+    
+    throw Error(`☝️ Looks like wrong content type: '${node.type}' from file: '${path}'`);
+}
+
 convertSimpleFilesystemToFilesystem.fix = (path) => {
     const array = ArrayExpression$1([]);
     
@@ -113602,7 +113948,8 @@ convertSimpleFilesystemToFilesystem.fix = (path) => {
         if (isArrayExpression(element)) {
             const [nodeValue, nodeContent] = element.node.elements;
             const {value} = nodeValue;
-            const content = nodeContent.value;
+            
+            const content = parseContent(nodeContent, element);
             
             array.elements.push(ObjectExpression([
                 getType(value),
@@ -113612,13 +113959,18 @@ convertSimpleFilesystemToFilesystem.fix = (path) => {
             continue;
         }
         
-        const {value} = element.node;
+        if (isStringLiteral(element)) {
+            const {value} = element.node;
+            
+            array.elements.push(ObjectExpression([
+                getType(value),
+                createFilename(noTrailingSlash(value)),
+                getFiles(value),
+            ].filter(Boolean)));
+            continue;
+        }
         
-        array.elements.push(ObjectExpression([
-            getType(value),
-            createFilename(noTrailingSlash(value)),
-            getFiles(value),
-        ].filter(Boolean)));
+        throw Error(`☝️ Looks like file '${element}' has wrong type: '${element.type}' expected: 'string | array'`);
     }
     
     buildTree(path, array);
@@ -113651,7 +114003,7 @@ function buildTree(path, list) {
         const name = basename(filename);
         const [dirPath] = findFile$4(root, dir);
         
-        if (!dirPath)
+        if (!dirPath || getFileType$1(dirPath) !== 'directory')
             throw Error(`☝️ Looks like directory '${dir}/' is missing`);
         
         if (type === 'directory') {
@@ -113673,7 +114025,7 @@ function check$2(filename) {
 
 var convertFilesystemToSimpleFilesystem = {};
 
-const {types: types$3} = bundle;
+const {types: types$4} = bundle;
 const {replaceWith, getProperty} = operate;
 const {__filesystem_name: __filesystem_name$1} = json;
 
@@ -113684,9 +114036,9 @@ const {
 } = filesystem;
 
 const {
-    StringLiteral,
+    StringLiteral: StringLiteral$1,
     ArrayExpression,
-} = types$3;
+} = types$4;
 
 const {isArray: isArray$1} = Array;
 const maybeAddSlash = (a) => a === '/' ? a : `${a}/`;
@@ -113720,13 +114072,13 @@ convertFilesystemToSimpleFilesystem.fix = (root, {files}) => {
     for (const name of names) {
         if (isArray$1(name)) {
             list.push(ArrayExpression([
-                StringLiteral(name[0]),
-                StringLiteral(name[1]),
+                StringLiteral$1(name[0]),
+                StringLiteral$1(name[1]),
             ]));
             continue;
         }
         
-        list.push(StringLiteral(name));
+        list.push(StringLiteral$1(name));
     }
     
     replaceWith(root, ArrayExpression(list));
@@ -114925,7 +115277,7 @@ report$3.default;
 
 var traverse$5 = {};
 
-const {types: types$2, traverse: babelTraverse} = bundle;
+const {types: types$3, traverse: babelTraverse} = bundle;
 
 const {
     compare,
@@ -114934,7 +115286,7 @@ const {
     getTemplateValues,
 } = compare$5;
 
-const {isFile, isProgram} = types$2;
+const {isFile, isProgram} = types$3;
 const {merge} = babelTraverse.visitors;
 const {entries: entries$2} = Object;
 
@@ -122122,7 +122474,7 @@ var addArgs = {};
 
 const {compareAny} = compare$5;
 const {template: template$1} = parser$6;
-const {types: types$1} = bundle;
+const {types: types$2} = bundle;
 const {
     ObjectPattern,
     ObjectProperty,
@@ -122131,7 +122483,7 @@ const {
     isLabeledStatement,
     isObjectPattern,
     isCallExpression,
-} = types$1;
+} = types$2;
 
 const {entries: entries$1} = Object;
 
@@ -122853,7 +123205,7 @@ factory.isPathValid = isPathValid;
 // Fixes typescript
 factory.default = factory;
 
-var ignore$1 = factory;
+var ignore$2 = factory;
 
 // Windows
 // --------------------------------------------------------------
@@ -122882,17 +123234,17 @@ if (
     || isNotRelative(path);
 }
 
-ignore$1.default;
+ignore$2.default;
 
 const {relative} = require$$0$2;
-const ignore = ignore$1;
+const ignore$1 = ignore$2;
 
 const isNegative = (a) => !a.indexOf('!');
 const positive = (a) => a.replace(/^!/, '');
 
 var ignores$1 = (dirOpt, resolvedName, options = {}) => {
     const relativeName = relative(dirOpt, resolvedName);
-    const ignorer = ignore();
+    const ignorer = ignore$1();
     const ignoreList = mergeIgnores(options.ignore || []);
     
     ignorer.add(ignoreList);
@@ -122915,6 +123267,8 @@ function mergeIgnores(ignores) {
 
 ignores$1.default;
 
+const {join: join$1, extname} = require$$0$2;
+
 const {parse: parse$2, print: print$1} = parser$6;
 const {transform: transform$1} = transform$5;
 const {findPlaces: findPlaces$1} = findPlaces$2;
@@ -122928,6 +123282,7 @@ const {
     writeFileContent,
     getFilename: getFilename$1,
     createFile,
+    removeFile,
     getParentDirectory: getParentDirectory$1,
 } = filesystem;
 
@@ -122946,41 +123301,46 @@ matchFiles.matchFiles = (files) => {
     };
 };
 
-function fix$1(path, {outputFilename, matchedJS, matchedAST, plugins}) {
+function fix$1(inputFile, {dirPath, mainPath, matchInputFilename, outputFilename, matchedJS, matchedAST, plugins}) {
     transform$1(matchedAST, matchedJS, {
         plugins,
     });
     
     const matchedJSON = magicPrint(outputFilename, matchedAST);
+    const outputFile = getOutputFile(mainPath, {
+        dirPath,
+        matchInputFilename,
+        outputFilename,
+        inputFile,
+    });
     
-    writeFileContent(path, matchedJSON);
+    writeFileContent(outputFile, matchedJSON);
+    
+    if (inputFile !== outputFile)
+        removeFile(inputFile);
 }
 
-const createScan = (files) => (path, {push, progress, options}) => {
+const createScan = (files) => (mainPath, {push, progress, options}) => {
     const allFiles = [];
-    const cwd = getFilename$1(path);
+    const cwd = getFilename$1(mainPath);
     
     for (const [filename, plugin] of entries(files)) {
         const [matchInputFilename, outputFilename = matchInputFilename] = parseMatcher(filename, options);
-        const inputFiles = findFile$1(path, matchInputFilename);
+        const inputFiles = findFile$1(mainPath, matchInputFilename);
         
         for (const inputFile of inputFiles) {
             const dirPath = getParentDirectory$1(inputFile);
             const inputFilename = getFilename$1(inputFile);
-            const outputFile = getOutputFile(path, {
-                dirPath,
-                matchInputFilename,
-                outputFilename,
-                inputFile,
-            });
             
             if (ignores(cwd, inputFilename, options))
                 continue;
             
             allFiles.push({
+                mainPath,
+                dirPath,
+                matchInputFilename,
                 plugin,
                 inputFile,
-                outputFile,
                 inputFilename,
                 outputFilename,
             });
@@ -122989,7 +123349,17 @@ const createScan = (files) => (path, {push, progress, options}) => {
     
     const n = allFiles.length;
     
-    for (const [i, {inputFile, outputFile, inputFilename, outputFilename, plugin}] of allFiles.entries()) {
+    for (const [i, current] of allFiles.entries()) {
+        const {
+            dirPath,
+            matchInputFilename,
+            inputFile,
+            inputFilename,
+            outputFilename,
+            plugin,
+            mainPath,
+        } = current;
+        
         progress({
             i,
             n,
@@ -123012,7 +123382,11 @@ const createScan = (files) => (path, {push, progress, options}) => {
         
         const {message} = places[0];
         
-        push(outputFile, {
+        push(inputFile, {
+            dirPath,
+            mainPath,
+            matchInputFilename,
+            
             outputFilename,
             message,
             plugins,
@@ -123063,7 +123437,8 @@ function getOutputFile(path, {dirPath, matchInputFilename, outputFilename, input
     if (matchInputFilename === outputFilename)
         return inputFile;
     
-    const [outputFile] = findFile$1(dirPath, outputFilename);
+    const name = join$1(getFilename$1(dirPath), outputFilename);
+    const [outputFile] = findFile$1(dirPath, name);
     
     if (outputFile)
         return outputFile;
@@ -123072,14 +123447,16 @@ function getOutputFile(path, {dirPath, matchInputFilename, outputFilename, input
 }
 
 function parseMatcher(matcher, options) {
-    for (const [name, value] of entries(options)) {
-        if (name === 'filename') {
-            const [name, ext] = value.split('.');
-            
-            matcher = matcher.replaceAll(`__name`, name);
-            matcher = matcher.replaceAll(`__ext`, ext);
-        }
-    }
+    const {filename} = options;
+    
+    if (!filename)
+        return matcher.split(' -> ');
+    
+    const ext = extname(filename);
+    const shortName = filename.replace(ext, '');
+    
+    matcher = matcher.replaceAll(`__name`, shortName);
+    matcher = matcher.replaceAll(`__ext`, ext);
     
     return matcher.split(' -> ');
 }
@@ -123161,6 +123538,111 @@ function findUpPackage(file) {
     return packageJSON;
 }
 
+var ignore = {};
+
+const {types: types$1} = bundle;
+const {traverseProperties} = operate;
+const {StringLiteral} = types$1;
+const getValue = ({value}) => value;
+
+ignore.ignore = (type, {name, property, list}) => {
+    const [, collector] = type.split(/\(|\)/);
+    
+    return {
+        report: createReport(name),
+        match: createMatch({
+            type,
+            property,
+            collector,
+            list,
+        }),
+        replace: createReplace({
+            type,
+            property,
+            collector,
+            list,
+        }),
+    };
+};
+
+const createReport = (name) => () => `Add dotfiles to '${name}'`;
+
+const createMatch = ({type, property, collector, list}) => ({options}) => {
+    const {dismiss = []} = options;
+    const newNames = filterNames(list, dismiss);
+    
+    return {
+        [type]: (vars) => {
+            const elements = parseElements(vars, {
+                property,
+                collector,
+            });
+            
+            if (!elements)
+                return false;
+            
+            const list = elements.map(getValue);
+            
+            for (const name of newNames) {
+                if (!list.includes(name))
+                    return true;
+            }
+            
+            return false;
+        },
+    };
+};
+
+const createReplace = ({type, property, collector, list}) => ({options}) => {
+    const {dismiss = []} = options;
+    const newNames = filterNames(list, dismiss);
+    
+    return {
+        [type]: (vars, path) => {
+            const elements = parseElements(vars, {
+                property,
+                collector,
+            });
+            
+            const list = elements.map(getValue);
+            
+            for (const name of newNames) {
+                if (!list.includes(name))
+                    elements.push(StringLiteral(name));
+            }
+            
+            return path;
+        },
+    };
+};
+
+function filterNames(names, dismiss) {
+    const newNames = [];
+    
+    for (const name of names) {
+        if (dismiss.includes(name))
+            continue;
+        
+        newNames.push(name);
+    }
+    
+    return newNames;
+}
+
+function parseElements(vars, {property, collector}) {
+    const node = vars[collector];
+    
+    if (!property)
+        return node.elements;
+    
+    const [prop] = traverseProperties(node, property);
+    
+    if (!prop)
+        return null;
+    
+    return prop.node.value.elements;
+}
+
 const {codeFrameColumns} = bundle;
 
 var codeframe = ({source, error, highlightCode = true}) => {
@@ -123317,6 +123799,7 @@ var operator = putout.exports.operator = {
     ...filesystem,
     ...matchFiles,
     ...renameFiles,
+    ...ignore,
 };
 
 putout.exports.ignores = ignores$1;