@bablr/agast-vm-helpers 0.3.1 → 0.4.0

package/lib/builders.js

@@ -1,14 +1,11 @@
 // import { i } from '@bablr/boot/shorthand.macro';
-import {
-  interpolateArray,
-  interpolateArrayChildren,
-  interpolateString,
-} from '@bablr/agast-helpers/template';
+import { interpolateArrayChildren, interpolateString } from '@bablr/agast-helpers/template';
 import { isNull } from '@bablr/agast-helpers/tree';
+import { buildLiteralTag as agastBuildLiteralTag } from '@bablr/agast-helpers/builders';
 import * as t from '@bablr/agast-helpers/shorthand';
 import * as l from './languages.js';
 
-const { getPrototypeOf, freeze } = Object;
+const { getPrototypeOf } = Object;
 const { isArray } = Array;
 
 const when = (condition, value) => (condition ? value : { *[Symbol.iterator]() {} });
@@ -20,27 +17,26 @@ function* repeat(times, ...values) {
   for (let i = 0; i < times; i++) for (const value of values) yield value;
 }
 
-export const buildReference = (name, isArray) => {
+export const buildReferenceTag = (name, isArray) => {
   return t.node(
     l.CSTML,
-    'Reference',
+    'ReferenceTag',
     [t.ref`name`, ...when(isArray, [t.ref`arrayOperatorToken`]), t.ref`sigilToken`],
     {
       name: buildIdentifier(name),
-      arrayOperatorToken: isArray ? t.s_node(l.CSTML, 'Punctuator', '[]') : t.null_node(),
       sigilToken: t.s_node(l.CSTML, 'Punctuator', ':'),
     },
   );
 };
 
-export const buildGap = () => {
-  return t.node(l.CSTML, 'Gap', [t.ref`sigilToken`], {
+export const buildGapTag = () => {
+  return t.node(l.CSTML, 'GapTag', [t.ref`sigilToken`], {
     sigilToken: t.s_node(l.CSTML, 'Punctuator', '<//>'),
   });
 };
 
-export const buildShift = () => {
-  return t.node(l.CSTML, 'Shift', [t.ref`sigilToken`], {
+export const buildShiftTag = () => {
+  return t.node(l.CSTML, 'ShiftTag', [t.ref`sigilToken`], {
     sigilToken: t.s_node(l.CSTML, 'Punctuator', '^^^'),
   });
 };
@@ -52,22 +48,24 @@ export const buildFlags = (flags = {}) => {
     throw new Error('invalid flags');
   }
 
-  return {
-    children: [
+  return t.node(
+    l.CSTML,
+    'Flags',
+    [
       ...when(trivia, [t.ref`triviaToken`]),
       ...when(intrinsic, [t.ref`intrinsicToken`]),
       ...when(token, [t.ref`tokenToken`]),
       ...when(escape, [t.ref`escapeToken`]),
       ...when(expression, [t.ref`expressionToken`]),
     ],
-    properties: {
+    {
       triviaToken: trivia ? t.s_node(l.CSTML, 'Punctuator', '#') : t.null_node(),
       intrinsicToken: intrinsic ? t.s_node(l.CSTML, 'Punctuator', '~') : t.null_node(),
       tokenToken: token ? t.s_node(l.CSTML, 'Punctuator', '*') : t.null_node(),
       escapeToken: escape ? t.s_node(l.CSTML, 'Punctuator', '@') : t.null_node(),
       expressionToken: expression ? t.s_node(l.CSTML, 'Punctuator', '+') : t.null_node(),
     },
-  };
+  );
 };
 
 export const buildSpamMatcher = (type = null, value = null, attributes = {}) => {
@@ -93,30 +91,37 @@ export const buildFullyQualifiedSpamMatcher = (
     language_ = lArr.length === 0 ? null : lArr;
   }
 
-  return t.node(
-    l.Spamex,
-    'NodeMatcher',
-    [
-      t.ref`openToken`,
-      t.ref`flags`,
-      ...when(language_, [t.ref`language`, t.ref`languageSeparator`]),
-      ...when(type, [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`closeToken`,
-    ],
-    {
-      openToken: t.s_node(l.CSTML, 'Punctuator', '<'),
-      flags: buildFlags(flags),
-      language: language_ ? buildLanguage(language_) : t.null_node(),
-      languageSeparator: language_ && type ? t.s_node(l.CSTML, 'Punctuator', ':') : t.null_node(),
-      type: type ? buildIdentifier(type) : t.null_node(),
-      intrinsicValue: intrinsicValue ? buildString(intrinsicValue) : t.null_node(),
-      attributes: attributes_,
-      closeToken: t.s_node(l.CSTML, 'Punctuator', '>'),
-    },
-  );
+  return t.node(l.Spamex, 'NodeMatcher', [t.ref`open`], {
+    open: t.node(
+      l.Spamex,
+      'NodeMatcher',
+      [
+        t.ref`openToken`,
+        t.ref`flags`,
+        ...when(language_, [t.ref`language`, t.ref`languageSeparator`]),
+        ...when(type, [t.ref`type`]),
+        ...when(intrinsicValue, [t.embedded(buildSpace()), t.ref`intrinsicValue`]),
+        ...when(attributes_.length, [t.embedded(buildSpace())]),
+        t.ref`attributes[]`,
+        t.arr(),
+        ...interpolateArrayChildren(attributes_, t.ref`attributes[]`, t.embedded(buildSpace())),
+        ...when(!type, [t.embedded(buildSpace())]),
+        t.ref`selfClosingTagToken`,
+        t.ref`closeToken`,
+      ],
+      {
+        openToken: t.s_node(l.CSTML, 'Punctuator', '<'),
+        flags: buildFlags(flags),
+        language: language_ ? buildLanguage(language_) : t.null_node(),
+        languageSeparator: language_ && type ? t.s_node(l.CSTML, 'Punctuator', ':') : t.null_node(),
+        type: type ? buildIdentifier(type) : t.null_node(),
+        intrinsicValue: intrinsicValue ? buildString(intrinsicValue) : t.null_node(),
+        attributes: attributes_,
+        selfClosingTagToken: t.s_node(l.CSTML, 'Punctuator', '/'),
+        closeToken: t.s_node(l.CSTML, 'Punctuator', '>'),
+      },
+    ),
+  });
 };
 
 export const buildNodeOpenTag = (flags, language, type = null, attributes = {}) => {
@@ -133,6 +138,8 @@ export const buildNodeOpenTag = (flags, language, type = null, attributes = {})
       ...when(language_, [t.ref`language`, t.ref`languageSeparator`]),
       ...when(type, [t.ref`type`]),
       ...when(attributes_.length, [t.embedded(buildSpace())]),
+      t.ref`attributes[]`,
+      t.arr(),
       ...interpolateArrayChildren(attributes_, t.ref`attributes[]`, t.embedded(buildSpace())),
       t.ref`closeToken`,
     ],
@@ -160,6 +167,8 @@ export const buildDoctypeTag = (attributes) => {
       t.ref`versionSeparator`,
       t.ref`doctype`,
       ...when(attributes_.length, [t.embedded(buildSpace())]),
+      t.ref`attributes[]`,
+      t.arr(),
       ...interpolateArrayChildren(attributes_, t.ref`attributes[]`, t.embedded(buildSpace())),
       t.ref`closeToken`,
     ],
@@ -186,7 +195,11 @@ export const buildIdentifierPath = (path) => {
   return t.node(
     l.CSTML,
     'IdentifierPath',
-    [...repeat(segments.length, t.ref`segments[]`, t.ref`separators[]`)].slice(0, -1),
+    [
+      t.ref`segments[]`,
+      t.arr(),
+      ...repeat(segments.length, t.ref`segments[]`, t.ref`separators`),
+    ].slice(0, -1),
     {
       segments,
       separators,
@@ -221,8 +234,8 @@ export const buildNodeCloseTag = (type, language) => {
   );
 };
 
-export const buildLiteral = (value) => {
-  return t.node(l.CSTML, 'Literal', [t.ref`value`], { value });
+export const buildLiteralTag = (value) => {
+  return t.node(l.CSTML, 'LiteralTag', [t.ref`value`], { value });
 };
 
 export const buildTerminalProps = (matcher) => {
@@ -280,8 +293,10 @@ export const buildInteger = (value, base = 10) => {
   return t.node(
     l.CSTML,
     'Integer',
-    digits.map((d) => t.ref`digits[]`),
-    { digits: digits.map((digit) => buildDigit(digit)) },
+    [t.ref`digits[]`, t.arr(), ...digits.map((d) => t.ref`digits[]`)],
+    {
+      digits: digits.map((digit) => buildDigit(digit)),
+    },
   );
 };
 
@@ -309,22 +324,15 @@ export const buildNumber = (value) => {
   }
 };
 
-const buildLiteralTerminal = (lit) => freeze({ type: 'Literal', value: lit });
-
 export const buildString = (value) => {
   const pieces = isArray(value) ? value : [value];
-  const terminals = [];
+  const tags = [];
   let lit = '';
 
   if (pieces.length === 1 && pieces[0] === "'") {
     return t.node(l.CSTML, 'String', [t.ref`openToken`, t.ref`content`, t.ref`closeToken`], {
       openToken: t.s_node(l.CSTML, 'Punctuator', '"'),
-      content: interpolateString(
-        freeze({
-          type: 'Literal',
-          value,
-        }),
-      ),
+      content: interpolateString(agastBuildLiteralTag(value)),
       closeToken: t.s_node(l.CSTML, 'Punctuator', '"'),
     });
   }
@@ -344,7 +352,7 @@ export const buildString = (value) => {
           chr.charCodeAt(0) < 32
         ) {
           if (lit) {
-            terminals.push(buildLiteralTerminal(lit));
+            tags.push(agastBuildLiteralTag(lit));
             lit = '';
           }
 
@@ -360,7 +368,12 @@ export const buildString = (value) => {
             value = t.node(
               l.CSTML,
               'EscapeCode',
-              [t.ref`sigilToken`, ...[...hexDigits].map((d) => t.ref`digits[]`)],
+              [
+                t.ref`sigilToken`,
+                t.ref`digits[]`,
+                t.arr(),
+                ...[...hexDigits].map((d) => t.ref`digits[]`),
+              ],
               {
                 sigilToken: buildKeyword('u'),
                 digits: [...hexDigits].map((digit) => buildDigit(digit)),
@@ -370,7 +383,7 @@ export const buildString = (value) => {
             value = buildKeyword(chr);
           }
 
-          terminals.push(
+          tags.push(
             t.buildEmbeddedNode(
               t.e_node(
                 l.CSTML,
@@ -389,25 +402,25 @@ export const buildString = (value) => {
         }
       }
     } else {
-      terminals.push(buildLiteralTerminal(lit));
+      tags.push(agastBuildLiteralTag(lit));
       lit = '';
 
       if (piece == null) {
         throw new Error('not implemented');
       } else if (isString(piece.type)) {
-        terminals.push(piece);
+        tags.push(piece);
       } else {
         throw new Error();
       }
     }
   }
 
-  if (lit) terminals.push(buildLiteralTerminal(lit));
+  if (lit) tags.push(agastBuildLiteralTag(lit));
   lit = '';
 
   return t.node(l.CSTML, 'String', [t.ref`openToken`, t.ref`content`, t.ref`closeToken`], {
     openToken: t.s_node(l.CSTML, 'Punctuator', "'"),
-    content: interpolateString(terminals),
+    content: interpolateString(tags),
     closeToken: t.s_node(l.CSTML, 'Punctuator', "'"),
   });
 };
@@ -418,7 +431,7 @@ export const buildBoolean = (value) => {
   });
 };
 
-export const buildNull = () => {
+export const buildNullTag = () => {
   return t.node(l.Instruction, 'Null', [t.ref`sigilToken`], {
     sigilToken: t.s_node(l.Instruction, 'Keyword', 'null'),
   });
@@ -430,6 +443,8 @@ export const buildArray = (elements) => {
     'Array',
     [
       t.ref`openToken`,
+      t.ref`elements[]`,
+      t.arr(),
       ...interpolateArrayChildren(
         elements,
         t.ref`elements[]`,
@@ -441,7 +456,7 @@ export const buildArray = (elements) => {
     ],
     {
       openToken: t.s_node(l.Instruction, 'Punctuator', '['),
-      elements: [...interpolateArray(elements)],
+      elements,
       closeToken: t.s_node(l.Instruction, 'Punctuator', ']'),
     },
   );
@@ -453,6 +468,8 @@ export const buildTuple = (values) => {
     'Tuple',
     [
       t.ref`openToken`,
+      t.ref`values[]`,
+      t.arr(),
       ...interpolateArrayChildren(
         values,
         t.ref`values[]`,
@@ -464,7 +481,7 @@ export const buildTuple = (values) => {
     ],
     {
       openToken: t.s_node(l.Instruction, 'Punctuator', '('),
-      values: [...interpolateArray(values)],
+      values,
       closeToken: t.s_node(l.Instruction, 'Punctuator', ')'),
     },
   );
@@ -476,6 +493,8 @@ export const buildObject = (properties) => {
     'Object',
     [
       t.ref`openToken`,
+      t.ref`properties[]`,
+      t.arr(),
       ...interpolateArrayChildren(
         Object.entries(properties).map(([key, value]) => buildProperty(key, value)),
         t.ref`properties[]`,
@@ -487,11 +506,7 @@ export const buildObject = (properties) => {
     ],
     {
       openToken: t.s_node(l.Instruction, 'Punctuator', '{'),
-      properties: [
-        ...interpolateArray(
-          Object.entries(properties).map(([key, value]) => buildProperty(key, value)),
-        ),
-      ],
+      properties: Object.entries(properties).map(([key, value]) => buildProperty(key, value)),
       closeToken: t.s_node(l.Instruction, 'Punctuator', '}'),
     },
     {},
@@ -518,7 +533,7 @@ export const buildAttribute = (key, value) => {
 };
 
 export const buildExpression = (expr) => {
-  if (isNull(expr)) return buildNull();
+  if (isNull(expr)) return buildNullTag();
 
   switch (typeof expr) {
     case 'boolean':
@@ -565,6 +580,8 @@ export const buildNodeMatcher = (flags, language, type, attributes = {}) => {
       ...when(language_, [t.ref`language`, t.ref`languageSeparator`]),
       t.ref`type`,
       ...when(attributes_.length, [t.embedded(buildSpace())]),
+      t.ref`attributes[]`,
+      t.arr(),
       ...interpolateArrayChildren(attributes_, t.ref`attributes[]`, t.embedded(buildSpace())),
       t.ref`closeToken`,
     ],

package/lib/deembed.js

@@ -1,3 +1,5 @@
+import { EmbeddedExpression } from '@bablr/agast-helpers/symbols';
+
 const { isArray } = Array;
 const isString = (val) => typeof val === 'string';
 const isNumber = (val) => typeof val === 'number';
@@ -18,6 +20,6 @@ export const deembedExpression = (expr) => {
 
 export const getEmbeddedExpression = (expr) => {
   if (!expr) return expr;
-  if (expr.type !== 'EmbeddedExpression') throw new Error();
+  if (expr.type !== EmbeddedExpression) throw new Error();
   return expr.value;
 };

package/lib/index.js

@@ -1,5 +1,18 @@
-import { getCooked, isNull } from '@bablr/agast-helpers/tree';
+import { sourceTextFor, getCooked, isNull, nodeFlags } from '@bablr/agast-helpers/tree';
+import * as btree from '@bablr/agast-helpers/btree';
 import * as sym from '@bablr/agast-helpers/symbols';
+import { buildNodeCloseTag, buildLiteralTag } from '@bablr/agast-helpers/builders';
+import {
+  DoctypeTag,
+  OpenNodeTag,
+  CloseNodeTag,
+  ReferenceTag,
+  ShiftTag,
+  GapTag,
+  NullTag,
+  ArrayTag,
+  LiteralTag,
+} from '@bablr/agast-helpers/symbols';
 
 export * from './builders.js';
 
@@ -32,11 +45,11 @@ const reifyFlags = (flags) => {
   let { triviaToken, escapeToken, tokenToken, expressionToken, intrinsicToken } = flags.properties;
 
   return {
-    token: reifyExpression(tokenToken),
-    escape: reifyExpression(escapeToken),
-    trivia: reifyExpression(triviaToken),
-    intrinsic: reifyExpression(intrinsicToken),
-    expression: reifyExpression(expressionToken),
+    token: !!reifyExpression(tokenToken),
+    escape: !!reifyExpression(escapeToken),
+    trivia: !!reifyExpression(triviaToken),
+    intrinsic: !!reifyExpression(intrinsicToken),
+    expression: !!reifyExpression(expressionToken),
   };
 };
 
@@ -46,6 +59,63 @@ export const reifyLanguage = (language) => {
   return typeof value === 'string' && !value.startsWith('https://') ? [value] : value;
 };
 
+export const reifyProperties = (properties = []) => {
+  const built = {};
+  for (const property of btree.traverse(properties)) {
+    switch (property.type) {
+      case 'Property': {
+        let { reference, value } = property.properties;
+
+        reference = reifyExpression(reference);
+        value = reifyExpression(value);
+
+        if (reference.value.isArray) {
+          built[reference.value.name] ||= [];
+          built[reference.value.name].push(value);
+        } else {
+          built[reference.value.name] = value;
+        }
+        break;
+      }
+      default:
+        throw new Error();
+    }
+  }
+  return built;
+};
+
+export const buildChildren = (node) => {
+  let { open, children = [], close } = node.properties;
+
+  const selfClosing = !!open.properties.selfClosingTagToken;
+  const { intrinsicValue } = open.properties;
+  const built = [];
+
+  open = reifyExpression(open);
+  close = reifyExpression(close);
+
+  if (selfClosing) {
+    built.push(open);
+    if (intrinsicValue) built.push(buildLiteralTag(intrinsicValue));
+    built.push(buildNodeCloseTag());
+  } else {
+    built.push(open);
+    for (const child of btree.traverse(children)) {
+      if (child.type !== 'Property') throw new Error('umimplemented');
+
+      let { reference } = child.properties;
+
+      reference = reifyExpression(reference);
+
+      built.push(reference);
+    }
+
+    built.push(close);
+  }
+
+  return built;
+};
+
 export const reifyExpression = (node) => {
   if (node instanceof Promise) throw new Error();
 
@@ -53,32 +123,72 @@ export const reifyExpression = (node) => {
 
   if (node.language === 'https://bablr.org/languages/core/en/cstml') {
     switch (node.type) {
+      case 'Document': {
+        let { doctype, tree } = node.properties;
+
+        doctype = reifyExpression(doctype);
+        tree = reifyExpression(tree);
+
+        let { attributes } = doctype.value;
+        let { children, properties } = tree;
+
+        return {
+          flags: nodeFlags,
+          language: attributes['bablr-language'],
+          type: sym.fragment,
+          children,
+          properties,
+          attributes,
+        };
+      }
+
+      case 'Node': {
+        let { open, children } = node.properties;
+
+        open = reifyExpression(open);
+
+        let { flags, language, type, attributes } = open.value;
+
+        const properties = reifyProperties(children);
+
+        return {
+          flags,
+          language,
+          type,
+          children: buildChildren(node),
+          properties,
+          attributes,
+        };
+      }
+
       case 'DoctypeTag': {
         let { doctype, version, attributes } = node.properties;
         return {
-          type: 'DoctypeTag',
+          type: DoctypeTag,
           value: {
             doctype: getCooked(doctype),
-            version: parseInt(getCooked(version), 10),
+            version: parseInt(sourceTextFor(version), 10),
             attributes: reifyAttributes(attributes),
           },
         };
       }
 
-      case 'Reference': {
+      case 'ReferenceTag': {
         let { name, arrayOperatorToken } = node.properties;
 
         name = reifyExpression(name);
 
-        return { type: 'Reference', value: { name, isArray: !isNull(arrayOperatorToken) } };
+        return { type: ReferenceTag, value: { name, isArray: !isNull(arrayOperatorToken) } };
       }
 
-      case 'Literal': {
+      case 'LiteralTag': {
         let { value } = node.properties;
 
-        return { type: 'Literal', value: getCooked(value.properties.content) };
+        return { type: LiteralTag, value: getCooked(value.properties.content) };
+      }
+      case 'Identifier': {
+        return getCooked(node);
       }
-
       case 'IdentifierPath': {
         return node.properties.segments.map((segment) => reifyExpression(segment));
       }
@@ -92,7 +202,7 @@ export const reifyExpression = (node) => {
         attributes = reifyAttributes(attributes);
 
         return {
-          type: 'OpenNodeTag',
+          type: OpenNodeTag,
           value: { flags, language, type, attributes },
         };
       }
@@ -103,7 +213,7 @@ export const reifyExpression = (node) => {
         language = reifyLanguage(language);
         type = reifyExpression(type);
 
-        return { type: 'CloseNodeTag', value: { language, type } };
+        return { type: CloseNodeTag, value: { language, type } };
       }
 
       case 'Integer': {
@@ -122,11 +232,17 @@ export const reifyExpression = (node) => {
       case 'String':
         return node.properties.content ? getCooked(node.properties.content) : '';
 
-      case 'Gap':
-        return { type: 'Gap', value: undefined };
+      case 'GapTag':
+        return { type: GapTag, value: undefined };
+
+      case 'ArrayTag':
+        return { type: ArrayTag, value: undefined };
+
+      case 'NullTag':
+        return { type: NullTag, value: undefined };
 
-      case 'Shift':
-        return { type: 'Shift', value: undefined };
+      case 'ShiftTag':
+        return { type: ShiftTag, value: undefined };
 
       default:
         throw new Error();
@@ -145,7 +261,7 @@ export const reifyExpression = (node) => {
 
   switch (node.type) {
     case 'NodeMatcher':
-      let { flags, language, type, attributes, intrinsicValue } = node.properties;
+      let { flags, language, type, attributes, intrinsicValue } = node.properties.open.properties;
 
       flags = reifyFlags(flags);
       language = reifyLanguage(language);
@@ -164,7 +280,7 @@ export const reifyExpression = (node) => {
       const { properties } = node.properties;
 
       return Object.fromEntries(
-        properties.map(({ properties: { key, value } }) => [
+        [...btree.traverse(properties)].map(({ properties: { key, value } }) => [
           getCooked(key),
           reifyExpression(value),
         ]),
@@ -174,16 +290,16 @@ export const reifyExpression = (node) => {
     case 'Tuple': {
       const { values = [] } = node.properties;
 
-      return [...values.map((el) => reifyExpression(el))];
+      return [...btree.traverse(values)].map((el) => reifyExpression(el));
     }
 
     case 'Array': {
-      const { elements } = node.properties;
+      const { elements = [] } = node.properties;
 
-      return [...elements.map((el) => reifyExpression(el))];
+      return [...btree.traverse(elements)].map((el) => reifyExpression(el));
     }
 
-    case 'Literal':
+    case 'LiteralTag':
     case 'Identifier':
       return getCooked(node);
 
@@ -221,15 +337,18 @@ export const reifyExpressionShallow = (node) => {
       const { properties } = node.properties;
 
       return Object.fromEntries(
-        properties.map(({ properties: { key, value } }) => [getCooked(key), value]),
+        [...btree.traverse(properties)].map(({ properties: { key, value } }) => [
+          getCooked(key),
+          value,
+        ]),
       );
     }
 
     case 'Array':
-      return [...node.properties.elements];
+      return [...btree.traverse(node.properties.elements)];
 
     case 'Tuple':
-      return [...node.properties.values];
+      return [...btree.traverse(node.properties.values)];
 
     default:
       return reifyExpression(node);
@@ -240,7 +359,7 @@ export const reifyAttributes = (attributes) => {
   if (attributes == null) return {};
 
   return Object.fromEntries(
-    attributes.map((attr) => {
+    [...btree.traverse(attributes)].map((attr) => {
       if (attr.type === 'MappingAttribute') {
         return [reifyExpression(attr.properties.key), reifyExpression(attr.properties.value)];
       } else if (attr.type === 'BooleanAttribute') {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bablr/agast-vm-helpers",
   "description": "Helper functions for working with the BABLR VM",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -18,7 +18,7 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@bablr/agast-helpers": "0.3.0"
+    "@bablr/agast-helpers": "0.4.0"
   },
   "devDependencies": {
     "@bablr/eslint-config-base": "github:bablr-lang/eslint-config-base#49f5952efed27f94ee9b94340eb1563c440bf64e",