@bablr/language-en-es6 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Conrad Buck
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/lib/grammar.js

@@ -0,0 +1,139 @@
+/* @macrome
+ * @generatedby @bablr/macrome-generator-bablr
+ * @generatedfrom ./grammar.macro.js#6042f078b7b381cf1100801b2c61981b32f17fc0
+ * This file is autogenerated. Please do not edit it directly.
+ * When editing run `npx macrome watch` then change the file this is generated from.
+ */
+import _applyDecs from "@babel/runtime/helpers/applyDecs2305";
+var _importMixin;
+let _initProto, _VariableDeclarationStatementDecs, _ForStatementDecs;
+import { re, spam as m } from '@bablr/boot';
+import { AllowEmpty, CoveredBy, Node } from '@bablr/helpers/decorators';
+import { eat, eatMatch, shiftMatch, match, o } from '@bablr/helpers/grammar';
+import { triviaEnhancer } from '@bablr/helpers/trivia';
+import * as Comment from '@bablr/language-en-c-comments';
+import * as es5 from '@bablr/language-en-es5';
+import { mixin as classMixin } from './mixins/class.js';
+import { mixin as importMixin } from './mixins/import.js';
+import { mixin as functionMixin } from './mixins/function.js';
+import { buildPattern } from '@bablr/helpers/builders';
+import { unaryPrefixOperatorAlternatives } from '@bablr/language-en-es5';
+export const dependencies = {
+  Comment
+};
+export { powerLevels, reservedWords, assignmentOperators, assignmentOperatorAlternatives, unaryPrefixOperators, unaryPrefixOperatorAlternatives, unaryPostfixOperators, unaryPostfixOperatorAlternatives, getBinaryOperatorAlternatives } from '@bablr/language-en-es5';
+export const canonicalURL = 'https://bablr.org/languages/universe/es6';
+export const atrivialGrammar = class ES6Grammar extends (_importMixin = importMixin(classMixin(functionMixin(es5.atrivialGrammar)))) {
+  static {
+    [_initProto] = _applyDecs(this, [[AllowEmpty, 2, "Statement"], [_VariableDeclarationStatementDecs, 2, "VariableDeclarationStatement"], [_ForStatementDecs, 2, "ForStatement"], [Node, 2, "VariableDeclarator"], [Node, 2, "Property"]], [], 0, void 0, _importMixin).e;
+  }
+  constructor(...args) {
+    super(...args);
+    _initProto(this);
+  }
+  *[(_VariableDeclarationStatementDecs = [CoveredBy('Statement'), Node], _ForStatementDecs = [CoveredBy('Statement'), Node], "Expression")](args) {
+    let {
+      props: {
+        power = 34,
+        noIn = false
+      },
+      s
+    } = args;
+    let res;
+    if (!s.holding) {
+      if (res = yield eatMatch(m`<ArrowFunctionExpression '(' />`)) {} else if (res = yield eatMatch(m`<ParenthesisExpression '(' />`)) {} else if (res = yield eatMatch(m`<_JSONExpression />`)) {} else if (res = yield eatMatch(m`<FunctionExpression 'function' />`)) {} else if (power >= 4 && (res = yield eatMatch(m`<UnaryExpression ${buildPattern(unaryPrefixOperatorAlternatives)} />`))) {} else if (power >= 4 && (res = yield eatMatch(m`<NewExpression 'new' />`, o({
+        power
+      })))) {} else if (res = yield eatMatch(m`<Identifier />`)) {}
+    } else {
+      if (res = yield eatMatch(m`<ArrowFunctionExpression /\g=\>/ />`)) {} else {
+        res = yield eatMatch(m`<_LogicExpression />`, o({
+          power,
+          noIn
+        }));
+      }
+    }
+    if (res) {
+      return shiftMatch(m`<__Expression />`, o({
+        power
+      }));
+    }
+  }
+  *Statement(args) {
+    if (yield eatMatch(m`<ImportDeclaration 'import' />`)) {} else if (yield eatMatch(m`<ExportDeclaration 'export' />`)) {} else if (yield eatMatch(m`<ClassDeclaration 'class' />`)) {} else if (yield eatMatch(m`<YieldStatement 'yield' />`)) {} else if (yield eatMatch(m`<VariableDeclarationStatement /var|const|let/ />`)) {} else {
+      yield* super.Statement(args);
+    }
+  }
+  *JSONExpression(args) {
+    if (yield eatMatch(m`<ClassExpression 'class' />`)) {} else if (yield eatMatch(m`<ThisExpression 'this' />`)) {} else if (yield eatMatch(m`<SuperExpression 'super' />`)) {} else if (yield eatMatch(m`<ArrowFunctionExpression '(' />`)) {} else {
+      yield* super.JSONExpression(args);
+    }
+  }
+  *VariableDeclarationStatement() {
+    yield eat(m`sigilToken: <*Keyword /var|const|let/ />`);
+    let sep = true;
+    while (sep) {
+      yield eatMatch(m`declarations[]: <VariableDeclarator />`);
+      sep = yield eatMatch(m`separatorTokens[]: <*Punctuator ',' />`);
+    }
+    yield eatMatch(m`endToken: <*Punctuator ';' />`, null, o({
+      bind: true
+    }));
+  }
+  *ForStatement() {
+    yield eat(m`sigilToken: <*Keyword 'for' />`);
+    yield eat(m`openHeaderToken: <*Punctuator '(' { balanced: ')' } />`);
+    if (!(yield eatMatch(m`init+$: <VariableDeclarationStatement />`, o({
+      noSemi: true
+    })))) {
+      yield eatMatch(m`init+$: <__Expression />`, o({
+        noIn: true
+      }));
+    }
+    let source = yield eatMatch(m`inToken: <*Keyword /in|of/ />`, o({}), o({
+      bind: true
+    }));
+    if (source) {
+      yield eatMatch(m`source+$: <__Expression />`);
+    } else {
+      yield eat(m`testSeparatorToken: <*Punctuator ';' />`);
+      yield eatMatch(m`test+$: <__Expression />`);
+      yield eat(m`updateSeparatorToken: <*Punctuator ';' />`);
+      yield eatMatch(m`update+$: <__Expression />`);
+    }
+    yield eat(m`closeHeaderToken: <*Punctuator ')' { balancer: true } />`);
+    yield eat(m`body: <__Statement />`);
+  }
+  *VariableDeclarator() {
+    if (yield match('{')) {
+      yield eat(m`target: <ObjectPattern />`);
+    } else {
+      yield eat(m`target: <Identifier />`);
+    }
+    if (yield match(re`/=/s`)) {
+      yield eat(m`assignmentOperator: <*Punctuator '=' />`);
+      yield eat(m`value+$: <__Expression />`, o({
+        power: 32
+      }));
+    } else {
+      yield eat(m`assignmentOperator: null`);
+      yield eat(m`value+$: null`);
+    }
+  }
+  *Property() {
+    yield eat(m`key$: <Identifier />`);
+    let op = yield eatMatch(m`mapOperator: <*Punctuator ':' />`, o({}), o({
+      bind: true
+    }));
+    if (op) {
+      yield eat(m`value+$: <__Expression />`, o({
+        power: 32
+      }));
+    } else {
+      yield eat(m`value+$: null`);
+    }
+  }
+};
+export const grammar = triviaEnhancer({
+  triviaIsAllowed: s => s.span === 'Bare',
+  triviaMatcher: m`#: :Comment: <_Trivia /[ \n\r\t]|\/\/|\/\*/ />`
+}, atrivialGrammar);

