@bablr/helpers 0.20.6 → 0.21.0

package/lib/decorators.js

@@ -14,8 +14,9 @@ export const AllowEmpty = (desc, context) => {
 };
 
 export const CoveredBy = (type) => {
-  if (!/^[a-zA-Z]+$/.test(printType(type))) throw new Error();
   return (desc, context) => {
+    if (!/^[a-zA-Z]+$/.test(printType(type))) throw new Error();
+
     context.addInitializer(function () {
       let covers = this.covers;
 

package/lib/enhancers.js

@@ -3,9 +3,7 @@ import {
   enhanceStrategyBuilderWithEmittedLogging as logEmitted,
 } from '@bablr/strategy_enhancer-debug-log';
 import { enhanceProductionWithDebugLogging as createProductionLogger } from '@bablr/language_enhancer-debug-log';
-import { getOwnPropertySymbols, getPrototypeOf } from './object.js';
-
-const { getOwnPropertyNames, hasOwn } = Object;
+import { mapProductions } from './grammar.js';
 
 export const memoize = (original) => {
   const cache = new WeakMap();
@@ -40,40 +38,10 @@ export const compose = (functions) => {
   return f;
 };
 
-export const mapProductions = (fn, Grammar) => {
-  let { prototype } = Grammar;
-
-  class MappedGrammar extends Grammar {}
-
-  const mapped = MappedGrammar.prototype;
-
-  while (prototype && prototype !== Object.prototype) {
-    for (const key of [...getOwnPropertyNames(prototype), ...getOwnPropertySymbols(prototype)]) {
-      if (!hasOwn(mapped, key)) {
-        mapped[key] = fn(prototype[key], key);
-      }
-    }
-    prototype = getPrototypeOf(prototype);
-  }
-
-  return MappedGrammar;
-};
-
-export function* generateProductions(Grammar) {
-  let { prototype } = Grammar;
-
-  while (prototype && prototype !== Object.prototype) {
-    for (const key of [...getOwnPropertyNames(prototype), ...getOwnPropertySymbols(prototype)]) {
-      let value = prototype[key];
-      if (key !== 'constructor') yield [key, value];
-    }
-    prototype = getPrototypeOf(prototype);
-  }
-}
-
 export const debugEnhancers = {
-  // agast: (strategy) => logEmitted(strategy, '<<< '),
-  createBablrStrategy: (strategy) => logStrategy(strategy, '    >>> '),
+  // bablr: (strategy) => logStrategy(strategy, '<<< '),
+  createBablrStrategy: (strategy) => (matcher, props) =>
+    logStrategy(strategy(matcher, props), '    >>> '),
   bablrProduction: createProductionLogger('>>> '),
 };
 

package/lib/grammar.js

@@ -1,15 +1,55 @@
 import every from 'iter-tools-es/methods/every';
 import isString from 'iter-tools-es/methods/is-string';
-import { getPrototypeOf, objectEntries } from './object.js';
-import { OpenNodeTag, CloseNodeTag } from './symbols.js';
+import { getOwnPropertySymbols, getPrototypeOf, objectEntries } from './object.js';
+import { OpenNodeTag, CloseNodeTag, NullTag } from './symbols.js';
+import { buildExpression } from './builders.js';
+import { buildEmbeddedObject } from '@bablr/agast-helpers/tree';
 
 export * from './decorators.js';
 
+const { getOwnPropertyNames, hasOwn } = Object;
+
 const { isArray } = Array;
 const isSymbol = (value) => typeof value === 'symbol';
 const isType = (value) => isString(value) || isSymbol(value);
 
+export const notNull = (facade) => {
+  return facade && (facade.type !== null || facade.openTag.type !== NullTag);
+};
+
+export const mapProductions = (fn, Grammar) => {
+  let { prototype } = Grammar;
+
+  class MappedGrammar extends Grammar {}
+
+  const mapped = MappedGrammar.prototype;
+
+  while (prototype && prototype !== Object.prototype) {
+    for (const key of [...getOwnPropertyNames(prototype), ...getOwnPropertySymbols(prototype)]) {
+      if (!hasOwn(mapped, key)) {
+        mapped[key] = fn(prototype[key], key);
+      }
+    }
+    prototype = getPrototypeOf(prototype);
+  }
+
+  return MappedGrammar;
+};
+
+export function* generateProductions(Grammar) {
+  let { prototype } = Grammar;
+
+  while (prototype && prototype !== Object.prototype) {
+    for (const key of [...getOwnPropertyNames(prototype), ...getOwnPropertySymbols(prototype)]) {
+      let value = prototype[key];
+      if (key !== 'constructor') yield [key, value];
+    }
+    prototype = getPrototypeOf(prototype);
+  }
+}
+
 export const resolveLanguage = (context, language, path) => {
+  const { languages } = context;
   if (isString(path)) {
     if (language.canonicalURL === path) {
       return language;
@@ -24,16 +64,18 @@ export const resolveLanguage = (context, language, path) => {
     throw new Error();
   }
 
+  let segments = isString(path) ? [path] : isArray(path) ? path : null;
+
   if (path == null) {
     return language;
-  } else if (isString(path)) {
-    l = l.dependencies[path];
-  } else if (isArray(path)) {
-    for (const segment of path) {
-      l = l.dependencies[segment];
-    }
   } else {
-    throw new Error();
+    for (const segment of segments) {
+      if (isString(l.dependencies[segment])) {
+        l = languages.get(l.dependencies[segment]);
+      } else {
+        l = l.dependencies[segment];
+      }
+    }
   }
 
   return l;
@@ -91,7 +133,11 @@ export const getProduction = (grammar, type) => {
 };
 
 const __buildDependentLanguages = (language, languages = new Map()) => {
+  languages.set(language.canonicalURL, language);
+
   for (const dependentLanguage of Object.values(language.dependencies || {})) {
+    if (isString(dependentLanguage)) continue;
+
     const { canonicalURL } = dependentLanguage;
     if (languages.has(canonicalURL) && dependentLanguage !== languages.get(canonicalURL)) {
       throw new Error();
@@ -101,15 +147,25 @@ const __buildDependentLanguages = (language, languages = new Map()) => {
       __buildDependentLanguages(dependentLanguage, languages);
     }
   }
-  languages.set(language.canonicalURL, language);
 
   return languages;
 };
 
-export const buildDependentLanguages = (language, transformLanguage = (l) => l) => {
+export const buildDependentLanguages = (language) => {
   return __buildDependentLanguages(language);
 };
 
+export const extendLanguage = (language, extension) => {
+  return {
+    ...language,
+    dependencies: extension.dependencies
+      ? { ...language.dependencies, ...extension.dependencies }
+      : language.dependencies,
+    canonicalURL: extension.canonicalURL || language.canonicalURL,
+    grammar: extension.grammar,
+  };
+};
+
 const arrayLast = (arr) => arr[arr.length - 1];
 
 export function* zipLanguages(tags, rootLanguage) {
@@ -139,3 +195,53 @@ export function* zipLanguages(tags, rootLanguage) {
     yield [tag, arrayLast(languages)];
   }
 }
+
+const safeShallowEmbed = (value) => {
+  if (typeof value !== 'object') {
+    return buildExpression(value);
+  } else {
+    return value;
+  }
+};
+
+const __buildCall = (verb, ...args) => {
+  while (args.length && args[args.length - 1] === undefined) {
+    args.pop();
+  }
+
+  return { verb, arguments: args };
+};
+
+export const eat = (matcher, value, options) => {
+  return __buildCall('eat', matcher, value, options);
+};
+
+export const eatMatch = (matcher, value, options) => {
+  return __buildCall('eatMatch', matcher, value, options);
+};
+
+export const match = (matcher, value, options) => {
+  return __buildCall('match', matcher, value, options);
+};
+
+export const guard = (matcher, value, options) => {
+  return __buildCall('guard', matcher, value, options);
+};
+
+export const holdForMatch = (matcher, value, options) => {
+  return __buildCall('holdForMatch', matcher, value, options);
+};
+
+export const fail = () => {
+  return __buildCall('fail');
+};
+
+export const bindAttribute = (key, value) => {
+  return __buildCall('bindAttribute', key, value);
+};
+
+export const write = (value) => {
+  return __buildCall('write', value);
+};
+
+export const o = buildEmbeddedObject;

package/lib/productions.js

@@ -1,127 +1,64 @@
 /* @macrome
  * @generatedby @bablr/macrome-generator-bablr
- * @generatedfrom ./productions.macro.js#ab30a55dff3676ff2418023be450dabe54386ee0
+ * @generatedfrom ./productions.macro.js#92256720d76d33560908ff2f462d2e33fc77b865
  * 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 { interpolateArray as _interpolateArray, interpolateFragmentChildren as _interpolateFragmentChildren, interpolateString as _interpolateString } from "@bablr/agast-helpers/template";
-import * as _l from "@bablr/agast-vm-helpers/languages";
-import * as _t from "@bablr/agast-helpers/shorthand";
+import { spam as m } from '@bablr/boot';
+import { buildEmbeddedMatcher, getCooked } from '@bablr/agast-helpers/tree';
+import { eat, eatMatch } from './grammar.js';
+import { EmbeddedMatcher } from './symbols.js';
+import { getEmbeddedMatcher, getEmbeddedObject } from '@bablr/agast-vm-helpers/deembed';
+import { buildPropertyMatcher } from './builders.js';
 export function* List({
-  value: props,
-  ctx
+  value: props
 }) {
   const {
     element,
     separator,
     allowHoles = false,
     allowTrailingSeparator = true
-  } = ctx.unbox(props);
-  yield _t.node(_l.Instruction, "Call", [_t.ref`verb`, _t.ref`arguments`], {
-    verb: _t.s_node(_l.Instruction, "Identifier", "eat"),
-    arguments: _t.node(_l.Instruction, "Tuple", [9, [[_t.ref`openToken`, _t.ref`values[]`, _t.arr(), _t.ref`values[]`], [_t.ref`separators[]`, _t.arr(), _t.ref`separators[]`, _t.ref`values[]`, _t.ref`closeToken`]]], {
-      openToken: _t.s_node(_l.Instruction, "Punctuator", "("),
-      values: [_t.node(_l.Instruction, "Array", [_t.ref`openToken`, _t.ref`closeToken`], {
-        openToken: _t.s_node(_l.Instruction, "Punctuator", "["),
-        closeToken: _t.s_node(_l.Instruction, "Punctuator", "]")
-      }, {}), _t.node(_l.CSTML, "String", [_t.ref`openToken`, _t.ref`content`, _t.ref`closeToken`], {
-        openToken: _t.s_node(_l.CSTML, "Punctuator", "'"),
-        content: _t.node(_l.CSTML, "Content", [_t.lit("separators[]")], {}, {}),
-        closeToken: _t.s_node(_l.CSTML, "Punctuator", "'")
-      }, {})],
-      separators: [_t.node(_l.Instruction, "Separator", [_t.embedded(_t.node(_l.Instruction, "Space", [_t.lit(" ")], {}, {}))], {}, {})],
-      closeToken: _t.s_node(_l.Instruction, "Punctuator", ")")
-    }, {})
-  }, {});
+  } = getEmbeddedObject(props);
+  if (!['#', '@'].includes(getCooked(getEmbeddedMatcher(separator).properties.refMatcher.node.properties.name.node))) {
+    yield eat(buildEmbeddedMatcher(buildPropertyMatcher(getEmbeddedMatcher(separator).properties.refMatcher.node, m.ArrayNodeMatcher`[]`)));
+  }
+  yield eat(buildEmbeddedMatcher(buildPropertyMatcher(getEmbeddedMatcher(element).properties.refMatcher.node, m.ArrayNodeMatcher`[]`)));
   let sep,
     it,
     anySep = false;
   for (;;) {
-    it = yield _t.node(_l.Instruction, "Call", [_t.ref`verb`, _t.ref`arguments`], {
-      verb: _t.s_node(_l.Instruction, "Identifier", "eatMatch"),
-      arguments: _t.node(_l.Instruction, "Tuple", [_t.ref`openToken`, _t.ref`values[]`, _t.arr(), ..._interpolateFragmentChildren(element, _t.ref`values[]`), _t.ref`closeToken`], {
-        openToken: _t.s_node(_l.Instruction, "Punctuator", "("),
-        values: [..._interpolateArray(element)],
-        closeToken: _t.s_node(_l.Instruction, "Punctuator", ")")
-      }, {})
-    }, {});
+    it = yield eatMatch(element);
     if (it || allowTrailingSeparator) {
-      sep = yield _t.node(_l.Instruction, "Call", [_t.ref`verb`, _t.ref`arguments`], {
-        verb: _t.s_node(_l.Instruction, "Identifier", "eatMatch"),
-        arguments: _t.node(_l.Instruction, "Tuple", [9, [[_t.ref`openToken`, _t.ref`values[]`, _t.arr(), ..._interpolateFragmentChildren(separator, _t.ref`values[]`)], [_t.ref`separators[]`, _t.arr(), _t.ref`separators[]`, _t.ref`values[]`, _t.ref`closeToken`]]], {
-          openToken: _t.s_node(_l.Instruction, "Punctuator", "("),
-          values: [..._interpolateArray(separator), _t.node(_l.CSTML, "String", [_t.ref`openToken`, _t.ref`content`, _t.ref`closeToken`], {
-            openToken: _t.s_node(_l.CSTML, "Punctuator", "'"),
-            content: _t.node(_l.CSTML, "Content", [_t.lit("separators[]")], {}, {}),
-            closeToken: _t.s_node(_l.CSTML, "Punctuator", "'")
-          }, {})],
-          separators: [_t.node(_l.Instruction, "Separator", [_t.embedded(_t.node(_l.Instruction, "Space", [_t.lit(" ")], {}, {}))], {}, {})],
-          closeToken: _t.s_node(_l.Instruction, "Punctuator", ")")
-        }, {})
-      }, {});
+      sep = yield eatMatch(separator);
       anySep ||= sep;
+    } else {
+      sep = null;
     }
     if (!(sep || allowHoles)) break;
   }
 }
 export function* Any({
-  value: matchers,
-  ctx
+  value: alternatives
 }) {
-  for (const matcher of ctx.unbox(matchers)) {
-    if (yield _t.node(_l.Instruction, "Call", [_t.ref`verb`, _t.ref`arguments`], {
-      verb: _t.s_node(_l.Instruction, "Identifier", "eatMatch"),
-      arguments: _t.node(_l.Instruction, "Tuple", [_t.ref`openToken`, _t.ref`values[]`, _t.arr(), ..._interpolateFragmentChildren(matcher, _t.ref`values[]`), _t.ref`closeToken`], {
-        openToken: _t.s_node(_l.Instruction, "Punctuator", "("),
-        values: [..._interpolateArray(matcher)],
-        closeToken: _t.s_node(_l.Instruction, "Punctuator", ")")
-      }, {})
-    }, {})) break;
+  for (const alternative of alternatives) {
+    if (alternative.type === EmbeddedMatcher) {
+      if (yield eatMatch(alternative)) break;
+    } else {
+      throw new Error();
+    }
   }
 }
 export function* All({
-  value: matchers,
-  ctx
+  value: matchers
 }) {
-  for (const matcher of ctx.unbox(matchers)) {
-    yield _t.node(_l.Instruction, "Call", [_t.ref`verb`, _t.ref`arguments`], {
-      verb: _t.s_node(_l.Instruction, "Identifier", "eat"),
-      arguments: _t.node(_l.Instruction, "Tuple", [_t.ref`openToken`, _t.ref`values[]`, _t.arr(), ..._interpolateFragmentChildren(matcher, _t.ref`values[]`), _t.ref`closeToken`], {
-        openToken: _t.s_node(_l.Instruction, "Punctuator", "("),
-        values: [..._interpolateArray(matcher)],
-        closeToken: _t.s_node(_l.Instruction, "Punctuator", ")")
-      }, {})
-    }, {});
+  for (const matcher of matchers) {
+    yield eat(m`.[]: ${getEmbeddedMatcher(matcher).properties.nodeMatcher.node}`);
   }
 }
 export function* Punctuator({
   intrinsicValue
 }) {
   if (!intrinsicValue) throw new Error('Intrinsic productions must have value');
-  yield _t.node(_l.Instruction, "Call", [_t.ref`verb`, _t.ref`arguments`], {
-    verb: _t.s_node(_l.Instruction, "Identifier", "eat"),
-    arguments: _t.node(_l.Instruction, "Tuple", [_t.ref`openToken`, _t.ref`values[]`, _t.arr(), ..._interpolateFragmentChildren(intrinsicValue, _t.ref`values[]`), _t.ref`closeToken`], {
-      openToken: _t.s_node(_l.Instruction, "Punctuator", "("),
-      values: [..._interpolateArray(intrinsicValue)],
-      closeToken: _t.s_node(_l.Instruction, "Punctuator", ")")
-    }, {})
-  }, {});
+  yield eat(intrinsicValue);
 }
-export const Keyword = Punctuator;
-export function* Optional({
-  value: matchers,
-  ctx
-}) {
-  const matchers_ = ctx.unbox(matchers);
-  if (matchers_.length > 1) {
-    throw new Error('Optional only allows one matcher');
-  }
-  yield _t.node(_l.Instruction, "Call", [_t.ref`verb`, _t.ref`arguments`], {
-    verb: _t.s_node(_l.Instruction, "Identifier", "eatMatch"),
-    arguments: _t.node(_l.Instruction, "Tuple", [_t.ref`openToken`, _t.ref`values[]`, _t.arr(), ..._interpolateFragmentChildren(matchers_[0], _t.ref`values[]`), _t.ref`closeToken`], {
-      openToken: _t.s_node(_l.Instruction, "Punctuator", "("),
-      values: [..._interpolateArray(matchers_[0])],
-      closeToken: _t.s_node(_l.Instruction, "Punctuator", ")")
-    }, {})
-  }, {});
-}
+export const Keyword = Punctuator;

package/lib/productions.macro.js

@@ -1,52 +1,77 @@
-import { i } from '@bablr/boot/shorthand.macro';
+import { spam as m } from '@bablr/boot';
+import { buildEmbeddedMatcher, getCooked } from '@bablr/agast-helpers/tree';
+import { eat, eatMatch } from './grammar.js';
+import { EmbeddedMatcher } from './symbols.js';
+import { getEmbeddedMatcher, getEmbeddedObject } from '@bablr/agast-vm-helpers/deembed';
+import { buildPropertyMatcher } from './builders.js';
 
-export function* List({ value: props, ctx }) {
+export function* List({ value: props }) {
   const {
     element,
     separator,
     allowHoles = false,
     allowTrailingSeparator = true,
-  } = ctx.unbox(props);
+  } = getEmbeddedObject(props);
 
-  yield i`eat([] 'separators[]')`;
+  if (
+    !['#', '@'].includes(
+      getCooked(getEmbeddedMatcher(separator).properties.refMatcher.node.properties.name.node),
+    )
+  ) {
+    yield eat(
+      buildEmbeddedMatcher(
+        buildPropertyMatcher(
+          getEmbeddedMatcher(separator).properties.refMatcher.node,
+          m.ArrayNodeMatcher`[]`,
+        ),
+      ),
+    );
+  }
+
+  yield eat(
+    buildEmbeddedMatcher(
+      buildPropertyMatcher(
+        getEmbeddedMatcher(element).properties.refMatcher.node,
+        m.ArrayNodeMatcher`[]`,
+      ),
+    ),
+  );
 
   let sep,
     it,
     anySep = false;
   for (;;) {
-    it = yield i`eatMatch(${element})`;
+    it = yield eatMatch(element);
     if (it || allowTrailingSeparator) {
-      sep = yield i`eatMatch(${separator} 'separators[]')`;
+      sep = yield eatMatch(separator);
       anySep ||= sep;
+    } else {
+      sep = null;
     }
     if (!(sep || allowHoles)) break;
   }
 }
 
-export function* Any({ value: matchers, ctx }) {
-  for (const matcher of ctx.unbox(matchers)) {
-    if (yield i`eatMatch(${matcher})`) break;
+export function* Any({ value: alternatives }) {
+  for (const alternative of alternatives) {
+    if (alternative.type === EmbeddedMatcher) {
+      if (yield eatMatch(alternative)) break;
+    } else {
+      throw new Error();
+    }
   }
 }
 
-export function* All({ value: matchers, ctx }) {
-  for (const matcher of ctx.unbox(matchers)) {
-    yield i`eat(${matcher})`;
+export function* All({ value: matchers }) {
+  for (const matcher of matchers) {
+    yield eat(m`.[]: ${getEmbeddedMatcher(matcher).properties.nodeMatcher.node}`);
   }
 }
 
 export function* Punctuator({ intrinsicValue }) {
   if (!intrinsicValue) throw new Error('Intrinsic productions must have value');
 
-  yield i`eat(${intrinsicValue})`;
+  yield eat(intrinsicValue);
 }
 
 export const Keyword = Punctuator;
-
-export function* Optional({ value: matchers, ctx }) {
-  const matchers_ = ctx.unbox(matchers);
-  if (matchers_.length > 1) {
-    throw new Error('Optional only allows one matcher');
-  }
-  yield i`eatMatch(${matchers_[0]})`;
-}

package/lib/shorthand.js

@@ -1,3 +1 @@
-import * as boot from '@bablr/boot';
-
-export const { i, re, spam } = boot;
+export { i, re, spam } from '@bablr/boot';

package/lib/source.js

@@ -92,8 +92,50 @@ function* __embeddedSourceFrom(iterable) {
 
 export const embeddedSourceFrom = (iterable) => new StreamIterable(__embeddedSourceFrom(iterable));
 
-function* __sourceFromTokenStream(Tags) {
-  let iter = getStreamIterator(Tags);
+function* __printEmbeddedSource(chrs) {
+  let iter = getStreamIterator(chrs);
+  let part = '';
+
+  let step;
+  for (;;) {
+    step = iter.next();
+
+    if (step instanceof Promise) {
+      step = yield step;
+    }
+
+    if (step.done) break;
+
+    const chr = step.value;
+
+    if (chr === null) {
+      if (part) {
+        yield `'`;
+        yield* part;
+        yield `'<//>`;
+
+        part = '';
+      }
+    } else if (chr === '\\' || chr === "'") {
+      part += `\\${chr}`;
+    } else {
+      part += chr;
+    }
+  }
+
+  if (part) {
+    yield `'`;
+    yield* part;
+    yield `'`;
+  }
+}
+
+export const printEmbeddedSource = (chrs) => {
+  return __printEmbeddedSource(chrs);
+};
+
+function* __sourceFromTokenStream(tags) {
+  let iter = getStreamIterator(tags);
   let step;
 
   for (;;) {
@@ -115,7 +157,7 @@ function* __sourceFromTokenStream(Tags) {
   }
 }
 
-export const sourceFromTokenStream = (Tags) => new StreamIterable(__sourceFromTokenStream(Tags));
+export const sourceFromTokenStream = (tags) => new StreamIterable(__sourceFromTokenStream(tags));
 
 function* __sourceFromQuasis(quasis) {
   let first = true;

package/lib/stream.js

@@ -1,7 +1,7 @@
 import { Coroutine } from '@bablr/coroutine';
 import {
-  generatePrettyCSTML as generatePrettyCSTMLStream,
-  generateCSTML as generateCSTMLStream,
+  generatePrettyCSTML as agastGeneratePrettyCSTML,
+  generateCSTML as agastGenerateCSTML,
   stringFromStream,
   getStreamIterator,
   StreamIterable,
@@ -14,7 +14,6 @@ import { unresolveLanguage } from './grammar.js';
 
 const { freeze } = Object;
 
-// bad: wrecks tree by breaking weak linkages
 function* __resolveTags(ctx, tags) {
   const co = new Coroutine(getStreamIterator(tags));
   let languages = emptyStack;
@@ -31,7 +30,7 @@ function* __resolveTags(ctx, tags) {
     const tag = co.value;
 
     if (tag.type === DoctypeTag) {
-      languages = languages.push(ctx.languages.get(tag.value.attributes['bablr-language']));
+      languages = languages.push(ctx.languages.get(tag.value.attributes.bablrLanguage));
     }
 
     if (tag.type === CloseNodeTag) {
@@ -69,20 +68,19 @@ export const resolveTags = (ctx, tags) => {
 export const generatePrettyCSTML = (tags, options = {}) => {
   const { ctx } = options;
 
-  return generatePrettyCSTMLStream(ctx ? resolveTags(ctx, tags) : tags, options);
+  return agastGeneratePrettyCSTML(ctx ? resolveTags(ctx, tags) : tags, options);
 };
 
 export const printPrettyCSTML = (tags, options = {}) => {
-  const { ctx } = options;
-  return stringFromStream(generatePrettyCSTMLStream(ctx ? resolveTags(ctx, tags) : tags, options));
+  return stringFromStream(generatePrettyCSTML(tags, options));
 };
 
 export const generateCSTML = (tags, options = {}) => {
   const { ctx } = options;
 
-  return generateCSTMLStream(ctx ? resolveTags(ctx, tags) : tags, options);
+  return agastGenerateCSTML(ctx ? resolveTags(ctx, tags) : tags, options);
 };
 
 export const printCSTML = (tags, options = {}) => {
-  return stringFromStream(generateCSTMLStream(tags, options));
+  return stringFromStream(generateCSTML(tags, options));
 };