securemark 0.295.0 → 0.295.2

package/src/parser/header.ts

@@ -1,5 +1,5 @@
 import { MarkdownParser } from '../../markdown';
-import { List, Data } from '../combinator/data/parser';
+import { List, Node } from '../combinator/data/parser';
 import { union, inits, some, block, line, validate, focus, clear, convert, lazy, fmap } from '../combinator';
 import { str } from './source';
 import { unwrap, invalid } from './util';
@@ -18,17 +18,17 @@ export const header: MarkdownParser.HeaderParser = lazy(() => validate(
           fmap(
             some(union([field])),
             ns => new List([
-              new Data(html('aside', { class: 'header' }, [
+              new Node(html('aside', { class: 'header' }, [
                 html('details',
                   { open: '' },
-                  defrag(unwrap(ns.unshift(new Data(html('summary', 'Header'))) && ns))),
+                  defrag(unwrap(ns.unshift(new Node(html('summary', 'Header'))) && ns))),
               ])),
             ]))))),
         ({ context }) => {
           const { source, position } = context;
           context.position += source.length;
           return new List([
-            new Data(html('pre', {
+            new Node(html('pre', {
               class: 'invalid',
               translate: 'no',
               ...invalid('header', 'syntax', 'Invalid syntax'),
@@ -43,7 +43,7 @@ const field: MarkdownParser.HeaderParser.FieldParser = line(({ context: { source
   const name = source.slice(position, source.indexOf(':', position));
   const value = source.slice(position + name.length + 1).trim();
   return new List([
-    new Data(html('span', { class: 'field', 'data-name': name.toLowerCase(), 'data-value': value }, [
+    new Node(html('span', { class: 'field', 'data-name': name.toLowerCase(), 'data-value': value }, [
       html('span', { class: 'field-name' }, name),
       ': ',
       html('span', { class: 'field-value' }, value),

package/src/parser/inline/annotation.test.ts

@@ -1,61 +1,61 @@
 import { annotation } from './annotation';
 import { some } from '../../combinator';
 import { input } from '../../combinator/data/parser';
+import { Context } from '../context';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/inline/annotation', () => {
   describe('annotation', () => {
-    const parser = (source: string) => some(annotation)(input(source, ctx));
-    const { context: ctx } = input('', {});
+    const parser = some(annotation);
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser(''), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('('), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('()'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('(('), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('(())'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('(()))'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('(("))'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('(([))'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('(([%))'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('(( ))'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('(( (a'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('((\n))'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('((\na))'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('((\\\na))'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('((a\n))'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('((a\\\n))'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('((a\nb))'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('((a\\\nb))'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('((*a\nb*))'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('((\\))'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('((a)b))'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('(((a))'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser(' ((a))'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser, input('', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('(', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('()', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('((', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('(())', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('(()))', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('(("))', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('(([))', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('(([%))', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('(( ))', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('(( (a', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('((\n))', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('((\na))', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('((\\\na))', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('((a\n))', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('((a\\\n))', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('((a\nb))', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('((a\\\nb))', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('((*a\nb*))', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('((\\))', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('((a)b))', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('(((a))', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input(' ((a))', new Context())), undefined);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser('(( a))'), ctx), [['<sup class="annotation"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('(( a ))'), ctx), [['<sup class="annotation"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('((\\ a))'), ctx), [['<sup class="annotation"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('((<wbr>a))'), ctx), [['<sup class="annotation"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('((a))'), ctx), [['<sup class="annotation"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('((a ))'), ctx), [['<sup class="annotation"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('((a  ))'), ctx), [['<sup class="annotation"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('((a &nbsp;))'), ctx), [['<sup class="annotation"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('((a <wbr>))'), ctx), [['<sup class="annotation"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('((ab))'), ctx), [['<sup class="annotation"><span>ab</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(( a))', new Context())), [['<sup class="annotation"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(( a ))', new Context())), [['<sup class="annotation"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('((\\ a))', new Context())), [['<sup class="annotation"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('((<wbr>a))', new Context())), [['<sup class="annotation"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('((a))', new Context())), [['<sup class="annotation"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('((a ))', new Context())), [['<sup class="annotation"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('((a  ))', new Context())), [['<sup class="annotation"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('((a &nbsp;))', new Context())), [['<sup class="annotation"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('((a <wbr>))', new Context())), [['<sup class="annotation"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('((ab))', new Context())), [['<sup class="annotation"><span>ab</span></sup>'], '']);
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser('((`a`))'), ctx), [['<sup class="annotation"><span><code data-src="`a`">a</code></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('((@a))'), ctx), [['<sup class="annotation"><span><a class="account" href="/@a">@a</a></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('((http://host))'), ctx), [['<sup class="annotation"><span><a class="url" href="http://host" target="_blank">http://host</a></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('((![]{a}))'), ctx), [['<sup class="annotation"><span>!<a class="url" href="a">a</a></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('(([[a] ]))'), ctx), [['<sup class="annotation"><span>[[a] ]</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('(((a)))'), ctx), [['<sup class="annotation"><span>(a)</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('((((a))))'), ctx), [['<sup class="annotation"><span><span class="paren">((a))</span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('(([[a]]))'), ctx), [['<sup class="annotation"><span><sup class="reference"><span>a</span></sup></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('((`a`))', new Context())), [['<sup class="annotation"><span><code data-src="`a`">a</code></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('((@a))', new Context())), [['<sup class="annotation"><span><a class="account" href="/@a">@a</a></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('((http://host))', new Context())), [['<sup class="annotation"><span><a class="url" href="http://host" target="_blank">http://host</a></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('((![]{a}))', new Context())), [['<sup class="annotation"><span>!<a class="url" href="a">a</a></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(([[a] ]))', new Context())), [['<sup class="annotation"><span>[[a] ]</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(((a)))', new Context())), [['<sup class="annotation"><span>(a)</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('((((a))))', new Context())), [['<sup class="annotation"><span><span class="paren">((a))</span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(([[a]]))', new Context())), [['<sup class="annotation"><span><sup class="reference"><span>a</span></sup></span></sup>'], '']);
     });
 
   });

package/src/parser/inline/annotation.ts

@@ -1,7 +1,7 @@
 import { AnnotationParser } from '../inline';
 import { State, Backtrack } from '../context';
-import { List, Data } from '../../combinator/data/parser';
-import { union, some, precedence, state, constraint, surround, lazy } from '../../combinator';
+import { List, Node } from '../../combinator/data/parser';
+import { union, some, precedence, state, constraint, surround, setBacktrack, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { trimBlankStart, trimBlankNodeEnd } from '../visibility';
 import { unwrap } from '../util';
@@ -13,8 +13,18 @@ export const annotation: AnnotationParser = lazy(() => constraint(State.annotati
   trimBlankStart(some(union([inline]), ')', [[')', 1]])))),
   '))',
   false,
-  [1 | Backtrack.common, 3 | Backtrack.doublebracket],
+  [2, 1 | Backtrack.common, 3 | Backtrack.doublebracket],
   ([, ns], context) =>
     context.linebreak === 0
-      ? new List([new Data(html('sup', { class: 'annotation' }, [html('span', defrag(unwrap(trimBlankNodeEnd(ns))))]))])
-      : undefined)));
+      ? new List([new Node(html('sup', { class: 'annotation' }, [html('span', defrag(unwrap(trimBlankNodeEnd(ns))))]))])
+      : undefined,
+  (_, context): undefined => {
+    const { source, position, range, linebreak } = context;
+    const head = position - range;
+    if (source[position] !== ')') {
+      setBacktrack(context, 2 | Backtrack.common, head + 1);
+    }
+    else if (linebreak !== 0) {
+      setBacktrack(context, 2 | Backtrack.doublebracket, head + 1);
+    }
+  })));

package/src/parser/inline/autolink/account.test.ts

@@ -1,48 +1,48 @@
 import { autolink } from '../autolink';
 import { some } from '../../../combinator';
 import { input } from '../../../combinator/data/parser';
+import { Context } from '../../context';
 import { inspect } from '../../../debug.test';
 
 describe('Unit: parser/inline/autolink/account', () => {
   describe('account', () => {
-    const parser = (source: string) => some(autolink)(input(source, ctx));
-    const { context: ctx } = input('', {});
+    const parser = some(autolink);
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser(''), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('@'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('@+'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('@_'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('@-'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('@.'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('@0'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('@a@'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('@a@b'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('@a@b@c'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('@ab@'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('@@'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('@@a'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('@@@a'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('@#'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('@#a'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('@a.b:c'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('@a.domain.com:b'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('@http://host'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser(' @a'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser, input('', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('@', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('@+', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('@_', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('@-', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('@.', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('@0', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('@a@', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('@a@b', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('@a@b@c', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('@ab@', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('@@', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('@@a', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('@@@a', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('@#', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('@#a', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('@a.b:c', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('@a.domain.com:b', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('@http://host', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input(' @a', new Context())), undefined);
     });
 
     it('valid', () => {
-      assert.deepStrictEqual(inspect(parser('@a'), ctx), [['<a class="account" href="/@a">@a</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('@A'), ctx), [['<a class="account" href="/@A">@A</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('@a_b'), ctx), [['<a class="account" href="/@a">@a</a>'], '_b']);
-      assert.deepStrictEqual(inspect(parser('@a__b'), ctx), [['<a class="account" href="/@a">@a</a>'], '__b']);
-      assert.deepStrictEqual(inspect(parser('@a-'), ctx), [['<a class="account" href="/@a">@a</a>'], '-']);
-      assert.deepStrictEqual(inspect(parser('@a-b'), ctx), [['<a class="account" href="/@a-b">@a-b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('@a--b'), ctx), [['<a class="account" href="/@a">@a</a>'], '--b']);
-      assert.deepStrictEqual(inspect(parser('@a.'), ctx), [['<a class="account" href="/@a">@a</a>'], '.']);
-      assert.deepStrictEqual(inspect(parser('@a.domain.com'), ctx), [['<a class="account" href="/@a.domain.com">@a.domain.com</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('@domain/a'), ctx), [['<a class="account" href="https://domain/@a" target="_blank">@domain/a</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('@domain.com/a'), ctx), [['<a class="account" href="https://domain.com/@a" target="_blank">@domain.com/a</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('@a', new Context())), [['<a class="account" href="/@a">@a</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('@A', new Context())), [['<a class="account" href="/@A">@A</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('@a_b', new Context())), [['<a class="account" href="/@a">@a</a>'], '_b']);
+      assert.deepStrictEqual(inspect(parser, input('@a__b', new Context())), [['<a class="account" href="/@a">@a</a>'], '__b']);
+      assert.deepStrictEqual(inspect(parser, input('@a-', new Context())), [['<a class="account" href="/@a">@a</a>'], '-']);
+      assert.deepStrictEqual(inspect(parser, input('@a-b', new Context())), [['<a class="account" href="/@a-b">@a-b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('@a--b', new Context())), [['<a class="account" href="/@a">@a</a>'], '--b']);
+      assert.deepStrictEqual(inspect(parser, input('@a.', new Context())), [['<a class="account" href="/@a">@a</a>'], '.']);
+      assert.deepStrictEqual(inspect(parser, input('@a.domain.com', new Context())), [['<a class="account" href="/@a.domain.com">@a.domain.com</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('@domain/a', new Context())), [['<a class="account" href="https://domain/@a" target="_blank">@domain/a</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('@domain.com/a', new Context())), [['<a class="account" href="https://domain.com/@a" target="_blank">@domain.com/a</a>'], '']);
     });
 
   });

package/src/parser/inline/autolink/account.ts

@@ -1,6 +1,6 @@
 import { AutolinkParser } from '../../inline';
 import { State, Backtrack } from '../../context';
-import { List, Data } from '../../../combinator/data/parser';
+import { List, Node } from '../../../combinator/data/parser';
 import { some, state, constraint, verify, surround, setBacktrack, lazy } from '../../../combinator';
 import { parse } from '../link';
 import { emoji } from './hashtag';
@@ -36,24 +36,24 @@ export const account: AutolinkParser.AccountParser = lazy(() => constraint(State
       const hashes = nodes.foldl((acc, { value }) => acc + '#' + value, '');
       const param = nodes.foldl((acc, { value }) => acc ? acc + '+' + value : value, '');
       return new List([
-        new Data(define(
+        new Node(define(
           parse(
-            new List([new Data(`@${host}${account}${hashes}`)]),
-            new List([new Data(host ? `https://${host}@${account}?ch=${param}` : `/@${account}?ch=${param}`)]),
+            new List([new Node(`@${host}${account}${hashes}`)]),
+            new List([new Node(host ? `https://${host}@${account}?ch=${param}` : `/@${account}?ch=${param}`)]),
             context),
           { class: 'channel' }))
       ]);
     },
     ([[{ value: host }, { value: account }]], context) => {
       if (context.source[context.position] === '#') {
-        assert(context.source[context.position - context.range!] === '@');
-        return void setBacktrack(context, 2 | Backtrack.unescapable, context.position - context.range!);
+        assert(context.source[context.position - context.range] === '@');
+        return void setBacktrack(context, 2 | Backtrack.unescapable, context.position - context.range);
       }
       return new List([
-        new Data(define(
+        new Node(define(
           parse(
-            new List([new Data(`@${host}${account}`)]),
-            new List([new Data(host ? `https://${host}@${account}` : `/@${account}`)]),
+            new List([new Node(`@${host}${account}`)]),
+            new List([new Node(host ? `https://${host}@${account}` : `/@${account}`)]),
             context),
           { class: 'account' }))
       ]);

package/src/parser/inline/autolink/anchor.test.ts

@@ -1,37 +1,37 @@
 import { autolink } from '../autolink';
 import { some } from '../../../combinator';
 import { input } from '../../../combinator/data/parser';
+import { Context } from '../../context';
 import { inspect } from '../../../debug.test';
 
 describe('Unit: parser/inline/autolink/anchor', () => {
   describe('anchor', () => {
-    const parser = (source: string) => some(autolink)(input(source, ctx));
-    const { context: ctx } = input('', {});
+    const parser = some(autolink);
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser(''), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('>'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('>>'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('>>-0'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('>>01#'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('>>01@'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('>>0-1:2'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('>>https://host'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('>>tel:1234567890'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('>>>'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('a>>0'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser(' >>0'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser, input('', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('>', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('>>', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('>>-0', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('>>01#', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('>>01@', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('>>0-1:2', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('>>https://host', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('>>tel:1234567890', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('>>>', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('a>>0', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input(' >>0', new Context())), undefined);
     });
 
     it('valid', () => {
-      assert.deepStrictEqual(inspect(parser('>>0'), ctx), [['<a class="anchor" href="?at=0">&gt;&gt;0</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('>>a'), ctx), [['<a class="anchor" href="?at=a">&gt;&gt;a</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('>>A'), ctx), [['<a class="anchor" href="?at=A">&gt;&gt;A</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('>>0-'), ctx), [['<a class="anchor" href="?at=0">&gt;&gt;0</a>'], '-']);
-      assert.deepStrictEqual(inspect(parser('>>0-a'), ctx), [['<a class="anchor" href="?at=0-a">&gt;&gt;0-a</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('>>0-A'), ctx), [['<a class="anchor" href="?at=0-A">&gt;&gt;0-A</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('>>0--a'), ctx), [['<a class="anchor" href="?at=0">&gt;&gt;0</a>'], '--a']);
-      assert.deepStrictEqual(inspect(parser('>>2000-0131-2359-59999'), ctx), [['<a class="anchor" href="?at=2000-0131-2359-59999">&gt;&gt;2000-0131-2359-59999</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('>>0', new Context())), [['<a class="anchor" href="?at=0">&gt;&gt;0</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('>>a', new Context())), [['<a class="anchor" href="?at=a">&gt;&gt;a</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('>>A', new Context())), [['<a class="anchor" href="?at=A">&gt;&gt;A</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('>>0-', new Context())), [['<a class="anchor" href="?at=0">&gt;&gt;0</a>'], '-']);
+      assert.deepStrictEqual(inspect(parser, input('>>0-a', new Context())), [['<a class="anchor" href="?at=0-a">&gt;&gt;0-a</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('>>0-A', new Context())), [['<a class="anchor" href="?at=0-A">&gt;&gt;0-A</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('>>0--a', new Context())), [['<a class="anchor" href="?at=0">&gt;&gt;0</a>'], '--a']);
+      assert.deepStrictEqual(inspect(parser, input('>>2000-0131-2359-59999', new Context())), [['<a class="anchor" href="?at=2000-0131-2359-59999">&gt;&gt;2000-0131-2359-59999</a>'], '']);
     });
 
   });

package/src/parser/inline/autolink/anchor.ts

@@ -1,6 +1,6 @@
 import { AutolinkParser } from '../../inline';
 import { State, Backtrack } from '../../context';
-import { List, Data } from '../../../combinator/data/parser';
+import { List, Node } from '../../../combinator/data/parser';
 import { state, constraint, surround, lazy } from '../../../combinator';
 import { parse } from '../link';
 import { str } from '../../source';
@@ -25,9 +25,9 @@ export const anchor: AutolinkParser.AnchorParser = lazy(() => constraint(State.a
     [3 | Backtrack.unescapable],
     ([, [{ value }]], context) =>
       new List([
-        new Data(define(parse(
-          new List([new Data(`>>${value}`)]),
-          new List([new Data(`?at=${value}`)]),
+        new Node(define(parse(
+          new List([new Node(`>>${value}`)]),
+          new List([new Node(`?at=${value}`)]),
           context),
           { class: 'anchor' }))
       ])))));

package/src/parser/inline/autolink/channel.test.ts

@@ -1,30 +1,30 @@
 import { autolink } from '../autolink';
 import { some } from '../../../combinator';
 import { input } from '../../../combinator/data/parser';
+import { Context } from '../../context';
 import { inspect } from '../../../debug.test';
 
 describe('Unit: parser/inline/autolink/channel', () => {
   describe('channel', () => {
-    const parser = (source: string) => some(autolink)(input(source, ctx));
-    const { context: ctx } = input('', {});
+    const parser = some(autolink);
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser(''), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('@a@'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('@a@b'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('@a#'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('@a#1'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('@a#b@'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('@a#1@b'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser(' @a#b'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser, input('', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('@a@', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('@a@b', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('@a#', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('@a#1', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('@a#b@', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('@a#1@b', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input(' @a#b', new Context())), undefined);
     });
 
     it('valid', () => {
-      assert.deepStrictEqual(inspect(parser('@a#b'), ctx), [['<a class="channel" href="/@a?ch=b">@a#b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('@a#b#'), ctx), [['<a class="channel" href="/@a?ch=b">@a#b</a>'], '#']);
-      assert.deepStrictEqual(inspect(parser('@a#b#1'), ctx), [['<a class="channel" href="/@a?ch=b">@a#b</a>'], '#1']);
-      assert.deepStrictEqual(inspect(parser('@a#b#c'), ctx), [['<a class="channel" href="/@a?ch=b+c">@a#b#c</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('@domain/a#b'), ctx), [['<a class="channel" href="https://domain/@a?ch=b" target="_blank">@domain/a#b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('@a#b', new Context())), [['<a class="channel" href="/@a?ch=b">@a#b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('@a#b#', new Context())), [['<a class="channel" href="/@a?ch=b">@a#b</a>'], '#']);
+      assert.deepStrictEqual(inspect(parser, input('@a#b#1', new Context())), [['<a class="channel" href="/@a?ch=b">@a#b</a>'], '#1']);
+      assert.deepStrictEqual(inspect(parser, input('@a#b#c', new Context())), [['<a class="channel" href="/@a?ch=b+c">@a#b#c</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('@domain/a#b', new Context())), [['<a class="channel" href="https://domain/@a?ch=b" target="_blank">@domain/a#b</a>'], '']);
     });
 
   });

package/src/parser/inline/autolink/email.test.ts

@@ -1,52 +1,52 @@
 import { autolink } from '../autolink';
 import { some } from '../../../combinator';
 import { input } from '../../../combinator/data/parser';
+import { Context } from '../../context';
 import { inspect } from '../../../debug.test';
 
 describe('Unit: parser/inline/autolink/email', () => {
   describe('email', () => {
-    const parser = (source: string) => some(autolink)(input(source, ctx));
-    const { context: ctx } = input('', {});
+    const parser = some(autolink);
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser(''), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('a@'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('a@+'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('a@_'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('a@-'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('a@.'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('a@b@'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('a@bc@'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('a@b@c'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('a@b#'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('a@b#1'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('a@@'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('a@@b'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('a+@b'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('a__b@c'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('a..b@c'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('a++b@c'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('a@b.c:d'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('a@b.domain.com:c'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('a@http://host'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser(' a@b'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser, input('', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('a@', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('a@+', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('a@_', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('a@-', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('a@.', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('a@b@', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('a@bc@', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('a@b@c', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('a@b#', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('a@b#1', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('a@@', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('a@@b', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('a+@b', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('a__b@c', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('a..b@c', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('a++b@c', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('a@b.c:d', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('a@b.domain.com:c', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('a@http://host', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input(' a@b', new Context())), undefined);
     });
 
     it('valid', () => {
-      assert.deepStrictEqual(inspect(parser('a@0'), ctx), [['<a class="email" href="mailto:a@0">a@0</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('a@b'), ctx), [['<a class="email" href="mailto:a@b">a@b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('a@A'), ctx), [['<a class="email" href="mailto:a@A">a@A</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('a@b+'), ctx), [['<a class="email" href="mailto:a@b">a@b</a>'], '+']);
-      assert.deepStrictEqual(inspect(parser('a@b+c'), ctx), [['<a class="email" href="mailto:a@b">a@b</a>'], '+c']);
-      assert.deepStrictEqual(inspect(parser('a@b_'), ctx), [['<a class="email" href="mailto:a@b">a@b</a>'], '_']);
-      assert.deepStrictEqual(inspect(parser('a@b_c'), ctx), [['<a class="email" href="mailto:a@b">a@b</a>'], '_c']);
-      assert.deepStrictEqual(inspect(parser('a@b-'), ctx), [['<a class="email" href="mailto:a@b">a@b</a>'], '-']);
-      assert.deepStrictEqual(inspect(parser('a@b-c'), ctx), [['<a class="email" href="mailto:a@b-c">a@b-c</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('a@b--c'), ctx), [['<a class="email" href="mailto:a@b">a@b</a>'], '--c']);
-      assert.deepStrictEqual(inspect(parser('a@b.'), ctx), [['<a class="email" href="mailto:a@b">a@b</a>'], '.']);
-      assert.deepStrictEqual(inspect(parser('a@b.c'), ctx), [['<a class="email" href="mailto:a@b.c">a@b.c</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('a@b..c'), ctx), [['<a class="email" href="mailto:a@b">a@b</a>'], '..c']);
-      assert.deepStrictEqual(inspect(parser('ab+cd@0'), ctx), [['<a class="email" href="mailto:ab+cd@0">ab+cd@0</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a@0', new Context())), [['<a class="email" href="mailto:a@0">a@0</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a@b', new Context())), [['<a class="email" href="mailto:a@b">a@b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a@A', new Context())), [['<a class="email" href="mailto:a@A">a@A</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a@b+', new Context())), [['<a class="email" href="mailto:a@b">a@b</a>'], '+']);
+      assert.deepStrictEqual(inspect(parser, input('a@b+c', new Context())), [['<a class="email" href="mailto:a@b">a@b</a>'], '+c']);
+      assert.deepStrictEqual(inspect(parser, input('a@b_', new Context())), [['<a class="email" href="mailto:a@b">a@b</a>'], '_']);
+      assert.deepStrictEqual(inspect(parser, input('a@b_c', new Context())), [['<a class="email" href="mailto:a@b">a@b</a>'], '_c']);
+      assert.deepStrictEqual(inspect(parser, input('a@b-', new Context())), [['<a class="email" href="mailto:a@b">a@b</a>'], '-']);
+      assert.deepStrictEqual(inspect(parser, input('a@b-c', new Context())), [['<a class="email" href="mailto:a@b-c">a@b-c</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a@b--c', new Context())), [['<a class="email" href="mailto:a@b">a@b</a>'], '--c']);
+      assert.deepStrictEqual(inspect(parser, input('a@b.', new Context())), [['<a class="email" href="mailto:a@b">a@b</a>'], '.']);
+      assert.deepStrictEqual(inspect(parser, input('a@b.c', new Context())), [['<a class="email" href="mailto:a@b.c">a@b.c</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a@b..c', new Context())), [['<a class="email" href="mailto:a@b">a@b</a>'], '..c']);
+      assert.deepStrictEqual(inspect(parser, input('ab+cd@0', new Context())), [['<a class="email" href="mailto:ab+cd@0">ab+cd@0</a>'], '']);
     });
 
   });

package/src/parser/inline/autolink/email.ts

@@ -1,6 +1,6 @@
 import { AutolinkParser } from '../../inline';
 import { State, Backtrack } from '../../context';
-import { List, Data } from '../../../combinator/data/parser';
+import { List, Node } from '../../../combinator/data/parser';
 import { state, constraint, verify, surround } from '../../../combinator';
 import { str } from '../../source';
 import { html } from 'typed-dom/dom';
@@ -17,4 +17,4 @@ export const email: AutolinkParser.EmailParser = constraint(State.autolink, stat
     false,
     [3 | Backtrack.unescapable],
     ([, [{ value }]]) =>
-      new List([new Data(html('a', { class: 'email', href: `mailto:${value}` }, value))]))));
+      new List([new Node(html('a', { class: 'email', href: `mailto:${value}` }, value))]))));