package/lib/grammar.macro.js

@@ -0,0 +1,155 @@
+import { re, spam as m } from '@bablr/boot';
+import { AllowEmpty, CoveredBy, Node } from '@bablr/helpers/decorators';
+import { eat, eatMatch, shiftMatch, match, o } from '@bablr/helpers/grammar';
+import { triviaEnhancer } from '@bablr/helpers/trivia';
+import * as Comment from '@bablr/language-en-c-comments';
+import * as es5 from '@bablr/language-en-es5';
+import { mixin as classMixin } from './mixins/class.js';
+import { mixin as importMixin } from './mixins/import.js';
+import { mixin as functionMixin } from './mixins/function.js';
+import { buildPattern } from '@bablr/helpers/builders';
+import { unaryPrefixOperatorAlternatives } from '@bablr/language-en-es5';
+
+export const dependencies = { Comment };
+
+export {
+  powerLevels,
+  reservedWords,
+  assignmentOperators,
+  assignmentOperatorAlternatives,
+  unaryPrefixOperators,
+  unaryPrefixOperatorAlternatives,
+  unaryPostfixOperators,
+  unaryPostfixOperatorAlternatives,
+  getBinaryOperatorAlternatives,
+} from '@bablr/language-en-es5';
+
+export const canonicalURL = 'https://bablr.org/languages/universe/es6';
+
+export const atrivialGrammar = class ES6Grammar extends importMixin(
+  classMixin(functionMixin(es5.atrivialGrammar)),
+) {
+  *Expression(args) {
+    let {
+      props: { power = 34, noIn = false },
+      s,
+    } = args;
+    let res;
+    if (!s.holding) {
+      if ((res = yield eatMatch(m`<ArrowFunctionExpression '(' />`))) {
+      } else if ((res = yield eatMatch(m`<ParenthesisExpression '(' />`))) {
+      } else if ((res = yield eatMatch(m`<_JSONExpression />`))) {
+      } else if ((res = yield eatMatch(m`<FunctionExpression 'function' />`))) {
+      } else if (
+        power >= 4 &&
+        (res = yield eatMatch(
+          m`<UnaryExpression ${buildPattern(unaryPrefixOperatorAlternatives)} />`,
+        ))
+      ) {
+      } else if (power >= 4 && (res = yield eatMatch(m`<NewExpression 'new' />`, o({ power })))) {
+      } else if ((res = yield eatMatch(m`<Identifier />`))) {
+      }
+    } else {
+      if ((res = yield eatMatch(m`<ArrowFunctionExpression /\g=\>/ />`))) {
+      } else {
+        res = yield eatMatch(m`<_LogicExpression />`, o({ power, noIn }));
+      }
+    }
+    if (res) {
+      return shiftMatch(m`<__Expression />`, o({ power }));
+    }
+  }
+
+  @AllowEmpty
+  *Statement(args) {
+    if (yield eatMatch(m`<ImportDeclaration 'import' />`)) {
+    } else if (yield eatMatch(m`<ExportDeclaration 'export' />`)) {
+    } else if (yield eatMatch(m`<ClassDeclaration 'class' />`)) {
+    } else if (yield eatMatch(m`<YieldStatement 'yield' />`)) {
+    } else if (yield eatMatch(m`<VariableDeclarationStatement /var|const|let/ />`)) {
+    } else {
+      yield* super.Statement(args);
+    }
+  }
+
+  *JSONExpression(args) {
+    if (yield eatMatch(m`<ClassExpression 'class' />`)) {
+    } else if (yield eatMatch(m`<ThisExpression 'this' />`)) {
+    } else if (yield eatMatch(m`<SuperExpression 'super' />`)) {
+    } else if (yield eatMatch(m`<ArrowFunctionExpression '(' />`)) {
+    } else {
+      yield* super.JSONExpression(args);
+    }
+  }
+
+  @CoveredBy('Statement')
+  @Node
+  *VariableDeclarationStatement() {
+    yield eat(m`sigilToken: <*Keyword /var|const|let/ />`);
+
+    let sep = true;
+    while (sep) {
+      yield eatMatch(m`declarations[]: <VariableDeclarator />`);
+      sep = yield eatMatch(m`separatorTokens[]: <*Punctuator ',' />`);
+    }
+
+    yield eatMatch(m`endToken: <*Punctuator ';' />`, null, o({ bind: true }));
+  }
+
+  @CoveredBy('Statement')
+  @Node
+  *ForStatement() {
+    yield eat(m`sigilToken: <*Keyword 'for' />`);
+    yield eat(m`openHeaderToken: <*Punctuator '(' { balanced: ')' } />`);
+    if (!(yield eatMatch(m`init+$: <VariableDeclarationStatement />`, o({ noSemi: true })))) {
+      yield eatMatch(m`init+$: <__Expression />`, o({ noIn: true }));
+    }
+    let source = yield eatMatch(m`inToken: <*Keyword /in|of/ />`, o({}), o({ bind: true }));
+    if (source) {
+      yield eatMatch(m`source+$: <__Expression />`);
+    } else {
+      yield eat(m`testSeparatorToken: <*Punctuator ';' />`);
+      yield eatMatch(m`test+$: <__Expression />`);
+      yield eat(m`updateSeparatorToken: <*Punctuator ';' />`);
+      yield eatMatch(m`update+$: <__Expression />`);
+    }
+    yield eat(m`closeHeaderToken: <*Punctuator ')' { balancer: true } />`);
+    yield eat(m`body: <__Statement />`);
+  }
+
+  @Node
+  *VariableDeclarator() {
+    if (yield match('{')) {
+      yield eat(m`target: <ObjectPattern />`);
+    } else {
+      yield eat(m`target: <Identifier />`);
+    }
+
+    if (yield match(re`/=/s`)) {
+      yield eat(m`assignmentOperator: <*Punctuator '=' />`);
+      yield eat(m`value+$: <__Expression />`, o({ power: 32 }));
+    } else {
+      yield eat(m`assignmentOperator: null`);
+      yield eat(m`value+$: null`);
+    }
+  }
+
+  @Node
+  *Property() {
+    yield eat(m`key$: <Identifier />`);
+    let op = yield eatMatch(m`mapOperator: <*Punctuator ':' />`, o({}), o({ bind: true }));
+    if (op) {
+      yield eat(m`value+$: <__Expression />`, o({ power: 32 }));
+    } else {
+      yield eat(m`value+$: null`);
+    }
+  }
+};
+
+export const grammar = triviaEnhancer(
+  {
+    triviaIsAllowed: (s) => s.span === 'Bare',
+    triviaMatcher: m`#: :Comment: <_Trivia /[ \n\r\t]|\/\/|\/\*/ />`,
+  },
+  atrivialGrammar,
+);

