@bablr/agast-vm-helpers 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 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/README.md

@@ -0,0 +1,3 @@
+# @bablr/agast-vm-helpers
+
+Helper functions for working with the agAST VM

package/lib/builders.js

@@ -0,0 +1,573 @@
+// import { i } from '@bablr/boot/shorthand.macro';
+import {
+  interpolateArray,
+  interpolateArrayChildren,
+  interpolateString,
+} from '@bablr/agast-helpers/template';
+import * as t from '@bablr/agast-helpers/shorthand';
+import * as l from './languages.js';
+
+const { getPrototypeOf, freeze } = Object;
+const { isArray } = Array;
+
+const when = (condition, value) => (condition ? value : { *[Symbol.iterator]() {} });
+
+const isString = (val) => typeof val === 'string';
+const isBoolean = (val) => typeof val === 'boolean';
+
+function* repeat(times, ...values) {
+  for (let i = 0; i < times; i++) for (const value of values) yield value;
+}
+
+export const buildReference = (name, isArray) => {
+  return t.node(l.CSTML, 'Reference', [t.ref`name`, ...when(isArray, [t.ref`arrayOperator`])], {
+    name: buildIdentifier(name),
+    arrayOperator: isArray ? t.s_node(l.CSTML, 'Punctuator', '[]') : null,
+  });
+};
+
+export const buildGap = () => {
+  return t.node(l.CSTML, 'Gap', [t.ref`value`], { value: t.s_node(l.CSTML, 'Punctuator', '<//>') });
+};
+
+const buildFlags = (flags) => {
+  const { token = null, escape = null, trivia = null, expression = null } = flags;
+
+  if ((trivia && escape) || (expression && (trivia || escape))) {
+    throw new Error('invalid flags');
+  }
+
+  return {
+    children: [
+      ...when(trivia, [t.ref`triviaFlag`]),
+      ...when(token, [t.ref`tokenFlag`]),
+      ...when(escape, [t.ref`escapeFlag`]),
+      ...when(expression, [t.ref`expressionFlag`]),
+    ],
+    properties: {
+      triviaFlag: trivia && t.s_node(l.CSTML, 'Punctuator', '#'),
+      tokenFlag: token && t.s_node(l.CSTML, 'Punctuator', '*'),
+      escapeFlag: escape && t.s_node(l.CSTML, 'Punctuator', '@'),
+      expressionFlag: expression && t.s_node(l.CSTML, 'Punctuator', '+'),
+    },
+  };
+};
+
+export const buildSpamMatcher = (type, value, attributes = {}) => {
+  return buildFullyQualifiedSpamMatcher({}, null, type, value, attributes);
+};
+
+export const buildFullyQualifiedSpamMatcher = (
+  flags,
+  language,
+  type,
+  intrinsicValue,
+  attributes = {},
+) => {
+  const attributes_ = Object.entries(attributes).map(({ 0: key, 1: value }) =>
+    buildAttribute(key, value),
+  );
+
+  const lArr = language ? [...language] : [];
+
+  let language_ = lArr.length === 0 ? null : lArr;
+
+  const flags_ = buildFlags(flags);
+  return t.node(
+    l.Spamex,
+    'NodeMatcher',
+    [
+      t.ref`open`,
+      ...flags_.children,
+      ...when(language_, [t.ref`language`, t.ref`languageSeparator`]),
+      t.ref`type`,
+      ...when(intrinsicValue, [t.embedded(buildSpace()), t.ref`intrinsicValue`]),
+      ...when(attributes_.length, [t.embedded(buildSpace())]),
+      ...interpolateArrayChildren(attributes, t.ref`attributes[]`, t.embedded(buildSpace())),
+      t.ref`close`,
+    ],
+    {
+      open: t.s_node(l.CSTML, 'Punctuator', '<'),
+      ...flags_.properties,
+      language: buildLanguage(language_),
+      languageSeparator: language_ && type && t.s_node(l.CSTML, 'Punctuator', ':'),
+      type: buildIdentifier(type),
+      intrinsicValue: intrinsicValue && buildString(intrinsicValue),
+      attributes: attributes_,
+      close: t.s_node(l.CSTML, 'Punctuator', '>'),
+    },
+  );
+};
+
+export const buildNodeOpenTag = (flags, language, type, intrinsicValue = null, attributes = {}) => {
+  const attributes_ = Object.entries(attributes).map(({ 0: key, 1: value }) =>
+    buildAttribute(key, value),
+  );
+
+  let language_ = !language || language.length === 0 ? null : language;
+
+  const flags_ = buildFlags(flags);
+
+  return t.node(
+    l.CSTML,
+    'OpenNodeTag',
+    [
+      t.ref`open`,
+      ...flags_.children,
+      ...when(language_, [t.ref`language`, t.ref`languageSeparator`]),
+      t.ref`type`,
+      ...when(intrinsicValue, [t.embedded(buildSpace()), t.ref`intrinsicValue`]),
+      ...when(attributes_.length, [t.embedded(buildSpace())]),
+      ...interpolateArrayChildren(attributes_, t.ref`attributes[]`, t.embedded(buildSpace())),
+      when(intrinsicValue, [t.embedded(buildSpace), t.ref`selfClosingToken`]),
+      t.ref`close`,
+    ],
+    {
+      open: t.s_node(l.CSTML, 'Punctuator', '<'),
+      ...flags_.properties,
+      language: buildLanguage(language_),
+      languageSeparator: language_ && type && t.s_node(l.CSTML, 'Punctuator', ':'),
+      type: buildIdentifier(type),
+      intrinsicValue: intrinsicValue && buildString(intrinsicValue),
+      attributes: attributes_,
+      selfClosingToken: intrinsicValue && t.s_node(l.CSTML, 'Punctuator', '/'),
+      close: t.s_node(l.CSTML, 'Punctuator', '>'),
+    },
+  );
+};
+
+export const buildDoctypeTag = (attributes) => {
+  const attributes_ = Object.entries(attributes).map(({ 0: key, 1: value }) =>
+    buildAttribute(key, value),
+  );
+
+  return t.node(
+    l.CSTML,
+    'DoctypeTag',
+    [
+      t.ref`open`,
+      t.ref`version`,
+      t.ref`versionSeparator`,
+      t.ref`doctype`,
+      ...when(attributes_.length, [t.embedded(buildSpace())]),
+      ...interpolateArrayChildren(attributes_, t.ref`attributes[]`, t.embedded(buildSpace())),
+      t.ref`close`,
+    ],
+    {
+      open: t.s_node(l.CSTML, 'Punctuator', '<!'),
+      version: t.s_node(l.CSTML, 'PositiveInteger', '0'),
+      versionSeparator: t.s_node(l.CSTML, 'Punctuator', ':'),
+      doctype: t.s_node(l.CSTML, 'Keyword', 'cstml'),
+      attributes: attributes_,
+      close: t.s_node(l.CSTML, 'Punctuator', '>'),
+    },
+  );
+};
+
+export const buildFragmentFlags = (flags = {}) => {
+  const { escape = null, trivia = null } = flags;
+  if (!(escape || trivia)) {
+    return null;
+  }
+
+  return t.node(
+    l.CSTML,
+    'NodeFlags',
+    [...when(trivia, [t.ref`trivia`]), ...when(escape, [t.ref`escape`])],
+    {
+      trivia: trivia && t.s_node(l.CSTML, 'Punctuator', '#'),
+      escape: escape && t.s_node(l.CSTML, 'Punctuator', '@'),
+    },
+  );
+};
+
+export const buildFragmentOpenTag = (flags) => {
+  return t.node(
+    l.CSTML,
+    'OpenFragmentTag',
+    [t.ref`open`, ...when(flags, [t.ref`flags`]), t.ref`close`],
+    {
+      open: t.s_node(l.CSTML, 'Punctuator', '<'),
+      flags: buildFragmentFlags(flags),
+      close: t.s_node(l.CSTML, 'Punctuator', '>'),
+    },
+  );
+};
+
+export const buildIdentifierPath = (path) => {
+  const path_ = [...path];
+  const segments = path_.map((name) => buildIdentifier(name));
+  const separators = path_.slice(0, -1).map((_) => t.s_node(l.CSTML, 'Punctuator', '.'));
+
+  if (!path_.length) {
+    return null;
+  }
+
+  return t.node(
+    l.CSTML,
+    'IdentifierPath',
+    [...repeat(segments.length, t.ref`segments[]`, t.ref`separators[]`)].slice(0, -1),
+    {
+      segments,
+      separators,
+    },
+  );
+};
+
+export const buildLanguage = (language) => {
+  return language && buildIdentifierPath(language);
+};
+
+export const buildNodeCloseTag = (type, language) => {
+  return t.node(
+    l.CSTML,
+    'CloseNodeTag',
+    [
+      t.ref`open`,
+      ...when(language, [t.ref`language`]),
+      ...when(type && language, [t.ref`languageSeparator`]),
+      ...when(type, [t.ref`type`]),
+      t.ref`close`,
+    ],
+    {
+      open: t.s_node(l.CSTML, 'Punctuator', '</'),
+      language: buildLanguage(language),
+      languageSeparator: language && type ? t.s_node(l.CSTML, 'Punctuator', ':') : null,
+      type: type && buildIdentifier(type),
+      close: t.s_node(l.CSTML, 'Punctuator', '>'),
+    },
+  );
+};
+
+export const buildFragmentCloseTag = () => {
+  return t.node(l.CSTML, 'CloseFragmentTag', [t.ref`open`, t.ref`close`], {
+    open: t.s_node(l.CSTML, 'Punctuator', '</'),
+    close: t.s_node(l.CSTML, 'Punctuator', '>'),
+  });
+};
+
+export const buildLiteral = (value) => {
+  return t.node(l.CSTML, 'Literal', [t.ref`value`], { value });
+};
+
+export const buildTerminalProps = (matcher) => {
+  const { attributes, value } = matcher.properties;
+
+  return buildObject({ value, attributes });
+};
+
+export const buildSpace = () => {
+  return t.t_node(l.Comment, null, [t.embedded(t.t_node(l.Space, 'Space', [t.lit(' ')]))]);
+};
+
+export const buildIdentifier = (name) => {
+  return t.node(l.Instruction, 'Identifier', [t.lit(name)]);
+};
+
+export const buildCall = (verb, ...args) => {
+  return t.node(l.Instruction, 'Call', [t.ref`verb`, t.ref`arguments`], {
+    verb: buildIdentifier(verb),
+    arguments: buildTuple(args),
+  });
+};
+
+export const buildProperty = (key, value) => {
+  return t.node(
+    l.Instruction,
+    'Property',
+    [t.ref`key`, t.ref`mapOperator`, t.embedded(buildSpace()), t.ref`value`],
+    {
+      key: buildIdentifier(key),
+      mapOperator: t.s_node(l.Instruction, 'Punctuator', ':'),
+      value: buildExpression(value),
+    },
+  );
+};
+
+const escapables = {
+  '\r': 'r',
+  '\n': 'n',
+  '\t': 't',
+  '\0': '0',
+};
+
+export const buildDigit = (value) => {
+  return t.s_node(l.CSTML, 'Digit', value);
+};
+
+export const buildInteger = (value) => {
+  const digits = value.toString(10).split('');
+
+  return t.node(
+    l.CSTML,
+    'Integer',
+    digits.map((d) => t.ref`digits[]`),
+    { digits: digits.map((digit) => buildDigit(digit)) },
+  );
+};
+
+export const buildInfinity = (value) => {
+  let sign;
+  if (value === Infinity) {
+    sign = '+';
+  } else if (value === -Infinity) {
+    sign = '-';
+  } else {
+    throw new Error();
+  }
+
+  return t.node(l.CSTML, 'Infinity', [t.ref`sign`, t.ref`value`], {
+    sign: t.s_node(l.CSTML, 'Punctuator', sign),
+    value: t.s_node(l.CSTML, 'Keyword', 'Infinity'),
+  });
+};
+
+export const buildNumber = (value) => {
+  if (Number.isFinite(value)) {
+    return buildInteger(value);
+  } else {
+    return buildInfinity(value);
+  }
+};
+
+export const buildString = (value) => {
+  const pieces = isArray(value) ? value : [value];
+  const terminals = [];
+  let lit = '';
+
+  if (pieces.length === 1 && pieces[0] === "'") {
+    return t.node(l.CSTML, 'String', [t.ref`open`, t.ref`content`, t.ref`close`], {
+      open: t.s_node(l.CSTML, 'Punctuator', '"'),
+      content: interpolateString(
+        freeze({
+          type: 'Literal',
+          value,
+        }),
+      ),
+      close: t.s_node(l.CSTML, 'Punctuator', '"'),
+    });
+  }
+
+  for (const piece of pieces) {
+    if (isString(piece)) {
+      const value = piece;
+
+      for (const chr of value) {
+        if (
+          chr === '\\' ||
+          chr === "'" ||
+          chr === '\n' ||
+          chr === '\r' ||
+          chr === '\t' ||
+          chr === '\0'
+        ) {
+          if (lit) {
+            terminals.push(freeze({ type: 'Literal', value: lit }));
+            lit = '';
+          }
+
+          terminals.push(
+            t.buildEmbedded(
+              t.e_node(
+                l.CSTML,
+                'Escape',
+                [t.ref`escape`, t.ref`escapee`],
+                {
+                  escape: t.s_node(l.CSTML, 'Punctuator', '\\'),
+                  escapee: t.s_node(l.CSTML, 'Literal', escapables[chr] || chr),
+                },
+                { cooked: chr },
+              ),
+            ),
+          );
+        } else {
+          lit += chr;
+        }
+      }
+    } else {
+      terminals.push(freeze({ type: 'Literal', value: lit }));
+      lit = '';
+
+      if (piece == null) {
+        throw new Error('not impelemented');
+      } else if (isString(piece.type)) {
+        terminals.push(piece);
+      } else {
+        throw new Error();
+      }
+    }
+  }
+
+  if (lit) terminals.push(freeze({ type: 'Literal', value: lit }));
+  lit = '';
+
+  return t.node(l.CSTML, 'String', [t.ref`open`, t.ref`content`, t.ref`close`], {
+    open: t.s_node(l.CSTML, 'Punctuator', "'"),
+    content: interpolateString(terminals),
+    close: t.s_node(l.CSTML, 'Punctuator', "'"),
+  });
+};
+
+export const buildBoolean = (value) => {
+  return t.node(l.Instruction, 'Boolean', [t.ref`value`], {
+    value: t.s_node(l.Instruction, 'Keyword', value ? 'true' : 'false'),
+  });
+};
+
+export const buildNull = () => {
+  return t.node(l.Instruction, 'Null', [t.ref`value`], {
+    value: t.s_node(l.Instruction, 'Keyword', 'null'),
+  });
+};
+
+export const buildArray = (elements) => {
+  return t.node(
+    l.Instruction,
+    'Array',
+    [
+      t.ref`open`,
+      ...interpolateArrayChildren(
+        elements,
+        t.ref`elements[]`,
+        t.embedded(
+          t.t_node(l.Comment, null, [t.embedded(t.t_node('Space', 'Space', [t.lit(' ')]))]),
+        ),
+      ),
+      t.ref`close`,
+    ],
+    {
+      open: t.s_node(l.Instruction, 'Punctuator', '['),
+      elements: [...interpolateArray(elements)],
+      close: t.s_node(l.Instruction, 'Punctuator', ']'),
+    },
+  );
+};
+
+export const buildTuple = (values) => {
+  return t.node(
+    l.Instruction,
+    'Tuple',
+    [
+      t.ref`open`,
+      ...interpolateArrayChildren(
+        values,
+        t.ref`values[]`,
+        t.embedded(
+          t.t_node(l.Comment, null, [t.embedded(t.t_node('Space', 'Space', [t.lit(' ')]))]),
+        ),
+      ),
+      t.ref`close`,
+    ],
+    {
+      open: t.s_node(l.Instruction, 'Punctuator', '('),
+      values: [...interpolateArray(values)],
+      close: t.s_node(l.Instruction, 'Punctuator', ')'),
+    },
+  );
+};
+
+export const buildObject = (properties) => {
+  return t.node(
+    l.Instruction,
+    'Object',
+    [
+      t.ref`open`,
+      ...interpolateArrayChildren(
+        Object.entries(properties).map(([key, value]) => buildProperty(key, value)),
+        t.ref`properties[]`,
+        t.embedded(
+          t.t_node(l.Comment, null, [t.embedded(t.t_node('Space', 'Space', [t.lit(' ')]))]),
+        ),
+      ),
+      t.ref`close`,
+    ],
+    {
+      open: t.s_node(l.Instruction, 'Punctuator', '{'),
+      properties: [
+        ...interpolateArray(
+          Object.entries(properties).map(([key, value]) => buildProperty(key, value)),
+        ),
+      ],
+      close: t.s_node(l.Instruction, 'Punctuator', '}'),
+    },
+    {},
+  );
+};
+
+export const buildMappingAttribute = (key, value) => {
+  return t.node(l.CSTML, 'MappingAttribute', [t.ref`key`, t.ref`mapOperator`, t.ref`value`], {
+    key: buildIdentifier(key),
+    mapOperator: t.s_node(l.CSTML, 'Punctuator', '='),
+    value: buildExpression(value),
+  });
+};
+
+export const buildBooleanAttribute = (key, value) => {
+  return t.node(l.CSTML, 'BooleanAttribute', [...when(!value, [t.ref`negateSigil`]), t.ref`key`], {
+    negateSigil: !value ? t.s_node(l.CSTML, 'Puncutator', '!') : null,
+    key: buildIdentifier(key),
+  });
+};
+
+export const buildAttribute = (key, value) => {
+  return isBoolean(value) ? buildBooleanAttribute(key, value) : buildMappingAttribute(key, value);
+};
+
+export const buildExpression = (expr) => {
+  if (expr == null) return buildNull();
+
+  switch (typeof expr) {
+    case 'boolean':
+      return buildBoolean(expr);
+    case 'string':
+      return buildString(expr);
+    case 'object': {
+      switch (getPrototypeOf(expr)) {
+        case Array.prototype:
+          return buildArray(expr);
+        case Object.prototype:
+          if (expr.type && expr.language && expr.children && expr.properties) {
+            return expr;
+          }
+          return buildObject(expr);
+        default:
+          throw new Error();
+      }
+    }
+    default:
+      throw new Error();
+  }
+};
+
+export const buildNodeMatcher = (flags, language, type, attributes = {}) => {
+  const attributes_ = Object.entries(attributes).map(({ 0: key, 1: value }) =>
+    buildAttribute(key, value),
+  );
+
+  let language_ = !language || language.length === 0 ? null : language;
+
+  const flags_ = buildFlags(flags);
+
+  return t.node(
+    l.Spamex,
+    'NodeMatcher',
+    [
+      t.ref`open`,
+      ...when(flags_, [t.ref`flags`]),
+      ...when(language_, [t.ref`language`, t.ref`languageSeparator`]),
+      t.ref`type`,
+      ...when(attributes_.length, [t.embedded(buildSpace())]),
+      ...interpolateArrayChildren(attributes_, t.ref`attributes[]`, t.embedded(buildSpace())),
+      t.ref`close`,
+    ],
+    {
+      open: t.s_node(l.CSTML, 'Punctuator', '<'),
+      language: buildLanguage(language_),
+      languageSeparator: language_ && type && t.s_node(l.CSTML, 'Punctuator', ':'),
+      flags: flags_,
+      type: buildIdentifier(type),
+      attributes: attributes_,
+      close: t.s_node(l.CSTML, 'Punctuator', '>'),
+    },
+  );
+};

