@bablr/helpers 0.23.0 → 0.24.0

package/lib/builders.js

@@ -1,13 +1,13 @@
-// import { i } from '@bablr/boot/shorthand.macro';
 import { interpolateFragment, buildFilledGapFunction } from '@bablr/agast-helpers/template';
 import {
   buildNullNode,
+  get,
   getRootArray,
   treeFromStreamSync as treeFromStream,
 } from '@bablr/agast-helpers/tree';
 import { buildLiteralTag as agastBuildLiteralTag } from '@bablr/agast-helpers/builders';
 import * as t from '@bablr/agast-helpers/shorthand';
-import * as sumtree from '@bablr/agast-helpers/children';
+import * as Tags from '@bablr/agast-helpers/tags';
 import * as l from '@bablr/agast-vm-helpers/languages';
 import { concat } from '@bablr/agast-vm-helpers/iterable';
 
@@ -103,8 +103,8 @@ export const buildNodeFlags = (flags = t.nodeFlags) => {
       gap(hasGap ? buildToken('Punctuator', '$') : buildNullNode()),
       t.ref`fragmentToken`,
       gap(fragment ? buildToken('Punctuator', '_') : buildNullNode()),
-      t.ref`coverFragmentToken`,
-      gap(cover ? buildToken('Punctuator', '_') : buildNullNode()),
+      t.ref`multiFragmentToken`,
+      gap(!cover ? buildToken('Punctuator', '_') : buildNullNode()),
       t.nodeClose(),
     ],
     { expressions },
@@ -115,12 +115,10 @@ export const buildSpamMatcher = (type = null, value = null, attributes = null) =
   return buildOpenNodeMatcher(buildNodeFlags(t.nodeFlags), null, type, value, attributes);
 };
 