package/lib/mixins/class.js

@@ -0,0 +1,82 @@
+/* @macrome
+ * @generatedby @bablr/macrome-generator-bablr
+ * @generatedfrom ./class.macro.js#4e159ba9b4b2272a008a11039caf5d564355a414
+ * This file is autogenerated. Please do not edit it directly.
+ * When editing run `npx macrome watch` then change the file this is generated from.
+ */
+import _applyDecs from "@babel/runtime/helpers/applyDecs2305";
+import { spam as m } from '@bablr/boot';
+import { CoveredBy, Node } from '@bablr/helpers/decorators';
+import { o, eat, eatMatch, fail } from '@bablr/helpers/grammar';
+export const mixin = Base => {
+  let _initProto, _ClassExpressionDecs, _ClassMethodDecs, _SuperExpressionDecs, _ThisExpressionDecs;
+  return class ES6ClassGrammar extends Base {
+    static {
+      [_initProto] = _applyDecs(this, [[Node, 2, "ClassDeclaration"], [_ClassExpressionDecs, 2, "ClassExpression"], [Node, 2, "ClassBody"], [_ClassMethodDecs, 2, "ClassMethod"], [_SuperExpressionDecs, 2, "SuperExpression"], [_ThisExpressionDecs, 2, "ThisExpression"]], [], 0, void 0, Base).e;
+    }
+    constructor(...args) {
+      super(...args);
+      _initProto(this);
+    }
+    *[(_ClassExpressionDecs = [CoveredBy('Expression'), Node], _ClassMethodDecs = [CoveredBy('ClassMember'), Node], _SuperExpressionDecs = [CoveredBy('Expression'), Node], _ThisExpressionDecs = [CoveredBy('Expression'), Node], "ClassDeclaration")]() {
+      yield eat(m`sigilToken: <*Keyword 'class' />`);
+      yield eat(m`name$: <Identifier />`);
+      if (yield eatMatch(m`extendsToken: <*Keyword 'extends' />`, o({}), o({
+        bind: true
+      }))) {
+        yield eat(m`superClass$: <__Expression>`);
+      } else {
+        yield eat(m`superClass$: null`);
+      }
+      yield eat(m`body: <ClassBody />`);
+    }
+    *ClassExpression() {
+      yield eat(m`sigilToken: <*Keyword 'class' />`);
+      yield eatMatch(m`name$: <Identifier />`);
+      if (yield eatMatch(m`extendsToken: <*Keyword 'extends' />`)) {
+        yield eat(m`superClass$: <__Expression>`);
+      } else {
+        yield eat(m`superClass$: null`);
+      }
+      yield eat(m`body: <ClassBody />`);
+    }
+    *ClassBody() {
+      yield eat(m`openToken: <*Punctuator '{' { balanced: '}' } />`);
+      while (yield eatMatch(m`members[]: <__ClassMember />`)) {}
+      yield eat(m`closeToken: <*Punctuator '}' { balancer: true } />`);
+    }
+    *ClassMember() {
+      yield eat(m`<ClassMethod />`);
+    }
+    *ClassMethod() {
+      yield eatMatch(m`staticToken: <*Keyword 'static' />`);
+      let acc, a, gen;
+      acc = yield eatMatch(m`kindToken: <*Keyword /get|set/ />`);
+      if (!acc) {
+        a = yield eatMatch(m`asyncToken: <*Keyword 'async' />`);
+        gen = yield eatMatch(m`starToken: <*Punctuator '*' />`);
+      } else {
+        yield eatMatch(m`asyncToken: null`);
+        yield eatMatch(m`starToken: null`);
+      }
+      if (a && gen) yield fail();
+      yield eatMatch(m`id: <Identifier />`, o({}), o({
+        bind: true
+      }));
+      yield eat(m`openParamsToken: <*Punctuator '(' { balanced: ')' } />`);
+      yield eat(m`params[]: <_List />`, o({
+        element: m`<Identifier />`,
+        allowTrailingSeparator: false,
+        separator: m`separatorTokens[]: <*Punctuator ',' />`
+      }));
+      yield eat(m`closeParamsToken: <*Punctuator ')' { balancer: true } />`);
+      yield eat(m`body: <BlockStatement />`);
+    }
+    *SuperExpression() {
+      yield eat(m`sigilToken: <*Keyword 'super' />`);
+    }
+    *ThisExpression() {
+      yield eat(m`sigilToken: <*Keyword 'this' />`);
+    }
+  };
+};

