clarity-pattern-parser 8.4.14 → 9.0.0

package/src/intellisense/AutoComplete.test.ts

@@ -1,11 +1,12 @@
-import { And } from "../patterns/And";
+import { Sequence } from "../patterns/Sequence";
 import { Literal } from "../patterns/Literal";
-import { Or } from "../patterns/Or";
+import { Options } from "../patterns/Options";
 import { Pattern } from "../patterns/Pattern";
 import { Reference } from "../patterns/Reference";
 import { Regex } from "../patterns/Regex";
 import { Repeat } from "../patterns/Repeat";
 import { AutoComplete, AutoCompleteOptions } from "./AutoComplete";
+import { Optional } from "../patterns/Optional";
 
 function generateFlagFromList(flagNames: string[]) {
     return flagNames.map(flagName => {
@@ -19,7 +20,7 @@ function generateFlagPattern(flagNames: string[]): Pattern {
         return new Literal('flag-name', singleFlagOption);
     }
 
-    const flagPattern = new Or('flags', generateFlagFromList(flagNames));
+    const flagPattern = new Options('flags', generateFlagFromList(flagNames));
     return flagPattern;
 }
 
@@ -40,25 +41,25 @@ export function generateExpression(flagNames: string[]): Repeat {
     const openParen = new Literal('open-paren', '(');
     const closeParen = new Literal('close-paren', ')');
     const space = new Regex('[space]', '\\s');
-    const and = new Literal('and-literal', 'AND');
-    const or = new Literal('or-literal', 'OR');
+    const and = new Literal('sequence-literal', 'AND');
+    const or = new Literal('options-literal', 'OR');
     const not = new Literal('not', 'NOT ');
-    const booleanOperator = new Or('booleanOperator', [and, or]);
-    const operatorWithSpaces = new And('operator-with-spaces', [
+    const booleanOperator = new Options('booleanOperator', [and, or]);
+    const operatorWithSpaces = new Sequence('operator-with-spaces', [
         space,
         booleanOperator,
         space,
     ]);
     const flag = generateFlagPattern(flagNames);
-    const group = new And('group', [
+    const group = new Sequence('group', [
         openParen,
         new Reference('flag-expression'),
         closeParen,
     ]);
-    const flagOrGroup = new Or('flag-or-group', [flag, group]);
-    const expressionBody = new And('flag-body', [
-        not.clone('optional-not', true),
-        flagOrGroup,
+    const flagOptionsGroup = new Options('flag-or-group', [flag, group]);
+    const expressionBody = new Sequence('flag-body', [
+        new Optional("optional-not", not),
+        flagOptionsGroup,
     ]);
     const flagExpression = new Repeat(
         'flag-expression',
@@ -85,7 +86,7 @@ describe("AutoComplete", () => {
         const space = new Literal("space", " ");
         const doe = new Literal("doe", "Doe");
         const smith = new Literal("smith", "Smith");
-        const name = new And("name", [john, space, new Or("last-name", [smith, doe])]);
+        const name = new Sequence("name", [john, space, new Options("last-name", [smith, doe])]);
 
         const autoComplete = new AutoComplete(name);
         const result = autoComplete.suggestFor("John Doe");
@@ -102,7 +103,7 @@ describe("AutoComplete", () => {
         const space = new Literal("space", " ");
         const doe = new Literal("doe", "Doe");
         const smith = new Literal("smith", "Smith");
-        const name = new And("name", [john, space, new Or("last-name", [smith, doe])]);
+        const name = new Sequence("name", [john, space, new Options("last-name", [smith, doe])]);
 
         const text = "John "
         const autoComplete = new AutoComplete(name);
@@ -127,7 +128,7 @@ describe("AutoComplete", () => {
         const space = new Literal("space", " ");
         const doe = new Literal("doe", "Doe");
         const smith = new Literal("smith", "Smith");
-        const name = new And("name", [john, space, new Or("last-name", [smith, doe])]);
+        const name = new Sequence("name", [john, space, new Options("last-name", [smith, doe])]);
         const divider = new Regex("divider", "\\s+,\\s+");
 
         divider.setTokens([", "])
@@ -207,9 +208,9 @@ describe("AutoComplete", () => {
         const space = new Literal("space", " ");
         const doe = new Literal("doe", "Doe");
         const smith = new Literal("smith", "Smith");
-        const firstName = new Or("first-name", [jack, john]);
-        const lastName = new Or("last-name", [doe, smith]);
-        const fullName = new And("full-name", [firstName, space, lastName]);
+        const firstName = new Options("first-name", [jack, john]);
+        const lastName = new Options("last-name", [doe, smith]);
+        const fullName = new Sequence("full-name", [firstName, space, lastName]);
 
         const text = "Jack";
         const autoComplete = new AutoComplete(fullName, autoCompleteOptions);
@@ -248,9 +249,9 @@ describe("AutoComplete", () => {
         const space = new Literal("space", " ");
         const doe = new Literal("doe", "Doe");
         const smith = new Literal("smith", "Smith");
-        const firstName = new Or("first-name", [jack, john]);
-        const lastName = new Or("last-name", [doe, smith]);
-        const fullName = new And("full-name", [firstName, space, lastName]);
+        const firstName = new Options("first-name", [jack, john]);
+        const lastName = new Options("last-name", [doe, smith]);
+        const fullName = new Sequence("full-name", [firstName, space, lastName]);
 
         const text = "Jack";
         const autoComplete = new AutoComplete(fullName, autoCompleteOptions);
@@ -282,10 +283,10 @@ describe("AutoComplete", () => {
         const a = new Literal("a", "a bank.");
         const the = new Literal("the", "the store.");
 
-        const first = new And("first", [start, a]);
-        const second = new And("second", [start, the]);
+        const first = new Sequence("first", [start, a]);
+        const second = new Sequence("second", [start, the]);
 
-        const both = new Or("both", [first, second]);
+        const both = new Options("both", [first, second]);
 
         const autoComplete = new AutoComplete(both);
         const result = autoComplete.suggestFor("John went to a gas station.");
@@ -297,7 +298,7 @@ describe("AutoComplete", () => {
     });
 
     test("Options on errors because of string ending, with match", () => {
-        const smalls = new Or("kahns", [
+        const smalls = new Options("kahns", [
             new Literal("large", "kahnnnnnn"),
             new Literal("medium", "kahnnnnn"),
             new Literal("small", "kahn"),
@@ -316,7 +317,7 @@ describe("AutoComplete", () => {
     });
 
     test("Options on errors because of string ending, between matches", () => {
-        const smalls = new Or("kahns", [
+        const smalls = new Options("kahns", [
             new Literal("large", "kahnnnnnn"),
             new Literal("medium", "kahnnnnn"),
             new Literal("small", "kahn"),
@@ -335,7 +336,7 @@ describe("AutoComplete", () => {
     });
 
     test("Options on errors because of string ending, match middle", () => {
-        const smalls = new Or("kahns", [
+        const smalls = new Options("kahns", [
             new Literal("large", "kahnnnnnn"),
             new Literal("medium", "kahnnnnn"),
             new Literal("small", "kahn"),
@@ -354,7 +355,7 @@ describe("AutoComplete", () => {
 
 
     test("Options on errors because of string ending on a variety, with match", () => {
-        const smalls = new Or("kahns", [
+        const smalls = new Options("kahns", [
             new Literal("different-3", "kahnnnnnnn3"),
             new Literal("different-21", "kahnnnnnn21"),
             new Literal("different-22", "kahnnnnnn22"),
@@ -382,10 +383,10 @@ describe("AutoComplete", () => {
     });
 
     test("Options on errors because of string ending on different branches, with match", () => {
-        const smalls = new Or("kahns", [
-            new And("kahn-combo-3", [new Literal("kah", "kah"), new And('partial', [new Literal("n", "n"), new Literal("three", "3")])]),
-            new And("kahn-combo", [new Literal("kahn", "kahn"), new Literal("one", "1")]),
-            new And("kahn-combo-2", [new Literal("kahn", "kahn"), new Literal("two", "2")]),
+        const smalls = new Options("kahns", [
+            new Sequence("kahn-combo-3", [new Literal("kah", "kah"), new Sequence('partial', [new Literal("n", "n"), new Literal("three", "3")])]),
+            new Sequence("kahn-combo", [new Literal("kahn", "kahn"), new Literal("one", "1")]),
+            new Sequence("kahn-combo-2", [new Literal("kahn", "kahn"), new Literal("two", "2")]),
             new Literal("small", "kahn"),
         ]);
 
@@ -436,19 +437,19 @@ describe("AutoComplete", () => {
         expect(result.errorAtIndex).toBe(15);
     });
 
-    test("Greedy Or", () => {
+    test("Greedy Options", () => {
         const john = new Literal("john", "John");
         const doe = new Literal("doe", "Doe");
         const jane = new Literal("jane", "Jane");
         const smith = new Literal("smith", "Smith");
         const space = new Literal("space", " ");
 
-        const firstName = new Or("first-name", [john, jane], false, true);
-        const lastName = new Or("last-name", [doe, smith], false, true);
+        const firstName = new Options("first-name", [john, jane], true);
+        const lastName = new Options("last-name", [doe, smith], true);
         const johnJohnson = new Literal("john-johnson", "John Johnson");
         const johnStockton = new Literal("john-stockton", "John Stockton");
-        const fullName = new And("full-name", [firstName, space, lastName]);
-        const names = new Or("names", [johnStockton, johnJohnson, fullName], false, true);
+        const fullName = new Sequence("full-name", [firstName, space, lastName]);
+        const names = new Options("names", [johnStockton, johnJohnson, fullName], true);
 
         const autoComplete = new AutoComplete(names);
         const results = autoComplete.suggestFor("John ");
@@ -476,9 +477,9 @@ describe("AutoComplete", () => {
     });
 
     test("Dedup suggestions", () => {
-        const branchOne = new And("branch-1", [new Literal("space", " "), new Literal("A", "A")]);
-        const branchTwo = new And("branch-2", [new Literal("space", " "), new Literal("B", "B")]);
-        const eitherBranch = new Or("either-branch", [branchOne, branchTwo]);
+        const branchOne = new Sequence("branch-1", [new Literal("space", " "), new Literal("A", "A")]);
+        const branchTwo = new Sequence("branch-2", [new Literal("space", " "), new Literal("B", "B")]);
+        const eitherBranch = new Options("either-branch", [branchOne, branchTwo]);
 
         const autoComplete = new AutoComplete(eitherBranch);
         const results = autoComplete.suggestFor("");

package/src/intellisense/css/method.ts

@@ -1,7 +1,7 @@
 import { Reference } from "../../patterns/Reference";
 import { Literal } from "../../patterns/Literal";
 import { Repeat } from "../../patterns/Repeat";
-import { And } from "../../patterns/And";
+import { Sequence } from "../../patterns/Sequence";
 import name from "./name";
 import optionalSpaces from "./optionalSpaces";
 import divider from "./divider";
@@ -13,7 +13,7 @@ const args = new Repeat("arguments", values, { divider, min: 0 });
 const methodName = name.clone("method-name");
 methodName.setTokens(["rgba", "radial-gradient", "linear-gradient"]);
 
-const method = new And("method", [
+const method = new Sequence("method", [
   methodName,
   openParen,
   optionalSpaces,

package/src/intellisense/css/unit.ts

@@ -1,10 +1,10 @@
-import { And } from "../../patterns/And";
+import { Sequence } from "../../patterns/Sequence";
 import { Regex } from "../../patterns/Regex";
 import number from "./number";
 
 const unitType = new Regex("unit-type", "[a-zA-Z%]+");
 unitType.setTokens(["px", "%", "em", "rem", "vh", "vw"]);
 
-const unit = new And("unit", [number, unitType]);
+const unit = new Sequence("unit", [number, unitType]);
 
 export default unit;

package/src/intellisense/css/value.ts

@@ -3,7 +3,7 @@ import hex from "./hex";
 import number from "./number";
 import method from "./method";
 import name from "./name"
-import { Or } from "../../patterns/Or";
+import { Options } from "../../patterns/Options";
 
 const value = new Or("value", [hex, method, unit, number, name]);
 

package/src/intellisense/javascript/Javascript.test.ts

@@ -12,45 +12,45 @@ import { prefixOperator } from "./prefixOperator";
 describe("Ecmascript 3", () => {
     test("Escaped Character", () => {
         let result = escapedCharacter.exec(`\\"`);
-        expect(result.ast?.value).toBe(`\\"`)
+        expect(result.ast?.value).toBe(`\\"`);
 
-        result = escapedCharacter.exec(`\\'`)
-        expect(result.ast?.value).toBe(`\\'`)
+        result = escapedCharacter.exec(`\\'`);
+        expect(result.ast?.value).toBe(`\\'`);
 
-        result = escapedCharacter.exec(`\\\\`)
-        expect(result.ast?.value).toBe(`\\\\`)
+        result = escapedCharacter.exec(`\\\\`);
+        expect(result.ast?.value).toBe(`\\\\`);
 
-        result = escapedCharacter.exec(`\\/`)
-        expect(result.ast?.value).toBe(`\\/`)
+        result = escapedCharacter.exec(`\\/`);
+        expect(result.ast?.value).toBe(`\\/`);
 
-        result = escapedCharacter.exec(`\\f`)
-        expect(result.ast?.value).toBe(`\\f`)
+        result = escapedCharacter.exec(`\\f`);
+        expect(result.ast?.value).toBe(`\\f`);
 
-        result = escapedCharacter.exec(`\\t`)
-        expect(result.ast?.value).toBe(`\\t`)
+        result = escapedCharacter.exec(`\\t`);
+        expect(result.ast?.value).toBe(`\\t`);
 
-        result = escapedCharacter.exec(`\\u00E9`)
-        expect(result.ast?.value).toBe(`\\u00E9`)
+        result = escapedCharacter.exec(`\\u00E9`);
+        expect(result.ast?.value).toBe(`\\u00E9`);
     });
 
     test("Exponent", () => {
         let result = exponent.exec("e+1");
-        expect(result.ast?.value).toBe("e+1")
+        expect(result.ast?.value).toBe("e+1");
 
         result = exponent.exec("e-1");
-        expect(result.ast?.value).toBe("e-1")
+        expect(result.ast?.value).toBe("e-1");
 
         result = exponent.exec("E+1");
-        expect(result.ast?.value).toBe("E+1")
+        expect(result.ast?.value).toBe("E+1");
 
         result = exponent.exec("E-1");
-        expect(result.ast?.value).toBe("E-1")
+        expect(result.ast?.value).toBe("E-1");
 
         result = exponent.exec("e+11");
-        expect(result.ast?.value).toBe("e+11")
+        expect(result.ast?.value).toBe("e+11");
 
         result = exponent.exec("11");
-        expect(result.ast).toBeNull()
+        expect(result.ast).toBeNull();
     });
 
     test("Integer", () => {
@@ -155,35 +155,35 @@ describe("Ecmascript 3", () => {
     });
 
     test("Object Literal", () => {
-        let result = expression.exec(`{}`)
+        let result = expression.exec(`{}`, true);
         expect(result.ast?.value).toBe("{}");
 
-        result = expression.exec(`{prop:{}}`)
+        result = expression.exec(`{prop:{}}`);
         expect(result.ast?.value).toBe("{prop:{}}");
 
-        result = expression.exec(`{prop:"value"}`)
+        result = expression.exec(`{prop:"value"}`);
         expect(result.ast?.value).toBe(`{prop:"value"}`);
 
-        result = expression.exec(`{prop:0.9}`)
+        result = expression.exec(`{prop:0.9}`);
         expect(result.ast?.value).toBe(`{prop:0.9}`);
 
-        result = expression.exec(`{prop:1}`)
+        result = expression.exec(`{prop:1}`);
         expect(result.ast?.value).toBe(`{prop:1}`);
 
-        result = expression.exec(`{"prop":1}`)
+        result = expression.exec(`{"prop":1}`);
         expect(result.ast?.value).toBe(`{"prop":1}`);
     });
 
     test("Expression", () => {
 
-        let result = expression.exec("[]")
+        let result = expression.exec("[]");
         expect(result.ast?.value).toBe("[]");
 
         result = expression.exec("[{}, 9, 0.9e-10, [1, 2]]")
         expect(result.ast?.value).toBe("[{}, 9, 0.9e-10, [1, 2]]");
 
         result = expression.exec(`"John"`);
-        expect(result.ast?.value).toBe(`"John"`)
+        expect(result.ast?.value).toBe(`"John"`);
 
         result = expression.exec(`variableName.property`);
         expect(result.ast?.value).toBe(`variableName.property`);
@@ -193,20 +193,19 @@ describe("Ecmascript 3", () => {
 
         const cursor = new Cursor(`name() == name.property === name2 ? {prop: name, blah: [ 0.9e-10 ]} : name`);
         cursor.startRecording();
-        const ast = expression.parse(cursor);
-    })
+    });
 
     test("Expression Statement", () => {
         let result = assignment.exec(`name = "John"`);
         expect(result.ast?.value).toBe(`name = "John"`);
 
-        result = assignment.exec(`name = othername = "John"`)
+        result = assignment.exec(`name = othername = "John"`);
         expect(result.ast?.value).toBe(`name = othername = "John"`);
 
-        result = assignment.exec(`name = othername.prop = "John"`)
+        result = assignment.exec(`name = othername.prop = "John"`);
         expect(result.ast?.value).toBe(`name = othername.prop = "John"`);
 
-        result = assignment.exec(`name = othername.prop += 2`)
+        result = assignment.exec(`name = othername.prop += 2`);
         expect(result.ast?.value).toBe(`name = othername.prop += 2`);
 
         result = assignment.exec(`name.prop().method(blah) = blah.prop() == ha ? first : second`)

package/src/intellisense/javascript/arrayLiteral.ts

@@ -1,21 +1,22 @@
-import { And } from "../../patterns/And";
+import { Sequence } from "../../patterns/Sequence";
 import { Literal } from "../../patterns/Literal";
-import { Or } from "../../patterns/Or";
+import { Options } from "../../patterns/Options";
 import { Reference } from "../../patterns/Reference";
 import { Regex } from "../../patterns/Regex";
 import { Repeat } from "../../patterns/Repeat";
 import { optionalSpaces } from "./optionalSpaces";
+import { Optional } from "../../patterns/Optional";
 
 const divider = new Regex("array-divider", "\\s*,\\s*");
-const arrayItems = new Repeat("array-items", new Reference("expression"), { divider, min: 0 });
+const arrayItems = new Optional("array-items", new Repeat("array-items", new Reference("expression"), { divider}));
 
-export const arrayLiteral = new Or("array-literal",
-    [new And("empty-array-literal", [
+export const arrayLiteral = new Options("array-literal",
+    [new Sequence("empty-array-literal", [
         new Literal("open-square-bracket", "["),
         optionalSpaces,
         new Literal("close-square-bracket", "]"),
     ]),
-    new And("array-literal", [
+    new Sequence("array-literal", [
         new Literal("open-square-bracket", "["),
         optionalSpaces,
         arrayItems,

package/src/intellisense/javascript/assignment.ts

@@ -1,22 +1,22 @@
-import { And } from "../../patterns/And";
+import { Sequence } from "../../patterns/Sequence";
 import { Literal } from "../../patterns/Literal";
-import { Or } from "../../patterns/Or";
+import { Options } from "../../patterns/Options";
 import { Reference } from "../../patterns/Reference";
 import { expression } from "./expression";
 import { optionalSpaces } from "./optionalSpaces";
 
-const assignmentOperators = new Or("assignment-operators", [
+const assignmentOperators = new Options("assignment-operators", [
     new Literal("assign", "="),
     new Literal("addition-assign", "+="),
     new Literal("subtraction-assign", "-="),
 ]);
 
-const assignment = new And("assignment", [
+const assignment = new Sequence("assignment", [
     expression,
     optionalSpaces,
     assignmentOperators,
     optionalSpaces,
-    new Or("assignment-right-operand", [
+    new Options("assignment-right-operand", [
         new Reference("assignment"),
         expression
     ]),
@@ -25,4 +25,4 @@ const assignment = new And("assignment", [
 
 
 
-export { assignment }
+export { assignment };

package/src/intellisense/javascript/deleteStatement.ts

@@ -1,11 +1,11 @@
-import { And } from "../../patterns/And";
+import { Sequence } from "../../patterns/Sequence";
 import { Literal } from "../../patterns/Literal";
 import { Regex } from "../../patterns/Regex";
 import { expression } from "./expression";
 import { propertyAccess } from "./propertyAccess";
 
 const space = new Regex("space", "\\s+");
-export const deleteStatement = new And("delete-statement", [
+export const deleteStatement = new Sequence("delete-statement", [
     new Literal("delete-keyword", "delete"),
     space,
     expression,

package/src/intellisense/javascript/escapedCharacter.ts

@@ -1,6 +1,6 @@
-import { And } from "../../patterns/And";
+import { Sequence } from "../../patterns/Sequence";
 import { Literal } from "../../patterns/Literal";
-import { Or } from "../../patterns/Or";
+import { Options } from "../../patterns/Options";
 import { Regex } from "../../patterns/Regex";
 
 const backslash = new Literal("backslash", "\\");
@@ -20,7 +20,7 @@ hexDigit.setTokens([
     "A", "B", "C", "D", "E", "F",
 ]);
 
-const unicode = new And("hex", [
+const unicode = new Sequence("hex", [
     new Literal("u", "u"),
     hexDigit,
     hexDigit,
@@ -28,7 +28,7 @@ const unicode = new And("hex", [
     hexDigit
 ]);
 
-const specialCharacter = new Or("special-character", [
+const specialCharacter = new Options("special-character", [
     doubleQuote,
     singleQuote,
     backslash,
@@ -41,9 +41,9 @@ const specialCharacter = new Or("special-character", [
     unicode,
 ]);
 
-const escapedCharacter = new And("escaped-character", [backslash, specialCharacter])
+const escapedCharacter = new Sequence("escaped-character", [backslash, specialCharacter]);
 
 export {
     escapedCharacter
-}
+};
 

package/src/intellisense/javascript/exponent.ts

@@ -1,24 +1,24 @@
-import { And } from "../../patterns/And";
+import { Sequence } from "../../patterns/Sequence";
 import { Literal } from "../../patterns/Literal";
-import { Or } from "../../patterns/Or";
+import { Options } from "../../patterns/Options";
 import { Regex } from "../../patterns/Regex";
 
-const e = new Or("e", [
+const e = new Options("e", [
     new Literal("e", "e"),
     new Literal("e", "E")
 ]);
 
-const optionalSign = new Or("sign", [
+const optionalSign = new Options("sign", [
     new Literal("plus", "+"),
     new Literal("minus", "-")
 ], true);
 
 const digit = new Regex("digit", "\\d+");
 
-const exponent = new And("exponent", [
+const exponent = new Sequence("exponent", [
     e,
     optionalSign,
     digit,
 ]);
 
-export { exponent }
+export { exponent };

package/src/intellisense/javascript/expression.ts

@@ -1,6 +1,6 @@
-import { And } from "../../patterns/And";
+import { Sequence } from "../../patterns/Sequence";
 import { Literal } from "../../patterns/Literal";
-import { Or } from "../../patterns/Or";
+import { Options } from "../../patterns/Options";
 import { Reference } from "../../patterns/Reference";
 import { Regex } from "../../patterns/Regex";
 import { Repeat } from "../../patterns/Repeat";
@@ -13,24 +13,25 @@ import { objectAccess } from "./objectAccess";
 import { optionalSpaces } from "./optionalSpaces";
 import { prefixOperator } from "./prefixOperator";
 import { propertyAccess } from "./propertyAccess";
+import { Optional } from "../../patterns/Optional";
 
-const space = new Regex("space", "\\s+")
+const space = new Regex("space", "\\s+");
 const newKeyword = new Literal("new-keyword", "new");
 const deleteKeyword = new Literal("delete-keyword", "delete");
 
-const newExpression = new And("new-expression", [
+const newExpression = new Sequence("new-expression", [
     newKeyword,
     space,
     new Reference("expression")
 ]);
 
-const deleteExpression = new And("delete-expression", [
+const deleteExpression = new Sequence("delete-expression", [
     deleteKeyword,
     space,
     new Reference("expression")
 ]);
 
-const groupExpression = new And("group-expression", [
+const groupExpression = new Sequence("group-expression", [
     new Literal("open-paren", "("),
     optionalSpaces,
     new Reference("expression"),
@@ -38,13 +39,13 @@ const groupExpression = new And("group-expression", [
     new Literal("close-paren", ")")
 ]);
 
-const prefixExpression = new And("prefix-expression", [
+const prefixExpression = new Sequence("prefix-expression", [
     prefixOperator,
     new Reference("expression")
 ]);
 
 const memberAccess = new Repeat("member-access",
-    new Or("member-access", [
+    new Options("member-access", [
         invocation,
         propertyAccess,
     ])
@@ -53,7 +54,7 @@ const memberAccess = new Repeat("member-access",
 
 var variableName = name.clone("variable-name");
 
-const expressions = new Or("expressions", [
+const expressions = new Options("expressions", [
     newExpression,
     deleteExpression,
     literal,
@@ -64,24 +65,24 @@ const expressions = new Or("expressions", [
     prefixExpression
 ]);
 
-const expressionBody = new And("expression-body", [
+const expressionBody = new Sequence("expression-body", [
     expressions,
-    memberAccess.clone(undefined, true),
+    new Optional("optional-member-access", memberAccess),
 ]);
 
-const infixExpression = new And("infix-expression", [
+const infixExpression = new Sequence("infix-expression", [
     expressionBody,
     optionalSpaces,
     infixOperator,
     optionalSpaces,
-    new Or("infix-right-operand", [
+    new Options("infix-right-operand", [
         new Reference("infix-expression"),
         expressionBody,
     ])
 ]);
 
-const ternaryExpression = new And("ternary", [
-    new Or("ternary-condition", [
+const ternaryExpression = new Sequence("ternary", [
+    new Options("ternary-condition", [
         infixExpression,
         expressionBody
     ]),
@@ -95,11 +96,11 @@ const ternaryExpression = new And("ternary", [
     new Reference("expression")
 ]);
 
-const expression = new Or("expression", [
+const expression = new Options("expression", [
     ternaryExpression,
     infixExpression,
     expressionBody
 ]);
 
-export { expression }
+export { expression };