@danielx/civet 0.5.43 → 0.5.44

package/dist/browser.js

@@ -530,6 +530,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,
@@ -4334,6 +4348,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;