package/lib/mixins/class.macro.js

@@ -0,0 +1,92 @@
+import { spam as m } from '@bablr/boot';
+import { CoveredBy, Node } from '@bablr/helpers/decorators';
+import { o, eat, eatMatch, fail } from '@bablr/helpers/grammar';
+
+export const mixin = (Base) =>
+  class ES6ClassGrammar extends Base {
+    @Node
+    *ClassDeclaration() {
+      yield eat(m`sigilToken: <*Keyword 'class' />`);
+
+      yield eat(m`name$: <Identifier />`);
+
+      if (yield eatMatch(m`extendsToken: <*Keyword 'extends' />`, o({}), o({ bind: true }))) {
+        yield eat(m`superClass$: <__Expression>`);
+      } else {
+        yield eat(m`superClass$: null`);
+      }
+
+      yield eat(m`body: <ClassBody />`);
+    }
+
+    @CoveredBy('Expression')
+    @Node
+    *ClassExpression() {
+      yield eat(m`sigilToken: <*Keyword 'class' />`);
+
+      yield eatMatch(m`name$: <Identifier />`);
+
+      if (yield eatMatch(m`extendsToken: <*Keyword 'extends' />`)) {
+        yield eat(m`superClass$: <__Expression>`);
+      } else {
+        yield eat(m`superClass$: null`);
+      }
+
+      yield eat(m`body: <ClassBody />`);
+    }
+
+    @Node
+    *ClassBody() {
+      yield eat(m`openToken: <*Punctuator '{' { balanced: '}' } />`);
+      while (yield eatMatch(m`members[]: <__ClassMember />`)) {}
+      yield eat(m`closeToken: <*Punctuator '}' { balancer: true } />`);
+    }
+
+    *ClassMember() {
+      yield eat(m`<ClassMethod />`);
+    }
+
+    @CoveredBy('ClassMember')
+    @Node
+    *ClassMethod() {
+      yield eatMatch(m`staticToken: <*Keyword 'static' />`);
+      let acc, a, gen;
+      acc = yield eatMatch(m`kindToken: <*Keyword /get|set/ />`);
+
+      if (!acc) {
+        a = yield eatMatch(m`asyncToken: <*Keyword 'async' />`);
+        gen = yield eatMatch(m`starToken: <*Punctuator '*' />`);
+      } else {
+        yield eatMatch(m`asyncToken: null`);
+        yield eatMatch(m`starToken: null`);
+      }
+
+      if (a && gen) yield fail();
+
+      yield eatMatch(m`id: <Identifier />`, o({}), o({ bind: true }));
+
+      yield eat(m`openParamsToken: <*Punctuator '(' { balanced: ')' } />`);
+      yield eat(
+        m`params[]: <_List />`,
+        o({
+          element: m`<Identifier />`,
+          allowTrailingSeparator: false,
+          separator: m`separatorTokens[]: <*Punctuator ',' />`,
+        }),
+      );
+      yield eat(m`closeParamsToken: <*Punctuator ')' { balancer: true } />`);
+      yield eat(m`body: <BlockStatement />`);
+    }
+
+    @CoveredBy('Expression')
+    @Node
+    *SuperExpression() {
+      yield eat(m`sigilToken: <*Keyword 'super' />`);
+    }
+
+    @CoveredBy('Expression')
+    @Node
+    *ThisExpression() {
+      yield eat(m`sigilToken: <*Keyword 'this' />`);
+    }
+  };

package/lib/mixins/function.js

