@matter/model 0.12.0-alpha.0-20241229-9d9c99934 → 0.12.0-alpha.0-20241231-14ac774ba

package/dist/cjs/aspects/Constraint.d.ts

@@ -9,17 +9,15 @@ import { Aspect } from "./Aspect.js";
  * An operational view of constraints as defined by the Matter specification.
  *
  * A "constraint" limits possible data values.
- *
- * Formally a constraint is not considered a quality by the specification. It is handled similarly to qualities, though,
- * so we keep it in the same section.
  */
 export declare class Constraint extends Aspect<Constraint.Definition> implements Constraint.Ast {
     desc?: boolean;
-    value?: FieldValue;
-    min?: FieldValue;
-    max?: FieldValue;
+    value?: Constraint.Expression;
+    min?: Constraint.Expression;
+    max?: Constraint.Expression;
     in?: FieldValue;
     entry?: Constraint;
+    cpMax?: number;
     parts?: Constraint[];
     /**
      * Initialize from a Constraint.Definition or the constraint DSL defined by the Matter Specification.
@@ -35,7 +33,7 @@ export declare class Constraint extends Aspect<Constraint.Definition> implements
 export declare namespace Constraint {
     type NumberOrIdentifier = number | string;
     /**
-     * Parsed list structure.
+     * Parsed constraint.
      */
     type Ast = {
         /**
@@ -45,15 +43,15 @@ export declare namespace Constraint {
         /**
          * Constant value.
          */
-        value?: FieldValue;
+        value?: Expression;
         /**
          * Lower bound on value or sequence length.
          */
-        min?: FieldValue;
+        min?: Expression;
         /**
          * Upper bound on value or sequence length.
          */
-        max?: FieldValue;
+        max?: Expression;
         /**
          * Require set membership for the value.
          */
@@ -62,21 +60,32 @@ export declare namespace Constraint {
          * Constraint on list child element.
          */
         entry?: Ast;
+        /**
+         * Constraint on codepoints in a string.
+         */
+        cpMax?: number;
         /**
          * List of sub-constraints in a sequence.
          */
         parts?: Ast[];
     };
+    /**
+     * Parsed binary operator.
+     */
+    interface BinaryOperator {
+        type: "+" | "-";
+        lhs: Expression;
+        rhs: Expression;
+    }
+    /**
+     * Parsed expression.
+     */
+    type Expression = FieldValue | BinaryOperator;
     /**
      * These are all ways to describe a constraint.
      */
     type Definition = (Ast & {
         definition?: Definition;
     }) | string | number | undefined;
-    /**
-     * Parse constraint DSL.  Extremely lenient.
-     */
-    function parse(constraint: Constraint, definition: string): Ast;
-    function serialize(ast: Ast): string;
 }
 //# sourceMappingURL=Constraint.d.ts.map

package/dist/cjs/aspects/Constraint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Constraint.d.ts","sourceRoot":"","sources":["../../../src/aspects/Constraint.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC;;;;;;;GAOG;AACH,qBAAa,UAAW,SAAQ,MAAM,CAAC,UAAU,CAAC,UAAU,CAAE,YAAW,UAAU,CAAC,GAAG;IAC3E,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB,EAAE,CAAC,EAAE,UAAU,CAAC;IAChB,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,KAAK,CAAC,EAAE,UAAU,EAAE,CAAC;IAE7B;;OAEG;gBACS,UAAU,EAAE,UAAU,CAAC,UAAU;IAwD7C;;OAEG;IACH,IAAI,CAAC,KAAK,EAAE,UAAU,EAAE,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO;IA0DzD,QAAQ;cAOE,MAAM;CAM5B;AAED,yBAAiB,UAAU,CAAC;IACxB,KAAY,kBAAkB,GAAG,MAAM,GAAG,MAAM,CAAC;IAEjD;;OAEG;IACH,KAAY,GAAG,GAAG;QACd;;WAEG;QACH,IAAI,CAAC,EAAE,OAAO,CAAC;QAEf;;WAEG;QACH,KAAK,CAAC,EAAE,UAAU,CAAC;QAEnB;;WAEG;QACH,GAAG,CAAC,EAAE,UAAU,CAAC;QAEjB;;WAEG;QACH,GAAG,CAAC,EAAE,UAAU,CAAC;QAEjB;;WAEG;QACH,EAAE,CAAC,EAAE,UAAU,CAAC;QAEhB;;WAEG;QACH,KAAK,CAAC,EAAE,GAAG,CAAC;QAEZ;;WAEG;QACH,KAAK,CAAC,EAAE,GAAG,EAAE,CAAC;KACjB,CAAC;IAEF;;OAEG;IACH,KAAY,UAAU,GAAG,CAAC,GAAG,GAAG;QAAE,UAAU,CAAC,EAAE,UAAU,CAAA;KAAE,CAAC,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IA8G3F;;OAEG;IACH,SAAgB,KAAK,CAAC,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAG,GAAG,CAwGrE;IA6BD,SAAgB,SAAS,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAQ1C;CACJ"}
+{"version":3,"file":"Constraint.d.ts","sourceRoot":"","sources":["../../../src/aspects/Constraint.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC;;;;GAIG;AACH,qBAAa,UAAW,SAAQ,MAAM,CAAC,UAAU,CAAC,UAAU,CAAE,YAAW,UAAU,CAAC,GAAG;IAC3E,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,UAAU,CAAC,UAAU,CAAC;IAC9B,GAAG,CAAC,EAAE,UAAU,CAAC,UAAU,CAAC;IAC5B,GAAG,CAAC,EAAE,UAAU,CAAC,UAAU,CAAC;IAC5B,EAAE,CAAC,EAAE,UAAU,CAAC;IAChB,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,UAAU,EAAE,CAAC;IAE7B;;OAEG;gBACS,UAAU,EAAE,UAAU,CAAC,UAAU;IA2D7C;;OAEG;IACH,IAAI,CAAC,KAAK,EAAE,UAAU,EAAE,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO;IAoFzD,QAAQ;cAOE,MAAM;CAM5B;AAED,yBAAiB,UAAU,CAAC;IACxB,KAAY,kBAAkB,GAAG,MAAM,GAAG,MAAM,CAAC;IAEjD;;OAEG;IACH,KAAY,GAAG,GAAG;QACd;;WAEG;QACH,IAAI,CAAC,EAAE,OAAO,CAAC;QAEf;;WAEG;QACH,KAAK,CAAC,EAAE,UAAU,CAAC;QAEnB;;WAEG;QACH,GAAG,CAAC,EAAE,UAAU,CAAC;QAEjB;;WAEG;QACH,GAAG,CAAC,EAAE,UAAU,CAAC;QAEjB;;WAEG;QACH,EAAE,CAAC,EAAE,UAAU,CAAC;QAEhB;;WAEG;QACH,KAAK,CAAC,EAAE,GAAG,CAAC;QAEZ;;WAEG;QACH,KAAK,CAAC,EAAE,MAAM,CAAC;QAEf;;WAEG;QACH,KAAK,CAAC,EAAE,GAAG,EAAE,CAAC;KACjB,CAAC;IAEF;;OAEG;IACH,UAAiB,cAAc;QAC3B,IAAI,EAAE,GAAG,GAAG,GAAG,CAAC;QAEhB,GAAG,EAAE,UAAU,CAAC;QAEhB,GAAG,EAAE,UAAU,CAAC;KACnB;IAED;;OAEG;IACH,KAAY,UAAU,GAAG,UAAU,GAAG,cAAc,CAAC;IAErD;;OAEG;IACH,KAAY,UAAU,GAAG,CAAC,GAAG,GAAG;QAAE,UAAU,CAAC,EAAE,UAAU,CAAA;KAAE,CAAC,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;CAC9F"}

package/dist/cjs/aspects/Constraint.js

@@ -21,6 +21,8 @@ __export(Constraint_exports, {
   Constraint: () => Constraint
 });
 module.exports = __toCommonJS(Constraint_exports);
+var import_Lexer = require("#parser/Lexer.js");
+var import_TokenStream = require("#parser/TokenStream.js");
 var import_general = require("@matter/general");
 var import_common = require("../common/index.js");
 var import_Aspect = require("./Aspect.js");
@@ -41,7 +43,7 @@ class Constraint extends import_Aspect.Aspect {
         if (definition.match(/(?:0b[0x ]*x[0x ]*)|(?:0x[0x_]*x[0x_]*)|(?:00[0x]*x)/i)) {
           break;
         }
-        ast = Constraint.parse(this, definition);
+        ast = Parser.parse(this, definition);
         break;
       case "number":
         ast = { value: definition };
@@ -74,6 +76,9 @@ class Constraint extends import_Aspect.Aspect {
     if (ast.entry !== void 0) {
       this.entry = new Constraint(ast.entry);
     }
+    if (ast.cpMax !== void 0) {
+      this.cpMax = ast.cpMax;
+    }
     if (ast.parts !== void 0) {
       this.parts = ast.parts.map((p) => new Constraint(p));
     }
@@ -87,10 +92,34 @@ class Constraint extends import_Aspect.Aspect {
       if (!raw && (typeof value2 === "string" || Array.isArray(value2))) {
         return value2.length;
       }
-      if ((0, import_general.isObject)(value2)) {
-        const { type, name } = value2;
-        if (type === import_common.FieldValue.reference && typeof name === "string") {
-          value2 = valueOf(properties?.[(0, import_general.camelize)(name)], raw);
+      if (typeof value2 === "object" && value2 !== null && "type" in value2) {
+        const { type } = value2;
+        switch (type) {
+          case import_common.FieldValue.reference:
+            if (typeof value2.name === "string") {
+              value2 = valueOf(properties?.[(0, import_general.camelize)(value2.name)], raw);
+            }
+            break;
+          case "+":
+            {
+              const lhs = valueOf(value2.lhs);
+              const rhs = valueOf(value2.rhs);
+              if (typeof lhs === "number" && typeof rhs === "number") {
+                return lhs + rhs;
+              }
+              return void 0;
+            }
+            break;
+          case "-":
+            {
+              const lhs = valueOf(value2.lhs);
+              const rhs = valueOf(value2.rhs);
+              if (typeof lhs === "number" && typeof rhs === "number") {
+                return lhs - rhs;
+              }
+              return void 0;
+            }
+            break;
         }
       }
       return value2;
@@ -101,7 +130,7 @@ class Constraint extends import_Aspect.Aspect {
     if (this.in) {
       let set = valueOf(this.in, true);
       if (!Array.isArray(set)) {
-        set = [set];
+        set = set === void 0 ? [] : [set];
       }
       return set.indexOf(value) !== -1;
     }
@@ -133,7 +162,7 @@ class Constraint extends import_Aspect.Aspect {
     if (!this.valid && this.definition) {
       return this.definition.toString();
     }
-    return Constraint.serialize(this);
+    return Serializer.serialize(this);
   }
   freeze() {
     if (this.parts) {
@@ -142,221 +171,262 @@ class Constraint extends import_Aspect.Aspect {
     super.freeze();
   }
 }
-((Constraint2) => {
-  function parseValue(numOrName) {
-    let value;
-    if (numOrName.match(/^-?0[xb]/)) {
-      value = Number.parseInt(numOrName.replace(/[_ ]/g, ""));
-    } else {
-      value = Number.parseFloat(numOrName);
-    }
-    if (typeof numOrName === "string") {
-      const lower = numOrName.toLowerCase();
-      switch (lower) {
-        case "true":
-          return true;
-        case "false":
-          return false;
-      }
-    }
-    if (Number.isNaN(value)) {
-      return import_common.FieldValue.Reference((0, import_general.camelize)(numOrName));
+var Serializer;
+((Serializer2) => {
+  function serialize(ast) {
+    if (ast.parts) {
+      return ast.parts.map(serialize).join(", ");
     }
-    if (numOrName.endsWith("%")) {
-      return import_common.FieldValue.Percent(value);
+    if (ast.entry) {
+      return `${serializeAtom(ast)}[${serialize(ast.entry)}]`;
     }
-    if (numOrName.endsWith("\xB0C")) {
-      return import_common.FieldValue.Celsius(value);
+    if (ast.cpMax) {
+      return `${serializeAtom(ast)}{${ast.cpMax}}`;
     }
-    return value;
-  }
-  function parseAtom(constraint, words) {
-    switch (words.length) {
-      case 0:
-        return void 0;
-      case 1:
-        switch (words[0].toLowerCase()) {
-          case "desc":
-            return { desc: true };
-          case "all":
-          case "any":
-            return {};
-        }
-        const value = parseValue(words[0]);
-        if (value === void 0 || value === null) {
-          return;
-        }
-        return { value };
-      case 2:
-        switch (words[0].toLowerCase()) {
-          case "min":
-            const min = parseValue(words[1]);
-            if (min === void 0 || min === null) {
-              return;
-            }
-            return { min };
-          case "max":
-            const max = parseValue(words[1]);
-            if (max === void 0 || max === null) {
-              return;
-            }
-            return { max };
-          case "in":
-            const ref = parseValue(words[1]);
-            return { in: ref };
-          default:
-            constraint.error(
-              "INVALID_CONSTRAINT",
-              `Two word constraint "${words.join(" ")}" does not start with "min" or "max"`
-            );
-        }
-        return;
-      case 3:
-        if (words[1].toLowerCase() === "to") {
-          let parseBound2 = function(name, pos) {
-            if (words[pos].toLowerCase() === name) {
-              return void 0;
-            }
-            return parseValue(words[pos]);
-          };
-          var parseBound = parseBound2;
-          const ast = {};
-          const min = parseBound2("min", 0);
-          if (min !== void 0 && min !== null) {
-            ast.min = min;
-          }
-          const max = parseBound2("max", 2);
-          if (max !== void 0 && max !== null) {
-            ast.max = max;
-          }
-          if (ast.min !== void 0 && ast.min !== null || ast.max !== void 0 && ast.max !== null) {
-            return ast;
-          }
-        }
-        return;
-    }
-    constraint.error("INVALID_CONSTRAINT", `Unrecognized value constraint "${words.join(" ")}"`);
+    return serializeAtom(ast);
   }
-  function parse(constraint, definition) {
-    let pos = 2;
-    let current = definition[0];
-    let peeked = definition[1];
-    function next() {
-      current = peeked;
-      if (pos === definition.length) {
-        peeked = void 0;
-      } else {
-        peeked = definition[pos];
-        pos++;
-      }
-    }
-    function scan(depth) {
-      const parts = Array();
-      let words = Array();
-      let word = "";
-      function parseWords() {
-        if (word) {
-          words.push(word);
-          word = "";
+  Serializer2.serialize = serialize;
+  function serializeValue(value, inExpr = false) {
+    if (typeof value !== "object" || value === null || Array.isArray(value) || value instanceof Date) {
+      return import_common.FieldValue.serialize(value);
+    }
+    switch (value.type) {
+      case "+":
+      case "-":
+        const sum = `${serializeValue(value.lhs, true)} ${value.type} ${serializeValue(value.rhs, true)}`;
+        if (inExpr) {
+          return `(${sum})`;
         }
-        const atom = parseAtom(constraint, words);
-        words = Array();
-        return atom;
-      }
-      function emit() {
-        const atom = parseWords();
-        if (atom !== void 0) {
-          parts.push(atom);
-        }
-      }
-      while (current !== void 0) {
-        switch (current) {
-          case " ":
-          case "	":
-          case "\r":
-          case "\n":
-          case "\v":
-          case "\f":
-            if (word) {
-              words.push(word);
-              word = "";
-            }
-            break;
-          case "[":
-            next();
-            let ast = parseWords();
-            const entry = scan(depth + 1);
-            if (entry) {
-              if (!ast) {
-                ast = {};
-              }
-              ast.entry = entry;
-            }
-            if (ast) {
-              parts.push(ast);
-            }
-            break;
-          case "]":
-            if (!depth) {
-              constraint.error("INVALID_CONSTRAINT", 'Unexpected "]"');
-              break;
-            }
-            emit();
-            if (parts.length > 1) {
-              return { parts };
-            }
-            return parts[0];
-          case ",":
-            emit();
-            break;
-          default:
-            word += current;
-            break;
-        }
-        next();
-      }
-      if (depth) {
-        constraint.error("INVALID_CONSTRAINT", "Unterminated sub-constraint");
-      }
-      emit();
-      if (parts.length < 2) {
-        return parts[0];
-      }
-      return { parts };
+        return sum;
+      default:
+        return import_common.FieldValue.serialize(value);
     }
-    return scan(0);
   }
-  Constraint2.parse = parse;
   function serializeAtom(ast) {
     if (ast.desc) {
       return "desc";
     }
     if (ast.value !== void 0 && ast.value !== null) {
-      return `${import_common.FieldValue.serialize(ast.value)}`;
+      return `${serializeValue(ast.value)}`;
     }
     if (ast.min !== void 0 && ast.min !== null) {
       if (ast.max === void 0 || ast.max === null) {
-        return `min ${import_common.FieldValue.serialize(ast.min)}`;
+        return `min ${serializeValue(ast.min)}`;
       }
-      return `${import_common.FieldValue.serialize(ast.min)} to ${import_common.FieldValue.serialize(ast.max)}`;
+      return `${serializeValue(ast.min)} to ${serializeValue(ast.max)}`;
     }
     if (ast.max !== void 0 && ast.max !== null) {
-      return `max ${import_common.FieldValue.serialize(ast.max)}`;
+      return `max ${serializeValue(ast.max)}`;
     }
     if (ast.in !== void 0) {
-      return `in ${import_common.FieldValue.serialize(ast.in)}`;
+      return `in ${serializeValue(ast.in)}`;
     }
     return "all";
   }
-  function serialize(ast) {
-    if (ast.parts) {
-      return ast.parts.map(serialize).join(", ");
+})(Serializer || (Serializer = {}));
+var Parser;
+((Parser2) => {
+  const lexer = new import_Lexer.Lexer(["in", "min", "max", "to", "all", "desc", "true", "false"]);
+  function parse(constraint, definition) {
+    const tokens = (0, import_TokenStream.TokenStream)(lexer.lex(definition, (code, message) => constraint.error(code, message)));
+    const result = parseParts();
+    if (tokens.token && tokens.token?.type !== ",") {
+      constraint.error("UNEXPECTED_CONSTRAINT_TOKEN", `Unexpected ${tokens.description}`);
     }
-    if (ast.entry) {
-      return `${serializeAtom(ast)}[${serialize(ast.entry)}]`;
+    return result;
+    function parseParts() {
+      const parts = Array();
+      while (true) {
+        const part = parsePart();
+        if (part !== void 0) {
+          parts.push(part);
+        }
+        if (tokens.done) {
+          break;
+        }
+        if (tokens.token?.type !== ",") {
+          break;
+        }
+        tokens.next();
+      }
+      if (!parts.length) {
+        return {};
+      }
+      if (parts.length === 1) {
+        return parts[0];
+      }
+      return { parts };
+    }
+    function parsePart() {
+      const result2 = parsePartWithoutSubconstraint();
+      if (result2 === void 0) {
+        return result2;
+      }
+      switch (tokens.token?.type) {
+        case "[":
+          {
+            tokens.next();
+            const entry = parseParts();
+            if (tokens.token?.type !== "]") {
+              constraint.error("MISSING_ENTRY_END", 'Entry constraint does not end with "]"');
+            }
+            tokens.next();
+            if (entry !== void 0) {
+              result2.entry = entry;
+            }
+          }
+          break;
+        case "{":
+          {
+            tokens.next();
+            if (tokens.token?.type !== "value") {
+              constraint.error(
+                "MISSING_CODEPOINT_MAX",
+                "Codepoint constraint does not specify maximum codepoint length"
+              );
+              if (tokens.peeked?.type === "}") {
+                tokens.next();
+              }
+            } else {
+              result2.cpMax = import_common.FieldValue.numericValue(
+                tokens.token.value
+              );
+              tokens.next();
+            }
+            if (tokens.token?.type !== "}") {
+              constraint.error("MISSING_CODEPOINT_END", 'Codepoint constraint does not end with "}"');
+            }
+            tokens.next();
+          }
+          break;
+      }
+      return result2;
+    }
+    function parsePartWithoutSubconstraint() {
+      const { token } = tokens;
+      if (!token) {
+        return;
+      }
+      switch (token.type) {
+        case "desc":
+          tokens.next();
+          return { desc: true };
+        case "all":
+          tokens.next();
+          return {};
+        case "min":
+        case "max":
+          tokens.next();
+          return parseSingleBound(token.type);
+        case "in":
+          tokens.next();
+          if (tokens.token?.type === "word") {
+            const name = tokens.token.value;
+            tokens.next();
+            return { in: import_common.FieldValue.Reference(name) };
+          }
+          constraint.error("MISSING_IN_FIELD", 'Expected field name to follow "in"');
+          break;
+      }
+      const value = parseExpression();
+      if (value === void 0 || tokens.token?.type !== "to") {
+        return { value };
+      }
+      tokens.next();
+      const max = parseExpression();
+      if (max === void 0) {
+        constraint.error("MISSING_UPPER_BOUND", `"to" must be followed by upper boundary value`);
+        return;
+      }
+      return {
+        min: value,
+        max
+      };
+    }
+    function parseSingleBound(kind) {
+      const bound = parseExpression();
+      if (bound === void 0) {
+        constraint.error("MISSING_SINGLE_BOUND", `"${kind}" must be followed by boundary value`);
+        return;
+      }
+      return { [kind]: bound };
+    }
+    function parseExpression() {
+      const value = parseValueExpression();
+      if (value === void 0) {
+        return value;
+      }
+      switch (tokens.token?.type) {
+        case "+":
+        case "-":
+          const type = tokens.token.type;
+          tokens.next();
+          const rhs = parseValueExpression();
+          if (rhs === void 0) {
+            constraint.error("MISSING_RIGHT_OPERAND", `Missing operand after "${type}"`);
+            return;
+          }
+          return {
+            type,
+            lhs: value,
+            rhs
+          };
+      }
+      return value;
+    }
+    function parseValueExpression() {
+      const { token } = tokens;
+      if (token === void 0) {
+        return;
+      }
+      switch (token.type) {
+        case "value":
+          tokens.next();
+          return token.value;
+        case "true":
+          tokens.next();
+          return true;
+        case "false":
+          tokens.next();
+          return false;
+        case "word":
+          const ref = import_common.FieldValue.Reference((0, import_general.camelize)(token.value));
+          tokens.next();
+          return ref;
+        case "-":
+        case "+": {
+          tokens.next();
+          let number = tokens.token?.type === "value" ? tokens.token.value : void 0;
+          if (number !== void 0) {
+            tokens.next();
+            if (token.type === "-") {
+              if (typeof number === "number") {
+                number *= -1;
+              } else if (import_common.FieldValue.is(number, import_common.FieldValue.percent) || import_common.FieldValue.is(number, import_common.FieldValue.celsius)) {
+                number.value *= -1;
+              } else {
+                number = void 0;
+              }
+            }
+          }
+          if (number === void 0) {
+            constraint.error("MISSING_NUMBER", `Unary "${token.type}" not followed by numeric value`);
+            return;
+          }
+          return number;
+        }
+        case "(": {
+          tokens.next();
+          const result2 = parseExpression();
+          if (tokens.token?.type !== ")") {
+            constraint.error("MISSING_GROUP_END", 'Group does not end with ")"');
+          }
+          tokens.next();
+          return result2;
+        }
+      }
     }
-    return serializeAtom(ast);
   }
-  Constraint2.serialize = serialize;
-})(Constraint || (Constraint = {}));
+  Parser2.parse = parse;
+})(Parser || (Parser = {}));
 //# sourceMappingURL=Constraint.js.map