securemark 0.295.0 → 0.295.2

package/src/parser/segment.ts

@@ -1,5 +1,5 @@
 import { MarkdownParser } from '../../markdown';
-import { Command } from './context';
+import { Context, Command } from './context';
 import { union, some } from '../combinator';
 import { segment as heading } from './block/heading';
 import { segment as codeblock } from './block/codeblock';
@@ -43,7 +43,7 @@ export function* segment(source: string): Generator<string, undefined, undefined
   if (!validate(source, MAX_INPUT_SIZE)) return yield `${Command.Error}Too large input over ${MAX_INPUT_SIZE.toLocaleString('en')} bytes.\n${source.slice(0, 1001)}`;
   assert(source.length < Number.MAX_SAFE_INTEGER);
   for (let position = 0; position < source.length;) {
-    const context = { source, position };
+    const context = new Context({ source, position });
     const result = parser({ context })!;
     assert(result);
     assert(context.position > position);

package/src/parser/source/escapable.test.ts

@@ -1,48 +1,48 @@
 import { escsource } from './escapable';
 import { some } from '../../combinator';
 import { input } from '../../combinator/data/parser';
+import { Context } from '../context';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/source/escsource', () => {
   describe('escsource', () => {
-    const parser = (source: string) => some(escsource)(input(source, ctx));
-    const { context: ctx } = input('', {});
+    const parser = some(escsource);
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser(''), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser, input('', new Context())), undefined);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser('a'), ctx), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser('ab'), ctx), [['ab'], '']);
-      assert.deepStrictEqual(inspect(parser('a b c'), ctx), [['a b c'], '']);
-      assert.deepStrictEqual(inspect(parser('09あいAZaz'), ctx), [['09あいAZaz'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a', new Context())), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('ab', new Context())), [['ab'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a b c', new Context())), [['a b c'], '']);
+      assert.deepStrictEqual(inspect(parser, input('09あいAZaz', new Context())), [['09あいAZaz'], '']);
     });
 
     it('space', () => {
-      assert.deepStrictEqual(inspect(parser(' '), ctx), [[' '], '']);
-      assert.deepStrictEqual(inspect(parser('  '), ctx), [['  '], '']);
-      assert.deepStrictEqual(inspect(parser('   '), ctx), [['   '], '']);
-      assert.deepStrictEqual(inspect(parser(' \n'), ctx), [[' ', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('  \n'), ctx), [['  ', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('   \n'), ctx), [['   ', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input(' ', new Context())), [[' '], '']);
+      assert.deepStrictEqual(inspect(parser, input('  ', new Context())), [['  '], '']);
+      assert.deepStrictEqual(inspect(parser, input('   ', new Context())), [['   '], '']);
+      assert.deepStrictEqual(inspect(parser, input(' \n', new Context())), [[' ', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('  \n', new Context())), [['  ', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('   \n', new Context())), [['   ', '<br>'], '']);
     });
 
     it('linebreak', () => {
-      assert.deepStrictEqual(inspect(parser('\n\n'), ctx), [['<br>', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\n\n', new Context())), [['<br>', '<br>'], '']);
     });
 
     it('\\', () => {
-      assert.deepStrictEqual(inspect(parser('\\'), ctx), [['\\'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\\'), ctx), [['\\\\'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\\\\'), ctx), [['\\\\', '\\'], '']);
-      assert.deepStrictEqual(inspect(parser('\\ '), ctx), [['\\ '], '']);
-      assert.deepStrictEqual(inspect(parser('\\_'), ctx), [['\\_'], '']);
-      assert.deepStrictEqual(inspect(parser('\\0'), ctx), [['\\0'], '']);
-      assert.deepStrictEqual(inspect(parser('\\a'), ctx), [['\\a'], '']);
-      assert.deepStrictEqual(inspect(parser('\\$'), ctx), [['\\$'], '']);
-      assert.deepStrictEqual(inspect(parser('\\　'), ctx), [['\\　'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\n'), ctx), [['\\', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\', new Context())), [['\\'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\\\', new Context())), [['\\\\'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\\\\\', new Context())), [['\\\\', '\\'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\ ', new Context())), [['\\ '], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\_', new Context())), [['\\_'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\0', new Context())), [['\\0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\a', new Context())), [['\\a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\$', new Context())), [['\\$'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\　', new Context())), [['\\　'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\\n', new Context())), [['\\', '<br>'], '']);
     });
 
   });

package/src/parser/source/escapable.ts

@@ -1,6 +1,6 @@
 import { EscapableSourceParser } from '../source';
 import { Command } from '../context';
-import { List, Data } from '../../combinator/data/parser';
+import { List, Node } from '../../combinator/data/parser';
 import { consume } from '../../combinator';
 import { next } from './text';
 import { html } from 'typed-dom/dom';
@@ -17,32 +17,32 @@ export const escsource: EscapableSourceParser = ({ context }) => {
     case Command.Escape:
       consume(1, context);
       context.position += 1;
-      return new List([new Data(source.slice(position + 1, position + 2))]);
+      return new List([new Node(source.slice(position + 1, position + 2))]);
     case '\\':
       switch (source[position + 1]) {
         case undefined:
-          return new List([new Data(char)]);
+          return new List([new Node(char)]);
         case '\n':
-          return new List([new Data(char)]);
+          return new List([new Node(char)]);
         default:
           consume(1, context);
           context.position += 1;
-          return new List([new Data(source.slice(position, position + 2))]);
+          return new List([new Node(source.slice(position, position + 2))]);
       }
     case '\r':
       consume(-1, context);
       return new List();
     case '\n':
       context.linebreak ||= source.length - position;
-      return new List([new Data(html('br'))]);
+      return new List([new Node(html('br'))]);
     default:
       assert(char !== '\n');
-      if (context.sequential) return new List([new Data(char)]);
+      if (context.sequential) return new List([new Node(char)]);
       let i = next(source, position, delimiter);
       assert(i > position);
       i -= position;
       consume(i - 1, context);
       context.position += i - 1;
-      return new List([new Data(source.slice(position, context.position))]);
+      return new List([new Node(source.slice(position, context.position))]);
   }
 };

package/src/parser/source/line.test.ts

@@ -1,32 +1,32 @@
 import { contentline } from './line';
 import { input } from '../../combinator/data/parser';
+import { Context } from '../context';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/source/line', () => {
   describe('contentline', () => {
-    const parser = (source: string) => contentline(input(source, ctx));
-    const { context: ctx } = input('', {});
+    const parser = contentline;
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser(''), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser(' '), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('\n'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser(' \n'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('\n\n'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser, input('', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input(' ', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('\n', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input(' \n', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('\n\n', new Context())), undefined);
     });
 
     it('valid', () => {
-      assert.deepStrictEqual(inspect(parser('a'), ctx), [[], '']);
-      assert.deepStrictEqual(inspect(parser('a '), ctx), [[], '']);
-      assert.deepStrictEqual(inspect(parser(' a'), ctx), [[], '']);
-      assert.deepStrictEqual(inspect(parser(' a '), ctx), [[], '']);
-      assert.deepStrictEqual(inspect(parser(' a\n'), ctx), [[], '']);
-      assert.deepStrictEqual(inspect(parser(' a \n'), ctx), [[], '']);
-      assert.deepStrictEqual(inspect(parser('ab'), ctx), [[], '']);
-      assert.deepStrictEqual(inspect(parser('a\nb'), ctx), [[], 'b']);
-      assert.deepStrictEqual(inspect(parser('\\\n'), ctx), [[], '']);
-      assert.deepStrictEqual(inspect(parser('\\ \\\n'), ctx), [[], '']);
-      assert.deepStrictEqual(inspect(parser('\\ \\ \\\n'), ctx), [[], '']);
+      assert.deepStrictEqual(inspect(parser, input('a', new Context())), [[], '']);
+      assert.deepStrictEqual(inspect(parser, input('a ', new Context())), [[], '']);
+      assert.deepStrictEqual(inspect(parser, input(' a', new Context())), [[], '']);
+      assert.deepStrictEqual(inspect(parser, input(' a ', new Context())), [[], '']);
+      assert.deepStrictEqual(inspect(parser, input(' a\n', new Context())), [[], '']);
+      assert.deepStrictEqual(inspect(parser, input(' a \n', new Context())), [[], '']);
+      assert.deepStrictEqual(inspect(parser, input('ab', new Context())), [[], '']);
+      assert.deepStrictEqual(inspect(parser, input('a\nb', new Context())), [[], 'b']);
+      assert.deepStrictEqual(inspect(parser, input('\\\n', new Context())), [[], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\ \\\n', new Context())), [[], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\ \\ \\\n', new Context())), [[], '']);
     });
 
   });

package/src/parser/source/str.ts

@@ -1,5 +1,5 @@
 import { StrParser } from '../source';
-import { Parser, List, Data } from '../../combinator/data/parser';
+import { Parser, List, Node } from '../../combinator/data/parser';
 import { matcher } from '../../combinator';
 
 export function str(pattern: string | RegExp): StrParser;
@@ -17,6 +17,6 @@ export function strs(pattern: string): Parser<string> {
       acc += pattern;
       context.position += pattern.length;
     }
-    return new List([new Data(acc)]);
+    return new List([new Node(acc)]);
   };
 }

package/src/parser/source/text.test.ts

@@ -1,121 +1,121 @@
 import { text } from './text';
 import { some } from '../../combinator';
 import { input } from '../../combinator/data/parser';
+import { Context } from '../context';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/source/text', () => {
   describe('text', () => {
-    const parser = (source: string) => some(text)(input(source, ctx));
-    const { context: ctx } = input('', {});
+    const parser = some(text);
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser(''), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser, input('', new Context())), undefined);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser('a'), ctx), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser('ab'), ctx), [['ab'], '']);
-      assert.deepStrictEqual(inspect(parser('a b c'), ctx), [['a b c'], '']);
-      assert.deepStrictEqual(inspect(parser('09あいAZaz'), ctx), [['09あいAZaz'], '']);
-      assert.deepStrictEqual(inspect(parser('a\nb'), ctx), [['a', '<br>', 'b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a', new Context())), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('ab', new Context())), [['ab'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a b c', new Context())), [['a b c'], '']);
+      assert.deepStrictEqual(inspect(parser, input('09あいAZaz', new Context())), [['09あいAZaz'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a\nb', new Context())), [['a', '<br>', 'b'], '']);
     });
 
     it('escape', () => {
-      assert.deepStrictEqual(inspect(parser('\\'), ctx), [[], '']);
-      assert.deepStrictEqual(inspect(parser('\\\\'), ctx), [['\\'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\\\\'), ctx), [['\\'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\\\\\\'), ctx), [['\\', '\\'], '']);
-      assert.deepStrictEqual(inspect(parser('\\ '), ctx), [[' '], '']);
-      assert.deepStrictEqual(inspect(parser('\\_'), ctx), [['_'], '']);
-      assert.deepStrictEqual(inspect(parser('\\0'), ctx), [['0'], '']);
-      assert.deepStrictEqual(inspect(parser('\\a'), ctx), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\\a'), ctx), [['\\', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('\\　'), ctx), [['　'], '']);
-      assert.deepStrictEqual(inspect(parser('\\。'), ctx), [['。'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\', new Context())), [[], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\\\', new Context())), [['\\'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\\\\\', new Context())), [['\\'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\\\\\\\', new Context())), [['\\', '\\'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\ ', new Context())), [[' '], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\_', new Context())), [['_'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\0', new Context())), [['0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\a', new Context())), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\\\a', new Context())), [['\\', 'a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\　', new Context())), [['　'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\。', new Context())), [['。'], '']);
     });
 
     it('space', () => {
-      assert.deepStrictEqual(inspect(parser(' '), ctx), [[], '']);
-      assert.deepStrictEqual(inspect(parser('  '), ctx), [[], '']);
-      assert.deepStrictEqual(inspect(parser('   '), ctx), [[], '']);
-      assert.deepStrictEqual(inspect(parser(' \n'), ctx), [['<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('  \n'), ctx), [['<br>'], '']);
-      assert.deepStrictEqual(inspect(parser(' \\\n'), ctx), [[' ', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('  \\\n'), ctx), [[' ', ' ', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser(' a'), ctx), [[' a'], '']);
-      assert.deepStrictEqual(inspect(parser('  a'), ctx), [[' ', ' a'], '']);
-      assert.deepStrictEqual(inspect(parser('   a'), ctx), [['  ', ' a'], '']);
-      assert.deepStrictEqual(inspect(parser('a '), ctx), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser('a  '), ctx), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser('a \n'), ctx), [['a', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('a  \n'), ctx), [['a', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('a \\\n'), ctx), [['a', ' ', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('a  \\\n'), ctx), [['a', ' ', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('a b'), ctx), [['a b'], '']);
-      assert.deepStrictEqual(inspect(parser('a  b'), ctx), [['a', ' b'], '']);
-      assert.deepStrictEqual(inspect(parser('a   b'), ctx), [['a', ' b'], '']);
+      assert.deepStrictEqual(inspect(parser, input(' ', new Context())), [[], '']);
+      assert.deepStrictEqual(inspect(parser, input('  ', new Context())), [[], '']);
+      assert.deepStrictEqual(inspect(parser, input('   ', new Context())), [[], '']);
+      assert.deepStrictEqual(inspect(parser, input(' \n', new Context())), [['<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('  \n', new Context())), [['<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input(' \\\n', new Context())), [[' ', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('  \\\n', new Context())), [[' ', ' ', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input(' a', new Context())), [[' a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('  a', new Context())), [[' ', ' a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('   a', new Context())), [['  ', ' a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a ', new Context())), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a  ', new Context())), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a \n', new Context())), [['a', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a  \n', new Context())), [['a', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a \\\n', new Context())), [['a', ' ', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a  \\\n', new Context())), [['a', ' ', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a b', new Context())), [['a b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a  b', new Context())), [['a', ' b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a   b', new Context())), [['a', ' b'], '']);
     });
 
     it('hardbreak', () => {
-      assert.deepStrictEqual(inspect(parser('\n'), ctx), [['<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('\n '), ctx), [['<br>'], '']);
-      assert.deepStrictEqual(inspect(parser(' \n'), ctx), [['<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('\n\n'), ctx), [['<br>', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser(' \n\n'), ctx), [['<br>', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('\n \n'), ctx), [['<br>', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('\n\n '), ctx), [['<br>', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('。\n'), ctx), [['。', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\n', new Context())), [['<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\n ', new Context())), [['<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input(' \n', new Context())), [['<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\n\n', new Context())), [['<br>', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input(' \n\n', new Context())), [['<br>', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\n \n', new Context())), [['<br>', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\n\n ', new Context())), [['<br>', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('。\n', new Context())), [['。', '<br>'], '']);
     });
 
     it('softbreak', () => {
-      assert.deepStrictEqual(inspect(parser('\\\n'), ctx), [['<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\n '), ctx), [['<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\na'), ctx), [['<br>', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('a\\\n'), ctx), [['a', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('a\\\nb\\\n'), ctx), [['a', '<br>', 'b', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\\\\\n'), ctx), [['\\', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\\n', new Context())), [['<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\\n ', new Context())), [['<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\\na', new Context())), [['<br>', 'a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a\\\n', new Context())), [['a', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a\\\nb\\\n', new Context())), [['a', '<br>', 'b', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\\\\\\n', new Context())), [['\\', '<br>'], '']);
     });
 
     it('account', () => {
-      assert.deepStrictEqual(inspect(parser('@0'), ctx), [['@0'], '']);
-      assert.deepStrictEqual(inspect(parser('_@0'), ctx), [['_', '@0'], '']);
-      assert.deepStrictEqual(inspect(parser('$@0'), ctx), [['$', '@0'], '']);
-      assert.deepStrictEqual(inspect(parser('+@0'), ctx), [['+', '@0'], '']);
-      assert.deepStrictEqual(inspect(parser('-@0'), ctx), [['-', '@0'], '']);
-      assert.deepStrictEqual(inspect(parser('0@0'), ctx), [['0', '@0'], '']);
-      assert.deepStrictEqual(inspect(parser('a@0'), ctx), [['a', '@0'], '']);
-      assert.deepStrictEqual(inspect(parser('A@0'), ctx), [['A', '@0'], '']);
-      assert.deepStrictEqual(inspect(parser('aA@0'), ctx), [['aA', '@0'], '']);
-      assert.deepStrictEqual(inspect(parser(' @0'), ctx), [[' ', '@0'], '']);
-      assert.deepStrictEqual(inspect(parser('@@0'), ctx), [['@', '@0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('@0', new Context())), [['@0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('_@0', new Context())), [['_', '@0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$@0', new Context())), [['$', '@0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('+@0', new Context())), [['+', '@0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('-@0', new Context())), [['-', '@0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('0@0', new Context())), [['0', '@0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a@0', new Context())), [['a', '@0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('A@0', new Context())), [['A', '@0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('aA@0', new Context())), [['aA', '@0'], '']);
+      assert.deepStrictEqual(inspect(parser, input(' @0', new Context())), [[' ', '@0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('@@0', new Context())), [['@', '@0'], '']);
     });
 
     it('hashtag', () => {
-      assert.deepStrictEqual(inspect(parser('#0'), ctx), [['#0'], '']);
-      assert.deepStrictEqual(inspect(parser('_#0'), ctx), [['_', '#0'], '']);
-      assert.deepStrictEqual(inspect(parser('$#0'), ctx), [['$', '#0'], '']);
-      assert.deepStrictEqual(inspect(parser('+#0'), ctx), [['+', '#0'], '']);
-      assert.deepStrictEqual(inspect(parser('-#0'), ctx), [['-', '#0'], '']);
-      assert.deepStrictEqual(inspect(parser('0#0'), ctx), [['0', '#0'], '']);
-      assert.deepStrictEqual(inspect(parser('a#0'), ctx), [['a', '#0'], '']);
-      assert.deepStrictEqual(inspect(parser('A#0'), ctx), [['A', '#0'], '']);
-      assert.deepStrictEqual(inspect(parser('aA#0'), ctx), [['aA', '#0'], '']);
-      assert.deepStrictEqual(inspect(parser(' #0'), ctx), [[' ', '#0'], '']);
-      assert.deepStrictEqual(inspect(parser('##0'), ctx), [['#', '#0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('#0', new Context())), [['#0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('_#0', new Context())), [['_', '#0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$#0', new Context())), [['$', '#0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('+#0', new Context())), [['+', '#0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('-#0', new Context())), [['-', '#0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('0#0', new Context())), [['0', '#0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a#0', new Context())), [['a', '#0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('A#0', new Context())), [['A', '#0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('aA#0', new Context())), [['aA', '#0'], '']);
+      assert.deepStrictEqual(inspect(parser, input(' #0', new Context())), [[' ', '#0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('##0', new Context())), [['#', '#0'], '']);
     });
 
     it('anchor', () => {
-      assert.deepStrictEqual(inspect(parser('>>0'), ctx), [['>', '>0'], '']);
-      assert.deepStrictEqual(inspect(parser('_>>0'), ctx), [['_', '>', '>0'], '']);
-      assert.deepStrictEqual(inspect(parser('$>>0'), ctx), [['$', '>', '>0'], '']);
-      assert.deepStrictEqual(inspect(parser('+>>0'), ctx), [['+', '>', '>0'], '']);
-      assert.deepStrictEqual(inspect(parser('->>0'), ctx), [['-', '>', '>0'], '']);
-      assert.deepStrictEqual(inspect(parser('0>>0'), ctx), [['0', '>', '>0'], '']);
-      assert.deepStrictEqual(inspect(parser('a>>0'), ctx), [['a', '>', '>0'], '']);
-      assert.deepStrictEqual(inspect(parser('A>>0'), ctx), [['A', '>', '>0'], '']);
-      assert.deepStrictEqual(inspect(parser('aA>>0'), ctx), [['aA', '>', '>0'], '']);
-      assert.deepStrictEqual(inspect(parser(' >>0'), ctx), [[' ', '>', '>0'], '']);
-      assert.deepStrictEqual(inspect(parser('>>>>0'), ctx), [['>', '>', '>', '>0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('>>0', new Context())), [['>', '>0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('_>>0', new Context())), [['_', '>', '>0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$>>0', new Context())), [['$', '>', '>0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('+>>0', new Context())), [['+', '>', '>0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('->>0', new Context())), [['-', '>', '>0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('0>>0', new Context())), [['0', '>', '>0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a>>0', new Context())), [['a', '>', '>0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('A>>0', new Context())), [['A', '>', '>0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('aA>>0', new Context())), [['aA', '>', '>0'], '']);
+      assert.deepStrictEqual(inspect(parser, input(' >>0', new Context())), [[' ', '>', '>0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('>>>>0', new Context())), [['>', '>', '>', '>0'], '']);
     });
 
   });

package/src/parser/source/text.ts

@@ -1,6 +1,6 @@
 import { TextParser, TxtParser } from '../source';
 import { Command } from '../context';
-import { List, Data } from '../../combinator/data/parser';
+import { List, Node } from '../../combinator/data/parser';
 import { union, consume } from '../../combinator';
 import { html } from 'typed-dom/dom';
 
@@ -26,17 +26,17 @@ export const text: TextParser = input => {
         default:
           consume(1, context);
           context.position += 1;
-          return new List([new Data(source.slice(position + 1, context.position))]);
+          return new List([new Node(source.slice(position + 1, context.position))]);
       }
     case '\r':
       consume(-1, context);
       return new List();
     case '\n':
       context.linebreak ||= source.length - position;
-      return new List([new Data(html('br'))]);
+      return new List([new Node(html('br'))]);
     default:
       assert(char !== '\n');
-      if (context.sequential) return new List([new Data(char)]);
+      if (context.sequential) return new List([new Node(char)]);
       nonWhitespace.lastIndex = position + 1;
       const s = canSkip(source, position);
       let i = s
@@ -55,7 +55,7 @@ export const text: TextParser = input => {
       const linestart = position === 0 || source[position - 1] === '\n';
       return position === context.position || s && !linestart || lineend
         ? new List()
-        : new List([new Data(source.slice(position, context.position))]);
+        : new List([new Node(source.slice(position, context.position))]);
   }
 };
 

package/src/parser/source/unescapable.test.ts

@@ -1,48 +1,48 @@
 import { unescsource } from './unescapable';
 import { some } from '../../combinator';
 import { input } from '../../combinator/data/parser';
+import { Context } from '../context';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/source/unescapable', () => {
   describe('unescsource', () => {
-    const parser = (source: string) => some(unescsource)(input(source, ctx));
-    const { context: ctx } = input('', {});
+    const parser = some(unescsource);
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser(''), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser, input('', new Context())), undefined);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser('a'), ctx), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser('ab'), ctx), [['ab'], '']);
-      assert.deepStrictEqual(inspect(parser('a b c'), ctx), [['a', ' b', ' c'], '']);
-      assert.deepStrictEqual(inspect(parser('09あいAZaz'), ctx), [['09', 'あいAZaz'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a', new Context())), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('ab', new Context())), [['ab'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a b c', new Context())), [['a', ' b', ' c'], '']);
+      assert.deepStrictEqual(inspect(parser, input('09あいAZaz', new Context())), [['09', 'あいAZaz'], '']);
     });
 
     it('space', () => {
-      assert.deepStrictEqual(inspect(parser(' '), ctx), [[' '], '']);
-      assert.deepStrictEqual(inspect(parser('  '), ctx), [['  '], '']);
-      assert.deepStrictEqual(inspect(parser('   '), ctx), [['   '], '']);
-      assert.deepStrictEqual(inspect(parser(' \n'), ctx), [[' ', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('  \n'), ctx), [['  ', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('   \n'), ctx), [['   ', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input(' ', new Context())), [[' '], '']);
+      assert.deepStrictEqual(inspect(parser, input('  ', new Context())), [['  '], '']);
+      assert.deepStrictEqual(inspect(parser, input('   ', new Context())), [['   '], '']);
+      assert.deepStrictEqual(inspect(parser, input(' \n', new Context())), [[' ', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('  \n', new Context())), [['  ', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('   \n', new Context())), [['   ', '<br>'], '']);
     });
 
     it('linebreak', () => {
-      assert.deepStrictEqual(inspect(parser('\n\n'), ctx), [['<br>', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\n\n', new Context())), [['<br>', '<br>'], '']);
     });
 
     it('\\', () => {
-      assert.deepStrictEqual(inspect(parser('\\'), ctx), [['\\'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\\'), ctx), [['\\', '\\'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\\\\'), ctx), [['\\', '\\', '\\'], '']);
-      assert.deepStrictEqual(inspect(parser('\\ '), ctx), [['\\', ' '], '']);
-      assert.deepStrictEqual(inspect(parser('\\_'), ctx), [['\\', '_'], '']);
-      assert.deepStrictEqual(inspect(parser('\\0'), ctx), [['\\0'], '']);
-      assert.deepStrictEqual(inspect(parser('\\a'), ctx), [['\\a'], '']);
-      assert.deepStrictEqual(inspect(parser('\\`'), ctx), [['\\', '`'], '']);
-      assert.deepStrictEqual(inspect(parser('\\　'), ctx), [['\\', '　'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\n'), ctx), [['\\', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\', new Context())), [['\\'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\\\', new Context())), [['\\', '\\'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\\\\\', new Context())), [['\\', '\\', '\\'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\ ', new Context())), [['\\', ' '], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\_', new Context())), [['\\', '_'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\0', new Context())), [['\\0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\a', new Context())), [['\\a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\`', new Context())), [['\\', '`'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\　', new Context())), [['\\', '　'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\\n', new Context())), [['\\', '<br>'], '']);
     });
 
   });

package/src/parser/source/unescapable.ts

@@ -1,6 +1,6 @@
 import { UnescapableSourceParser } from '../source';
 import { Command } from '../context';
-import { List, Data } from '../../combinator/data/parser';
+import { List, Node } from '../../combinator/data/parser';
 import { consume } from '../../combinator';
 import { nonWhitespace, canSkip, next } from './text';
 import { html } from 'typed-dom/dom';
@@ -17,15 +17,15 @@ export const unescsource: UnescapableSourceParser = ({ context }) => {
     case Command.Escape:
       consume(1, context);
       context.position += 1;
-      return new List([new Data(source.slice(position + 1, position + 2))]);
+      return new List([new Node(source.slice(position + 1, position + 2))]);
     case '\r':
       return new List();
     case '\n':
       context.linebreak ||= source.length - position;
-      return new List([new Data(html('br'))]);
+      return new List([new Node(html('br'))]);
     default:
       assert(char !== '\n');
-      if (context.sequential) return new List([new Data(char)]);
+      if (context.sequential) return new List([new Node(char)]);
       nonWhitespace.lastIndex = position + 1;
       let i = canSkip(source, position)
         ? nonWhitespace.test(source)
@@ -36,6 +36,6 @@ export const unescsource: UnescapableSourceParser = ({ context }) => {
       i -= position;
       consume(i - 1, context);
       context.position += i - 1;
-      return new List([new Data(source.slice(position, context.position))]);
+      return new List([new Node(source.slice(position, context.position))]);
   }
 };