@@ -0,0 +1,142 @@
+/* @macrome
+ * @generatedby @bablr/macrome-generator-bablr
+ * @generatedfrom ./function.macro.js#831c60a39d2152781cdb56f58146f685d97b53d3
+ * This file is autogenerated. Please do not edit it directly.
+ * When editing run `npx macrome watch` then change the file this is generated from.
+ */
+import _applyDecs from "@babel/runtime/helpers/applyDecs2305";
+import { spam as m, re } from '@bablr/boot';
+import { CoveredBy, Node } from '@bablr/helpers/decorators';
+import { o, eat, eatMatch, fail, match, shiftMatch } from '@bablr/helpers/grammar';
+export const mixin = Base => {
+  let _initProto, _FunctionExpressionDecs;
+  return class es6FunctionGrammar extends Base {
+    static {
+      [_initProto] = _applyDecs(this, [[_FunctionExpressionDecs, 2, "FunctionExpression"], [Node, 2, "YieldStatement"], [Node, 2, "ObjectPattern"], [Node, 2, "PropertyPattern"], [Node, 2, "AssignmentPattern"], [Node, 2, "ArrayPattern"], [Node, 2, "ArrowFunctionExpression"]], [], 0, void 0, Base).e;
+    }
+    constructor(...args) {
+      super(...args);
+      _initProto(this);
+    }
+    *[(_FunctionExpressionDecs = [CoveredBy('Expression'), Node], "FunctionExpression")]({
+      props: {
+        shorthand
+      }
+    }) {
+      if (!shorthand) {
+        yield eat(m`sigilToken: <*Keyword 'function' />`);
+      } else {
+        yield eat(m`sigilToken: null`);
+      }
+      let a = yield eatMatch(m`asyncToken: <*Keyword 'async' />`);
+      let gen = yield eatMatch(m`starToken: <*Punctuator '*' />`);
+      if (a && gen) yield fail();
+      if (!shorthand) {
+        yield eatMatch(m`id: <Identifier />`, o({}), o({
+          bind: true
+        }));
+      } else {
+        yield eat(m`id: null`);
+      }
+      yield eat(m`openParamsToken: <*Punctuator '(' { balanced: ')' } />`);
+      yield eat(m`params[]+: <_List />`, o({
+        element: m`<__CapturePattern />`,
+        allowTrailingSeparator: false,
+        separator: m`separatorTokens[]: <*Punctuator ',' />`
+      }));
+      yield eat(m`closeParamsToken: <*Punctuator ')' { balancer: true } />`);
+      yield eat(m`body: <BlockStatement />`);
+    }
+    *YieldStatement() {
+      yield eat(m`sigilToken: <*Keyword 'yield' />`);
+      yield eat(m`expression+$: <__Expression />`);
+      yield eatMatch(m`endToken: <*Punctuator ';' />`, null, o({
+        bind: true
+      }));
+    }
+
+    // (type = null, { prop, value: name = {} }) => {};
+
+    *CapturePattern({
+      ctx
+    }) {
+      let pn;
+      if (pn = yield match(re`/[[{]/`)) {
+        switch (ctx.sourceTextFor(pn).trim()) {
+          case '{':
+            yield eat(m`<ObjectPattern />`);
+            break;
+          case '[':
+            yield eat(m`<ArrayPattern />`);
+            break;
+        }
+      } else {
+        yield eat(m`<Identifier />`);
+        return shiftMatch(m`<AssignmentPattern '=' />`);
+      }
+    }
+    *ObjectPattern() {
+      yield eat(m`openToken: <*Punctuator '{' { balanced: '}' } />`);
+      yield eat(m`params[]+$: <_List />`, o({
+        element: m`<PropertyPattern />`,
+        allowTrailingSeparator: true,
+        separator: m`separatorTokens[]: <*Punctuator ',' />`
+      }));
+      yield eat(m`closeToken: <*Punctuator '}' { balancer: true } />`);
+    }
+    *PropertyPattern() {
+      if (yield eatMatch(m`key$: <Identifier />`)) {
+        let cn = yield eatMatch(m`mapOperator: <*Punctuator ':' />`, null, o({
+          bind: true
+        }));
+        if (cn) {
+          yield eat(m`value+$: <__CapturePattern />`);
+        }
+      } else {
+        yield eat(m`key$: <Identifier />`, o({
+          scoped: false
+        }));
+        yield eat(m`mapOperator: <*Punctuator ':' />`);
+        yield eat(m`value+$: <__CapturePattern />`);
+      }
+    }
+    *AssignmentPattern() {
+      yield eat(m`source+$: <Identifier />`);
+      yield eat(m`assignmentOperator: <*Punctuator '=' />`);
+      yield eat(m`defaultValue+$: <__Expression />`, o({
+        power: 32
+      }));
+    }
+    *ArrayPattern() {
+      yield eat(m`openToken: <*Punctuator '[' { balanced: ']' } />`);
+      yield eat(m`params[]+$: <_List />`, o({
+        element: m`<__CapturePattern />`,
+        allowTrailingSeparator: true,
+        separator: m`separatorTokens[]: <*Punctuator ',' />`
+      }));
+      yield eat(m`closeToken: <*Punctuator ']' { balancer: true } />`);
+    }
+    *ArrowFunctionExpression() {
+      // yield eat(m`params[]+: []`);
+      if (yield match('(')) {
+        yield eat(m`openParamsToken: <*Punctuator '(' { balanced: ')' } />`);
+        yield eat(m`params[]+$: <_List />`, o({
+          element: m`<__CapturePattern />`,
+          allowTrailingSeparator: false,
+          separator: m`separatorTokens[]: <*Punctuator ',' />`
+        }));
+        yield eat(m`closeParamsToken: <*Punctuator ')' { balancer: true } />`);
+      } else {
+        yield eat(m`params[]+$: <Identifier />`);
+        yield eat(m`openParamsToken: null`);
+        yield eat(m`closeParamsToken: null`);
+      }
+      yield eat(m`sigilToken: <*Keyword '=>' />`);
+      if (yield match('{')) {
+        yield eat(m`body+: <BlockStatement />`);
+      } else {
+        yield eat(m`body+: <__Expression />`);
+      }
+    }
+  };
+};

package/lib/mixins/function.macro.js

