@danielx/civet 0.5.93 → 0.5.94

package/dist/browser.js

@@ -386,6 +386,82 @@ var Civet = (() => {
           return '"' + str.replace(/"/g, '\\"') + '"';
         }
       }
+      function lastAccessInCallExpression(exp) {
+        let children, i;
+        do {
+          ({ children } = exp);
+          i = children.length - 1;
+          while (i >= 0 && (children[i].type === "Call" || children[i].type === "NonNullAssertion" || children[i].type === "Optional"))
+            i--;
+          if (i < 0)
+            return;
+        } while (children[i].type === "MemberExpression" && (exp = children[i]));
+        return children[i];
+      }
+      function convertMethodToFunction(method) {
+        const { signature, block } = method;
+        let { modifier } = signature;
+        if (modifier) {
+          if (modifier.get || modifier.set) {
+            return;
+          } else if (modifier.async) {
+            modifier = [modifier.children[0][0], " function ", ...modifier.children.slice(1)];
+          } else {
+            modifier = ["function ", ...modifier.children];
+          }
+        } else {
+          modifier = "function ";
+        }
+        return {
+          ...signature,
+          id: signature.name,
+          type: "FunctionExpression",
+          children: [
+            [modifier, ...signature.children.slice(1)],
+            block
+          ],
+          block
+        };
+      }
+      function convertObjectToJSXAttributes(obj) {
+        const { content } = obj;
+        const parts = [];
+        const rest = [];
+        for (let i = 0; i < content.length; i++) {
+          if (i > 0)
+            parts.push(" ");
+          const part = content[i];
+          switch (part.type) {
+            case "Identifier":
+              parts.push([part.name, "={", part.name, "}"]);
+              break;
+            case "Property":
+              if (part.name.type === "ComputedPropertyName") {
+                rest.push(part);
+              } else {
+                parts.push([part.name, "={", insertTrimmingSpace(part.value, ""), "}"]);
+              }
+              break;
+            case "SpreadProperty":
+              parts.push(["{", part.dots, part.value, "}"]);
+              break;
+            case "MethodDefinition":
+              const func = convertMethodToFunction(part);
+              if (func) {
+                parts.push([part.name, "={", convertMethodToFunction(part), "}"]);
+              } else {
+                rest.push(part);
+              }
+              break;
+            default:
+              throw new Error(`invalid object literal type in JSX attribute: ${part.type}`);
+          }
+        }
+        if (rest.length) {
+          parts.push(["{...{", ...rest, "}}"]);
+        }
+        return parts;
+      }
       function processCoffeeInterpolation(s, parts, e, $loc) {
         if (parts.length === 0 || parts.length === 1 && parts[0].token != null) {
           return {
@@ -534,6 +610,8 @@ var Civet = (() => {
       module.exports = {
         blockWithPrefix,
         clone,
+        convertMethodToFunction,
+        convertObjectToJSXAttributes,
         deepCopy,
         findAncestor,
         forRange,
@@ -549,6 +627,7 @@ var Civet = (() => {
         hoistRefDecs,
         insertTrimmingSpace,
         isFunction,
+        lastAccessInCallExpression,
         literalValue,
         modifyString,
         processCoffeeInterpolation,
@@ -1052,6 +1131,7 @@ ${input.slice(result.pos)}
         SliceParameters,
         PropertyAccess,
         PropertyGlob,
+        PropertyBind,
         SuperProperty,
         MetaProperty,
         ReturnValue,
@@ -1839,7 +1919,7 @@ ${input.slice(result.pos)}
       var $R48 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
       var $R49 = $R(new RegExp("\\s", "suy"));
       var $R50 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
-      var $R51 = $R(new RegExp("[\\s>]", "suy"));
+      var $R51 = $R(new RegExp("[\\s>]|\\/>", "suy"));
       var $R52 = $R(new RegExp("(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+", "suy"));
       var $R53 = $R(new RegExp(`"[^"]*"|'[^']*'`, "suy"));
       var $R54 = $R(new RegExp("[<>]", "suy"));
@@ -4148,14 +4228,14 @@ ${input.slice(result.pos)}
       }
       var CallExpression$0 = $TS($S($EXPECT($L14, fail, 'CallExpression "super"'), ArgumentsWithTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
         var rest = $3;
-        return module.processGlob({
+        return module.processCallMemberExpression({
           type: "CallExpression",
           children: [$1, ...$2, ...rest.flat()]
         });
       });
       var CallExpression$1 = $TS($S($EXPECT($L15, fail, 'CallExpression "import"'), ArgumentsWithTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
         var rest = $3;
-        return module.processGlob({
+        return module.processCallMemberExpression({
           type: "CallExpression",
           children: [$1, ...$2, ...rest.flat()]
         });
@@ -4166,7 +4246,7 @@ ${input.slice(result.pos)}
         var rest = $3;
         if (rest.length || trailing.length) {
           rest = rest.flat();
-          return module.processGlob({
+          return module.processCallMemberExpression({
             type: "CallExpression",
             children: [member, ...trailing, ...rest]
           });
@@ -4309,7 +4389,7 @@ ${input.slice(result.pos)}
       var MemberExpression$0 = $TS($S($C(PrimaryExpression, SuperProperty, MetaProperty), $Q(MemberExpressionRest)), function($skip, $loc, $0, $1, $2) {
         var rest = $2;
         if (rest.length || Array.isArray($1)) {
-          return module.processGlob({
+          return module.processCallMemberExpression({
             type: "MemberExpression",
             children: [$1, ...rest].flat()
           });
@@ -4349,7 +4429,8 @@ ${input.slice(result.pos)}
       });
       var MemberExpressionRest$1 = PropertyAccess;
       var MemberExpressionRest$2 = PropertyGlob;
-      var MemberExpressionRest$3 = NonNullAssertion;
+      var MemberExpressionRest$3 = PropertyBind;
+      var MemberExpressionRest$4 = NonNullAssertion;
       function MemberExpressionRest(state) {
         let eventData;
         if (state.events) {
@@ -4361,12 +4442,12 @@ ${input.slice(result.pos)}
           }
         }
         if (state.tokenize) {
-          const result = $TOKEN("MemberExpressionRest", state, MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state) || MemberExpressionRest$3(state));
+          const result = $TOKEN("MemberExpressionRest", state, MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state) || MemberExpressionRest$3(state) || MemberExpressionRest$4(state));
           if (state.events)
             state.events.exit?.("MemberExpressionRest", state, result, eventData);
           return result;
         } else {
-          const result = MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state) || MemberExpressionRest$3(state);
+          const result = MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state) || MemberExpressionRest$3(state) || MemberExpressionRest$4(state);
           if (state.events)
             state.events.exit?.("MemberExpressionRest", state, result, eventData);
           return result;
@@ -4576,9 +4657,11 @@ ${input.slice(result.pos)}
         }
       }
       var PropertyGlob$0 = $TS($S(OptionalDot, BracedObjectLiteral), function($skip, $loc, $0, $1, $2) {
+        var dot = $1;
         var object = $2;
         return {
           type: "PropertyGlob",
+          dot,
           object,
           children: $0
         };
@@ -4605,6 +4688,38 @@ ${input.slice(result.pos)}
           return result;
         }
       }
+      var PropertyBind$0 = $TS($S($E($C(QuestionMark, NonNullAssertion)), At, OptionalDot, $C(IdentifierName, PrivateIdentifier)), function($skip, $loc, $0, $1, $2, $3, $4) {
+        var modifier = $1;
+        var dot = $3;
+        var id = $4;
+        return {
+          type: "PropertyBind",
+          name: id.name,
+          children: [modifier, dot, id]
+        };
+      });
+      function PropertyBind(state) {
+        let eventData;
+        if (state.events) {
+          const result = state.events.enter?.("PropertyBind", state);
+          if (result) {
+            if (result.cache)
+              return result.cache;
+            eventData = result.data;
+          }
+        }
+        if (state.tokenize) {
+          const result = $TOKEN("PropertyBind", state, PropertyBind$0(state));
+          if (state.events)
+            state.events.exit?.("PropertyBind", state, result, eventData);
+          return result;
+        } else {
+          const result = PropertyBind$0(state);
+          if (state.events)
+            state.events.exit?.("PropertyBind", state, result, eventData);
+          return result;
+        }
+      }
       var SuperProperty$0 = $S($EXPECT($L14, fail, 'SuperProperty "super"'), MemberBracketContent);
       var SuperProperty$1 = $S($EXPECT($L14, fail, 'SuperProperty "super"'), $N($C(QuestionMark, NonNullAssertion)), PropertyAccess);
       function SuperProperty(state) {
@@ -8125,11 +8240,11 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var PropertyDefinition$0 = $TS($S(__, At, IdentifierReference), function($skip, $loc, $0, $1, $2, $3) {
+      var PropertyDefinition$0 = $TS($S(__, AtThis, IdentifierReference), function($skip, $loc, $0, $1, $2, $3) {
         var ws = $1;
         var at = $2;
         var id = $3;
-        const value = [{ ...at, token: "this." }, id];
+        const value = [at, ".", id];
         return {
           type: "Property",
           children: [ws, id, ": ", ...value],
@@ -8187,26 +8302,19 @@ ${input.slice(result.pos)}
         if (value.type === "Identifier") {
           return { ...value, children: [ws, ...value.children] };
         }
-        let exp = value, children, i;
-        do {
-          ({ children } = exp);
-          i = children.length - 1;
-          while (i >= 0 && (children[i].type === "Call" || children[i].type === "NonNullAssertion" || children[i].type === "Optional"))
-            i--;
-          if (i < 0)
-            return $skip;
-        } while (children[i].type === "MemberExpression" && (exp = children[i]));
-        const last = children[i];
+        const last = lastAccessInCallExpression(value);
+        if (!last)
+          return $skip;
         let name;
-        if (last.name) {
-          ({ name } = last);
-        } else if (last.type === "Index") {
+        if (last.type === "Index") {
           name = {
             type: "ComputedPropertyName",
             children: last.children
           };
         } else {
-          return $skip;
+          ({ name } = last);
+          if (!name)
+            return $skip;
         }
         return {
           type: "Property",
@@ -12512,7 +12620,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var ExportDeclaration$0 = $TS($S(Export, __, Default, __, $C(HoistableDeclaration, ClassDeclaration, ExtendedExpression)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+      var ExportDeclaration$0 = $TS($S($E(Decorators), Export, __, Default, __, $C(HoistableDeclaration, ClassDeclaration, ExtendedExpression)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
         return { type: "ExportDeclaration", children: $0 };
       });
       var ExportDeclaration$1 = $TS($S(Export, __, ExportFromClause, __, FromClause), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
@@ -17193,42 +17301,7 @@ ${input.slice(result.pos)}
         }
       }
       var JSXAttribute$0 = $TS($S(BracedObjectLiteral), function($skip, $loc, $0, $1) {
-        const { children } = $1;
-        const parts = [];
-        const rest = [];
-        for (let i = 1; i < children.length - 1; i++) {
-          if (i > 1)
-            parts.push(" ");
-          const part = children[i];
-          switch (part.type) {
-            case "Identifier":
-              parts.push([part.name, "={", part.name, "}"]);
-              break;
-            case "Property":
-              if (part.name.type === "ComputedPropertyName") {
-                rest.push(part);
-              } else {
-                parts.push([part.name, "={", insertTrimmingSpace(part.value, ""), "}"]);
-              }
-              break;
-            case "SpreadProperty":
-              parts.push(["{", part.dots, part.value, "}"]);
-              break;
-            case "MethodDefinition":
-              try {
-                parts.push([part.name, "={", module.convertMethodToFunction(part), "}"]);
-              } catch {
-                rest.push(part);
-              }
-              break;
-            default:
-              throw new Error(`invalid object literal type in JSX attribute: ${part.type}`);
-          }
-        }
-        if (rest.length) {
-          parts.push(["{...{", ...rest, "}}"]);
-        }
-        return parts;
+        return convertObjectToJSXAttributes($1);
       });
       var JSXAttribute$1 = $TS($S(JSXAttributeName, $C(JSXAttributeInitializer, $Y(JSXAttributeSpace))), function($skip, $loc, $0, $1, $2) {
         var name = $1;
@@ -17248,16 +17321,73 @@ ${input.slice(result.pos)}
         }
       });
       var JSXAttribute$2 = $S(InsertInlineOpenBrace, DotDotDot, InlineJSXAttributeValue, InsertCloseBrace, $Y(JSXAttributeSpace));
-      var JSXAttribute$3 = $TS($S($EXPECT($L13, fail, 'JSXAttribute "#"'), JSXShorthandString), function($skip, $loc, $0, $1, $2) {
+      var JSXAttribute$3 = $TS($S(AtThis, $E(Identifier), $Q(InlineJSXCallExpressionRest), $Y(JSXAttributeSpace)), function($skip, $loc, $0, $1, $2, $3, $4) {
+        var at = $1;
+        var id = $2;
+        var rest = $3;
+        const access = id && {
+          type: "PropertyAccess",
+          children: [".", id],
+          name: id
+        };
+        const expr = module.processCallMemberExpression({
+          type: "CallExpression",
+          children: [at, access, ...rest.flat()]
+        });
+        const last = lastAccessInCallExpression(expr);
+        if (!last)
+          return $skip;
+        let name;
+        if (last.type === "Index") {
+          return [
+            "{...{",
+            { ...last, type: "ComputedPropertyName" },
+            ": ",
+            expr,
+            "}}"
+          ];
+        } else if (last.name) {
+          return [last.name, "={", expr, "}"];
+        }
+        return $skip;
+      });
+      var JSXAttribute$4 = $TS($S(Identifier, $P(InlineJSXCallExpressionRest), $Y(JSXAttributeSpace)), function($skip, $loc, $0, $1, $2, $3) {
+        var id = $1;
+        var rest = $2;
+        const expr = module.processCallMemberExpression({
+          type: "CallExpression",
+          children: [id, ...rest.flat()]
+        });
+        if (expr.type === "ObjectExpression") {
+          return convertObjectToJSXAttributes(expr);
+        }
+        const last = lastAccessInCallExpression(expr);
+        if (!last)
+          return $skip;
+        let name;
+        if (last.type === "Index") {
+          return [
+            "{...{",
+            { ...last, type: "ComputedPropertyName" },
+            ": ",
+            expr,
+            "}}"
+          ];
+        } else if (last.name) {
+          return [last.name, "={", expr, "}"];
+        }
+        return $skip;
+      });
+      var JSXAttribute$5 = $TS($S($EXPECT($L13, fail, 'JSXAttribute "#"'), JSXShorthandString), function($skip, $loc, $0, $1, $2) {
         return [" ", "id=", $2];
       });
-      var JSXAttribute$4 = $TS($S(Dot, JSXShorthandString), function($skip, $loc, $0, $1, $2) {
+      var JSXAttribute$6 = $TS($S(Dot, JSXShorthandString), function($skip, $loc, $0, $1, $2) {
         return {
           type: "JSXClass",
           class: $2
         };
       });
-      var JSXAttribute$5 = $TS($S($TEXT($EXPECT($R6, fail, "JSXAttribute /[!+-]/")), JSXAttributeName), function($skip, $loc, $0, $1, $2) {
+      var JSXAttribute$7 = $TS($S($TEXT($EXPECT($R6, fail, "JSXAttribute /[!+-]/")), JSXAttributeName, $Y(JSXAttributeSpace)), function($skip, $loc, $0, $1, $2, $3) {
         var toggle = $1;
         var id = $2;
         const value = toggle === "+" ? "true" : "false";
@@ -17274,18 +17404,18 @@ ${input.slice(result.pos)}
           }
         }
         if (state.tokenize) {
-          const result = $TOKEN("JSXAttribute", state, JSXAttribute$0(state) || JSXAttribute$1(state) || JSXAttribute$2(state) || JSXAttribute$3(state) || JSXAttribute$4(state) || JSXAttribute$5(state));
+          const result = $TOKEN("JSXAttribute", state, JSXAttribute$0(state) || JSXAttribute$1(state) || JSXAttribute$2(state) || JSXAttribute$3(state) || JSXAttribute$4(state) || JSXAttribute$5(state) || JSXAttribute$6(state) || JSXAttribute$7(state));
           if (state.events)
             state.events.exit?.("JSXAttribute", state, result, eventData);
           return result;
         } else {
-          const result = JSXAttribute$0(state) || JSXAttribute$1(state) || JSXAttribute$2(state) || JSXAttribute$3(state) || JSXAttribute$4(state) || JSXAttribute$5(state);
+          const result = JSXAttribute$0(state) || JSXAttribute$1(state) || JSXAttribute$2(state) || JSXAttribute$3(state) || JSXAttribute$4(state) || JSXAttribute$5(state) || JSXAttribute$6(state) || JSXAttribute$7(state);
           if (state.events)
             state.events.exit?.("JSXAttribute", state, result, eventData);
           return result;
         }
       }
-      var JSXAttributeSpace$0 = $R$0($EXPECT($R51, fail, "JSXAttributeSpace /[\\s>]/"));
+      var JSXAttributeSpace$0 = $R$0($EXPECT($R51, fail, "JSXAttributeSpace /[\\s>]|\\/>/"));
       function JSXAttributeSpace(state) {
         let eventData;
         if (state.events) {
@@ -17388,12 +17518,14 @@ ${input.slice(result.pos)}
       var JSXAttributeValue$0 = $S(OpenBrace, PostfixedExpression, $E(Whitespace), CloseBrace);
       var JSXAttributeValue$1 = JSXElement;
       var JSXAttributeValue$2 = JSXFragment;
-      var JSXAttributeValue$3 = $TS($S(InsertInlineOpenBrace, InlineJSXAttributeValue, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3) {
+      var JSXAttributeValue$3 = $TS($S(InsertInlineOpenBrace, InlineJSXAttributeValue, InsertCloseBrace, $Y(JSXAttributeSpace)), function($skip, $loc, $0, $1, $2, $3, $4) {
+        var open = $1;
         var value = $2;
+        var close = $3;
         if (value.type === "StringLiteral") {
           return $skip;
         }
-        return $0;
+        return [open, value, close];
       });
       var JSXAttributeValue$4 = $R$0($EXPECT($R53, fail, `JSXAttributeValue /"[^"]*"|'[^']*'/`));
       function JSXAttributeValue(state) {
@@ -17576,12 +17708,41 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var InlineJSXCallExpression$0 = $S($EXPECT($L14, fail, 'InlineJSXCallExpression "super"'), ExplicitArguments);
-      var InlineJSXCallExpression$1 = $S($EXPECT($L15, fail, 'InlineJSXCallExpression "import"'), OpenParen, PostfixedExpression, __, CloseParen);
+      var InlineJSXCallExpression$0 = $TS($S($EXPECT($L14, fail, 'InlineJSXCallExpression "super"'), ExplicitArguments, $Q(InlineJSXCallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
+        var args = $2;
+        var rest = $3;
+        return module.processCallMemberExpression({
+          type: "CallExpression",
+          children: [
+            $1,
+            { type: "Call", children: args },
+            ...rest.flat()
+          ]
+        });
+      });
+      var InlineJSXCallExpression$1 = $TS($S($EXPECT($L15, fail, 'InlineJSXCallExpression "import"'), ExplicitArguments, $Q(InlineJSXCallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
+        var args = $2;
+        var rest = $3;
+        return module.processCallMemberExpression({
+          type: "CallExpression",
+          children: [
+            $1,
+            { type: "Call", children: args },
+            ...rest.flat()
+          ]
+        });
+      });
       var InlineJSXCallExpression$2 = $TS($S(InlineJSXMemberExpression, $Q(InlineJSXCallExpressionRest)), function($skip, $loc, $0, $1, $2) {
-        if ($2.length)
-          return $0;
-        return $1;
+        var member = $1;
+        var rest = $2;
+        if (rest.length) {
+          rest = rest.flat();
+          return module.processCallMemberExpression({
+            type: "CallExpression",
+            children: [member, ...rest]
+          });
+        }
+        return member;
       });
       function InlineJSXCallExpression(state) {
         let eventData;
@@ -17605,9 +17766,20 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var InlineJSXCallExpressionRest$0 = MemberExpressionRest;
-      var InlineJSXCallExpressionRest$1 = TemplateLiteral;
-      var InlineJSXCallExpressionRest$2 = $S($E($C(OptionalShorthand, NonNullAssertion)), ExplicitArguments);
+      var InlineJSXCallExpressionRest$0 = InlineJSXMemberExpressionRest;
+      var InlineJSXCallExpressionRest$1 = $TV($C(TemplateLiteral, StringLiteral), function($skip, $loc, $0, $1) {
+        if ($1.type === "StringLiteral") {
+          return "`" + $1.token.slice(1, -1).replace(/(`|\$\{)/g, "\\$1") + "`";
+        }
+        return $1;
+      });
+      var InlineJSXCallExpressionRest$2 = $TS($S($E($C(OptionalShorthand, NonNullAssertion)), ExplicitArguments), function($skip, $loc, $0, $1, $2) {
+        var args = $2;
+        args = { type: "Call", children: args };
+        if (!$1)
+          return args;
+        return [$1, args];
+      });
       function InlineJSXCallExpressionRest(state) {
         let eventData;
         if (state.events) {
@@ -17630,13 +17802,16 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var InlineJSXMemberExpression$0 = $TS($S(InlineJSXPrimaryExpression, $Q(InlineJSXMemberExpressionRest)), function($skip, $loc, $0, $1, $2) {
-        if ($2.length)
-          return $0;
+      var InlineJSXMemberExpression$0 = $TS($S($C(InlineJSXPrimaryExpression, SuperProperty, MetaProperty), $Q(InlineJSXMemberExpressionRest)), function($skip, $loc, $0, $1, $2) {
+        var rest = $2;
+        if (rest.length || Array.isArray($1)) {
+          return module.processCallMemberExpression({
+            type: "MemberExpression",
+            children: [$1, ...rest].flat()
+          });
+        }
         return $1;
       });
-      var InlineJSXMemberExpression$1 = SuperProperty;
-      var InlineJSXMemberExpression$2 = MetaProperty;
       function InlineJSXMemberExpression(state) {
         let eventData;
         if (state.events) {
@@ -17648,12 +17823,12 @@ ${input.slice(result.pos)}
           }
         }
         if (state.tokenize) {
-          const result = $TOKEN("InlineJSXMemberExpression", state, InlineJSXMemberExpression$0(state) || InlineJSXMemberExpression$1(state) || InlineJSXMemberExpression$2(state));
+          const result = $TOKEN("InlineJSXMemberExpression", state, InlineJSXMemberExpression$0(state));
           if (state.events)
             state.events.exit?.("InlineJSXMemberExpression", state, result, eventData);
           return result;
         } else {
-          const result = InlineJSXMemberExpression$0(state) || InlineJSXMemberExpression$1(state) || InlineJSXMemberExpression$2(state);
+          const result = InlineJSXMemberExpression$0(state);
           if (state.events)
             state.events.exit?.("InlineJSXMemberExpression", state, result, eventData);
           return result;
@@ -17669,7 +17844,9 @@ ${input.slice(result.pos)}
         return $2;
       });
       var InlineJSXMemberExpressionRest$1 = PropertyAccess;
-      var InlineJSXMemberExpressionRest$2 = NonNullAssertion;
+      var InlineJSXMemberExpressionRest$2 = PropertyGlob;
+      var InlineJSXMemberExpressionRest$3 = PropertyBind;
+      var InlineJSXMemberExpressionRest$4 = NonNullAssertion;
       function InlineJSXMemberExpressionRest(state) {
         let eventData;
         if (state.events) {
@@ -17681,12 +17858,12 @@ ${input.slice(result.pos)}
           }
         }
         if (state.tokenize) {
-          const result = $TOKEN("InlineJSXMemberExpressionRest", state, InlineJSXMemberExpressionRest$0(state) || InlineJSXMemberExpressionRest$1(state) || InlineJSXMemberExpressionRest$2(state));
+          const result = $TOKEN("InlineJSXMemberExpressionRest", state, InlineJSXMemberExpressionRest$0(state) || InlineJSXMemberExpressionRest$1(state) || InlineJSXMemberExpressionRest$2(state) || InlineJSXMemberExpressionRest$3(state) || InlineJSXMemberExpressionRest$4(state));
           if (state.events)
             state.events.exit?.("InlineJSXMemberExpressionRest", state, result, eventData);
           return result;
         } else {
-          const result = InlineJSXMemberExpressionRest$0(state) || InlineJSXMemberExpressionRest$1(state) || InlineJSXMemberExpressionRest$2(state);
+          const result = InlineJSXMemberExpressionRest$0(state) || InlineJSXMemberExpressionRest$1(state) || InlineJSXMemberExpressionRest$2(state) || InlineJSXMemberExpressionRest$3(state) || InlineJSXMemberExpressionRest$4(state);
           if (state.events)
             state.events.exit?.("InlineJSXMemberExpressionRest", state, result, eventData);
           return result;
@@ -19804,7 +19981,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var TypeParameter$0 = $S(__, Identifier, $E(TypeConstraint), $E(TypeInitializer), TypeParameterDelimiter);
+      var TypeParameter$0 = $S(__, $E($S($EXPECT($L129, fail, 'TypeParameter "const"'), $E(_))), Identifier, $E(TypeConstraint), $E(TypeInitializer), TypeParameterDelimiter);
       function TypeParameter(state) {
         let eventData;
         if (state.events) {
@@ -21303,12 +21480,12 @@ ${input.slice(result.pos)}
             Object.assign(module.config, directive.config);
           }
         });
-        module.processGlob = (node) => {
+        module.processCallMemberExpression = (node) => {
           const { children } = node;
           for (let i = 0; i < children.length; i++) {
             const glob = children[i];
             if (glob?.type === "PropertyGlob") {
-              const prefix = children.slice(0, i).concat(glob.children[0]);
+              const prefix = children.slice(0, i).concat(glob.dot);
               const parts = [];
               for (const part of glob.object.content) {
                 if (part.type === "MethodDefinition") {
@@ -21333,7 +21510,7 @@ ${input.slice(result.pos)}
                   });
                 } else {
                   parts.push({
-                    type: part.type,
+                    type: part.type === "Identifier" ? "Property" : part.type,
                     name: part.name,
                     value,
                     delim: part.delim,
@@ -21351,6 +21528,7 @@ ${input.slice(result.pos)}
               }
               const object = {
                 type: "ObjectExpression",
+                content: parts,
                 children: [
                   glob.object.children[0],
                   ...parts,
@@ -21359,10 +21537,24 @@ ${input.slice(result.pos)}
               };
               if (i === children.length - 1)
                 return object;
-              return module.processGlob({
+              return module.processCallMemberExpression({
                 ...node,
                 children: [object, ...children.slice(i + 1)]
               });
+            } else if (glob?.type === "PropertyBind") {
+              const prefix = children.slice(0, i);
+              return module.processCallMemberExpression({
+                ...node,
+                children: [
+                  prefix,
+                  {
+                    ...glob,
+                    type: "PropertyAccess",
+                    children: [...glob.children, ".bind(", prefix, ")"]
+                  },
+                  ...children.slice(i + 1)
+                ]
+              });
             }
           }
           return node;
@@ -22306,31 +22498,6 @@ ${input.slice(result.pos)}
               throw new Error("Unknown postfix statement");
           }
         };
-        module.convertMethodToFunction = function(method) {
-          const { signature, block } = method;
-          let { modifier } = signature;
-          if (modifier) {
-            if (modifier.get || modifier.set) {
-              throw new Error("cannot convert get/set method to function");
-            } else if (modifier.async) {
-              modifier = [modifier.children[0][0], " function ", ...modifier.children.slice(1)];
-            } else {
-              modifier = ["function ", ...modifier.children];
-            }
-          } else {
-            modifier = "function ";
-          }
-          return {
-            ...signature,
-            id: signature.name,
-            type: "FunctionExpression",
-            children: [
-              [modifier, ...signature.children.slice(1)],
-              block
-            ],
-            block
-          };
-        };
         function getPatternConditions(pattern, ref, conditions) {
           switch (pattern.type) {
             case "ArrayMatchingPattern": {
@@ -23303,6 +23470,8 @@ ${input.slice(result.pos)}
       var {
         blockWithPrefix,
         clone,
+        convertMethodToFunction,
+        convertObjectToJSXAttributes,
         deepCopy,
         findAncestor,
         forRange,
@@ -23318,6 +23487,7 @@ ${input.slice(result.pos)}
         hoistRefDecs,
         insertTrimmingSpace,
         isFunction,
+        lastAccessInCallExpression,
         literalValue,
         modifyString,
         processCoffeeInterpolation,