@bablr/agast-helpers 0.10.10 → 0.11.0

package/lib/builders.js

@@ -1,5 +1,8 @@
-import emptyStack from '@iter-tools/imm-stack';
-import { isObject, isSymbol } from './object.js';
+import * as BList from './b-list.js';
+import { hasOwn, isObject, isArray, isSymbol, isString, isFrozen, freezeRecord } from './object.js';
+import { buildParser, match } from './parse.js';
+import { printExpression, printTag } from './print.js';
+
 import {
   DoctypeTag,
   OpenNodeTag,
@@ -16,83 +19,78 @@ import {
   NullNode,
   GapNode,
   TreeNode,
+  StreamTag,
 } from './symbols.js';
 
-const { freeze, values } = Object;
-const { isArray } = Array;
-
-export const deepFreeze = (object) => {
-  let list = emptyStack.push(object);
-  while (list.size) {
-    let item = list.value;
-    list = list.pop();
+export const symbolName = (name) => {
+  return isString(name) ? Symbol.for(name) : name;
+};
 
-    for (const value of values(item)) {
-      if (isObject(value)) {
-        list = list.push(value);
-      }
-    }
+export const buildSpan = (name, guard = null, props = '{}') => {
+  if (!name) throw new Error();
+  if (!isString(props)) throw new Error();
 
-    freeze(item);
-  }
+  return freezeRecord({ name, guard, props });
 };
 
-export const buildSpan = (name, guard = null, props = {}) => {
-  if (!name) throw new Error();
-  deepFreeze(props);
-  return freeze({ name, guard, props });
+export const buildSpanEntry = (name, guard = null, props = '{}') => {
+  return freezeRecord([name, buildSpan(name, guard, props)]);
 };
 
 export const buildProperty = (tags, shift) => {
   if (shift && !shift.index) throw new Error();
-  freeze(tags);
-
-  if (tags[0] && ![ReferenceTag, ShiftTag].includes(tags[0].type)) throw new Error();
-  if (tags.length > 1 && !isArray(tags[1])) throw new Error();
+  let { 0: open, 1: bindings, 2: node } = tags[1];
 
-  freeze(tags[1]);
+  if (!BList.getType(tags) === Symbol.for('List')) throw new Error();
+  if (
+    !(
+      (isArray(open) && open[0] === 0) ||
+      (isString(open) && [ReferenceTag, ShiftTag].includes(parseTagType(open)))
+    )
+  )
+    throw new Error();
+  if (tags[1].length > 1 && !isArray(bindings)) throw new Error();
 
   // if (property.node && !(tags.length === 3)) throw new Error();
   // if (tags[0].type === ShiftTag && !property.shift) throw new Error();
 
-  if ((tags[0]?.type == ShiftTag) !== !!shift) throw new Error();
-  if (tags[2] && ![NullNode, GapNode, TreeNode].includes(tags[2].type)) throw new Error();
+  if (!isArray(open) && (parseTagType(open) === ShiftTag) !== !!shift) throw new Error();
+  if (node && ![NullNode, GapNode, TreeNode].includes(node.type)) throw new Error();
 
-  return freeze({
+  return freezeRecord({
     tags,
-    reference: tags[0]?.type === ShiftTag ? null : tags[0]?.value || buildReference(),
-    bindings: freeze(tags[1]?.map((tag) => tag.value) || []),
-    node: tags[2] || null,
-    shift: tags[0]?.type == ShiftTag ? shift : null,
+    reference: shift ? null : (!isArray(open) && parseTag(open).value) || buildReference(),
+    bindings: freezeRecord(
+      bindings ? [...BList.traverse(bindings)].map((tag) => parseTag(tag).value) : [],
+    ),
+    node: node || null,
+    shift: shift ? shift : null,
   });
 };
 
 export const buildPathFrame = (property, parentIndex = null, isGap = false) => {
-  return freeze({ property, parentIndex, isGap });
+  return freezeRecord({ property, parentIndex, isGap });
 };
 
 export const buildPropertyTag = (tags, shift) => {
-  return freeze({ type: Property, value: buildProperty(tags, shift) });
+  if (BList.getType(tags) !== Symbol.for('List')) throw new Error();
+  return buildTag(Property, buildProperty(tags, shift));
 };
 
 export const buildDocument = (doctypeTag, tree) => {
-  return freeze({ type: Document, value: freeze({ doctypeTag, tree }) });
+  return buildTag(Document, { doctypeTag, tree });
 };
 
 export const buildBeginningOfStreamToken = () => {
-  return freeze({ type: Symbol.for('@bablr/beginning-of-stream'), value: undefined });
+  return buildTag(Symbol.for('@bablr/beginning-of-stream'));
 };
 
 export const buildReferenceTag = (type = null, name = null, flags = referenceFlags) => {
-  if (!Object.isFrozen(flags)) throw new Error();
-
-  return freeze({
-    type: ReferenceTag,
-    value: buildReference(type, name, flags),
-  });
+  return buildTag(ReferenceTag, buildReference(type, name, flags));
 };
 
 export const buildReference = (type = null, name = null, flags = referenceFlags) => {
+  if (!Object.isFrozen(flags)) throw new Error();
   if (type != null && !['_', '.', '#', '@'].includes(type)) throw new Error();
   if (type && ['_', '#', '@'].includes(type) && (flags.intrinsic || flags.hasGap))
     throw new Error();
@@ -106,74 +104,78 @@ export const buildReference = (type = null, name = null, flags = referenceFlags)
 
   let type_ = type == null && name == null ? '.' : type;
 
-  return freeze({ type: type_, name, flags: freeze({ array, expression, intrinsic, hasGap }) });
+  return freezeRecord({
+    type: type_,
+    name,
+    flags: freezeRecord({ array, expression, intrinsic, hasGap }),
+  });
 };
 
 export const referenceFromMatcher = (matcher) => {
+  if (!matcher) return buildReference();
   let { type, name, flags } = matcher;
+
   return buildReference(type, name, flags);
 };
 
+export const buildBounds = (leading, trailing) => {
+  return freezeRecord({ leading, trailing });
+};
+
 export const buildShift = (index, height) => {
   if (index == null || height == null) throw new Error();
-  return freeze({ index, height });
+
+  return freezeRecord({ index, height });
 };
 
 export const buildNullTag = () => {
-  return freeze({ type: NullTag, value: undefined });
+  return buildTag(NullTag);
 };
 
-export const buildBinding = (segments = []) => {
-  // TODO relax this restriction
-  if (!isArray(segments) || !segments.length) throw new Error();
-  if (segments.includes(undefined)) throw new Error();
-  return freeze({
-    segments: segments.map((segment) =>
-      freeze(isString(segment) ? { type: null, name: segment } : segment),
-    ),
-  });
+export const buildBinding = (type, name) => {
+  if (type && (!isSymbol(type) || !['..', '_'].includes(type.desription))) throw new Error();
+  if (name && !isSymbol(name)) throw new Error();
+  if (type && name) throw new Error();
+
+  return freezeRecord({ type, name });
 };
 
-export const buildBindingTag = (segments = []) => {
-  return freeze({
-    type: BindingTag,
-    value: buildBinding(segments),
-  });
+export const buildBindingTag = (type, name) => {
+  return buildTag(BindingTag, buildBinding(type, name));
+};
+
+export const buildStreamTag = (processPath, stream) => {
+  if (stream && !(stream >= 1 && stream <= 4)) throw new Error();
+
+  return buildTag(StreamTag, { processPath, stream });
 };
 
 export const buildChild = (type, value) => {
   if (!isSymbol(type)) throw new Error();
-  return freeze({ type, value });
+  let child = buildTag(type, value);
+  if (!parseTag(child)) throw new Error();
+  return child;
 };
 
 export const buildGapTag = () => {
-  return freeze({ type: GapTag, value: undefined });
+  return buildTag(GapTag);
 };
 
 export const buildShiftTag = () => {
-  let value = Object.defineProperties(
-    {},
-    {
-      index: {
-        get() {
-          throw new Error('moved');
-        },
-      },
-      height: {
-        get() {
-          throw new Error('moved');
-        },
-      },
-    },
-  );
-  return freeze({ type: ShiftTag, value });
+  return buildTag(ShiftTag);
 };
 
-export const buildDoctypeTag = (version = 0, attributes = freeze({})) => {
-  return freeze({
-    type: DoctypeTag,
-    value: freeze({ doctype: 'cstml', version, attributes }),
-  });
+export const buildDoctype = (version = 0, attributes = '{}') => {
+  if (!isString(attributes)) throw new Error();
+  return freezeRecord({ doctype: 'cstml', version, attributes });
+};
+
+export const buildTag = (type, value) => {
+  return freezeRecord({ type, value });
+};
+
+export const buildDoctypeTag = (version = 0, attributes = '{}') => {
+  return buildTag(DoctypeTag, buildDoctype(version, attributes));
 };
 
 export const buildOpenFragmentTag = (flags = nodeFlags, selfClosing = false) => {
@@ -188,55 +190,67 @@ export const buildOpenNodeTag = (
   flags,
   name,
   literalValue = null,
-  attributes = {},
+  attributes = '{}',
   selfClosing = !!literalValue,
 ) => {
-  if (!name && !flags.token) throw new Error();
   return buildFullOpenNodeTag(flags, null, name, literalValue, attributes, selfClosing);
 };
 
-export const buildFullOpenNodeTag = (
+export const buildOpenNode = (
   flags = nodeFlags,
   type = Symbol.for('__'),
   name = null,
   literalValue = null,
-  attributes = {},
+  attributes = '{}',
   selfClosing = !!literalValue,
 ) => {
-  if (!isObject(attributes)) throw new Error();
+  if (!isString(attributes)) throw new Error();
   if (literalValue && !isString(literalValue)) throw new Error();
-  if (!type && !name && !flags.token && !literalValue) throw new Error();
-
-  deepFreeze(attributes);
-
-  return freeze({
-    type: OpenNodeTag,
-    value: freeze({
-      flags: freeze(flags),
-      name: isString(name) ? Symbol.for(name) : name,
-      type: isString(type) ? Symbol.for(type) : type,
-      literalValue,
-      attributes,
-      selfClosing,
-    }),
+  if (!type && !name && !flags.token && literalValue != null) throw new Error();
+  if (literalValue != null && !selfClosing) throw new Error();
+
+  return freezeRecord({
+    flags,
+    name: symbolName(name),
+    type: symbolName(type),
+    literalValue,
+    attributes,
+    selfClosing,
   });
 };
 
-export const buildCloseNodeTag = () => {
-  return freeze({ type: CloseNodeTag, value: undefined });
+export const buildFullOpenNodeTag = (
+  flags = nodeFlags,
+  type = Symbol.for('__'),
+  name = null,
+  literalValue = null,
+  attributes = '{}',
+  selfClosing = !!literalValue,
+) => {
+  if (!hasOwn(flags, 'token')) throw new Error();
+  return buildTag(
+    OpenNodeTag,
+    buildOpenNode(flags, type, name, literalValue, attributes, selfClosing),
+  );
 };
 
-const isString = (val) => typeof val === 'string';
+export const buildCloseNodeTag = () => {
+  return buildTag(CloseNodeTag);
+};
 
 export const buildLiteralTag = (value) => {
   if (!isString(value)) throw new Error('invalid literal');
-  return freeze({ type: LiteralTag, value });
+  return buildTag(LiteralTag, value);
 };
 
 export const buildAttributeDefinition = (key, value) => {
   if (!key?.length) throw new Error();
-  freeze(key);
-  return freeze({ type: AttributeDefinition, value: freeze({ path: key, value }) });
+
+  return freezeRecord({ path: key, value });
+};
+
+export const buildAttributeDefinitionTag = (key, value) => {
+  return buildTag(AttributeDefinition, buildAttributeDefinition(key, value));
 };
 
 const flagsWithGap = new WeakMap();
@@ -246,7 +260,7 @@ export const getFlagsWithGap = (flags, hasGap = true) => {
 
   let gapFlags = flagsWithGap.get(flags);
   if (!gapFlags) {
-    gapFlags = freeze({
+    gapFlags = freezeRecord({
       token: flags.token,
       hasGap,
     });
@@ -255,40 +269,828 @@ export const getFlagsWithGap = (flags, hasGap = true) => {
   return gapFlags;
 };
 
-export const nodeFlags = freeze({
+export const nodeFlags = freezeRecord({
   token: false,
   hasGap: false,
 });
 
-export const tokenFlags = freeze({
+export const tokenFlags = freezeRecord({
   token: true,
   hasGap: false,
 });
 
-export const referenceFlags = freeze({
+export const referenceFlags = freezeRecord({
   array: false,
   expression: false,
   intrinsic: false,
   hasGap: false,
 });
 
-export const intrinsicReferenceFlags = freeze({
+export const intrinsicReferenceFlags = freezeRecord({
   array: false,
   expression: false,
   intrinsic: true,
   hasGap: false,
 });
 
-export const gapReferenceFlags = freeze({
+export const gapReferenceFlags = freezeRecord({
   array: false,
   expression: false,
   intrinsic: false,
   hasGap: true,
 });
 
-export const expressionReferenceFlags = freeze({
+export const expressionReferenceFlags = freezeRecord({
   array: false,
   expression: true,
   intrinsic: false,
   hasGap: false,
 });
+
+export const canStartIdentifier = (chr) => {
+  let code = chr.charCodeAt(0);
+  return (
+    (code >= 97 && code <= 122) ||
+    (code >= 65 && code <= 90) ||
+    code === 96 ||
+    (code >= 0x80 && code <= 0x10ffff)
+  );
+};
+
+export const canContinueIdentifier = (chr) => {
+  if (canStartIdentifier(chr)) return true;
+  let code = chr.charCodeAt(0);
+
+  return code === 45 || code === 95 || (code >= 48 && code <= 57);
+};
+
+export const parseTagType = (input) => {
+  let p = buildTagParser(input);
+  let { str, idx } = p;
+  if (str == null) return null;
+  if (isObject(str)) return str.type;
+  if (!isString(str)) throw new Error();
+  if (!str.length) throw new Error();
+
+  switch (str[idx]) {
+    case 'n':
+      return str[idx + 1] === 'u' && str[idx + 2] === 'l' && str[idx + 3] === 'l'
+        ? NullTag
+        : ReferenceTag;
+    case '<':
+      if (str[idx + 1] === '-' && str[idx + 2] === '-' && str[idx + 3] === '-') {
+        throw new Error('reserved syntax');
+      }
+      return str[idx + 1] === '!'
+        ? DoctypeTag
+        : str[idx + 1] === '/'
+        ? str[idx + 2] === '/'
+          ? GapTag
+          : CloseNodeTag
+        : str[idx + 1] === '-'
+        ? StreamTag
+        : OpenNodeTag;
+    case '^':
+      return ShiftTag;
+    case ':':
+      return BindingTag;
+    case '.':
+    case '#':
+    case '@':
+    case '_':
+      return ReferenceTag;
+    case '"':
+    case "'":
+      return LiteralTag;
+    case '{':
+      return AttributeDefinition;
+    default:
+      if (canStartIdentifier(str[idx])) {
+        return ReferenceTag;
+      } else {
+        throw new Error();
+      }
+  }
+};
+
+export const parseObject = (input) => {
+  let p = buildParser(input);
+  let { str } = p;
+  if (!str.length) throw new Error();
+  let obj = {};
+  let chr = str[p.idx];
+
+  if (chr !== '{') throw new Error();
+  chr = str[++p.idx];
+
+  while (chr === ' ') {
+    chr = str[++p.idx];
+  }
+
+  let sep = true;
+  while (sep && chr !== '}') {
+    let key = `'"`.includes(chr) ? parseString(p) : parseIdentifier(p);
+    chr = str[p.idx];
+
+    if (chr !== ':') throw new Error();
+    chr = str[++p.idx];
+
+    while (chr === ' ') chr = str[++p.idx];
+
+    let value = parseExpression(p);
+    chr = str[p.idx];
+
+    obj[key] = value;
+
+    sep = chr === ',' ? chr : null;
+    if (sep) {
+      chr = str[++p.idx];
+    }
+
+    while (chr === ' ') chr = str[++p.idx];
+  }
+
+  if (chr !== '}') throw new Error();
+  chr = str[++p.idx];
+
+  return freezeRecord(obj);
+};
+
+export const parseArray = (input) => {
+  let p = buildParser(input);
+  let { str } = p;
+  let arr = [];
+  let chr = str[p.idx];
+
+  if (chr !== '[') throw new Error();
+  chr = str[++p.idx];
+
+  while (chr === ' ') {
+    chr = str[++p.idx];
+  }
+
+  let value = parseExpression(p);
+  chr = str[p.idx];
+
+  arr.push(value);
+
+  while (chr === ' ') {
+    chr = str[++p.idx];
+  }
+
+  if (chr !== ']') throw new Error();
+  chr = str[++p.idx];
+
+  return freezeRecord(arr);
+};
+
+export const parseString = (input) => {
+  let p = buildParser(input);
+  let { str } = p;
+  let chr = str[p.idx];
+  let q = chr;
+  let result = [];
+
+  if (!`'"`.includes(q)) throw new Error();
+  chr = str[++p.idx];
+
+  while (chr && chr !== q) {
+    if (chr === '\\') {
+      result.push(parseEscape(p));
+      chr = str[p.idx];
+    } else {
+      result.push(chr);
+      chr = str[++p.idx];
+    }
+  }
+
+  if (chr === q) {
+    chr = str[++p.idx];
+  } else {
+    throw new Error();
+  }
+
+  return result.join('');
+};
+
+export const parseUnsignedInteger = (input) => {
+  let p = buildParser(input);
+  let { str } = p;
+  let chr = str[p.idx];
+  let digits = [];
+
+  while (chr >= '0' && chr <= '9') {
+    digits.push(chr);
+    chr = str[++p.idx];
+  }
+
+  return parseInt(digits.join(''), 10);
+};
+
+export const parseEscape = (input) => {
+  let p = buildParser(input);
+  let { str } = p;
+  let chr = str[p.idx];
+
+  if (chr !== '\\') throw new Error();
+  chr = str[++p.idx];
+
+  switch (chr) {
+    case 'u': {
+      chr = str[++p.idx];
+
+      let digits = [];
+      let q = chr === '{' ? chr : null;
+      if (q) {
+        chr = str[++p.idx];
+      }
+
+      let i = 0;
+      while (q ? chr !== '}' : i < 4) {
+        if (
+          !((chr >= '0' && chr <= '9') || (chr >= 'a' && chr <= 'z') || (chr >= 'A' && chr <= 'Z'))
+        )
+          throw new Error();
+
+        digits.push(chr);
+        chr = str[++p.idx];
+        i++;
+      }
+
+      if (q) {
+        if (chr !== '}') throw new Error();
+        chr = str[++p.idx];
+      }
+      return String.fromCodePoint(parseInt(digits.join(''), 16));
+    }
+    case 'r':
+      chr = str[++p.idx];
+      return '\r';
+    case 'n':
+      chr = str[++p.idx];
+      return '\n';
+    case 't':
+      chr = str[++p.idx];
+      return '\t';
+    case '\\':
+    case '"':
+    case "'":
+    case '`':
+      ++p.idx;
+      return chr;
+  }
+};
+
+export const parseExpression = (input) => {
+  let p = buildParser(input);
+  let { str } = p;
+  let chr = str[p.idx];
+
+  switch (chr) {
+    case '{':
+      return parseObject(p);
+    case '[':
+      return parseArray(p);
+    case '"':
+    case "'":
+      return parseString(p);
+    case 'n':
+      if (match(p, 'null')) {
+        p.idx += 4;
+        return null;
+      } else {
+        throw new Error();
+      }
+    case 't':
+      if (match(p, 'true')) {
+        p.idx += 4;
+        return true;
+      } else {
+        throw new Error();
+      }
+    case 'f':
+      if (match(p, 'false')) {
+        p.idx += 5;
+        return false;
+      } else {
+        throw new Error();
+      }
+    case 'u':
+      if (match(p, 'undefined')) {
+        p.idx += 9;
+        return undefined;
+      } else {
+        throw new Error();
+      }
+    case 'N':
+      if (match(p, 'NaN')) {
+        p.idx += 3;
+        return NaN;
+      } else {
+        throw new Error();
+      }
+    case 'I':
+      if (match(p, 'Infinity')) {
+        p.idx += 8;
+        return Infinity;
+      } else {
+        throw new Error();
+      }
+    case '-':
+      if (str[p.idx + 1] === 'I' && match(p, '-Infinity')) {
+        p.idx += 9;
+        return -Infinity;
+      } else {
+        throw new Error();
+      }
+    case '+':
+      if (str[p.idx + 1] === 'I' && match(p, '+Infinity')) {
+        p.idx += 9;
+        return Infinity;
+      } else {
+        throw new Error();
+      }
+    default:
+      if (chr >= '0' && chr <= '9') {
+        return parseUnsignedInteger(p);
+      } else {
+        throw new Error();
+      }
+  }
+};
+
+export const parseIdentifier = (input) => {
+  let p = buildParser(input);
+  let { str } = p;
+  let chr = str[p.idx];
+  let value = [];
+
+  let q = chr === '`' ? chr : null;
+  if (q) {
+    chr = str[++p.idx];
+  }
+
+  let lit, esc;
+  do {
+    lit = null;
+    esc = null;
+    if (chr === '\\') {
+      esc = parseEscape(p);
+      chr = str[p.idx];
+    } else {
+      if (!q) {
+        if (!value.length) {
+          if (canStartIdentifier(chr)) {
+            lit = chr;
+            value.push(chr);
+            chr = str[++p.idx];
+          } else {
+            throw new Error();
+          }
+        }
+
+        while (chr && canContinueIdentifier(chr)) {
+          lit = chr;
+          value.push(chr);
+          chr = str[++p.idx];
+        }
+      } else {
+        while (!'`\\\r\n'.includes(chr)) {
+          lit = chr;
+          value.push(chr);
+          chr = str[++p.idx];
+        }
+      }
+    }
+  } while (lit || esc);
+
+  if (q) {
+    if (chr !== '`') throw new Error();
+    chr = str[++p.idx];
+  }
+  return value.join('');
+};
+
+let buildTagParser = (tag) => {
+  switch (typeof tag) {
+    case 'string':
+      return { idx: 0, str: tag };
+    case 'object':
+      if (tag.type) {
+        // TODO str is sometimes not a string!
+        return { idx: 0, str: typeof tag === 'string' ? tag : printTag(tag) };
+      } else {
+        return tag;
+      }
+  }
+};
+
+export const parseOpenNodeTag = (tag) => {
+  let p = buildTagParser(tag);
+  let { str } = p;
+  let chr = str[p.idx];
+
+  if (chr !== '<') throw new Error();
+  chr = str[++p.idx];
+  let token = false;
+  let hasGap = false;
+  if (chr === '*') {
+    chr = str[++p.idx];
+    token = true;
+  }
+  if (chr === '$') {
+    chr = str[++p.idx];
+    hasGap = true;
+  }
+
+  let flags = token ? tokenFlags : nodeFlags;
+
+  let type = null;
+  let name = null;
+
+  if (chr === '_') {
+    chr = str[++p.idx];
+    type = Symbol.for('_');
+
+    if (chr === '_') {
+      chr = str[++p.idx];
+      type = Symbol.for('__');
+    }
+  }
+  if (!` {'"/>`.includes(chr)) {
+    name = parseIdentifier(p);
+    chr = str[p.idx];
+  }
+
+  while (chr === ' ') {
+    chr = str[++p.idx];
+  }
+
+  let literalValue = null;
+
+  if (`'"`.includes(chr)) {
+    literalValue = parseString(p);
+    chr = str[p.idx];
+
+    while (chr === ' ') chr = str[++p.idx];
+  }
+
+  let attributes = freezeRecord({});
+
+  if (chr === '{') {
+    attributes = parseObject(p);
+    chr = str[p.idx];
+
+    while (chr === ' ') chr = str[++p.idx];
+  }
+
+  let selfClosing = false;
+
+  if (chr === '/') {
+    chr = str[++p.idx];
+    selfClosing = true;
+  }
+
+  if (chr === '>') {
+    chr = str[++p.idx];
+  }
+
+  if (isString(tag) && p.idx !== str.length) throw new Error();
+
+  if (hasGap) flags = getFlagsWithGap(flags);
+
+  return buildTag(OpenNodeTag, {
+    flags,
+    name: symbolName(name),
+    type: symbolName(type),
+    literalValue,
+    attributes: printExpression(attributes),
+    selfClosing,
+  });
+};
+
+export const parseReferenceFlags = (input) => {
+  let p = buildTagParser(input);
+  let { str } = p;
+  let chr = str[p.idx];
+  let array = false;
+  let expression = false;
+  let intrinsic = false;
+  let hasGap = false;
+
+  if (chr === '[') {
+    chr = str[++p.idx];
+    array = true;
+    if (chr !== ']') throw new Error();
+    chr = str[++p.idx];
+  }
+
+  if (chr === '+') {
+    chr = str[++p.idx];
+    expression = true;
+  }
+
+  if (chr === '*') {
+    chr = str[++p.idx];
+    intrinsic = true;
+  }
+
+  if (chr === '$') {
+    chr = str[++p.idx];
+    hasGap = true;
+  }
+
+  return freezeRecord({ array, expression, intrinsic, hasGap });
+};
+
+export const parseReferenceTag = (tag) => {
+  let p = buildTagParser(tag);
+  let { str } = p;
+  let chr = str[p.idx];
+  let type = null;
+  let name = null;
+
+  if ('.#@_'.includes(chr)) {
+    type = chr;
+    chr = str[++p.idx];
+  }
+
+  if (!type || (type === '#' && canStartIdentifier(chr))) {
+    name = parseIdentifier(p);
+    chr = str[p.idx];
+  }
+  while (chr === ' ') chr = str[++p.idx];
+
+  let flags = parseReferenceFlags(p);
+  chr = str[p.idx];
+
+  while (chr === ' ') chr = str[++p.idx];
+
+  if (chr !== ':') throw new Error();
+  chr = str[++p.idx];
+
+  if (isString(tag) && p.idx !== p.str.length) throw new Error();
+
+  return buildTag(ReferenceTag, { type, name, flags });
+};
+
+export const parseLiteralTag = (tag) => {
+  let p = buildTagParser(tag);
+
+  let str = parseString(p);
+
+  if (isString(tag) && p.idx !== p.str.length) throw new Error();
+
+  return buildLiteralTag(str);
+};
+
+export const parseCloseNodeTag = (tag) => {
+  let p = buildTagParser(tag);
+  if (!match(p, '</>')) throw new Error();
+  p.idx += 3;
+
+  if (isString(tag) && p.idx !== p.str.length) throw new Error();
+
+  return buildCloseNodeTag();
+};
+
+export const parseGapTag = (tag) => {
+  let p = buildTagParser(tag);
+  if (!match(p, '<//>')) throw new Error();
+  p.idx += 4;
+  if (isString(tag) && p.idx !== p.str.length) throw new Error();
+  return buildGapTag();
+};
+
+export const parseNullTag = (tag) => {
+  let p = buildTagParser(tag);
+  if (!match(p, 'null')) throw new Error();
+  p.idx += 4;
+  if (isString(tag) && p.idx !== p.str.length) throw new Error();
+  return buildNullTag();
+};
+
+export const parseShiftTag = (tag) => {
+  let p = buildTagParser(tag);
+  if (!match(p, '^^^')) throw new Error();
+  p.idx += 3;
+  if (isString(tag) && p.idx !== p.str.length) throw new Error();
+  return buildShiftTag();
+};
+
+export const parseIdentifierPath = (p) => {
+  let { str } = buildParser(p);
+  let chr = str[p.idx];
+  let segments = [];
+
+  let sep = true;
+  while (sep) {
+    segments.push(parseIdentifier(p));
+    chr = str[p.idx];
+
+    sep = chr === '.' ? chr : null;
+  }
+
+  return freezeRecord(segments);
+};
+
+export const parseAttributeDefinitionTag = (tag) => {
+  let p = buildTagParser(tag);
+  let { str } = p;
+  let chr = str[p.idx];
+
+  if (chr !== '{') throw new Error();
+  chr = str[++p.idx];
+
+  while (chr === ' ') {
+    chr = str[++p.idx];
+  }
+
+  let key = parseIdentifierPath(p);
+  chr = str[p.idx];
+
+  if (chr !== ':') throw new Error();
+  chr = str[++p.idx];
+
+  while (chr === ' ') {
+    chr = str[++p.idx];
+  }
+
+  let value = parseExpression(p);
+  chr = str[p.idx];
+
+  while (chr === ' ') {
+    chr = str[++p.idx];
+  }
+
+  if (chr !== '}') throw new Error();
+  chr = str[++p.idx];
+
+  if (isString(tag) && p.idx !== p.str.length) throw new Error();
+
+  return buildTag(AttributeDefinition, { path: key, value });
+};
+
+export const parseBindingTag = (tag) => {
+  let p = buildTagParser(tag);
+  let { str } = p;
+  let chr = str[p.idx];
+  let type = null;
+  let name = null;
+
+  if (chr !== ':') throw new Error();
+  chr = str[++p.idx];
+
+  if (chr === '.' && str[p.idx + 1] === '.') {
+    p.idx += 2;
+    type = Symbol.for('..');
+  } else {
+    name = Symbol.for(parseIdentifier(p));
+    chr = str[p.idx];
+  }
+
+  if (chr !== ':') throw new Error();
+  chr = str[++p.idx];
+
+  if (isString(tag) && p.idx !== p.str.length) throw new Error();
+
+  return buildBindingTag(type, name);
+};
+
+export const parseDoctypeTag = (tag) => {
+  let p = buildTagParser(tag);
+  let { str } = p;
+  let chr = str[p.idx];
+
+  if (chr !== '<' || str[p.idx + 1] !== '!') throw new Error();
+  p.idx += 2;
+
+  let version = parseUnsignedInteger(p);
+  chr = str[p.idx];
+
+  if (!match(p, ':cstml')) throw new Error();
+  p.idx += 6;
+  chr = str[p.idx];
+
+  while (chr === ' ') {
+    chr = str[++p.idx];
+  }
+
+  let attributes = {};
+  if (chr === '{') {
+    attributes = parseObject(p);
+    chr = str[p.idx];
+
+    while (chr === ' ') chr = str[++p.idx];
+  }
+
+  if (chr !== '>') throw new Error();
+  chr = str[++p.idx];
+
+  if (isString(tag) && p.idx !== p.str.length) throw new Error();
+
+  return buildDoctypeTag(version, printExpression(attributes));
+};
+
+export const parseStreamTag = (tag) => {
+  let p = buildTagParser(tag);
+  let { str } = p;
+  let chr = str[p.idx];
+
+  if (chr !== '<') throw new Error();
+  chr = str[++p.idx];
+
+  let processPath = [];
+  let stream = 1;
+
+  if (chr >= '0' && chr <= '9') {
+    do {
+      let digits = [];
+      while (chr >= '0' && chr <= '9') {
+        digits.push(chr);
+        chr = str[++p.idx];
+      }
+      processPath.push(parseInt(digits.join(''), 10));
+    } while (chr === '.');
+  }
+
+  if (chr === '-') {
+    chr = str[++p.idx];
+    if ('1234'.includes(chr)) {
+      stream = parseInt(chr, 10);
+      chr = str[++p.idx];
+    }
+  }
+
+  if (chr !== '>') throw new Error();
+  chr = str[++p.idx];
+
+  return buildStreamTag(processPath, stream);
+};
+
+export const parseTag = (tag) => {
+  let p = buildTagParser(tag);
+  if (tag == null) return null;
+
+  let tagType = parseTagType(p);
+
+  switch (tagType) {
+    case DoctypeTag:
+      return parseDoctypeTag(tag);
+    case AttributeDefinition:
+      return parseAttributeDefinitionTag(tag);
+    case OpenNodeTag:
+      return parseOpenNodeTag(tag);
+    case ReferenceTag:
+      return parseReferenceTag(tag);
+    case BindingTag:
+      return parseBindingTag(tag);
+    case LiteralTag:
+      return parseLiteralTag(tag);
+    case CloseNodeTag:
+      return parseCloseNodeTag(tag);
+    case StreamTag:
+      return parseStreamTag(tag);
+    case GapTag:
+      return parseGapTag(tag);
+    case NullTag:
+      return parseNullTag(tag);
+    case ShiftTag:
+      return parseShiftTag(tag);
+    case Property:
+      return tag;
+    case TreeNode:
+    case GapNode:
+    case NullNode:
+    default:
+      throw new Error();
+  }
+};
+
+export const isValidTag = (tag) => {
+  if (isString(tag)) return !!parseTag(tag);
+  if (!isFrozen(tag)) return false;
+  if (!hasOwn(tag, 'type') || !hasOwn(tag, 'value')) return false;
+
+  switch (tag.type) {
+    case ReferenceTag:
+    case OpenNodeTag:
+    case AttributeDefinition:
+    case CloseNodeTag:
+    case ShiftTag:
+    case NullTag:
+    case GapTag:
+    case LiteralTag:
+    case BindingTag:
+    case DoctypeTag:
+      return parseTag(tag);
+    case Property:
+    case TreeNode:
+    case GapNode:
+    case NullNode:
+      return false;
+
+    default:
+      throw new Error();
+  }
+};