@danielx/civet 0.5.43 → 0.5.44

package/dist/main.mjs

@@ -527,6 +527,20 @@ ${input.slice(result.pos)}
       BindingElement,
       BindingRestElement,
       EmptyBindingPattern,
+      MatchingPattern,
+      ObjectMatchingPattern,
+      ObjectMatchingPatternContent,
+      NestedMatchingProperties,
+      NestedMatchingProperty,
+      MatchingProperty,
+      NestedMatchingRestProperty,
+      MatchingRestProperty,
+      ArrayMatchingPattern,
+      ArrayMatchingPatternContent,
+      NestedMatchingElements,
+      NestedMatchingElement,
+      MatchingElement,
+      MatchingRestElement,
       FunctionDeclaration,
       FunctionSignature,
       FunctionExpression,
@@ -4331,6 +4345,492 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var MatchingPattern$0 = ObjectMatchingPattern;
+    var MatchingPattern$1 = ArrayMatchingPattern;
+    var MatchingPattern$2 = Literal;
+    var MatchingPattern$3 = RegularExpressionLiteral;
+    function MatchingPattern(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("MatchingPattern", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("MatchingPattern", state, MatchingPattern$0(state) || MatchingPattern$1(state) || MatchingPattern$2(state) || MatchingPattern$3(state));
+        if (state.events)
+          state.events.exit?.("MatchingPattern", state, result, eventData);
+        return result;
+      } else {
+        const result = MatchingPattern$0(state) || MatchingPattern$1(state) || MatchingPattern$2(state) || MatchingPattern$3(state);
+        if (state.events)
+          state.events.exit?.("MatchingPattern", state, result, eventData);
+        return result;
+      }
+    }
+    var ObjectMatchingPattern$0 = $TS($S(OpenBrace, ObjectMatchingPatternContent, __, CloseBrace), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var open = $1;
+      var content = $2;
+      var ws = $3;
+      var close = $4;
+      return {
+        type: "ObjectMatchingPattern",
+        children: [open, ...content.children, ...ws, close]
+      };
+    });
+    function ObjectMatchingPattern(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("ObjectMatchingPattern", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("ObjectMatchingPattern", state, ObjectMatchingPattern$0(state));
+        if (state.events)
+          state.events.exit?.("ObjectMatchingPattern", state, result, eventData);
+        return result;
+      } else {
+        const result = ObjectMatchingPattern$0(state);
+        if (state.events)
+          state.events.exit?.("ObjectMatchingPattern", state, result, eventData);
+        return result;
+      }
+    }
+    var ObjectMatchingPatternContent$0 = NestedMatchingProperties;
+    var ObjectMatchingPatternContent$1 = $TS($S($Q(MatchingProperty), $E(MatchingRestProperty), $Q(MatchingProperty)), function($skip, $loc, $0, $1, $2, $3) {
+      var props = $1;
+      var rest = $2;
+      var after = $3;
+      const names = props.flatMap((p) => p.names);
+      const children = [...props];
+      if (rest) {
+        [rest, after] = module.reorderBindingRestProperty(rest, after);
+        children.push(...after, rest);
+        names.push(...after.flatMap((p) => p.names), ...rest.names);
+      }
+      return {
+        names,
+        children
+      };
+    });
+    function ObjectMatchingPatternContent(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("ObjectMatchingPatternContent", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("ObjectMatchingPatternContent", state, ObjectMatchingPatternContent$0(state) || ObjectMatchingPatternContent$1(state));
+        if (state.events)
+          state.events.exit?.("ObjectMatchingPatternContent", state, result, eventData);
+        return result;
+      } else {
+        const result = ObjectMatchingPatternContent$0(state) || ObjectMatchingPatternContent$1(state);
+        if (state.events)
+          state.events.exit?.("ObjectMatchingPatternContent", state, result, eventData);
+        return result;
+      }
+    }
+    var NestedMatchingProperties$0 = $TS($S(PushIndent, $Q(NestedMatchingProperty), $E(NestedMatchingRestProperty), $Q(NestedMatchingProperty), PopIndent), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+      var props = $2;
+      var rest = $3;
+      var after = $4;
+      if (!(props.length || rest))
+        return $skip;
+      const names = props.flatMap((p) => p.names);
+      const children = [...props];
+      if (rest) {
+        [rest, after] = module.reorderBindingRestProperty(rest, after);
+        children.push(...after, rest);
+        names.push(...after.flatMap((p) => p.names), ...rest.names);
+      }
+      return {
+        children,
+        names
+      };
+    });
+    function NestedMatchingProperties(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("NestedMatchingProperties", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("NestedMatchingProperties", state, NestedMatchingProperties$0(state));
+        if (state.events)
+          state.events.exit?.("NestedMatchingProperties", state, result, eventData);
+        return result;
+      } else {
+        const result = NestedMatchingProperties$0(state);
+        if (state.events)
+          state.events.exit?.("NestedMatchingProperties", state, result, eventData);
+        return result;
+      }
+    }
+    var NestedMatchingProperty$0 = $TS($S(Nested, MatchingProperty), function($skip, $loc, $0, $1, $2) {
+      var indent = $1;
+      var prop = $2;
+      return {
+        ...prop,
+        children: [...indent, ...prop.children]
+      };
+    });
+    function NestedMatchingProperty(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("NestedMatchingProperty", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("NestedMatchingProperty", state, NestedMatchingProperty$0(state));
+        if (state.events)
+          state.events.exit?.("NestedMatchingProperty", state, result, eventData);
+        return result;
+      } else {
+        const result = NestedMatchingProperty$0(state);
+        if (state.events)
+          state.events.exit?.("NestedMatchingProperty", state, result, eventData);
+        return result;
+      }
+    }
+    var MatchingProperty$0 = $TS($S(__, PropertyName, __, Colon, $C(BindingIdentifier, MatchingPattern), ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+      var m = $5;
+      return {
+        names: m.names,
+        children: $0
+      };
+    });
+    var MatchingProperty$1 = $TS($S(BindingIdentifier, ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2) {
+      var b = $1;
+      if (b.type === "AtBinding") {
+        return {
+          type: "AtBindingProperty",
+          ref: b.ref,
+          names: [],
+          children: $0
+        };
+      }
+      return {
+        names: b.names,
+        children: $0
+      };
+    });
+    function MatchingProperty(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("MatchingProperty", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("MatchingProperty", state, MatchingProperty$0(state) || MatchingProperty$1(state));
+        if (state.events)
+          state.events.exit?.("MatchingProperty", state, result, eventData);
+        return result;
+      } else {
+        const result = MatchingProperty$0(state) || MatchingProperty$1(state);
+        if (state.events)
+          state.events.exit?.("MatchingProperty", state, result, eventData);
+        return result;
+      }
+    }
+    var NestedMatchingRestProperty$0 = $TS($S(Nested, MatchingRestProperty), function($skip, $loc, $0, $1, $2) {
+      var indent = $1;
+      var prop = $2;
+      return {
+        ...prop,
+        children: [indent, ...prop.children]
+      };
+    });
+    function NestedMatchingRestProperty(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("NestedMatchingRestProperty", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("NestedMatchingRestProperty", state, NestedMatchingRestProperty$0(state));
+        if (state.events)
+          state.events.exit?.("NestedMatchingRestProperty", state, result, eventData);
+        return result;
+      } else {
+        const result = NestedMatchingRestProperty$0(state);
+        if (state.events)
+          state.events.exit?.("NestedMatchingRestProperty", state, result, eventData);
+        return result;
+      }
+    }
+    var MatchingRestProperty$0 = BindingRestProperty;
+    function MatchingRestProperty(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("MatchingRestProperty", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("MatchingRestProperty", state, MatchingRestProperty$0(state));
+        if (state.events)
+          state.events.exit?.("MatchingRestProperty", state, result, eventData);
+        return result;
+      } else {
+        const result = MatchingRestProperty$0(state);
+        if (state.events)
+          state.events.exit?.("MatchingRestProperty", state, result, eventData);
+        return result;
+      }
+    }
+    var ArrayMatchingPattern$0 = $TS($S(OpenBracket, ArrayMatchingPatternContent, __, CloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var open = $1;
+      var content = $2;
+      var ws = $3;
+      var close = $4;
+      return {
+        type: "ArrayMatchingPattern",
+        children: $0
+      };
+    });
+    function ArrayMatchingPattern(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("ArrayMatchingPattern", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("ArrayMatchingPattern", state, ArrayMatchingPattern$0(state));
+        if (state.events)
+          state.events.exit?.("ArrayMatchingPattern", state, result, eventData);
+        return result;
+      } else {
+        const result = ArrayMatchingPattern$0(state);
+        if (state.events)
+          state.events.exit?.("ArrayMatchingPattern", state, result, eventData);
+        return result;
+      }
+    }
+    var ArrayMatchingPatternContent$0 = NestedMatchingElements;
+    var ArrayMatchingPatternContent$1 = $TS($S($Q($C(MatchingElement, Elision)), $E($S(MatchingRestElement, ArrayElementDelimiter)), $Q($C(MatchingElement, Elision))), function($skip, $loc, $0, $1, $2, $3) {
+      var props = $1;
+      var rest = $2;
+      var after = $3;
+      const names = props.flatMap((p) => p.names || []);
+      const children = [...props];
+      let blockPrefix;
+      if (rest) {
+        const [restBinding] = rest;
+        children.push(restBinding);
+        let restIdentifier;
+        if (restBinding.ref) {
+          restIdentifier = restBinding.ref;
+        } else {
+          restIdentifier = restBinding.names[0];
+          names.push(...restBinding.names);
+        }
+        if (after.length) {
+          const spliceRef = module.getRef("splice");
+          blockPrefix = {
+            children: ["[", module.insertTrimmingSpace(after, ""), "] = ", spliceRef, ".call(", restIdentifier, ", -", after.length.toString(), ")"],
+            names: after.flatMap((p) => p.names)
+          };
+        }
+      }
+      return {
+        names,
+        children,
+        blockPrefix
+      };
+    });
+    function ArrayMatchingPatternContent(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("ArrayMatchingPatternContent", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("ArrayMatchingPatternContent", state, ArrayMatchingPatternContent$0(state) || ArrayMatchingPatternContent$1(state));
+        if (state.events)
+          state.events.exit?.("ArrayMatchingPatternContent", state, result, eventData);
+        return result;
+      } else {
+        const result = ArrayMatchingPatternContent$0(state) || ArrayMatchingPatternContent$1(state);
+        if (state.events)
+          state.events.exit?.("ArrayMatchingPatternContent", state, result, eventData);
+        return result;
+      }
+    }
+    var NestedMatchingElements$0 = $TS($S(PushIndent, $Q(NestedMatchingElement), $E($S(Nested, MatchingRestElement, ArrayElementDelimiter)), $Q(NestedMatchingElement), PopIndent), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+      var props = $2;
+      var rest = $3;
+      var after = $4;
+      if (!(props.length || rest))
+        return $skip;
+      const names = props.flatMap((p) => p.names), children = [...props];
+      let blockPrefix;
+      if (rest) {
+        const [, restBinding] = rest;
+        let restIdentifier;
+        if (restBinding.ref) {
+          restIdentifier = restBinding.binding.ref;
+        } else {
+          restIdentifier = restBinding.names[0];
+        }
+        if (after.length) {
+          const spliceRef = module.getRef("splice");
+          blockPrefix = {
+            children: ["[", module.insertTrimmingSpace(after, ""), "] = ", spliceRef, ".call(", restIdentifier, ", -", after.length.toString(), ")"],
+            names: after.flatMap((p) => p.names)
+          };
+        }
+        children.push(...rest);
+        names.push(...restBinding.names);
+      }
+      return {
+        children,
+        names,
+        blockPrefix
+      };
+    });
+    function NestedMatchingElements(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("NestedMatchingElements", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("NestedMatchingElements", state, NestedMatchingElements$0(state));
+        if (state.events)
+          state.events.exit?.("NestedMatchingElements", state, result, eventData);
+        return result;
+      } else {
+        const result = NestedMatchingElements$0(state);
+        if (state.events)
+          state.events.exit?.("NestedMatchingElements", state, result, eventData);
+        return result;
+      }
+    }
+    var NestedMatchingElement$0 = $TS($S(Nested, MatchingElement), function($skip, $loc, $0, $1, $2) {
+      var indent = $1;
+      var element = $2;
+      return {
+        ...element,
+        children: [indent, ...element.children]
+      };
+    });
+    function NestedMatchingElement(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("NestedMatchingElement", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("NestedMatchingElement", state, NestedMatchingElement$0(state));
+        if (state.events)
+          state.events.exit?.("NestedMatchingElement", state, result, eventData);
+        return result;
+      } else {
+        const result = NestedMatchingElement$0(state);
+        if (state.events)
+          state.events.exit?.("NestedMatchingElement", state, result, eventData);
+        return result;
+      }
+    }
+    var MatchingElement$0 = $TS($S($C(BindingIdentifier, MatchingPattern), ArrayElementDelimiter), function($skip, $loc, $0, $1, $2) {
+      var binding = $1;
+      return {
+        names: binding.names,
+        children: $0
+      };
+    });
+    function MatchingElement(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("MatchingElement", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("MatchingElement", state, MatchingElement$0(state));
+        if (state.events)
+          state.events.exit?.("MatchingElement", state, result, eventData);
+        return result;
+      } else {
+        const result = MatchingElement$0(state);
+        if (state.events)
+          state.events.exit?.("MatchingElement", state, result, eventData);
+        return result;
+      }
+    }
+    var MatchingRestElement$0 = BindingRestElement;
+    function MatchingRestElement(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("MatchingRestElement", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("MatchingRestElement", state, MatchingRestElement$0(state));
+        if (state.events)
+          state.events.exit?.("MatchingRestElement", state, result, eventData);
+        return result;
+      } else {
+        const result = MatchingRestElement$0(state);
+        if (state.events)
+          state.events.exit?.("MatchingRestElement", state, result, eventData);
+        return result;
+      }
+    }
     var FunctionDeclaration$0 = FunctionExpression;
     function FunctionDeclaration(state) {
       let eventData;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielx/civet",
-  "version": "0.5.43",
+  "version": "0.5.44",
   "description": "CoffeeScript style syntax for TypeScript",
   "main": "dist/main.js",
   "module": "dist/main.mjs",