@@ -0,0 +1,144 @@
+import { spam as m, re } from '@bablr/boot';
+import { CoveredBy, Node } from '@bablr/helpers/decorators';
+import { o, eat, eatMatch, fail, match, shiftMatch } from '@bablr/helpers/grammar';
+
+export const mixin = (Base) =>
+  class es6FunctionGrammar extends Base {
+    @CoveredBy('Expression')
+    @Node
+    *FunctionExpression({ props: { shorthand } }) {
+      if (!shorthand) {
+        yield eat(m`sigilToken: <*Keyword 'function' />`);
+      } else {
+        yield eat(m`sigilToken: null`);
+      }
+
+      let a = yield eatMatch(m`asyncToken: <*Keyword 'async' />`);
+      let gen = yield eatMatch(m`starToken: <*Punctuator '*' />`);
+
+      if (a && gen) yield fail();
+
+      if (!shorthand) {
+        yield eatMatch(m`id: <Identifier />`, o({}), o({ bind: true }));
+      } else {
+        yield eat(m`id: null`);
+      }
+
+      yield eat(m`openParamsToken: <*Punctuator '(' { balanced: ')' } />`);
+      yield eat(
+        m`params[]+: <_List />`,
+        o({
+          element: m`<__CapturePattern />`,
+          allowTrailingSeparator: false,
+          separator: m`separatorTokens[]: <*Punctuator ',' />`,
+        }),
+      );
+      yield eat(m`closeParamsToken: <*Punctuator ')' { balancer: true } />`);
+      yield eat(m`body: <BlockStatement />`);
+    }
+
+    @Node
+    *YieldStatement() {
+      yield eat(m`sigilToken: <*Keyword 'yield' />`);
+      yield eat(m`expression+$: <__Expression />`);
+      yield eatMatch(m`endToken: <*Punctuator ';' />`, null, o({ bind: true }));
+    }
+
+    // (type = null, { prop, value: name = {} }) => {};
+
+    *CapturePattern({ ctx }) {
+      let pn;
+      if ((pn = yield match(re`/[[{]/`))) {
+        switch (ctx.sourceTextFor(pn).trim()) {
+          case '{':
+            yield eat(m`<ObjectPattern />`);
+            break;
+          case '[':
+            yield eat(m`<ArrayPattern />`);
+            break;
+        }
+      } else {
+        yield eat(m`<Identifier />`);
+
+        return shiftMatch(m`<AssignmentPattern '=' />`);
+      }
+    }
+
+    @Node
+    *ObjectPattern() {
+      yield eat(m`openToken: <*Punctuator '{' { balanced: '}' } />`);
+      yield eat(
+        m`params[]+$: <_List />`,
+        o({
+          element: m`<PropertyPattern />`,
+          allowTrailingSeparator: true,
+          separator: m`separatorTokens[]: <*Punctuator ',' />`,
+        }),
+      );
+      yield eat(m`closeToken: <*Punctuator '}' { balancer: true } />`);
+    }
+
+    @Node
+    *PropertyPattern() {
+      if (yield eatMatch(m`key$: <Identifier />`)) {
+        let cn = yield eatMatch(m`mapOperator: <*Punctuator ':' />`, null, o({ bind: true }));
+        if (cn) {
+          yield eat(m`value+$: <__CapturePattern />`);
+        }
+      } else {
+        yield eat(m`key$: <Identifier />`, o({ scoped: false }));
+        yield eat(m`mapOperator: <*Punctuator ':' />`);
+        yield eat(m`value+$: <__CapturePattern />`);
+      }
+    }
+
+    @Node
+    *AssignmentPattern() {
+      yield eat(m`source+$: <Identifier />`);
+      yield eat(m`assignmentOperator: <*Punctuator '=' />`);
+      yield eat(m`defaultValue+$: <__Expression />`, o({ power: 32 }));
+    }
+
+    @Node
+    *ArrayPattern() {
+      yield eat(m`openToken: <*Punctuator '[' { balanced: ']' } />`);
+      yield eat(
+        m`params[]+$: <_List />`,
+        o({
+          element: m`<__CapturePattern />`,
+          allowTrailingSeparator: true,
+          separator: m`separatorTokens[]: <*Punctuator ',' />`,
+        }),
+      );
+      yield eat(m`closeToken: <*Punctuator ']' { balancer: true } />`);
+    }
+
+    @Node
+    *ArrowFunctionExpression() {
+      // yield eat(m`params[]+: []`);
+      if (yield match('(')) {
+        yield eat(m`openParamsToken: <*Punctuator '(' { balanced: ')' } />`);
+        yield eat(
+          m`params[]+$: <_List />`,
+          o({
+            element: m`<__CapturePattern />`,
+            allowTrailingSeparator: false,
+            separator: m`separatorTokens[]: <*Punctuator ',' />`,
+          }),
+        );
+        yield eat(m`closeParamsToken: <*Punctuator ')' { balancer: true } />`);
+      } else {
+        yield eat(m`params[]+$: <Identifier />`);
+        yield eat(m`openParamsToken: null`);
+        yield eat(m`closeParamsToken: null`);
+      }
+
+      yield eat(m`sigilToken: <*Keyword '=>' />`);
+
+      if (yield match('{')) {
+        yield eat(m`body+: <BlockStatement />`);
+      } else {
+        yield eat(m`body+: <__Expression />`);
+      }
+    }
+  };

package/lib/mixins/import.js