package/lib/facades.js

@@ -0,0 +1,37 @@
+export const buildFacadeLayer = () => {
+  const _facades = new WeakMap();
+
+  const facades = {
+    get(actual) {
+      return actual == null ? actual : _facades.get(actual);
+    },
+
+    set(actual, facade) {
+      if (_facades.has(actual) || actual === facade) {
+        throw new Error('facade mappings must be 1:1');
+      }
+
+      _facades.set(actual, facade);
+      _actuals.set(facade, actual);
+    },
+  };
+
+  const _actuals = new WeakMap();
+
+  const actuals = {
+    get(facade) {
+      return facade == null ? facade : _actuals.get(facade);
+    },
+
+    set(facade, actual) {
+      if (_facades.has(actual) || _actuals.has(facade) || actual === facade) {
+        throw new Error('facade mappings must be 1:1');
+      }
+
+      _facades.set(actual, facade);
+      _actuals.set(facade, actual);
+    },
+  };
+
+  return { facades, actuals };
+};

package/lib/index.js

@@ -0,0 +1,258 @@
+import { getCooked } from '@bablr/agast-helpers/tree';
+
+export * from './builders.js';
+
+export const effectsFor = (verb) => {
+  switch (verb) {
+    case 'eat':
+    case 'holdFor':
+      return { success: 'eat', failure: 'fail' };
+
+    case 'eatMatch':
+    case 'holdForMatch':
+      return { success: 'eat', failure: 'none' };
+
+    case 'match':
+      return { success: 'none', failure: 'none' };
+
+    case 'guard':
+      return { success: 'none', failure: 'fail' };
+
+    default:
+      throw new Error('invalid match verb');
+  }
+};
+
+export const shouldBranch = (effects) => {
+  return effects ? effects.success === 'none' || effects.failure === 'none' : false;
+};
+
+const reifyFlags = (node) => {
+  let { triviaFlag, escapeFlag, tokenFlag, expressionFlag, intrinsicValue } = node.properties || {};
+
+  return {
+    token: !!tokenFlag,
+    escape: !!escapeFlag,
+    trivia: !!triviaFlag,
+    intrinsic: !!intrinsicValue,
+    expression: !!expressionFlag,
+  };
+};
+
+export const reifyLanguage = (language) => {
+  const value = reifyExpression(language);
+
+  if (typeof value === 'string' && !value.startsWith('https://')) {
+    throw new Error('bad language');
+  }
+
+  return value;
+};
+
+export const reifyExpression = (node) => {
+  if (node instanceof Promise) throw new Error();
+
+  if (!node) return null;
+
+  if (node.language === 'https://bablr.org/languages/core/cstml') {
+    switch (node.type) {
+      case 'DoctypeTag': {
+        let { doctype, version, attributes } = node.properties;
+        return {
+          type: 'DoctypeTag',
+          value: {
+            doctype: getCooked(doctype),
+            version: parseInt(getCooked(version), 10),
+            attributes: reifyAttributes(attributes),
+          },
+        };
+      }
+
+      case 'Reference': {
+        let { name, arrayOperator } = node.properties;
+
+        name = reifyExpression(name);
+
+        return { type: 'Reference', value: { name, isArray: !!arrayOperator } };
+      }
+
+      case 'Literal': {
+        let { value } = node.properties;
+
+        return { type: 'Literal', value: getCooked(value.properties.content) };
+      }
+
+      case 'OpenFragmentTag': {
+        return { type: 'OpenFragmentTag', value: undefined };
+      }
+
+      case 'CloseFragmentTag': {
+        return { type: 'CloseFragmentTag', value: {} };
+      }
+
+      case 'IdentifierPath': {
+        return node.properties.segments.map((segment) => reifyExpression(segment));
+      }
+
+      case 'OpenNodeTag': {
+        let { language, type, attributes, intrinsicValue } = node.properties;
+
+        let flags = reifyFlags(node);
+        language = reifyLanguage(language);
+        type = reifyExpression(type);
+        attributes = reifyAttributes(attributes);
+        intrinsicValue = reifyExpression(intrinsicValue);
+
+        return {
+          type: 'OpenNodeTag',
+          value: { flags, language, type, intrinsicValue, properties: {}, attributes },
+        };
+      }
+
+      case 'CloseNodeTag': {
+        let { language, type } = node.properties;
+
+        language = reifyLanguage(language);
+        type = reifyExpression(type);
+
+        return { type: 'CloseNodeTag', value: { language, type } };
+      }
+
+      case 'Integer': {
+        let { digits } = node.properties;
+        return parseInt(digits.map((digit) => getCooked(digit)).join(''), 10);
+      }
+
+      case 'Infinity': {
+        return node.properties.sign === '-' ? -Infinity : Infinity;
+      }
+
+      case 'String':
+        return node.properties.content ? getCooked(node.properties.content) : '';
+
+      case 'Gap':
+        return { type: 'Gap', value: undefined };
+
+      default:
+        throw new Error();
+    }
+  }
+
+  if (
+    ![
+      'https://bablr.org/languages/core/bablr-vm-instruction',
+      'https://bablr.org/languages/core/cstml',
+      'https://bablr.org/languages/core/spamex',
+    ].includes(node.language)
+  ) {
+    return node;
+  }
+
+  switch (node.type) {
+    case 'NodeMatcher':
+      let { language, type, attributes, intrinsicValue } = node.properties;
+
+      let flags = reifyFlags(node);
+      language = reifyExpression(language);
+      type = reifyExpression(type);
+      attributes = reifyAttributes(attributes);
+      intrinsicValue = reifyExpression(intrinsicValue);
+
+      return { flags, language, type, intrinsicValue, attributes };
+
+    case 'Call': {
+      const { verb, arguments: args } = node.properties;
+      return { verb: reifyExpression(verb), arguments: reifyExpression(args) };
+    }
+
+    case 'Object': {
+      const { properties } = node.properties;
+
+      return Object.fromEntries(
+        properties.map(({ properties: { key, value } }) => [
+          getCooked(key),
+          reifyExpression(value),
+        ]),
+      );
+    }
+
+    case 'Tuple': {
+      const { values = [] } = node.properties;
+
+      return [...values.map((el) => reifyExpression(el))];
+    }
+
+    case 'Array': {
+      const { elements } = node.properties;
+
+      return [...elements.map((el) => reifyExpression(el))];
+    }
+
+    case 'Literal':
+    case 'Identifier':
+      return getCooked(node);
+
+    case 'Boolean': {
+      // prettier-ignore
+      switch (getCooked(node.properties.value)) {
+        case 'true': return true;
+        case 'false': return false;
+        default: throw new Error();
+      }
+    }
+
+    case 'Null':
+      return null;
+
+    default:
+      throw new Error('bad expression');
+  }
+};
+
+export const reifyExpressionShallow = (node) => {
+  if (!node) return null;
+
+  if (
+    ![
+      'https://bablr.org/languages/core/bablr-vm-instruction',
+      'https://bablr.org/languages/core/cstml',
+    ].includes(node.language)
+  ) {
+    return node;
+  }
+
+  switch (node.type) {
+    case 'Object': {
+      const { properties } = node.properties;
+
+      return Object.fromEntries(
+        properties.map(({ properties: { key, value } }) => [getCooked(key), value]),
+      );
+    }
+
+    case 'Array':
+      return [...node.properties.elements];
+
+    case 'Tuple':
+      return [...node.properties.values];
+
+    default:
+      return reifyExpression(node);
+  }
+};
+
+export const reifyAttributes = (attributes) => {
+  if (attributes == null) return {};
+
+  return Object.fromEntries(
+    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), !attr.properties.negateSigil];
+      } else {
+        throw new Error();
+      }
+    }),
+  );
+};

package/lib/languages.js

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

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@bablr/agast-vm-helpers",
+  "description": "Helper functions for working with the BABLR VM",
+  "version": "0.1.0",
+  "author": "Conrad Buck<conartist6@gmail.com>",
+  "type": "module",
+  "files": [
+    "lib"
+  ],
+  "exports": {
+    ".": "./lib/index.js",
+    "./facades": "./lib/facades.js",
+    "./builders": "./lib/builders.js",
+    "./languages": "./lib/languages.js"
+  },
+  "sideEffects": false,
+  "dependencies": {
+    "@bablr/agast-helpers": "0.1.0"
+  },
+  "devDependencies": {
+    "@bablr/eslint-config-base": "github:bablr-lang/eslint-config-base#49f5952efed27f94ee9b94340eb1563c440bf64e",
+    "enhanced-resolve": "^5.12.0",
+    "eslint": "^8.32.0",
+    "eslint-import-resolver-enhanced-resolve": "^1.0.5",
+    "eslint-plugin-import": "^2.27.5",
+    "prettier": "^2.6.2"
+  },
+  "repository": "github:bablr-lang/agast-vm-helpers",
+  "homepage": "https://github.com/bablr-lang/agast-vm-helpers",
+  "license": "MIT"
+}