-export const buildOpenNodeMatcher = (flags, type, intrinsicValue, attributes = null) => {
+export const buildOpenNodeMatcher = (flags, type, literalValue, attributes = null) => {
   const expressions = [];
   const gap = buildFilledGapFunction(expressions);
 
-  let language_;
-
   if (!type) throw new Error();
 
   return treeFromStream(
@@ -133,20 +131,20 @@ export const buildOpenNodeMatcher = (flags, type, intrinsicValue, attributes = n
       yield t.ref`type`;
       yield gap(typeof type === 'string' ? buildIdentifier(type) : type);
 
-      yield* when(intrinsicValue, [t.ref`#`, ...buildSpace().children]);
+      yield* when(literalValue, [t.ref`#`, ...buildSpace().tags]);
 
-      yield t.ref`intrinsicValue`;
-      yield gap(intrinsicValue ? buildString(intrinsicValue) : buildNullNode());
+      yield t.ref`literalValue`;
+      yield gap(literalValue ? buildString(literalValue) : buildNullNode());
 
       let rootArr = getRootArray(attributes);
 
       if (rootArr.length) {
         yield t.ref`#`;
-        yield* buildSpace().children;
+        yield* buildSpace().tags;
         yield* interpolateFragment(attributes, t.ref`attributes[]`, expressions);
       }
 
-      yield t.ref`selfClosingTagToken`;
+      yield t.ref`selfClosingToken`;
       yield gap(buildToken('Punctuator', '/'));
       yield t.ref`closeToken`;
       yield gap(buildToken('Punctuator', '>'));
@@ -190,14 +188,14 @@ export const buildReferenceMatcher = (type, name, isArray, flags) => {
       yield t.ref`sigilToken`;
       yield gap(buildToken('Punctuator', ':'));
       yield t.ref`#`;
-      yield* sumtree.traverse(buildSpace().children);
+      yield* Tags.traverse(buildSpace().tags);
       yield t.nodeClose();
     })(),
     { expressions },
   );
 };
 
-export const buildFragmentMatcher = (flags = buildNodeFlags({ fragment: true })) => {
+export const buildFragmentMatcher = (flags = buildNodeFlags({ fragment: true, cover: true })) => {
   const expressions = [];
   const gap = buildFilledGapFunction(expressions);
 
@@ -205,7 +203,7 @@ export const buildFragmentMatcher = (flags = buildNodeFlags({ fragment: true }))
 
   return treeFromStream(
     (function* () {
-      yield t.nodeOpen(t.nodeFlags, 'FragmentMatcher');
+      yield t.nodeOpen(t.fragmentFlags, 'FragmentMatcher');
       yield t.ref`openToken`;
       yield gap(buildToken('Punctuator', '<'));
       yield t.ref`flags`;
@@ -265,7 +263,7 @@ export const buildDoctypeTag = (attributes) => {
       yield gap(buildKeyword('cstml'));
       yield t.nodeClose();
 
-      yield* when(getRootArray(attributes).length, [t.ref`#`, ...buildSpace().children]);
+      yield* when(getRootArray(attributes).length, [t.ref`#`, ...buildSpace().tags]);
       yield* interpolateFragment(attributes, t.ref`attributes[]`, expressions);
 
       yield t.ref`closeToken`;
@@ -340,7 +338,8 @@ export const buildLiteralTag = (value) => {
 };
 
 export const buildTerminalProps = (matcher) => {
-  const { attributes, value } = matcher.properties;
+  const value = get('value', matcher);
+  const attributes = get('attributes', matcher);
 
   return buildObject({ value, attributes });
 };
@@ -350,20 +349,68 @@ export const buildSpace = () => {
 };
 
 export const buildIdentifier = (name) => {
-  if (!/^[a-zA-Z_]+$/.test(name)) throw new Error();
-
+  let unquoted = /^[a-zA-Z\u{80}-\u{10ffff}][a-zA-Z0-9_\u{80}-\u{10ffff}-]*$/uy.test(name);
   const expressions = [];
   const gap = buildFilledGapFunction(expressions);
 
-  return treeFromStream(
-    [
-      t.nodeOpen(t.nodeFlags, 'Identifier'),
-      t.ref`content`,
-      gap(buildIdentifierContent(name)),
-      t.nodeClose(),
-    ],
-    { expressions },
-  );
+  if (unquoted) {
+    return treeFromStream(
+      [
+        t.nodeOpen(t.nodeFlags, 'Identifier'),
+        t.ref`content`,
+        gap(buildIdentifierContent(name)),
+        t.nodeClose(),
+      ],
+      { expressions },
+    );
+  } else {
+    return treeFromStream(
+      (function* () {
+        yield t.nodeOpen(t.nodeFlags, 'Identifier');
+
+        yield t.ref`openToken`;
+        yield gap(buildToken('Punctuator', '`'));
+        yield t.ref`content`;
+        yield t.nodeOpen(t.tokenFlags, 'IdentifierContent');
+
+        let lit = '';
+
+        let pieces = name.split(/[\\`]/g);
+
+        for (const piece of pieces) {
+          if (/[\\`]/y.test(piece)) {
+            let chr = piece;
+            if (lit) {
+              yield agastBuildLiteralTag(lit);
+              lit = '';
+            }
+
+            let value = buildKeyword(chr);
+
+            yield t.ref`@`;
+            yield t.nodeOpen(t.nodeFlags, 'EscapeSequence', { cooked: chr });
+            yield t.ref`escape`;
+            yield gap(buildToken('Punctuator', '\\'));
+            yield t.ref`value`;
+            yield gap(value);
+            yield t.nodeClose();
+          } else {
+            lit += piece;
+          }
+        }
+
+        if (lit) yield agastBuildLiteralTag(lit);
+        lit = '';
+
+        yield t.nodeClose();
+
+        yield t.ref`closeToken`;
+        yield gap(buildToken('Punctuator', '`'));
+        yield t.nodeClose();
+      })(),
+      { expressions },
+    );
+  }
 };
 
 export const buildIdentifierContent = (value) => {
@@ -633,6 +680,21 @@ export const buildNull = () => {
   );
 };
 
+export const buildUndefined = () => {
+  const expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    [
+      t.nodeOpen(t.nodeFlags, 'Undefined'),
+      t.ref`sigilToken`,
+      gap(buildToken('Keyword', 'undefined')),
+      t.nodeClose(),
+    ],
+    { expressions },
+  );
+};
+
 export const buildNullTag = () => {
   const expressions = [];
   const gap = buildFilledGapFunction(expressions);
@@ -672,14 +734,14 @@ export const buildArrayElements = (values) => {
     (function* () {
       yield t.doctype({ bablrLanguage: l.Instruction });
       yield t.nodeOpen(t.nodeFlags);
-      yield* buildSpaceSeparatedList(values, t.ref`.[]`, expressions);
+      yield* buildCommaSeparatedList(values, t.ref`.[]`, expressions);
       yield t.nodeClose();
     })(),
     { expressions },
   );
 };
 
-export function* buildSpaceSeparatedList(values, ref, expressions) {
+export function* buildCommaSeparatedList(values, ref, expressions) {
   const gap = buildFilledGapFunction(expressions);
 
   if (!ref.value.isArray) throw new Error();
@@ -691,7 +753,7 @@ export function* buildSpaceSeparatedList(values, ref, expressions) {
   for (const value of values) {
     if (!first) {
       yield t.buildReferenceTag('#');
-      yield gap(buildSpace());
+      yield gap(buildToken('Punctuator', ','));
     }
     yield freeze({ ...ref });
     yield gap(value || buildNullNode());
@@ -705,7 +767,7 @@ export const buildObjectProperties = (properties) => {
   return treeFromStream(
     concat(
       [t.doctype({ bablrLanguage: l.Instruction }), t.nodeOpen(t.nodeFlags)],
-      buildSpaceSeparatedList(properties, t.ref`properties[]`, expressions),
+      buildCommaSeparatedList(properties, t.ref`properties[]`, expressions),
       [t.nodeClose()],
     ),
     { expressions },
@@ -876,6 +938,50 @@ export const buildElements = (elements) => {
   );
 };
 
+export const buildJSExpressionDeep = (expr) => {
+  if (expr === null) {
+    return buildNull();
+  } else if (expr === undefined) {
+    return buildUndefined();
+  }
+
+  switch (typeof expr) {
+    case 'boolean':
+      return buildBoolean(expr);
+
+    case 'string':
+      return buildString(expr);
+
+    case 'number':
+      return buildInteger(expr);
+
+    case 'object': {
+      switch (Object.getPrototypeOf(expr)) {
+        case Array.prototype:
+          return buildArray(buildArrayElements(expr.map((e) => buildJSExpressionDeep(e))));
+
+        case Object.prototype:
+          return buildObject(
+            buildObjectProperties(
+              Object.entries(expr).map((e) =>
+                buildProperty(
+                  /^[a-zA-Z_]+$/.test(e[0]) ? buildIdentifier(e[0]) : buildString(e[0]),
+                  buildJSExpressionDeep(e[1]),
+                ),
+              ),
+            ),
+          );
+
+        default:
+          throw new Error();
+      }
+    }
+
+    default:
+      throw new Error();
+  }
+};
+
 export const buildTaggedString = (tag, content) => {
   const expressions = [];
   const gap = buildFilledGapFunction(expressions);

package/lib/productions.js

@@ -1,13 +1,13 @@
 /* @macrome
  * @generatedby @bablr/macrome-generator-bablr
- * @generatedfrom ./productions.macro.js#b095c92e30507ebaab43cd0c2b1dcee55853950f
+ * @generatedfrom ./productions.macro.js#a661312b1d84c6cc48eac8794f36c3b607a57892
  * 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 { spam as m } from '@bablr/boot';
-import { getCooked } from '@bablr/agast-helpers/tree';
+import { get, getCooked } from '@bablr/agast-helpers/tree';
 import { eat, eatMatch } from './grammar.js';
-import { EmbeddedMatcher } from './symbols.js';
+import { Matcher } from './symbols.js';
 import { getEmbeddedMatcher } from '@bablr/agast-vm-helpers/deembed';
 import { buildPropertyMatcher } from './builders.js';
 import { buildEmbeddedMatcher } from '@bablr/agast-vm-helpers/builders';
@@ -20,10 +20,10 @@ export function* List({
     allowHoles = false,
     allowTrailingSeparator = true
   } = props;
-  if (!['#', '@'].includes(getCooked(getEmbeddedMatcher(separator).properties.refMatcher?.node.properties.type?.node))) {
-    yield eat(buildEmbeddedMatcher(buildPropertyMatcher(getEmbeddedMatcher(separator).properties.refMatcher?.node, null, m.ArrayNodeMatcher`[]`)));
+  if (getCooked(get(['refMatcher', 'name', 'content'], getEmbeddedMatcher(separator)))) {
+    yield eat(buildEmbeddedMatcher(buildPropertyMatcher(get('refMatcher', getEmbeddedMatcher(separator)), null, m.ArrayNodeMatcher`[]`)));
   }
-  yield eat(buildEmbeddedMatcher(buildPropertyMatcher(getEmbeddedMatcher(Array.isArray(element) ? element[0] : element).properties.refMatcher?.node, null, m.ArrayNodeMatcher`[]`)));
+  yield eat(buildEmbeddedMatcher(buildPropertyMatcher(get('refMatcher', getEmbeddedMatcher(Array.isArray(element) ? element[0] : element)), null, m.ArrayNodeMatcher`[]`)));
   let sep,
     it,
     anySep = false;
@@ -46,7 +46,7 @@ export function* Any({
   for (const alternative of alternatives) {
     if (Array.isArray(alternative)) {
       if (yield eatMatch(...alternative)) break;
-    } else if (alternative.type === EmbeddedMatcher) {
+    } else if (alternative.type === Matcher) {
       if (yield eatMatch(alternative)) break;
     } else {
       throw new Error();
@@ -75,10 +75,10 @@ export function* Optional({
 }
 export function* Literal({
   ctx,
-  intrinsicValue
+  literalValue
 }) {
-  if (!intrinsicValue) throw new Error('Intrinsic productions must have value');
-  yield eat(ctx.sourceTextFor(intrinsicValue.value));
+  if (!literalValue) throw new Error('Intrinsic productions must have value');
+  yield eat(ctx.sourceTextFor(literalValue.value));
 }
 export const Keyword = Literal;
 export const Punctuator = Literal;

package/lib/productions.macro.js

@@ -1,7 +1,7 @@
 import { spam as m } from '@bablr/boot';
-import { getCooked } from '@bablr/agast-helpers/tree';
+import { get, getCooked } from '@bablr/agast-helpers/tree';
 import { eat, eatMatch } from './grammar.js';
-import { EmbeddedMatcher } from './symbols.js';
+import { Matcher } from './symbols.js';
 import { getEmbeddedMatcher } from '@bablr/agast-vm-helpers/deembed';
 import { buildPropertyMatcher } from './builders.js';
 import { buildEmbeddedMatcher } from '@bablr/agast-vm-helpers/builders';
@@ -9,15 +9,11 @@ import { buildEmbeddedMatcher } from '@bablr/agast-vm-helpers/builders';
 export function* List({ props }) {
   const { element, separator, allowHoles = false, allowTrailingSeparator = true } = props;
 
-  if (
-    !['#', '@'].includes(
-      getCooked(getEmbeddedMatcher(separator).properties.refMatcher?.node.properties.type?.node),
-    )
-  ) {
+  if (getCooked(get(['refMatcher', 'name', 'content'], getEmbeddedMatcher(separator)))) {
     yield eat(
       buildEmbeddedMatcher(
         buildPropertyMatcher(
-          getEmbeddedMatcher(separator).properties.refMatcher?.node,
+          get('refMatcher', getEmbeddedMatcher(separator)),
           null,
           m.ArrayNodeMatcher`[]`,
         ),
@@ -28,8 +24,7 @@ export function* List({ props }) {
   yield eat(
     buildEmbeddedMatcher(
       buildPropertyMatcher(
-        getEmbeddedMatcher(Array.isArray(element) ? element[0] : element).properties.refMatcher
-          ?.node,
+        get('refMatcher', getEmbeddedMatcher(Array.isArray(element) ? element[0] : element)),
         null,
         m.ArrayNodeMatcher`[]`,
       ),
@@ -55,7 +50,7 @@ export function* Any({ props: { value: alternatives } }) {
   for (const alternative of alternatives) {
     if (Array.isArray(alternative)) {
       if (yield eatMatch(...alternative)) break;
-    } else if (alternative.type === EmbeddedMatcher) {
+    } else if (alternative.type === Matcher) {
       if (yield eatMatch(alternative)) break;
     } else {
       throw new Error();
@@ -77,10 +72,10 @@ export function* Optional({ props: { value: matcher } }) {
   yield eatMatch(matcher);
 }
 
-export function* Literal({ ctx, intrinsicValue }) {
-  if (!intrinsicValue) throw new Error('Intrinsic productions must have value');
+export function* Literal({ ctx, literalValue }) {
+  if (!literalValue) throw new Error('Intrinsic productions must have value');
 
-  yield eat(ctx.sourceTextFor(intrinsicValue.value));
+  yield eat(ctx.sourceTextFor(literalValue.value));
 }
 export const Keyword = Literal;
 

package/lib/trivia.js

@@ -3,9 +3,9 @@ import { spam as m } from '@bablr/boot';
 import { Coroutine } from '@bablr/coroutine';
 import { eat, eatMatch, mapOwnProductions, mapProductions, o } from './grammar.js';
 import {
-  EmbeddedMatcher,
-  EmbeddedRegex,
-  EmbeddedNode,
+  Matcher,
+  Regex,
+  Node,
   OpenNodeTag,
   CloseNodeTag,
   ReferenceTag,
@@ -15,7 +15,7 @@ import { buildIdentifier, buildString } from './builders.js';
 import { buildCall, buildEmbeddedInstruction } from '@bablr/agast-vm-helpers/builders';
 import { getEmbeddedInstruction } from '@bablr/agast-vm-helpers/deembed';
 import { reifyExpression } from '@bablr/agast-vm-helpers';
-import { getCooked } from '@bablr/agast-helpers/tree';
+import { get, getCooked } from '@bablr/agast-helpers/tree';
 import { buildPathSegment } from '@bablr/agast-helpers/path';
 
 const lookbehind = (context, s) => {
@@ -60,11 +60,8 @@ export const basicTriviaEnhancer = ({ triviaIsAllowed, triviaMatcher }, grammar)
               if (
                 matcher &&
                 !isCovered &&
-                matcher.type === EmbeddedMatcher &&
-                getCooked(
-                  matcher.value.properties.refMatcher?.node.properties.type?.node.properties.value
-                    ?.node,
-                ) !== '#'
+                matcher.type === Matcher &&
+                getCooked(get(['refMatcher', 'type', 'value'], matcher.value)) !== '#'
               ) {
                 const previous = lookbehind(ctx, s);
                 if (triviaIsAllowed(s) && (!previous || !matchedResults.has(previous))) {
@@ -87,9 +84,7 @@ export const basicTriviaEnhancer = ({ triviaIsAllowed, triviaMatcher }, grammar)
         }
 
         if (co.value) {
-          let realMatcher = reifyExpression(
-            co.value.arguments[0].value.properties.nodeMatcher.node,
-          );
+          let realMatcher = reifyExpression(get('nodeMatcher', co.value.arguments[0].value));
           let { flags: matcherFlags } = realMatcher;
 
           let isNode = matcherFlags && !matcherFlags.fragment;
@@ -107,7 +102,7 @@ export const basicTriviaEnhancer = ({ triviaIsAllowed, triviaMatcher }, grammar)
 
           return co.value;
         } else {
-          if (!s.depths.path && !flags.token && !(isCovered || isCover)) {
+          if (!s.depths.path && !flags.token && !isCovered) {
             if (triviaIsAllowed(s)) {
               yield eatMatch(triviaMatcher);
             }
@@ -166,9 +161,9 @@ export const triviaEnhancer = (
               const { 0: matcher, 1: props, 2: options } = args;
 
               if (
-                matcher.type === EmbeddedMatcher &&
+                matcher.type === Matcher &&
                 ['ArrayNodeMatcher', 'NullNodeMatcher'].includes(
-                  matcher.value.properties.nodeMatcher.node.type.description,
+                  get('nodeMatcher', matcher.value).type.description,
                 )
               ) {
                 returnValue = yield instr;
@@ -176,9 +171,9 @@ export const triviaEnhancer = (
               }
 
               if (
-                matcher.type === EmbeddedRegex ||
+                matcher.type === Regex ||
                 typeof matcher === 'string' ||
-                (matcher.type === EmbeddedNode && matcher.value.flags.token)
+                (matcher.type === Node && matcher.value.flags.token)
               ) {
                 if (triviaIsAllowed(s) && !flags.token) {
                   let isString = typeof matcher === 'string';
@@ -188,7 +183,7 @@ export const triviaEnhancer = (
 
                   let tmi = buildEmbeddedInstruction(eatMatch(triviaMatcher));
 
-                  let result = yield buildCall(verb, m`<_${buildIdentifier(Wrapper_)} />`, [
+                  let result = yield buildCall(verb, m`<__${buildIdentifier(Wrapper_)} />`, [
                     tmi,
                     buildEmbeddedInstruction(eat(wrappedMatcher, props, options)),
                   ]);
@@ -196,28 +191,27 @@ export const triviaEnhancer = (
                   let prop = null;
 
                   if (result) {
-                    for (let child of result.children) {
-                      if (child.type === Property) prop = child;
+                    for (let child of result.tagsInner) {
+                      if (child.type === Property) prop = child.value;
                     }
                   }
 
-                  returnValue = prop?.value.node;
+                  returnValue = prop?.node;
                 } else {
                   returnValue = yield instr;
                 }
                 break;
               }
 
-              let { type: refType } =
-                reifyExpression(matcher.value.properties.refMatcher?.node) || {};
-              let realMatcher = reifyExpression(matcher.value.properties.nodeMatcher?.node);
+              let { type: refType } = reifyExpression(get('refMatcher', matcher.value)) || {};
+              let realMatcher = reifyExpression(get('nodeMatcher', matcher.value));
               let { flags: matcherFlags } = realMatcher;
 
               let isNode = matcherFlags && !matcherFlags.fragment;
               let isCoverBoundary = matcherFlags && (matcherFlags.cover || (isNode && !isCovered));
               if (
                 matcher &&
-                (matcher.type !== EmbeddedMatcher || refType !== '#') &&
+                (matcher.type !== Matcher || refType !== '#') &&
                 !s.holding &&
                 !flags.token &&
                 isCoverBoundary
@@ -231,7 +225,7 @@ export const triviaEnhancer = (
 
                   let result = yield buildCall(
                     verb,
-                    m`<_${buildIdentifier(Wrapper_)} />`,
+                    m`<__${buildIdentifier(Wrapper_)} />`,
                     [tmi, buildEmbeddedInstruction(eat(matcher, props, options))],
                     o({ bind: options?.value.bind ?? false }),
                   );
@@ -239,15 +233,16 @@ export const triviaEnhancer = (
 
                   if (result && !result.isNull) {
                     if (isNode || isCoverBoundary) {
-                      let { refMatcher } = matcher.value.properties;
+                      let refMatcher = get('refMatcher', matcher.value);
 
                       let name, isArray;
 
                       if (!refMatcher) {
                         ({ name, isArray } = mergedReference);
                       } else {
-                        let { name: name_, openIndexToken } = refMatcher.node.properties;
-                        name = name_ && ctx.sourceTextFor(name_.node);
+                        let name_ = get('name', refMatcher);
+                        let openIndexToken = get('openIndexToken', refMatcher);
+                        name = name_ && ctx.sourceTextFor(name_);
                         isArray = !!openIndexToken;
                       }
 
@@ -288,7 +283,7 @@ export const triviaEnhancer = (
           }
         } else if (co.value) {
           let matcher = co.value.arguments[0];
-          let realMatcher = reifyExpression(matcher.value.properties.nodeMatcher.node);
+          let realMatcher = reifyExpression(get('nodeMatcher', matcher.value));
           let { flags: matcherFlags } = realMatcher;
 
           let isNode = matcherFlags && !matcherFlags.fragment;
@@ -304,7 +299,7 @@ export const triviaEnhancer = (
               let tmi = buildEmbeddedInstruction(
                 triviaIsRequired() ? eat(triviaMatcher) : eatMatch(triviaMatcher),
               );
-              let result = yield buildCall(co.value.verb, m`<_${buildIdentifier(Wrapper_)} />`, [
+              let result = yield buildCall(co.value.verb, m`<__${buildIdentifier(Wrapper_)} />`, [
                 tmi,
                 buildEmbeddedInstruction(eat(co.value.arguments[0], co.value.arguments[1])),
               ]);
@@ -313,15 +308,16 @@ export const triviaEnhancer = (
 
               if (result && !result.isNull) {
                 if (isNode || isCoverBoundary) {
-                  let { refMatcher } = matcher.value.properties;
+                  let refMatcher = get('refMatcher', matcher.value);
 
                   let name, isArray;
 
                   if (!refMatcher) {
                     ({ name, isArray } = mergedReference);
                   } else {
-                    let { name, openIndexToken } = refMatcher.node.properties;
-                    name = name && ctx.sourceTextFor(name.node);
+                    let name = get('name', refMatcher);
+                    let openIndexToken = get('openIndexToken', refMatcher);
+                    name = name && ctx.sourceTextFor(name);
                     isArray = !!openIndexToken;
                   }
 
@@ -378,8 +374,8 @@ export const triviaEnhancer = (
       }
     }
 
-    *[Literal_]({ intrinsicValue }) {
-      yield eat(intrinsicValue);
+    *[Literal_]({ literalValue }) {
+      yield eat(literalValue);
     }
   };
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bablr/helpers",
   "description": "Command helpers for use in writing BABLR grammars",
-  "version": "0.23.0",
+  "version": "0.24.0",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -29,13 +29,13 @@
     "clean": "macrome clean"
   },
   "dependencies": {
-    "@bablr/language_enhancer-debug-log": "0.10.0",
-    "@bablr/strategy_enhancer-debug-log": "0.9.0",
-    "@bablr/agast-helpers": "0.8.0",
-    "@bablr/agast-vm-helpers": "0.8.0",
-    "@bablr/boot": "0.9.0",
+    "@bablr/language_enhancer-debug-log": "0.11.1",
+    "@bablr/strategy_enhancer-debug-log": "0.10.0",
+    "@bablr/agast-helpers": "0.9.0",
+    "@bablr/agast-vm-helpers": "0.9.0",
+    "@bablr/boot": "0.10.0",
     "@bablr/coroutine": "0.1.0",
-    "@iter-tools/imm-stack": "1.1.0",
+    "@iter-tools/imm-stack": "1.2.0",
     "iter-tools-es": "^7.5.3"
   },
   "devDependencies": {