@@ -0,0 +1,138 @@
+/* @macrome
+ * @generatedby @bablr/macrome-generator-bablr
+ * @generatedfrom ./import.macro.js#21371d90722f9817f110bb3037864d40e321d2bf
+ * This file is autogenerated. Please do not edit it directly.
+ * When editing run `npx macrome watch` then change the file this is generated from.
+ */
+import _applyDecs from "@babel/runtime/helpers/applyDecs2305";
+import { spam as m } from '@bablr/boot';
+import { Node } from '@bablr/helpers/decorators';
+import { o, eat, eatMatch, match, fail } from '@bablr/helpers/grammar';
+export const mixin = Base => {
+  let _initProto;
+  return class ES6ImportGrammar extends Base {
+    static {
+      [_initProto] = _applyDecs(this, [[Node, 2, "ImportDeclaration"], [Node, 2, "ImportSpecifier"], [Node, 2, "ImportDefaultSpecifier"], [Node, 2, "ImportNamespaceSpecifier"], [Node, 2, "ExportDeclaration"], [Node, 2, "ExportDefaultSpecifier"], [Node, 2, "ExportAllSpecifier"], [Node, 2, "ExportSpecifier"]], [], 0, void 0, Base).e;
+    }
+    constructor(...args) {
+      super(...args);
+      _initProto(this);
+    }
+    *ImportDeclaration() {
+      yield eat(m`sigilToken: <*Keyword 'import' />`);
+      if (yield eatMatch(m`specifiers[]$: <ImportNamespaceSpecifier '*' />`)) {
+        yield eat(m`fromToken: <*Keyword 'from' />`);
+      } else {
+        let spec = yield eatMatch(m`specifiers[]$: <ImportDefaultSpecifier />`);
+        let sep = spec ? null : yield eatMatch(m`separators[]: <*Punctuator ',' />`);
+        let open = yield eatMatch(m`openSpecifiersToken: <*Punctuator '{' { balanced: '}' } />`, o({}), o({
+          bind: true
+        }));
+        if (open) {
+          let first = true;
+          while (first || sep) {
+            spec = yield eatMatch(m`specifiers[]$: <ImportSpecifier />`);
+            sep = yield eatMatch(m`separators[]: <*Punctuator ',' />`);
+            first = false;
+          }
+          yield eat(m`closeSpecifiersToken: <*Punctuator '}' { balancer: true } />`);
+        } else {
+          yield eat(m`closeSpecifiersToken: null`);
+        }
+        yield eat(m`fromToken: <*Keyword 'from' />`);
+      }
+      yield eat(m`source$: <String />`);
+      yield eatMatch(m`endToken: <*Punctuator ';' />`, o({}), o({
+        bind: true
+      }));
+    }
+    *ImportSpecifier() {
+      let str;
+      if (str = yield eatMatch(m`imported$: <String /['"]/ />`)) {} else {
+        yield eat(m`imported$: <Identifier />`);
+      }
+      if (str || (yield match('as'))) {
+        yield eat(m`mapOperator: <*Keyword 'as' />`);
+        yield eat(m`local$: <Identifier />`);
+      } else {
+        yield eat(m`mapOperator: null`);
+        yield eat(m`local$: null`);
+      }
+    }
+    *ImportDefaultSpecifier() {
+      yield eat(m`local: <Identifier />`);
+    }
+    *ImportNamespaceSpecifier() {
+      yield eat(m`sigilToken: <*Punctuator '*' />`);
+      yield eat(m`mapOperator: <*Keyword 'as' />`);
+      yield eat(m`local$: <Identifier />`);
+    }
+    *ExportDeclaration() {
+      yield eat(m`sigilToken: <*Keyword 'export' />`);
+      let curly, defSpec, spec, def, from, sep;
+      yield eatMatch(m`declaration$: null`);
+      if (def = yield match('default')) {
+        yield eatMatch(m`defaultToken: <*Keyword 'default' />`);
+        if (yield eatMatch(m`declaration$: <ClassDeclaration 'class' />`)) {} else if (yield eatMatch(m`declaration: <FunctionStatement /function|async/ />`)) {} else {
+          yield eat(m`declaration$: <__Expression />`);
+        }
+      } else {
+        yield eat(m`defaultToken: null`);
+      }
+      defSpec = spec = yield eatMatch(m`specifiers[]$: <ExportDefaultSpecifier />`);
+      defSpec = defSpec || (yield eatMatch(m`specifiers[]$: <ExportAllSpecifier '*' />`));
+      if (spec) {
+        sep = yield eatMatch(m`specifierSeparatorTokens[]: <*Punctuator ',' />`);
+      }
+      if ((!defSpec || sep) && (curly = yield match('{'))) {
+        yield eat(m`openSpecifiersToken: <*Punctuator '{' { balanced: '}' } />`);
+        let first = true;
+        while (first || spec && sep) {
+          spec = yield eat(m`specifiers[]$: <ExportSpecifier />`);
+          sep = yield eatMatch(m`specifierSeparatorTokens[]: <*Punctuator ',' />`);
+          first = false;
+        }
+        yield eat(m`closeSpecifiersToken: <*Punctuator '}' { balancer: true } />`);
+      } else {
+        yield eat(m`openSpecifiersToken: null />`);
+        yield eat(m`specifiers[]$: []`);
+        yield eat(m`specifierSeparatorTokens[]: []`);
+        yield eat(m`closeSpecifiersToken: null />`);
+      }
+      if ((defSpec || curly) && (from = yield match('from'))) {
+        yield eatMatch(m`fromToken: <*Keyword 'from' />`);
+        yield eat(m`source$: <String />`);
+      } else {
+        yield eatMatch(m`fromToken: null`);
+        yield eat(m`source$: null`);
+      }
+      if (!def && !defSpec && !curly && !from) {
+        if (yield eatMatch(m`declaration: <VariableDeclarationStatement /var|const|let/ />`)) {} else if (yield eatMatch(m`declaration: <ClassDeclaration 'class' />`)) {} else if (yield eatMatch(m`declaration: <FunctionStatement />`)) {} else {
+          yield fail();
+        }
+      }
+      yield eatMatch(m`endToken: <*Punctuator ';' />`, o({}), o({
+        bind: true
+      }));
+    }
+    *ExportDefaultSpecifier() {
+      yield eat(m`local$: <Identifier />`);
+    }
+    *ExportAllSpecifier() {
+      yield eat(m`sigilToken: <*Keyword '*' />`);
+    }
+    *ExportSpecifier() {
+      yield eat(m`local$: <Identifier />`);
+      let as_ = yield eatMatch(m`mapOperator: <*Keyword 'as' />`, o({}), o({
+        bind: true
+      }));
+      if (as_) {
+        if (yield eatMatch(m`imported$: <String /['"]/ />`)) {} else {
+          yield eat(m`imported$: <Identifier />`);
+        }
+      } else {
+        yield eat(m`imported$: null`);
+      }
+    }
+  };
+};

package/lib/mixins/import.macro.js

