@angular-wave/angular.ts 0.4.0 → 0.4.2

package/src/core/{parser → parse}/parse.spec.js

@@ -1,15 +1,15 @@
-import { AST } from "./ast";
-import { Lexer } from "./lexer";
+import { AST } from "./ast/ast.js";
+import { Lexer } from "./lexer/lexer.js";
 import {
   isFunction,
   sliceArgs,
   csp,
   valueFn,
   extend,
-} from "../../shared/utils";
-import { createInjector } from "../di/injector";
-import { ASTType } from "./ast-type";
-import { Angular } from "../../loader";
+} from "../../shared/utils.js";
+import { createInjector } from "../di/injector.js";
+import { ASTType } from "./ast-type.js";
+import { Angular } from "../../loader.js";
 
 describe("parser", () => {
   let $rootScope;
@@ -32,1725 +32,6 @@ describe("parser", () => {
     $rootScope = injector.get("$rootScope");
   });
 
-  describe("lexer", () => {
-    let lex;
-
-    beforeEach(() => {
-      lex = function () {
-        const lexer = new Lexer({});
-        return lexer.lex.apply(lexer, arguments);
-      };
-    });
-
-    it("should only match number chars with isNumber", () => {
-      expect(Lexer.prototype.isNumber("0")).toBe(true);
-      expect(Lexer.prototype.isNumber("")).toBeFalsy();
-      expect(Lexer.prototype.isNumber(" ")).toBeFalsy();
-      expect(Lexer.prototype.isNumber(0)).toBeFalsy();
-      expect(Lexer.prototype.isNumber(false)).toBeFalsy();
-      expect(Lexer.prototype.isNumber(true)).toBeFalsy();
-      expect(Lexer.prototype.isNumber(undefined)).toBeFalsy();
-      expect(Lexer.prototype.isNumber(null)).toBeFalsy();
-    });
-
-    it("should tokenize a string", () => {
-      const tokens = lex("a.bc[22]+1.3|f:'a\\'c':\"d\\\"e\"");
-      let i = 0;
-      expect(tokens[i].index).toEqual(0);
-      expect(tokens[i].text).toEqual("a");
-
-      i++;
-      expect(tokens[i].index).toEqual(1);
-      expect(tokens[i].text).toEqual(".");
-
-      i++;
-      expect(tokens[i].index).toEqual(2);
-      expect(tokens[i].text).toEqual("bc");
-
-      i++;
-      expect(tokens[i].index).toEqual(4);
-      expect(tokens[i].text).toEqual("[");
-
-      i++;
-      expect(tokens[i].index).toEqual(5);
-      expect(tokens[i].text).toEqual("22");
-      expect(tokens[i].value).toEqual(22);
-      expect(tokens[i].constant).toEqual(true);
-
-      i++;
-      expect(tokens[i].index).toEqual(7);
-      expect(tokens[i].text).toEqual("]");
-
-      i++;
-      expect(tokens[i].index).toEqual(8);
-      expect(tokens[i].text).toEqual("+");
-
-      i++;
-      expect(tokens[i].index).toEqual(9);
-      expect(tokens[i].text).toEqual("1.3");
-      expect(tokens[i].value).toEqual(1.3);
-      expect(tokens[i].constant).toEqual(true);
-
-      i++;
-      expect(tokens[i].index).toEqual(12);
-      expect(tokens[i].text).toEqual("|");
-
-      i++;
-      expect(tokens[i].index).toEqual(13);
-      expect(tokens[i].text).toEqual("f");
-
-      i++;
-      expect(tokens[i].index).toEqual(14);
-      expect(tokens[i].text).toEqual(":");
-
-      i++;
-      expect(tokens[i].index).toEqual(15);
-      expect(tokens[i].value).toEqual("a'c");
-
-      i++;
-      expect(tokens[i].index).toEqual(21);
-      expect(tokens[i].text).toEqual(":");
-
-      i++;
-      expect(tokens[i].index).toEqual(22);
-      expect(tokens[i].value).toEqual('d"e');
-    });
-
-    it("should tokenize identifiers with spaces around dots the same as without spaces", () => {
-      function getText(t) {
-        return t.text;
-      }
-      const spaces = lex("foo. bar . baz").map(getText);
-      const noSpaces = lex("foo.bar.baz").map(getText);
-
-      expect(spaces).toEqual(noSpaces);
-    });
-
-    it("should use callback functions to know when an identifier is valid", () => {
-      function getText(t) {
-        return t.text;
-      }
-      const isIdentifierStart = jasmine.createSpy("start");
-      const isIdentifierContinue = jasmine.createSpy("continue");
-      isIdentifierStart.and.returnValue(true);
-      const lex = new Lexer({
-        isIdentifierStart,
-        isIdentifierContinue,
-      });
-
-      isIdentifierContinue.and.returnValue(true);
-      let tokens = lex.lex("πΣε").map(getText);
-      expect(tokens).toEqual(["πΣε"]);
-
-      isIdentifierContinue.and.returnValue(false);
-      tokens = lex.lex("πΣε").map(getText);
-      expect(tokens).toEqual(["π", "Σ", "ε"]);
-    });
-
-    it("should send the unicode characters and code points", () => {
-      function getText(t) {
-        return t.text;
-      }
-      const isIdentifierStart = jasmine.createSpy("start");
-      const isIdentifierContinue = jasmine.createSpy("continue");
-      isIdentifierStart.and.returnValue(true);
-      isIdentifierContinue.and.returnValue(true);
-      const lex = new Lexer({
-        isIdentifierStart,
-        isIdentifierContinue,
-      });
-      const tokens = lex.lex("\uD801\uDC37\uD852\uDF62\uDBFF\uDFFF");
-      expect(isIdentifierStart).toHaveBeenCalledTimes(1);
-      expect(isIdentifierStart.calls.argsFor(0)).toEqual([
-        "\uD801\uDC37",
-        0x10437,
-      ]);
-      expect(isIdentifierContinue).toHaveBeenCalledTimes(2);
-      expect(isIdentifierContinue.calls.argsFor(0)).toEqual([
-        "\uD852\uDF62",
-        0x24b62,
-      ]);
-      expect(isIdentifierContinue.calls.argsFor(1)).toEqual([
-        "\uDBFF\uDFFF",
-        0x10ffff,
-      ]);
-    });
-
-    it("should tokenize undefined", () => {
-      const tokens = lex("undefined");
-      const i = 0;
-      expect(tokens[i].index).toEqual(0);
-      expect(tokens[i].text).toEqual("undefined");
-    });
-
-    it("should tokenize quoted string", () => {
-      const str = "['\\'', \"\\\"\"]";
-      const tokens = lex(str);
-
-      expect(tokens[1].index).toEqual(1);
-      expect(tokens[1].value).toEqual("'");
-
-      expect(tokens[3].index).toEqual(7);
-      expect(tokens[3].value).toEqual('"');
-    });
-
-    it("should tokenize escaped quoted string", () => {
-      const str = '"\\"\\n\\f\\r\\t\\v\\u00A0"';
-      const tokens = lex(str);
-
-      expect(tokens[0].value).toEqual('"\n\f\r\t\v\u00A0');
-    });
-
-    it("should tokenize unicode", () => {
-      const tokens = lex('"\\u00A0"');
-      expect(tokens.length).toEqual(1);
-      expect(tokens[0].value).toEqual("\u00a0");
-    });
-
-    it("should ignore whitespace", () => {
-      const tokens = lex("a \t \n \r b");
-      expect(tokens[0].text).toEqual("a");
-      expect(tokens[1].text).toEqual("b");
-    });
-
-    it("should tokenize relation and equality", () => {
-      const tokens = lex("! == != < > <= >= === !==");
-      expect(tokens[0].text).toEqual("!");
-      expect(tokens[1].text).toEqual("==");
-      expect(tokens[2].text).toEqual("!=");
-      expect(tokens[3].text).toEqual("<");
-      expect(tokens[4].text).toEqual(">");
-      expect(tokens[5].text).toEqual("<=");
-      expect(tokens[6].text).toEqual(">=");
-      expect(tokens[7].text).toEqual("===");
-      expect(tokens[8].text).toEqual("!==");
-    });
-
-    it("should tokenize logical and ternary", () => {
-      const tokens = lex("&& || ? :");
-      expect(tokens[0].text).toEqual("&&");
-      expect(tokens[1].text).toEqual("||");
-      expect(tokens[2].text).toEqual("?");
-      expect(tokens[3].text).toEqual(":");
-    });
-
-    it("should tokenize statements", () => {
-      const tokens = lex("a;b;");
-      expect(tokens[0].text).toEqual("a");
-      expect(tokens[1].text).toEqual(";");
-      expect(tokens[2].text).toEqual("b");
-      expect(tokens[3].text).toEqual(";");
-    });
-
-    it("should tokenize function invocation", () => {
-      const tokens = lex("a()");
-      expect(tokens.map((t) => t.text)).toEqual(["a", "(", ")"]);
-    });
-
-    it("should tokenize method invocation", () => {
-      const tokens = lex("a.b.c (d) - e.f()");
-      expect(tokens.map((t) => t.text)).toEqual([
-        "a",
-        ".",
-        "b",
-        ".",
-        "c",
-        "(",
-        "d",
-        ")",
-        "-",
-        "e",
-        ".",
-        "f",
-        "(",
-        ")",
-      ]);
-    });
-
-    it("should tokenize number", () => {
-      const tokens = lex("0.5");
-      expect(tokens[0].value).toEqual(0.5);
-    });
-
-    it("should tokenize negative number", () => {
-      let value = $rootScope.$eval("-0.5");
-      expect(value).toEqual(-0.5);
-
-      value = $rootScope.$eval("{a:-0.5}");
-      expect(value).toEqual({ a: -0.5 });
-    });
-
-    it("should tokenize number with exponent", () => {
-      let tokens = lex("0.5E-10");
-      expect(tokens[0].value).toEqual(0.5e-10);
-      expect($rootScope.$eval("0.5E-10")).toEqual(0.5e-10);
-
-      tokens = lex("0.5E+10");
-      expect(tokens[0].value).toEqual(0.5e10);
-    });
-
-    it("should throws exception for invalid exponent", () => {
-      expect(() => {
-        lex("0.5E-");
-      }).toThrowError(/lexerr/);
-
-      expect(() => {
-        lex("0.5E-A");
-      }).toThrowError(/lexerr/);
-    });
-
-    it("should tokenize number starting with a dot", () => {
-      const tokens = lex(".5");
-      expect(tokens[0].value).toEqual(0.5);
-    });
-
-    it("should throw error on invalid unicode", () => {
-      expect(() => {
-        lex("'\\u1''bla'");
-      }).toThrowError(/lexerr/);
-    });
-  });
-
-  describe("ast", () => {
-    let createAst;
-
-    beforeEach(() => {
-      /* global AST: false */
-      createAst = function () {
-        const lexer = new Lexer({});
-        const ast = new AST(lexer, {
-          csp: false,
-          literals: {
-            true: true,
-            false: false,
-            undefined: undefined,
-            null: null,
-          },
-        });
-        return ast.ast.apply(ast, arguments);
-      };
-    });
-
-    it("should handle an empty list of tokens", () => {
-      expect(createAst("")).toEqual({ type: ASTType.Program, body: [] });
-    });
-
-    it("should understand identifiers", () => {
-      expect(createAst("foo")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: { type: ASTType.Identifier, name: "foo" },
-          },
-        ],
-      });
-    });
-
-    it("should understand non-computed member expressions", () => {
-      expect(createAst("foo.bar")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.MemberExpression,
-              object: { type: ASTType.Identifier, name: "foo" },
-              property: { type: ASTType.Identifier, name: "bar" },
-              computed: false,
-            },
-          },
-        ],
-      });
-    });
-
-    it("should associate non-computed member expressions left-to-right", () => {
-      expect(createAst("foo.bar.baz")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.MemberExpression,
-              object: {
-                type: ASTType.MemberExpression,
-                object: { type: ASTType.Identifier, name: "foo" },
-                property: { type: ASTType.Identifier, name: "bar" },
-                computed: false,
-              },
-              property: { type: ASTType.Identifier, name: "baz" },
-              computed: false,
-            },
-          },
-        ],
-      });
-    });
-
-    it("should understand computed member expressions", () => {
-      expect(createAst("foo[bar]")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.MemberExpression,
-              object: { type: ASTType.Identifier, name: "foo" },
-              property: { type: ASTType.Identifier, name: "bar" },
-              computed: true,
-            },
-          },
-        ],
-      });
-    });
-
-    it("should associate computed member expressions left-to-right", () => {
-      expect(createAst("foo[bar][baz]")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.MemberExpression,
-              object: {
-                type: ASTType.MemberExpression,
-                object: { type: ASTType.Identifier, name: "foo" },
-                property: { type: ASTType.Identifier, name: "bar" },
-                computed: true,
-              },
-              property: { type: ASTType.Identifier, name: "baz" },
-              computed: true,
-            },
-          },
-        ],
-      });
-    });
-
-    it("should understand call expressions", () => {
-      expect(createAst("foo()")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.CallExpression,
-              callee: { type: ASTType.Identifier, name: "foo" },
-              arguments: [],
-            },
-          },
-        ],
-      });
-    });
-
-    it("should parse call expression arguments", () => {
-      expect(createAst("foo(bar, baz)")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.CallExpression,
-              callee: { type: ASTType.Identifier, name: "foo" },
-              arguments: [
-                { type: ASTType.Identifier, name: "bar" },
-                { type: ASTType.Identifier, name: "baz" },
-              ],
-            },
-          },
-        ],
-      });
-    });
-
-    it("should parse call expression left-to-right", () => {
-      expect(createAst("foo(bar, baz)(man, shell)")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.CallExpression,
-              callee: {
-                type: ASTType.CallExpression,
-                callee: { type: ASTType.Identifier, name: "foo" },
-                arguments: [
-                  { type: ASTType.Identifier, name: "bar" },
-                  { type: ASTType.Identifier, name: "baz" },
-                ],
-              },
-              arguments: [
-                { type: ASTType.Identifier, name: "man" },
-                { type: ASTType.Identifier, name: "shell" },
-              ],
-            },
-          },
-        ],
-      });
-    });
-
-    it("should keep the context when having superfluous parenthesis", () => {
-      expect(createAst("(foo)(bar, baz)")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.CallExpression,
-              callee: { type: ASTType.Identifier, name: "foo" },
-              arguments: [
-                { type: ASTType.Identifier, name: "bar" },
-                { type: ASTType.Identifier, name: "baz" },
-              ],
-            },
-          },
-        ],
-      });
-    });
-
-    it("should treat member expressions and call expression with the same precedence", () => {
-      expect(createAst("foo.bar[baz]()")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.CallExpression,
-              callee: {
-                type: ASTType.MemberExpression,
-                object: {
-                  type: ASTType.MemberExpression,
-                  object: { type: ASTType.Identifier, name: "foo" },
-                  property: { type: ASTType.Identifier, name: "bar" },
-                  computed: false,
-                },
-                property: { type: ASTType.Identifier, name: "baz" },
-                computed: true,
-              },
-              arguments: [],
-            },
-          },
-        ],
-      });
-      expect(createAst("foo[bar]().baz")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.MemberExpression,
-              object: {
-                type: ASTType.CallExpression,
-                callee: {
-                  type: ASTType.MemberExpression,
-                  object: { type: ASTType.Identifier, name: "foo" },
-                  property: { type: ASTType.Identifier, name: "bar" },
-                  computed: true,
-                },
-                arguments: [],
-              },
-              property: { type: ASTType.Identifier, name: "baz" },
-              computed: false,
-            },
-          },
-        ],
-      });
-      expect(createAst("foo().bar[baz]")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.MemberExpression,
-              object: {
-                type: ASTType.MemberExpression,
-                object: {
-                  type: ASTType.CallExpression,
-                  callee: { type: ASTType.Identifier, name: "foo" },
-                  arguments: [],
-                },
-                property: { type: ASTType.Identifier, name: "bar" },
-                computed: false,
-              },
-              property: { type: ASTType.Identifier, name: "baz" },
-              computed: true,
-            },
-          },
-        ],
-      });
-    });
-
-    it("should understand literals", () => {
-      // In a strict sense, `undefined` is not a literal but an identifier
-      Object.entries({
-        123: 123,
-        '"123"': "123",
-        true: true,
-        false: false,
-        null: null,
-        undefined: undefined,
-      }).forEach(([expression, value]) => {
-        expect(createAst(expression)).toEqual({
-          type: ASTType.Program,
-          body: [
-            {
-              type: ASTType.ExpressionStatement,
-              expression: { type: ASTType.Literal, value },
-            },
-          ],
-        });
-      });
-    });
-
-    it("should understand the `this` expression", () => {
-      expect(createAst("this")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: { type: ASTType.ThisExpression },
-          },
-        ],
-      });
-    });
-
-    it("should understand the `$locals` expression", () => {
-      expect(createAst("$locals")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: { type: ASTType.LocalsExpression },
-          },
-        ],
-      });
-    });
-
-    it("should not confuse `this`, `$locals`, `undefined`, `true`, `false`, `null` when used as identifiers", () => {
-      ["this", "$locals", "undefined", "true", "false", "null"].forEach(
-        (identifier) => {
-          expect(createAst(`foo.${identifier}`)).toEqual({
-            type: ASTType.Program,
-            body: [
-              {
-                type: ASTType.ExpressionStatement,
-                expression: {
-                  type: ASTType.MemberExpression,
-                  object: { type: ASTType.Identifier, name: "foo" },
-                  property: { type: ASTType.Identifier, name: identifier },
-                  computed: false,
-                },
-              },
-            ],
-          });
-        },
-      );
-    });
-
-    it("should throw when trying to use non-identifiers as identifiers", () => {
-      expect(() => {
-        createAst("foo.)");
-      }).toThrowError(/syntax/);
-    });
-
-    it("should throw when all tokens are not consumed", () => {
-      expect(() => {
-        createAst("foo bar");
-      }).toThrowError(/syntax/);
-    });
-
-    it("should understand the unary operators `-`, `+` and `!`", () => {
-      ["-", "+", "!"].forEach((operator) => {
-        expect(createAst(`${operator}foo`)).toEqual({
-          type: ASTType.Program,
-          body: [
-            {
-              type: ASTType.ExpressionStatement,
-              expression: {
-                type: ASTType.UnaryExpression,
-                operator,
-                prefix: true,
-                argument: { type: ASTType.Identifier, name: "foo" },
-              },
-            },
-          ],
-        });
-      });
-    });
-
-    it("should handle all unary operators with the same precedence", () => {
-      [
-        ["+", "-", "!"],
-        ["-", "!", "+"],
-        ["!", "+", "-"],
-      ].forEach((operators) => {
-        expect(createAst(`${operators.join("")}foo`)).toEqual({
-          type: ASTType.Program,
-          body: [
-            {
-              type: ASTType.ExpressionStatement,
-              expression: {
-                type: ASTType.UnaryExpression,
-                operator: operators[0],
-                prefix: true,
-                argument: {
-                  type: ASTType.UnaryExpression,
-                  operator: operators[1],
-                  prefix: true,
-                  argument: {
-                    type: ASTType.UnaryExpression,
-                    operator: operators[2],
-                    prefix: true,
-                    argument: { type: ASTType.Identifier, name: "foo" },
-                  },
-                },
-              },
-            },
-          ],
-        });
-      });
-    });
-
-    it("should be able to understand binary operators", () => {
-      [
-        "*",
-        "/",
-        "%",
-        "+",
-        "-",
-        "<",
-        ">",
-        "<=",
-        ">=",
-        "==",
-        "!=",
-        "===",
-        "!==",
-      ].forEach((operator) => {
-        expect(createAst(`foo${operator}bar`)).toEqual({
-          type: ASTType.Program,
-          body: [
-            {
-              type: ASTType.ExpressionStatement,
-              expression: {
-                type: ASTType.BinaryExpression,
-                operator,
-                left: { type: ASTType.Identifier, name: "foo" },
-                right: { type: ASTType.Identifier, name: "bar" },
-              },
-            },
-          ],
-        });
-      });
-    });
-
-    it("should associate binary operators with the same precedence left-to-right", () => {
-      const operatorsByPrecedence = [
-        ["*", "/", "%"],
-        ["+", "-"],
-        ["<", ">", "<=", ">="],
-        ["==", "!=", "===", "!=="],
-      ];
-      operatorsByPrecedence.forEach((operators) => {
-        operators.forEach((op1) => {
-          operators.forEach((op2) => {
-            expect(createAst(`foo${op1}bar${op2}baz`)).toEqual({
-              type: ASTType.Program,
-              body: [
-                {
-                  type: ASTType.ExpressionStatement,
-                  expression: {
-                    type: ASTType.BinaryExpression,
-                    operator: op2,
-                    left: {
-                      type: ASTType.BinaryExpression,
-                      operator: op1,
-                      left: { type: ASTType.Identifier, name: "foo" },
-                      right: { type: ASTType.Identifier, name: "bar" },
-                    },
-                    right: { type: ASTType.Identifier, name: "baz" },
-                  },
-                },
-              ],
-            });
-          });
-        });
-      });
-    });
-
-    it("should give higher precedence to member calls than to unary expressions", () => {
-      ["!", "+", "-"].forEach((operator) => {
-        expect(createAst(`${operator}foo()`)).toEqual({
-          type: ASTType.Program,
-          body: [
-            {
-              type: ASTType.ExpressionStatement,
-              expression: {
-                type: ASTType.UnaryExpression,
-                operator,
-                prefix: true,
-                argument: {
-                  type: ASTType.CallExpression,
-                  callee: { type: ASTType.Identifier, name: "foo" },
-                  arguments: [],
-                },
-              },
-            },
-          ],
-        });
-        expect(createAst(`${operator}foo.bar`)).toEqual({
-          type: ASTType.Program,
-          body: [
-            {
-              type: ASTType.ExpressionStatement,
-              expression: {
-                type: ASTType.UnaryExpression,
-                operator,
-                prefix: true,
-                argument: {
-                  type: ASTType.MemberExpression,
-                  object: { type: ASTType.Identifier, name: "foo" },
-                  property: { type: ASTType.Identifier, name: "bar" },
-                  computed: false,
-                },
-              },
-            },
-          ],
-        });
-        expect(createAst(`${operator}foo[bar]`)).toEqual({
-          type: ASTType.Program,
-          body: [
-            {
-              type: ASTType.ExpressionStatement,
-              expression: {
-                type: ASTType.UnaryExpression,
-                operator,
-                prefix: true,
-                argument: {
-                  type: ASTType.MemberExpression,
-                  object: { type: ASTType.Identifier, name: "foo" },
-                  property: { type: ASTType.Identifier, name: "bar" },
-                  computed: true,
-                },
-              },
-            },
-          ],
-        });
-      });
-    });
-
-    it("should give higher precedence to unary operators over multiplicative operators", () => {
-      ["!", "+", "-"].forEach((op1) => {
-        ["*", "/", "%"].forEach((op2) => {
-          expect(createAst(`${op1}foo${op2}${op1}bar`)).toEqual({
-            type: ASTType.Program,
-            body: [
-              {
-                type: ASTType.ExpressionStatement,
-                expression: {
-                  type: ASTType.BinaryExpression,
-                  operator: op2,
-                  left: {
-                    type: ASTType.UnaryExpression,
-                    operator: op1,
-                    prefix: true,
-                    argument: { type: ASTType.Identifier, name: "foo" },
-                  },
-                  right: {
-                    type: ASTType.UnaryExpression,
-                    operator: op1,
-                    prefix: true,
-                    argument: { type: ASTType.Identifier, name: "bar" },
-                  },
-                },
-              },
-            ],
-          });
-        });
-      });
-    });
-
-    it("should give binary operators their right precedence", () => {
-      const operatorsByPrecedence = [
-        ["*", "/", "%"],
-        ["+", "-"],
-        ["<", ">", "<=", ">="],
-        ["==", "!=", "===", "!=="],
-      ];
-      for (let i = 0; i < operatorsByPrecedence.length - 1; ++i) {
-        operatorsByPrecedence[i].forEach((op1) => {
-          operatorsByPrecedence[i + 1].forEach((op2) => {
-            expect(createAst(`foo${op1}bar${op2}baz${op1}man`)).toEqual({
-              type: ASTType.Program,
-              body: [
-                {
-                  type: ASTType.ExpressionStatement,
-                  expression: {
-                    type: ASTType.BinaryExpression,
-                    operator: op2,
-                    left: {
-                      type: ASTType.BinaryExpression,
-                      operator: op1,
-                      left: { type: ASTType.Identifier, name: "foo" },
-                      right: { type: ASTType.Identifier, name: "bar" },
-                    },
-                    right: {
-                      type: ASTType.BinaryExpression,
-                      operator: op1,
-                      left: { type: ASTType.Identifier, name: "baz" },
-                      right: { type: ASTType.Identifier, name: "man" },
-                    },
-                  },
-                },
-              ],
-            });
-          });
-        });
-      }
-    });
-
-    it("should understand logical operators", () => {
-      ["||", "&&"].forEach((operator) => {
-        expect(createAst(`foo${operator}bar`)).toEqual({
-          type: ASTType.Program,
-          body: [
-            {
-              type: ASTType.ExpressionStatement,
-              expression: {
-                type: ASTType.LogicalExpression,
-                operator,
-                left: { type: ASTType.Identifier, name: "foo" },
-                right: { type: ASTType.Identifier, name: "bar" },
-              },
-            },
-          ],
-        });
-      });
-    });
-
-    it("should associate logical operators left-to-right", () => {
-      ["||", "&&"].forEach((op) => {
-        expect(createAst(`foo${op}bar${op}baz`)).toEqual({
-          type: ASTType.Program,
-          body: [
-            {
-              type: ASTType.ExpressionStatement,
-              expression: {
-                type: ASTType.LogicalExpression,
-                operator: op,
-                left: {
-                  type: ASTType.LogicalExpression,
-                  operator: op,
-                  left: { type: ASTType.Identifier, name: "foo" },
-                  right: { type: ASTType.Identifier, name: "bar" },
-                },
-                right: { type: ASTType.Identifier, name: "baz" },
-              },
-            },
-          ],
-        });
-      });
-    });
-
-    it("should understand ternary operators", () => {
-      expect(createAst("foo?bar:baz")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.ConditionalExpression,
-              test: { type: ASTType.Identifier, name: "foo" },
-              alternate: { type: ASTType.Identifier, name: "bar" },
-              consequent: { type: ASTType.Identifier, name: "baz" },
-            },
-          },
-        ],
-      });
-    });
-
-    it("should associate the conditional operator right-to-left", () => {
-      expect(createAst("foo0?foo1:foo2?bar0?bar1:bar2:man0?man1:man2")).toEqual(
-        {
-          type: ASTType.Program,
-          body: [
-            {
-              type: ASTType.ExpressionStatement,
-              expression: {
-                type: ASTType.ConditionalExpression,
-                test: { type: ASTType.Identifier, name: "foo0" },
-                alternate: { type: ASTType.Identifier, name: "foo1" },
-                consequent: {
-                  type: ASTType.ConditionalExpression,
-                  test: { type: ASTType.Identifier, name: "foo2" },
-                  alternate: {
-                    type: ASTType.ConditionalExpression,
-                    test: { type: ASTType.Identifier, name: "bar0" },
-                    alternate: { type: ASTType.Identifier, name: "bar1" },
-                    consequent: { type: ASTType.Identifier, name: "bar2" },
-                  },
-                  consequent: {
-                    type: ASTType.ConditionalExpression,
-                    test: { type: ASTType.Identifier, name: "man0" },
-                    alternate: { type: ASTType.Identifier, name: "man1" },
-                    consequent: { type: ASTType.Identifier, name: "man2" },
-                  },
-                },
-              },
-            },
-          ],
-        },
-      );
-    });
-
-    it("should understand assignment operator", () => {
-      // Currently, only `=` is supported
-      expect(createAst("foo=bar")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.AssignmentExpression,
-              left: { type: ASTType.Identifier, name: "foo" },
-              right: { type: ASTType.Identifier, name: "bar" },
-              operator: "=",
-            },
-          },
-        ],
-      });
-    });
-
-    it("should associate assignments right-to-left", () => {
-      // Currently, only `=` is supported
-      expect(createAst("foo=bar=man")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.AssignmentExpression,
-              left: { type: ASTType.Identifier, name: "foo" },
-              right: {
-                type: ASTType.AssignmentExpression,
-                left: { type: ASTType.Identifier, name: "bar" },
-                right: { type: ASTType.Identifier, name: "man" },
-                operator: "=",
-              },
-              operator: "=",
-            },
-          },
-        ],
-      });
-    });
-
-    it("should give higher precedence to equality than to the logical `and` operator", () => {
-      ["==", "!=", "===", "!=="].forEach((operator) => {
-        expect(createAst(`foo${operator}bar && man${operator}shell`)).toEqual({
-          type: ASTType.Program,
-          body: [
-            {
-              type: ASTType.ExpressionStatement,
-              expression: {
-                type: ASTType.LogicalExpression,
-                operator: "&&",
-                left: {
-                  type: ASTType.BinaryExpression,
-                  operator,
-                  left: { type: ASTType.Identifier, name: "foo" },
-                  right: { type: ASTType.Identifier, name: "bar" },
-                },
-                right: {
-                  type: ASTType.BinaryExpression,
-                  operator,
-                  left: { type: ASTType.Identifier, name: "man" },
-                  right: { type: ASTType.Identifier, name: "shell" },
-                },
-              },
-            },
-          ],
-        });
-      });
-    });
-
-    it("should give higher precedence to logical `and` than to logical `or`", () => {
-      expect(createAst("foo&&bar||man&&shell")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.LogicalExpression,
-              operator: "||",
-              left: {
-                type: ASTType.LogicalExpression,
-                operator: "&&",
-                left: { type: ASTType.Identifier, name: "foo" },
-                right: { type: ASTType.Identifier, name: "bar" },
-              },
-              right: {
-                type: ASTType.LogicalExpression,
-                operator: "&&",
-                left: { type: ASTType.Identifier, name: "man" },
-                right: { type: ASTType.Identifier, name: "shell" },
-              },
-            },
-          },
-        ],
-      });
-    });
-
-    it("should give higher precedence to the logical `or` than to the conditional operator", () => {
-      expect(createAst("foo||bar?man:shell")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.ConditionalExpression,
-              test: {
-                type: ASTType.LogicalExpression,
-                operator: "||",
-                left: { type: ASTType.Identifier, name: "foo" },
-                right: { type: ASTType.Identifier, name: "bar" },
-              },
-              alternate: { type: ASTType.Identifier, name: "man" },
-              consequent: { type: ASTType.Identifier, name: "shell" },
-            },
-          },
-        ],
-      });
-    });
-
-    it("should give higher precedence to the conditional operator than to assignment operators", () => {
-      expect(createAst("foo=bar?man:shell")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.AssignmentExpression,
-              left: { type: ASTType.Identifier, name: "foo" },
-              right: {
-                type: ASTType.ConditionalExpression,
-                test: { type: ASTType.Identifier, name: "bar" },
-                alternate: { type: ASTType.Identifier, name: "man" },
-                consequent: { type: ASTType.Identifier, name: "shell" },
-              },
-              operator: "=",
-            },
-          },
-        ],
-      });
-    });
-
-    it("should understand array literals", () => {
-      expect(createAst("[]")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.ArrayExpression,
-              elements: [],
-            },
-          },
-        ],
-      });
-      expect(createAst("[foo]")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.ArrayExpression,
-              elements: [{ type: ASTType.Identifier, name: "foo" }],
-            },
-          },
-        ],
-      });
-      expect(createAst("[foo,]")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.ArrayExpression,
-              elements: [{ type: ASTType.Identifier, name: "foo" }],
-            },
-          },
-        ],
-      });
-      expect(createAst("[foo,bar,man,shell]")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.ArrayExpression,
-              elements: [
-                { type: ASTType.Identifier, name: "foo" },
-                { type: ASTType.Identifier, name: "bar" },
-                { type: ASTType.Identifier, name: "man" },
-                { type: ASTType.Identifier, name: "shell" },
-              ],
-            },
-          },
-        ],
-      });
-      expect(createAst("[foo,bar,man,shell,]")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.ArrayExpression,
-              elements: [
-                { type: ASTType.Identifier, name: "foo" },
-                { type: ASTType.Identifier, name: "bar" },
-                { type: ASTType.Identifier, name: "man" },
-                { type: ASTType.Identifier, name: "shell" },
-              ],
-            },
-          },
-        ],
-      });
-    });
-
-    it("should understand objects", () => {
-      expect(createAst("{}")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.ObjectExpression,
-              properties: [],
-            },
-          },
-        ],
-      });
-      expect(createAst("{foo: bar}")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.ObjectExpression,
-              properties: [
-                {
-                  type: ASTType.Property,
-                  kind: "init",
-                  key: { type: ASTType.Identifier, name: "foo" },
-                  computed: false,
-                  value: { type: ASTType.Identifier, name: "bar" },
-                },
-              ],
-            },
-          },
-        ],
-      });
-      expect(createAst("{foo: bar,}")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.ObjectExpression,
-              properties: [
-                {
-                  type: ASTType.Property,
-                  kind: "init",
-                  key: { type: ASTType.Identifier, name: "foo" },
-                  computed: false,
-                  value: { type: ASTType.Identifier, name: "bar" },
-                },
-              ],
-            },
-          },
-        ],
-      });
-      expect(createAst('{foo: bar, "man": "shell", 42: 23}')).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.ObjectExpression,
-              properties: [
-                {
-                  type: ASTType.Property,
-                  kind: "init",
-                  key: { type: ASTType.Identifier, name: "foo" },
-                  computed: false,
-                  value: { type: ASTType.Identifier, name: "bar" },
-                },
-                {
-                  type: ASTType.Property,
-                  kind: "init",
-                  key: { type: ASTType.Literal, value: "man" },
-                  computed: false,
-                  value: { type: ASTType.Literal, value: "shell" },
-                },
-                {
-                  type: ASTType.Property,
-                  kind: "init",
-                  key: { type: ASTType.Literal, value: 42 },
-                  computed: false,
-                  value: { type: ASTType.Literal, value: 23 },
-                },
-              ],
-            },
-          },
-        ],
-      });
-      expect(createAst('{foo: bar, "man": "shell", 42: 23,}')).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.ObjectExpression,
-              properties: [
-                {
-                  type: ASTType.Property,
-                  kind: "init",
-                  key: { type: ASTType.Identifier, name: "foo" },
-                  computed: false,
-                  value: { type: ASTType.Identifier, name: "bar" },
-                },
-                {
-                  type: ASTType.Property,
-                  kind: "init",
-                  key: { type: ASTType.Literal, value: "man" },
-                  computed: false,
-                  value: { type: ASTType.Literal, value: "shell" },
-                },
-                {
-                  type: ASTType.Property,
-                  kind: "init",
-                  key: { type: ASTType.Literal, value: 42 },
-                  computed: false,
-                  value: { type: ASTType.Literal, value: 23 },
-                },
-              ],
-            },
-          },
-        ],
-      });
-    });
-
-    it("should understand ES6 object initializer", () => {
-      // Shorthand properties definitions.
-      expect(createAst("{x, y, z}")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.ObjectExpression,
-              properties: [
-                {
-                  type: ASTType.Property,
-                  kind: "init",
-                  key: { type: ASTType.Identifier, name: "x" },
-                  computed: false,
-                  value: { type: ASTType.Identifier, name: "x" },
-                },
-                {
-                  type: ASTType.Property,
-                  kind: "init",
-                  key: { type: ASTType.Identifier, name: "y" },
-                  computed: false,
-                  value: { type: ASTType.Identifier, name: "y" },
-                },
-                {
-                  type: ASTType.Property,
-                  kind: "init",
-                  key: { type: ASTType.Identifier, name: "z" },
-                  computed: false,
-                  value: { type: ASTType.Identifier, name: "z" },
-                },
-              ],
-            },
-          },
-        ],
-      });
-      expect(() => {
-        createAst('{"foo"}');
-      }).toThrow();
-
-      // Computed properties
-      expect(createAst("{[x]: x}")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.ObjectExpression,
-              properties: [
-                {
-                  type: ASTType.Property,
-                  kind: "init",
-                  key: { type: ASTType.Identifier, name: "x" },
-                  computed: true,
-                  value: { type: ASTType.Identifier, name: "x" },
-                },
-              ],
-            },
-          },
-        ],
-      });
-      expect(createAst("{[x + 1]: x}")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.ObjectExpression,
-              properties: [
-                {
-                  type: ASTType.Property,
-                  kind: "init",
-                  key: {
-                    type: ASTType.BinaryExpression,
-                    operator: "+",
-                    left: { type: ASTType.Identifier, name: "x" },
-                    right: { type: ASTType.Literal, value: 1 },
-                  },
-                  computed: true,
-                  value: { type: ASTType.Identifier, name: "x" },
-                },
-              ],
-            },
-          },
-        ],
-      });
-    });
-
-    it("should understand multiple expressions", () => {
-      expect(createAst("foo = bar; man = shell")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.AssignmentExpression,
-              left: { type: ASTType.Identifier, name: "foo" },
-              right: { type: ASTType.Identifier, name: "bar" },
-              operator: "=",
-            },
-          },
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.AssignmentExpression,
-              left: { type: ASTType.Identifier, name: "man" },
-              right: { type: ASTType.Identifier, name: "shell" },
-              operator: "=",
-            },
-          },
-        ],
-      });
-    });
-
-    // This is non-standard syntax
-    it("should understand filters", () => {
-      expect(createAst("foo | bar")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.CallExpression,
-              callee: { type: ASTType.Identifier, name: "bar" },
-              arguments: [{ type: ASTType.Identifier, name: "foo" }],
-              filter: true,
-            },
-          },
-        ],
-      });
-    });
-
-    it("should understand filters with extra parameters", () => {
-      expect(createAst("foo | bar:baz")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.CallExpression,
-              callee: { type: ASTType.Identifier, name: "bar" },
-              arguments: [
-                { type: ASTType.Identifier, name: "foo" },
-                { type: ASTType.Identifier, name: "baz" },
-              ],
-              filter: true,
-            },
-          },
-        ],
-      });
-    });
-
-    it("should associate filters right-to-left", () => {
-      expect(createAst("foo | bar:man | shell")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.CallExpression,
-              callee: { type: ASTType.Identifier, name: "shell" },
-              arguments: [
-                {
-                  type: ASTType.CallExpression,
-                  callee: { type: ASTType.Identifier, name: "bar" },
-                  arguments: [
-                    { type: ASTType.Identifier, name: "foo" },
-                    { type: ASTType.Identifier, name: "man" },
-                  ],
-                  filter: true,
-                },
-              ],
-              filter: true,
-            },
-          },
-        ],
-      });
-    });
-
-    it("should give higher precedence to assignments over filters", () => {
-      expect(createAst("foo=bar | man")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.CallExpression,
-              callee: { type: ASTType.Identifier, name: "man" },
-              arguments: [
-                {
-                  type: ASTType.AssignmentExpression,
-                  left: { type: ASTType.Identifier, name: "foo" },
-                  right: { type: ASTType.Identifier, name: "bar" },
-                  operator: "=",
-                },
-              ],
-              filter: true,
-            },
-          },
-        ],
-      });
-    });
-
-    it("should accept expression as filters parameters", () => {
-      expect(createAst("foo | bar:baz=man")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.CallExpression,
-              callee: { type: ASTType.Identifier, name: "bar" },
-              arguments: [
-                { type: ASTType.Identifier, name: "foo" },
-                {
-                  type: ASTType.AssignmentExpression,
-                  left: { type: ASTType.Identifier, name: "baz" },
-                  right: { type: ASTType.Identifier, name: "man" },
-                  operator: "=",
-                },
-              ],
-              filter: true,
-            },
-          },
-        ],
-      });
-    });
-
-    it("should accept expression as computer members", () => {
-      expect(createAst("foo[a = 1]")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.MemberExpression,
-              object: { type: ASTType.Identifier, name: "foo" },
-              property: {
-                type: ASTType.AssignmentExpression,
-                left: { type: ASTType.Identifier, name: "a" },
-                right: { type: ASTType.Literal, value: 1 },
-                operator: "=",
-              },
-              computed: true,
-            },
-          },
-        ],
-      });
-    });
-
-    it("should accept expression in function arguments", () => {
-      expect(createAst("foo(a = 1)")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.CallExpression,
-              callee: { type: ASTType.Identifier, name: "foo" },
-              arguments: [
-                {
-                  type: ASTType.AssignmentExpression,
-                  left: { type: ASTType.Identifier, name: "a" },
-                  right: { type: ASTType.Literal, value: 1 },
-                  operator: "=",
-                },
-              ],
-            },
-          },
-        ],
-      });
-    });
-
-    it("should accept expression as part of ternary operators", () => {
-      expect(createAst("foo || bar ? man = 1 : shell = 1")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.ConditionalExpression,
-              test: {
-                type: ASTType.LogicalExpression,
-                operator: "||",
-                left: { type: ASTType.Identifier, name: "foo" },
-                right: { type: ASTType.Identifier, name: "bar" },
-              },
-              alternate: {
-                type: ASTType.AssignmentExpression,
-                left: { type: ASTType.Identifier, name: "man" },
-                right: { type: ASTType.Literal, value: 1 },
-                operator: "=",
-              },
-              consequent: {
-                type: ASTType.AssignmentExpression,
-                left: { type: ASTType.Identifier, name: "shell" },
-                right: { type: ASTType.Literal, value: 1 },
-                operator: "=",
-              },
-            },
-          },
-        ],
-      });
-    });
-
-    it("should accept expression as part of array literals", () => {
-      expect(createAst("[foo = 1]")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.ArrayExpression,
-              elements: [
-                {
-                  type: ASTType.AssignmentExpression,
-                  left: { type: ASTType.Identifier, name: "foo" },
-                  right: { type: ASTType.Literal, value: 1 },
-                  operator: "=",
-                },
-              ],
-            },
-          },
-        ],
-      });
-    });
-
-    it("should accept expression as part of object literals", () => {
-      expect(createAst("{foo: bar = 1}")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.ObjectExpression,
-              properties: [
-                {
-                  type: ASTType.Property,
-                  kind: "init",
-                  key: { type: ASTType.Identifier, name: "foo" },
-                  computed: false,
-                  value: {
-                    type: ASTType.AssignmentExpression,
-                    left: { type: ASTType.Identifier, name: "bar" },
-                    right: { type: ASTType.Literal, value: 1 },
-                    operator: "=",
-                  },
-                },
-              ],
-            },
-          },
-        ],
-      });
-    });
-
-    it("should be possible to use parenthesis to indicate precedence", () => {
-      expect(createAst("(foo + bar).man")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: {
-              type: ASTType.MemberExpression,
-              object: {
-                type: ASTType.BinaryExpression,
-                operator: "+",
-                left: { type: ASTType.Identifier, name: "foo" },
-                right: { type: ASTType.Identifier, name: "bar" },
-              },
-              property: { type: ASTType.Identifier, name: "man" },
-              computed: false,
-            },
-          },
-        ],
-      });
-    });
-
-    it("should skip empty expressions", () => {
-      expect(createAst("foo;;;;bar")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: { type: ASTType.Identifier, name: "foo" },
-          },
-          {
-            type: ASTType.ExpressionStatement,
-            expression: { type: ASTType.Identifier, name: "bar" },
-          },
-        ],
-      });
-      expect(createAst(";foo")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: { type: ASTType.Identifier, name: "foo" },
-          },
-        ],
-      });
-      expect(createAst("foo;")).toEqual({
-        type: ASTType.Program,
-        body: [
-          {
-            type: ASTType.ExpressionStatement,
-            expression: { type: ASTType.Identifier, name: "foo" },
-          },
-        ],
-      });
-      expect(createAst(";;;;")).toEqual({ type: ASTType.Program, body: [] });
-      expect(createAst("")).toEqual({ type: ASTType.Program, body: [] });
-    });
-  });
-
   let filterProvider;
 
   beforeEach(() => {