@bablr/agast-vm-helpers 0.5.1 → 0.6.0

package/lib/deembed.js

@@ -1,25 +1,37 @@
-import { EmbeddedExpression } from '@bablr/agast-helpers/symbols';
+import {
+  EmbeddedNode,
+  EmbeddedObject,
+  EmbeddedTag,
+  EmbeddedMatcher,
+  EmbeddedRegex,
+} from '@bablr/agast-helpers/symbols';
 
-const { isArray } = Array;
-const isString = (val) => typeof val === 'string';
-const isNumber = (val) => typeof val === 'number';
+export const getEmbeddedObject = (expr) => {
+  if (!expr) return expr;
+  if (expr.type !== EmbeddedObject) throw new Error();
+  return expr.value;
+};
 
-export const deembedExpression = (expr) => {
-  if (isString(expr) || expr == null || typeof expr === 'boolean' || isNumber(expr)) {
-    return expr;
-  } else if (isArray(expr)) {
-    return expr.map((value) => deembedExpression(value));
-  } else if (typeof expr === 'object') {
-    return Object.fromEntries(
-      Object.entries(expr.value).map(({ 0: key, 1: value }) => [key, deembedExpression(value)]),
-    );
-  } else {
-    throw new Error();
-  }
+export const getEmbeddedNode = (expr) => {
+  if (!expr) return expr;
+  if (expr.type !== EmbeddedNode) throw new Error();
+  return expr.value;
 };
 
-export const getEmbeddedExpression = (expr) => {
+export const getEmbeddedMatcher = (expr) => {
   if (!expr) return expr;
-  if (expr.type !== EmbeddedExpression) throw new Error();
+  if (expr.type !== EmbeddedMatcher) throw new Error();
   return expr.value;
 };
+
+export const getEmbeddedRegex = (expr) => {
+  if (!expr) return expr;
+  if (expr.type !== EmbeddedRegex) throw new Error();
+  return expr.value;
+};
+
+export const getEmbeddedTag = (expr) => {
+  if (expr.type !== EmbeddedTag) throw new Error();
+  const tag = expr.value;
+  return tag;
+};

package/lib/embed.js

@@ -1,4 +1,4 @@
-import { buildEmbeddedExpression } from './internal-builders.js';
+import { buildEmbeddedObject } from './internal-builders.js';
 
 const { isArray } = Array;
 const isString = (val) => typeof val === 'string';
@@ -10,7 +10,7 @@ export const embedExpression = (expr) => {
   } else if (isArray(expr)) {
     return expr.map((value) => embedExpression(value));
   } else if (typeof expr === 'object') {
-    return buildEmbeddedExpression(
+    return buildEmbeddedObject(
       Object.fromEntries(
         Object.entries(expr).map(({ 0: key, 1: value }) => [key, embedExpression(value)]),
       ),
@@ -19,3 +19,5 @@ export const embedExpression = (expr) => {
     throw new Error();
   }
 };
+
+export { buildEmbeddedObject, buildEmbeddedObject as o };

package/lib/index.js

@@ -1,22 +1,37 @@
-import { sourceTextFor, getCooked, isNull, nodeFlags } from '@bablr/agast-helpers/tree';
+import {
+  sourceTextFor,
+  getCooked,
+  isNull,
+  nodeFlags,
+  printType,
+  buildGapTag,
+  buildEmbeddedMatcher,
+  isNullNode,
+  buildNullTag,
+  buildStubNode,
+  isFragmentNode,
+  buildReferenceTag,
+} from '@bablr/agast-helpers/tree';
 import * as btree from '@bablr/agast-helpers/btree';
-import * as sym from '@bablr/agast-helpers/symbols';
-import { buildNodeCloseTag, buildLiteralTag, buildDoctypeTag } from '@bablr/agast-helpers/builders';
+import {
+  buildCloseNodeTag,
+  buildLiteralTag,
+  buildDoctypeTag,
+  referenceFlags,
+  buildEmbeddedRegex,
+} from '@bablr/agast-helpers/builders';
 import {
   DoctypeTag,
   OpenNodeTag,
-  OpenFragmentTag,
-  CloseFragmentTag,
   CloseNodeTag,
-  ReferenceTag,
   ShiftTag,
   GapTag,
   NullTag,
-  ArrayTag,
+  ArrayInitializerTag,
   LiteralTag,
 } from '@bablr/agast-helpers/symbols';
 
-export * from './builders.js';
+const { freeze } = Object;
 
 export const effectsFor = (verb) => {
   switch (verb) {
@@ -43,15 +58,21 @@ export const shouldBranch = (effects) => {
   return effects ? effects.success === 'none' || effects.failure === 'none' : false;
 };
 
-const reifyFlags = (flags) => {
-  let { triviaToken, escapeToken, tokenToken, expressionToken, hasGapToken } = flags.properties;
+export const reifyNodeFlags = (flags) => {
+  let { tokenToken, hasGapToken } = flags.properties;
 
   return {
-    token: !!reifyExpression(tokenToken),
-    escape: !!reifyExpression(escapeToken),
-    trivia: !!reifyExpression(triviaToken),
-    expression: !!reifyExpression(expressionToken),
-    hasGap: !!reifyExpression(hasGapToken),
+    token: !!(tokenToken && reifyExpression(tokenToken.node)),
+    hasGap: !!(hasGapToken && reifyExpression(hasGapToken.node)),
+  };
+};
+
+export const reifyReferenceFlags = (flags) => {
+  let { expressionToken, hasGapToken } = flags.properties;
+
+  return {
+    expression: !!(expressionToken && reifyExpression(expressionToken.node)),
+    hasGap: !!(hasGapToken && reifyExpression(hasGapToken.node)),
   };
 };
 
@@ -64,18 +85,18 @@ export const reifyLanguage = (language) => {
 export const reifyProperties = (properties = []) => {
   const built = {};
   for (const property of btree.traverse(properties)) {
-    switch (property.type) {
-      case 'Property': {
-        let { reference, value } = property.properties;
+    switch (property.node.type) {
+      case Symbol.for('Property'): {
+        let { reference, value: node } = property.node.properties;
 
-        reference = reifyExpression(reference);
-        value = reifyExpression(value);
+        reference = reifyExpression(reference.node);
+        node = reifyExpression(node.node);
 
         if (reference.value.isArray) {
           built[reference.value.name] ||= [];
-          built[reference.value.name].push(value);
+          built[reference.value.name].push({ reference, node });
         } else {
-          built[reference.value.name] = value;
+          built[reference.value.name] = { reference, node };
         }
         break;
       }
@@ -91,19 +112,20 @@ export const buildFragmentChildren = (node) => {
 
   let built = [];
 
-  open = reifyExpression(open);
-  close = reifyExpression(close);
+  open = reifyExpression(open.node);
+  close = reifyExpression(close.node);
 
   built = btree.push(built, open);
 
   for (const child of btree.traverse(children)) {
-    if (child.type !== 'Property') throw new Error('umimplemented');
+    if (child.node.type !== Symbol.for('Property')) throw new Error('umimplemented');
 
-    let { reference } = child.properties;
+    let { reference } = child.node.properties;
 
-    reference = reifyExpression(reference);
+    reference = reifyExpression(reference.node);
 
     built = btree.push(built, reference);
+    built = btree.push(built, buildGapTag());
   }
 
   built = btree.push(built, close);
@@ -114,29 +136,30 @@ export const buildFragmentChildren = (node) => {
 export const buildChildren = (node) => {
   let { open, children = [], close } = node.properties;
 
-  const selfClosing = !!open.properties.selfClosingTagToken;
-  const { intrinsicValue } = open.properties;
+  const selfClosing = !isNull(open.node.properties.selfClosingTagToken?.node);
+  const { intrinsicValue } = open.node.properties;
   let built = [];
 
-  open = reifyExpression(open);
-  close = reifyExpression(close);
+  open = reifyExpression(open.node);
+  close = reifyExpression(close?.node);
 
   if (selfClosing) {
     built = btree.push(built, open);
-    if (intrinsicValue) {
-      built = btree.push(built, buildLiteralTag(intrinsicValue));
+    if (!isNull(intrinsicValue?.node)) {
+      built = btree.push(built, buildLiteralTag(intrinsicValue.node));
     }
-    built = btree.push(built, buildNodeCloseTag());
+    built = btree.push(built, buildCloseNodeTag());
   } else {
     built = btree.push(built, open);
     for (const child of btree.traverse(children)) {
-      if (child.type !== 'Property') throw new Error('umimplemented');
+      if (child.node.type !== Symbol.for('Property')) throw new Error('umimplemented');
 
-      let { reference } = child.properties;
+      let { reference } = child.node.properties;
 
-      reference = reifyExpression(reference);
+      reference = reifyExpression(reference.node);
 
       built = btree.push(built, reference);
+      built = btree.push(built, buildGapTag());
     }
 
     built = btree.push(built, close);
@@ -148,10 +171,11 @@ export const buildChildren = (node) => {
 export const reifyExpression = (node) => {
   if (node instanceof Promise) throw new Error();
 
-  if (!node || node.type === sym.null) return null;
+  if (node == null) return node;
+  if (isNullNode(node)) return null;
 
-  if (!node.type) {
-    node = node.properties['.'];
+  if (isFragmentNode(node)) {
+    node = node.properties['.'].node;
   }
 
   if (node.language === 'https://bablr.org/languages/core/en/cstml') {
@@ -159,19 +183,19 @@ export const reifyExpression = (node) => {
       case 'Document': {
         let { doctype, tree } = node.properties;
 
-        doctype = reifyExpression(doctype);
-        tree = reifyExpression(tree);
+        doctype = reifyExpression(doctype.node);
+        tree = reifyExpression(tree.node);
 
         let { attributes } = doctype.value;
         let { properties } = tree;
 
         return {
           flags: nodeFlags,
-          language: attributes['bablr-language'],
+          language: attributes.bablrLanguage,
           type: null,
           children: btree.addAt(
             0,
-            buildFragmentChildren(node.properties.tree),
+            buildFragmentChildren(node.properties.tree.node),
             buildDoctypeTag(attributes),
           ),
           properties,
@@ -182,7 +206,7 @@ export const reifyExpression = (node) => {
       case 'Node': {
         let { open, children } = node.properties;
 
-        open = reifyExpression(open);
+        open = reifyExpression(open.node);
 
         let { flags, language, type, attributes } = open.value;
 
@@ -201,7 +225,7 @@ export const reifyExpression = (node) => {
       case 'Fragment': {
         let { open, children } = node.properties;
 
-        open = reifyExpression(open);
+        open = reifyExpression(open.node);
 
         let { flags } = open.value;
 
@@ -218,26 +242,24 @@ export const reifyExpression = (node) => {
       }
 
       case 'DoctypeTag': {
-        let { doctype, version, attributes } = node.properties;
+        let { doctypeToken, version, attributes } = node.properties;
         return {
           type: DoctypeTag,
           value: {
-            doctype: getCooked(doctype),
-            version: parseInt(sourceTextFor(version), 10),
-            attributes: reifyAttributes(attributes),
+            doctypeToken: getCooked(doctypeToken?.node),
+            version: parseInt(sourceTextFor(version.node), 10),
+            attributes: reifyExpression(attributes.node),
           },
         };
       }
 
       case 'ReferenceTag': {
-        let { name, arrayOperatorToken, hasGapToken } = node.properties;
+        let { name, arrayOperatorToken, flags } = node.properties;
 
-        name = reifyExpression(name);
+        name = reifyExpression(name.node);
+        flags = freeze({ expression: !!flags?.expressionToken, hasGap: !!flags?.hasGapToken });
 
-        return {
-          type: ReferenceTag,
-          value: { name, isArray: !isNull(arrayOperatorToken), hasGap: !isNull(hasGapToken) },
-        };
+        return buildReferenceTag(name, !isNull(arrayOperatorToken?.node), flags);
       }
 
       case 'LiteralTag': {
@@ -245,20 +267,22 @@ export const reifyExpression = (node) => {
 
         return { type: LiteralTag, value: getCooked(value.properties.content) };
       }
+
       case 'Identifier': {
         return getCooked(node);
       }
+
       case 'IdentifierPath': {
-        return node.properties.segments.map((segment) => reifyExpression(segment));
+        return node.properties.segments.map((segment) => reifyExpression(segment.node));
       }
 
       case 'OpenNodeTag': {
         let { flags, language, type, attributes } = node.properties;
 
-        flags = reifyFlags(flags);
-        language = reifyLanguage(language);
-        type = reifyExpression(type);
-        attributes = reifyAttributes(attributes);
+        flags = reifyNodeFlags(flags.node);
+        language = reifyLanguage(language?.node);
+        type = reifyExpression(type?.node);
+        attributes = reifyExpression(attributes?.node);
 
         return {
           type: OpenNodeTag,
@@ -267,50 +291,27 @@ export const reifyExpression = (node) => {
       }
 
       case 'CloseNodeTag': {
-        let { language, type } = node.properties;
-
-        language = reifyLanguage(language);
-        type = reifyExpression(type);
-
-        return { type: CloseNodeTag, value: { language, type } };
-      }
-
-      case 'OpenFragmentTag': {
-        let { flags } = node.properties;
-
-        flags = reifyFlags(flags);
-
-        return {
-          type: OpenFragmentTag,
-          value: { flags },
-        };
-      }
-
-      case 'CloseFragmentTag': {
-        return { type: CloseFragmentTag, value: undefined };
+        return { type: CloseNodeTag, value: undefined };
       }
 
       case 'Integer': {
         let { digits } = node.properties;
-        return parseInt(digits.map((digit) => getCooked(digit)).join(''), 10);
+        return parseInt(digits.map((digit) => getCooked(digit.node)).join(''), 10);
       }
 
       case 'Infinity': {
-        return node.properties.sign === '-' ? -Infinity : Infinity;
+        return getCooked(node.properties.sign.node) === '-' ? -Infinity : Infinity;
       }
 
       case 'Punctuator': {
         return getCooked(node);
       }
 
-      case 'String':
-        return node.properties.content ? getCooked(node.properties.content) : '';
-
       case 'GapTag':
         return { type: GapTag, value: undefined };
 
-      case 'ArrayTag':
-        return { type: ArrayTag, value: undefined };
+      case 'ArrayInitializerTag':
+        return { type: ArrayInitializerTag, value: undefined };
 
       case 'NullTag':
         return { type: NullTag, value: undefined };
@@ -326,6 +327,7 @@ export const reifyExpression = (node) => {
   if (
     ![
       'https://bablr.org/languages/core/en/bablr-vm-instruction',
+      'https://bablr.org/languages/core/en/cstml-json',
       'https://bablr.org/languages/core/en/cstml',
       'https://bablr.org/languages/core/en/spamex',
     ].includes(node.language)
@@ -333,44 +335,112 @@ export const reifyExpression = (node) => {
     return node;
   }
 
-  switch (node.type) {
-    case 'NodeMatcher':
-      let { flags, language, type, attributes, intrinsicValue } = node.properties.open.properties;
+  switch (printType(node.type)) {
+    case 'String':
+      return node.properties.content.node ? getCooked(node.properties.content.node) : '';
+
+    case 'SpamexString': {
+      return buildEmbeddedMatcher(node.properties.content.node);
+    }
+
+    case 'RegexString': {
+      return buildEmbeddedRegex(node.properties.content.node);
+    }
+
+    case 'OpenNodeMatcher': {
+      let { flags, language, type, attributes, intrinsicValue } = node.properties;
 
-      flags = reifyFlags(flags);
-      language = reifyLanguage(language);
-      type = reifyExpression(type);
-      attributes = reifyAttributes(attributes);
-      intrinsicValue = reifyExpression(intrinsicValue);
+      flags = (flags && reifyNodeFlags(flags.node)) || {};
+      language = language && reifyLanguage(language.node);
+      type =
+        type.node.type === Symbol.for('String')
+          ? getCooked(type.node.properties.content.node)
+          : getCooked(type.node);
+      attributes = attributes ? reifyExpression(attributes.node) : {};
+      intrinsicValue = intrinsicValue && reifyExpression(intrinsicValue.node);
 
       return { flags, language, type, intrinsicValue, attributes };
+    }
+
+    case 'FragmentMatcher': {
+      let { flags } = node.properties;
+
+      flags = (flags && reifyNodeFlags(flags.node)) || {};
+
+      return {
+        flags,
+        language: null,
+        type: Symbol.for('@bablr/fragment'),
+        intrinsicValue: null,
+        attributes: null,
+      };
+    }
+
+    case 'BasicNodeMatcher': {
+      let { open } = node.properties;
+
+      return reifyExpression(open.node);
+    }
+
+    case 'PropertyMatcher': {
+      let { refMatcher, nodeMatcher } = node.properties;
+
+      refMatcher = refMatcher ? reifyExpression(refMatcher.node) : null;
+      nodeMatcher = reifyExpression(nodeMatcher.node);
+
+      return { refMatcher, nodeMatcher };
+    }
+
+    case 'ReferenceMatcher': {
+      let { name, openIndexToken, flags } = node.properties;
+
+      name =
+        name &&
+        (name.node.type === Symbol.for('Identifier')
+          ? reifyExpression(name.node)
+          : getCooked(name.node));
+      let isArray = !isNull(openIndexToken?.node);
+      flags = (flags && reifyReferenceFlags(flags?.node)) || referenceFlags;
+
+      return { name, isArray, flags };
+    }
+
+    case 'GapNodeMatcher':
+      return buildStubNode(buildGapTag());
+
+    case 'NullNodeMatcher':
+      return buildStubNode(buildNullTag());
+
+    case 'ArrayNodeMatcher':
+      return [];
 
     case 'Call': {
       const { verb, arguments: args } = node.properties;
-      return { verb: reifyExpression(verb), arguments: reifyExpression(args) };
+
+      const args_ = [...btree.traverse(args)].map((el) => reifyExpression(el.node));
+
+      return { verb: reifyExpression(verb.node), arguments: args_ };
     }
 
     case 'Object': {
       const { properties } = node.properties;
 
       return Object.fromEntries(
-        [...btree.traverse(properties)].map(({ properties: { key, value } }) => [
-          getCooked(key),
-          reifyExpression(value),
-        ]),
+        [...btree.traverse(properties)].map((property) => {
+          const {
+            node: {
+              properties: { key, value },
+            },
+          } = property;
+          return [getCooked(key.node), reifyExpression(value.node)];
+        }),
       );
     }
 
-    case 'Tuple': {
-      const { values = [] } = node.properties;
-
-      return [...btree.traverse(values)].map((el) => reifyExpression(el));
-    }
-
     case 'Array': {
       const { elements = [] } = node.properties;
 
-      return [...btree.traverse(elements)].map((el) => reifyExpression(el));
+      return [...btree.traverse(elements)].map((el) => reifyExpression(el.node));
     }
 
     case 'LiteralTag':
@@ -379,7 +449,7 @@ export const reifyExpression = (node) => {
 
     case 'Boolean': {
       // prettier-ignore
-      switch (getCooked(node.properties.sigilToken)) {
+      switch (getCooked(node.properties.sigilToken.node)) {
         case 'true': return true;
         case 'false': return false;
         default: throw new Error();
@@ -395,52 +465,56 @@ export const reifyExpression = (node) => {
 };
 
 export const reifyExpressionShallow = (node) => {
-  if (!node || node.type === sym.null) return null;
+  if (!node || isNullNode(node)) return null;
 
   if (
     ![
       'https://bablr.org/languages/core/en/bablr-vm-instruction',
       'https://bablr.org/languages/core/en/cstml',
+      'https://bablr.org/languages/core/en/cstml-json',
+      'https://bablr.org/languages/core/en/spamex',
     ].includes(node.language)
   ) {
     return node;
   }
 
-  switch (node.type) {
+  switch (printType(node.type)) {
+    case 'String':
+    case 'SpamexString':
+    case 'RegexString': {
+      return reifyExpression(node);
+    }
+
     case 'Object': {
       const { properties } = node.properties;
 
       return Object.fromEntries(
-        [...btree.traverse(properties)].map(({ properties: { key, value } }) => [
-          getCooked(key),
-          value,
-        ]),
+        [...btree.traverse(properties)].map(
+          ({
+            node: {
+              properties: { key, value },
+            },
+          }) => [getCooked(key.node), value.node],
+        ),
       );
     }
 
     case 'Array':
-      return [...btree.traverse(node.properties.elements)];
+      return [...btree.traverse(node.properties.elements)].map((prop) => prop.node);
 
-    case 'Tuple':
-      return [...btree.traverse(node.properties.values)];
+    case 'Boolean': {
+      // prettier-ignore
+      switch (getCooked(node.properties.sigilToken.node)) {
+        case 'true': return true;
+        case 'false': return false;
+        default: throw new Error();
+      }
+    }
+
+    case 'Null':
+      return null;
 
     default:
       return reifyExpression(node);
   }
 };
-
-export const reifyAttributes = (attributes) => {
-  if (attributes == null) return {};
-
-  return Object.fromEntries(
-    [...btree.traverse(attributes)].map((attr) => {
-      if (attr.type === 'MappingAttribute') {
-        return [reifyExpression(attr.properties.key), reifyExpression(attr.properties.value)];
-      } else if (attr.type === 'BooleanAttribute') {
-        return [reifyExpression(attr.properties.key), isNull(attr.properties.negateToken)];
-      } else {
-        throw new Error();
-      }
-    }),
-  );
-};

package/lib/iterable.js

@@ -0,0 +1,29 @@
+export function* concat(...iterables) {
+  for (const iterable of iterables) yield* iterable;
+}
+
+export const reduce = (reducer, values, initial) => {
+  let acc = initial;
+
+  for (const value of values) {
+    acc = reducer(acc, value);
+  }
+
+  return acc;
+};
+
+export function* takeWhile(fn, iterable) {
+  for (const value of iterable) {
+    if (fn(value)) {
+      yield value;
+    } else {
+      break;
+    }
+  }
+}
+
+export function* map(fn, iterable) {
+  for (const value of iterable) {
+    yield fn(value);
+  }
+}

package/lib/languages.js

@@ -1,6 +1,6 @@
 export const Spamex = 'https://bablr.org/languages/core/en/spamex';
 export const CSTML = 'https://bablr.org/languages/core/en/cstml';
+export const JSON = 'https://bablr.org/languages/core/en/cstml-json';
 export const Regex = 'https://bablr.org/languages/core/en/bablr-regex-pattern';
 export const Instruction = 'https://bablr.org/languages/core/en/bablr-vm-instruction';
-export const Comment = 'https://bablr.org/languages/core/en/c-comments';
 export const Space = 'https://bablr.org/languages/core/en/space-tab-newline';