@@ -0,0 +1,160 @@
+import { spam as m } from '@bablr/boot';
+import { Node } from '@bablr/helpers/decorators';
+import { o, eat, eatMatch, match, fail } from '@bablr/helpers/grammar';
+
+export const mixin = (Base) =>
+  class ES6ImportGrammar extends Base {
+    @Node
+    *ImportDeclaration() {
+      yield eat(m`sigilToken: <*Keyword 'import' />`);
+
+      if (yield eatMatch(m`specifiers[]$: <ImportNamespaceSpecifier '*' />`)) {
+        yield eat(m`fromToken: <*Keyword 'from' />`);
+      } else {
+        let spec = yield eatMatch(m`specifiers[]$: <ImportDefaultSpecifier />`);
+        let sep = spec ? null : yield eatMatch(m`separators[]: <*Punctuator ',' />`);
+
+        let open = yield eatMatch(
+          m`openSpecifiersToken: <*Punctuator '{' { balanced: '}' } />`,
+          o({}),
+          o({ bind: true }),
+        );
+
+        if (open) {
+          let first = true;
+          while (first || sep) {
+            spec = yield eatMatch(m`specifiers[]$: <ImportSpecifier />`);
+            sep = yield eatMatch(m`separators[]: <*Punctuator ',' />`);
+            first = false;
+          }
+
+          yield eat(m`closeSpecifiersToken: <*Punctuator '}' { balancer: true } />`);
+        } else {
+          yield eat(m`closeSpecifiersToken: null`);
+        }
+
+        yield eat(m`fromToken: <*Keyword 'from' />`);
+      }
+      yield eat(m`source$: <String />`);
+      yield eatMatch(m`endToken: <*Punctuator ';' />`, o({}), o({ bind: true }));
+    }
+
+    @Node
+    *ImportSpecifier() {
+      let str;
+
+      if ((str = yield eatMatch(m`imported$: <String /['"]/ />`))) {
+      } else {
+        yield eat(m`imported$: <Identifier />`);
+      }
+
+      if (str || (yield match('as'))) {
+        yield eat(m`mapOperator: <*Keyword 'as' />`);
+        yield eat(m`local$: <Identifier />`);
+      } else {
+        yield eat(m`mapOperator: null`);
+        yield eat(m`local$: null`);
+      }
+    }
+
+    @Node
+    *ImportDefaultSpecifier() {
+      yield eat(m`local: <Identifier />`);
+    }
+
+    @Node
+    *ImportNamespaceSpecifier() {
+      yield eat(m`sigilToken: <*Punctuator '*' />`);
+      yield eat(m`mapOperator: <*Keyword 'as' />`);
+      yield eat(m`local$: <Identifier />`);
+    }
+
+    @Node
+    *ExportDeclaration() {
+      yield eat(m`sigilToken: <*Keyword 'export' />`);
+
+      let curly, defSpec, spec, def, from, sep;
+
+      yield eatMatch(m`declaration$: null`);
+
+      if ((def = yield match('default'))) {
+        yield eatMatch(m`defaultToken: <*Keyword 'default' />`);
+
+        if (yield eatMatch(m`declaration$: <ClassDeclaration 'class' />`)) {
+        } else if (yield eatMatch(m`declaration: <FunctionStatement /function|async/ />`)) {
+        } else {
+          yield eat(m`declaration$: <__Expression />`);
+        }
+      } else {
+        yield eat(m`defaultToken: null`);
+      }
+
+      defSpec = spec = yield eatMatch(m`specifiers[]$: <ExportDefaultSpecifier />`);
+      defSpec = defSpec || (yield eatMatch(m`specifiers[]$: <ExportAllSpecifier '*' />`));
+
+      if (spec) {
+        sep = yield eatMatch(m`specifierSeparatorTokens[]: <*Punctuator ',' />`);
+      }
+
+      if ((!defSpec || sep) && (curly = yield match('{'))) {
+        yield eat(m`openSpecifiersToken: <*Punctuator '{' { balanced: '}' } />`);
+
+        let first = true;
+        while (first || (spec && sep)) {
+          spec = yield eat(m`specifiers[]$: <ExportSpecifier />`);
+          sep = yield eatMatch(m`specifierSeparatorTokens[]: <*Punctuator ',' />`);
+          first = false;
+        }
+        yield eat(m`closeSpecifiersToken: <*Punctuator '}' { balancer: true } />`);
+      } else {
+        yield eat(m`openSpecifiersToken: null />`);
+        yield eat(m`specifiers[]$: []`);
+        yield eat(m`specifierSeparatorTokens[]: []`);
+        yield eat(m`closeSpecifiersToken: null />`);
+      }
+
+      if ((defSpec || curly) && (from = yield match('from'))) {
+        yield eatMatch(m`fromToken: <*Keyword 'from' />`);
+        yield eat(m`source$: <String />`);
+      } else {
+        yield eatMatch(m`fromToken: null`);
+        yield eat(m`source$: null`);
+      }
+
+      if (!def && !defSpec && !curly && !from) {
+        if (yield eatMatch(m`declaration: <VariableDeclarationStatement /var|const|let/ />`)) {
+        } else if (yield eatMatch(m`declaration: <ClassDeclaration 'class' />`)) {
+        } else if (yield eatMatch(m`declaration: <FunctionStatement />`)) {
+        } else {
+          yield fail();
+        }
+      }
+      yield eatMatch(m`endToken: <*Punctuator ';' />`, o({}), o({ bind: true }));
+    }
+
+    @Node
+    *ExportDefaultSpecifier() {
+      yield eat(m`local$: <Identifier />`);
+    }
+
+    @Node
+    *ExportAllSpecifier() {
+      yield eat(m`sigilToken: <*Keyword '*' />`);
+    }
+
+    @Node
+    *ExportSpecifier() {
+      yield eat(m`local$: <Identifier />`);
+
+      let as_ = yield eatMatch(m`mapOperator: <*Keyword 'as' />`, o({}), o({ bind: true }));
+
+      if (as_) {
+        if (yield eatMatch(m`imported$: <String /['"]/ />`)) {
+        } else {
+          yield eat(m`imported$: <Identifier />`);
+        }
+      } else {
+        yield eat(m`imported$: null`);
+      }
+    }
+  };

package/lib/regex.js

@@ -0,0 +1 @@
+export * from '@bablr/language-en-es5/regex';

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@bablr/language-en-es6",
+  "version": "0.1.0",
+  "description": "A BABLR language for ES6 (JavaScript)",
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "type": "module",
+  "exports": {
+    ".": "./lib/grammar.js",
+    "./regex": "./lib/regex.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/**/*.js"
+  ],
+  "scripts": {
+    "build": "macrome build",
+    "watch": "macrome watch",
+    "clean": "macrome clean",
+    "test": "mocha test/*.test.js"
+  },
+  "sideEffects": false,
+  "dependencies": {
+    "@babel/runtime": "7.24.6",
+    "@bablr/agast-vm-helpers": "0.8.0",
+    "@bablr/boot": "0.9.0",
+    "@bablr/helpers": "0.23.0",
+    "@bablr/language-en-c-comments": "0.8.0",
+    "@bablr/language-en-es5": "0.1.0"
+  },
+  "devDependencies": {
+    "@bablr/agast-helpers": "^0.8.0",
+    "@bablr/eslint-config-base": "github:bablr-lang/eslint-config-base#49f5952efed27f94ee9b94340eb1563c440bf64e",
+    "@bablr/macrome": "0.1.3",
+    "@bablr/macrome-generator-bablr": "0.3.2",
+    "@qnighy/dedent": "0.1.1",
+    "bablr": "0.9.0",
+    "enhanced-resolve": "^5.12.0",
+    "eslint": "^7.32.0",
+    "eslint-import-resolver-enhanced-resolve": "^1.0.5",
+    "eslint-plugin-import": "^2.27.5",
+    "expect": "29.7.0",
+    "iter-tools-es": "^7.5.3",
+    "mocha": "10.4.0",
+    "prettier": "^2.0.5"
+  },
+  "keywords": [
+    "bablr-language",
+    "grammar",
+    "english",
+    "es6",
+    "ecmascript"
+  ],
+  "repository": "git@github.com:bablr-lang/language-en-es6.git",
+  "homepage": "https://github.com/bablr-lang/language-en-es6",
+  "author": "Conrad Buck <conartist6@gmail.com>",
+  "license": "MIT"
+}