securemark 0.299.4 → 0.300.1

package/src/parser/source/escapable.ts

@@ -1,46 +1,45 @@
 import { EscapableSourceParser } from '../source';
+import { Result, Node } from '../../combinator/parser';
+import { spend } from '../../combinator';
 import { Command } from '../context';
 import { Flag } from '../node';
-import { List, Node } from '../../combinator/data/parser';
-import { spend } from '../../combinator';
 import { html } from 'typed-dom/dom';
 
-export const escsource: EscapableSourceParser = context => {
-  const { source, position } = context;
+export const escsource: EscapableSourceParser = (input, output) => {
+  const { source, position } = input;
   if (position === source.length) return;
   const char = source[position];
-  spend(context, 1);
-  context.position += 1;
+  spend(input, output, 1);
+  input.position += 1;
   switch (char) {
     case Command.Escape:
-      spend(context, 1);
-      context.position += 1;
-      return new List([new Node(source.slice(position + 1, position + 2))]);
+      spend(input, output, 1);
+      input.position += 1;
+      return output.append(new Node(source.slice(position + 1, position + 2)));
     case '\\':
       switch (source[position + 1]) {
         case undefined:
         case '\r':
         case '\n':
-          return new List([new Node(char)]);
+          return output.append(new Node(char));
         default:
-          spend(context, 1);
-          context.position += 1;
-          return new List([new Node(source.slice(position, position + 2))]);
+          spend(input, output, 1);
+          input.position += 1;
+          return output.append(new Node(source.slice(position, position + 2)));
       }
     case '\r':
-      return new List();
+      return Result.succ;
     case '\n':
-      context.linebreak ||= source.length - position;
-      return new List([new Node(html('br'), Flag.blank)]);
+      input.linebreak ||= source.length - position;
+      return output.append(new Node(html('br'), Flag.blank));
     default:
       assert(char !== '\n');
-      if (context.sequential) return new List([new Node(char)]);
       let i = seek(source, position);
       assert(i > position);
       i -= position;
-      spend(context, i - 1);
-      context.position += i - 1;
-      return new List([new Node(source.slice(position, context.position))]);
+      spend(input, output, i - 1);
+      input.position += i - 1;
+      return output.append(new Node(source.slice(position, input.position)));
   }
 };
 

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

@@ -1,6 +1,5 @@
 import { contentline } from './line';
-import { input } from '../../combinator/data/parser';
-import { Context } from '../context';
+import { input } from '../context';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/source/line', () => {
@@ -8,25 +7,25 @@ describe('Unit: parser/source/line', () => {
     const parser = contentline;
 
     it('invalid', () => {
-      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);
+      assert.deepStrictEqual(inspect(parser, input('')), undefined);
+      assert.deepStrictEqual(inspect(parser, input(' ')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('\n')), undefined);
+      assert.deepStrictEqual(inspect(parser, input(' \n')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('\n\n')), undefined);
     });
 
     it('valid', () => {
-      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())), [[], '']);
+      assert.deepStrictEqual(inspect(parser, input('a')), [[], '']);
+      assert.deepStrictEqual(inspect(parser, input('a ')), [[], '']);
+      assert.deepStrictEqual(inspect(parser, input(' a')), [[], '']);
+      assert.deepStrictEqual(inspect(parser, input(' a ')), [[], '']);
+      assert.deepStrictEqual(inspect(parser, input(' a\n')), [[], '']);
+      assert.deepStrictEqual(inspect(parser, input(' a \n')), [[], '']);
+      assert.deepStrictEqual(inspect(parser, input('ab')), [[], '']);
+      assert.deepStrictEqual(inspect(parser, input('a\nb')), [[], 'b']);
+      assert.deepStrictEqual(inspect(parser, input('\\\n')), [[], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\ \\\n')), [[], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\ \\ \\\n')), [[], '']);
     });
 
   });

package/src/parser/source/line.ts

@@ -1,39 +1,35 @@
 import { AnyLineParser, EmptyLineParser, EmptySegmentParser, ContentLineParser } from '../source';
 import { Segment } from '../context';
-import { List } from '../../combinator/data/parser';
 
-export const anyline: AnyLineParser = input => {
-  const context = input;
-  const { source, position } = context;
+export const anyline: AnyLineParser = (input, output) => {
+  const { source, position } = input;
   if (position === source.length) return;
-  context.position = source.indexOf('\n', position) + 1 || source.length;
-  return new List();
+  input.position = source.indexOf('\n', position) + 1 || source.length;
+  return output.context;
 };
 
 const regEmptyline = /[^\S\r\n]*(?:$|\r?\n)/y;
-export const emptyline: EmptyLineParser = input => {
-  const context = input;
-  const { source, position } = context;
+export const emptyline: EmptyLineParser = (input, output) => {
+  const { source, position } = input;
   if (position === source.length) return;
   const i = eoel(source, position);
   if (i === position) return;
-  context.position = i;
-  return new List();
+  input.position = i;
+  return output.context;
 };
-export const emptysegment: EmptySegmentParser = input => {
-  const context = input;
-  const { source, position, segment } = context;
+export const emptysegment: EmptySegmentParser = (input, output) => {
+  const { source, position, segment } = input;
   if (position === source.length) return;
   if (segment & Segment.write) {
     if (segment !== (Segment.empty | Segment.write)) return;
-    context.position = source.length;
-    return new List();
+    input.position = source.length;
+    return output.context;
   }
   const i = eoel(source, position);
   if (i === position) return;
-  context.position = i;
-  context.segment = Segment.empty;
-  return new List();
+  input.position = i;
+  input.segment = Segment.empty;
+  return output.context;
 };
 function eoel(source: string, position: number): number {
   const char = source[position];
@@ -44,9 +40,8 @@ function eoel(source: string, position: number): number {
 }
 
 const regContentline = /[^\S\r\n]*\S[^\r\n]*(?:$|\r?\n)/y;
-export const contentline: ContentLineParser = input => {
-  const context = input;
-  const { source, position } = context;
+export const contentline: ContentLineParser = (input, output) => {
+  const { source, position } = input;
   if (position === source.length) return;
   const char = source[position];
   if (char === '\n' || char === '\r' && source[position + 1] === '\n') return;
@@ -54,6 +49,6 @@ export const contentline: ContentLineParser = input => {
   regContentline.test(source);
   const i = regContentline.lastIndex;
   if (i === 0) return;
-  context.position = i;
-  return new List();
+  input.position = i;
+  return output.context;
 };

package/src/parser/source/str.ts

@@ -1,23 +1,30 @@
 import { StrParser } from '../source';
-import { Parser, List, Node } from '../../combinator/data/parser';
-import { matcher, tester } from '../../combinator/data/delimiter';
+import { Parser, Node } from '../../combinator/parser';
+import { matcher, tester } from '../../combinator/delimiter';
 
 export function str(pattern: string | RegExp, after?: string | RegExp): StrParser;
 export function str(pattern: string | RegExp, after?: string | RegExp): Parser<string> {
-  return matcher(pattern, true, after ? tester(after, false) : undefined);
+  const match = matcher(pattern, true, after ? tester(after, false) : undefined);
+  return (input, output) => {
+    const src = match(input, output);
+    if (src === undefined) return;
+    return output.append(new Node(src));
+  };
 }
 
 export function strs(char: string, min?: number, max?: number): StrParser;
 export function strs(char: string, min: number = 1, max: number = -1): Parser<string> {
   assert(char.length === 1);
-  return context => {
-    const { source, position } = context;
+  return (input, output) => {
+    const { source, position } = input;
+    let pos = position;
     let cnt = 0;
-    for (; cnt !== max && context.position < source.length && source[context.position] === char; ++cnt) {
-      context.position += char.length;
+    for (; cnt !== max && pos < source.length && source[pos] === char;) {
+      pos += char.length;
+      ++cnt;
     }
-    return cnt >= min
-      ? new List([new Node(source.slice(position, context.position))])
-      : undefined;
+    if (cnt < min) return;
+    input.position = pos;
+    return output.append(new Node(source.slice(position, input.position)));
   };
 }

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

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

package/src/parser/source/text.ts

@@ -1,49 +1,48 @@
 import { TextParser, TxtParser } from '../source';
+import { Result, Node } from '../../combinator/parser';
+import { union, spend } from '../../combinator';
 import { State, Command } from '../context';
 import { Flag } from '../node';
-import { List, Node } from '../../combinator/data/parser';
-import { union, spend } from '../../combinator';
+import { isWhitespace } from './whitespace';
 import { html } from 'typed-dom/dom';
 
 export const nonWhitespace = /[^ \t　]/g;
 
-export const text: TextParser = input => {
-  const context = input;
-  const { source, position, state } = context;
+export const text: TextParser = (input, output) => {
+  const { source, position, state } = input;
   if (position === source.length) return;
   const char = source[position];
-  spend(context, 1);
-  context.position += 1;
+  spend(input, output, 1);
+  input.position += 1;
   switch (char) {
     case Command.Escape:
     case '\\':
       switch (source[position + 1]) {
         case undefined:
-          return new List();
+          return Result.succ;
         case '\r':
         case '\n':
           assert(char !== Command.Escape);
-          return new List();
+          return Result.succ;
         default:
-          spend(context, 1);
-          context.position += 1;
-          return new List([new Node(source.slice(position + 1, context.position))]);
+          spend(input, output, 1);
+          input.position += 1;
+          return output.append(new Node(source.slice(position + 1, input.position)));
       }
     case '\r':
-      return new List();
+      return Result.succ;
     case '\n':
-      context.linebreak ||= source.length - position;
-      return new List([new Node(html('br'), Flag.blank)]);
+      input.linebreak ||= source.length - position;
+      return output.append(new Node(html('br'), Flag.blank));
     default:
       assert(char !== '\n');
-      if (context.sequential) return new List([new Node(char)]);
       nonWhitespace.lastIndex = position + 1;
       const s = canSkip(source, position);
       let i = s
         ? nonWhitespace.test(source)
           ? nonWhitespace.lastIndex - 1
           : source.length
-        : next(source, position, state);
+        : next(source, position, input.whitespace, state);
       assert(i > position);
       const lineend = 0
         || s && i === source.length
@@ -51,11 +50,11 @@ export const text: TextParser = input => {
         || s && source[i] === '\n';
       i -= position;
       i = lineend ? i : i - +s || 1;
-      spend(context, i - 1);
-      context.position += i - 1;
+      spend(input, output, i - 1);
+      input.position += i - 1;
       const linestart = position === 0 || source[position - 1] === '\n';
-      if (position === context.position || s && !linestart || lineend) return new List();
-      return new List([new Node(source.slice(position, context.position))]);
+      if (position === input.position || s && !linestart || lineend) return Result.succ;
+      return output.append(new Node(source.slice(position, input.position)));
   }
 };
 
@@ -69,28 +68,15 @@ export function canSkip(source: string, position: number): boolean {
   if (position + 1 === source.length) return true;
   return isWhitespace(source[position + 1], true);
 }
-function isWhitespace(char: string, linebreak: boolean): boolean {
-  switch (char) {
-    case ' ':
-    case '\t':
-    case '　':
-      return true;
-    case '\r':
-    case '\n':
-      return linebreak;
-    default:
-      return false;
-  }
-}
 
-function next(source: string, position: number, state: number): number {
-  let index= seek(source, position, state);
+function next(source: string, position: number, space: boolean, state: number): number {
+  let index= seek(source, position, space, state);
   assert(index > position);
   if (index === source.length) return index;
   const char = source[index];
   switch (char) {
     case '%':
-      assert(source.startsWith('%]', index) && isWhitespace(source[index - 1], true));
+      assert(source.startsWith('%]', index) && isWhitespace(source[index - 1]));
       index += index - 1 > position
         ? -1
         : 0;
@@ -168,7 +154,7 @@ export function isAlphanumeric(char: string): boolean {
   return 'A' <= char && char <= 'Z';
 }
 
-function seek(source: string, position: number, state: number): number {
+function seek(source: string, position: number, space: boolean, state: number): number {
   for (let i = position + 1; i < source.length; ++i) {
     const char = source[i];
     switch (char) {
@@ -209,7 +195,7 @@ function seek(source: string, position: number, state: number): number {
         if (source[i + 1] === char && source[i + 2] === char) return i;
         continue;
       case '%':
-        if (source[i + 1] === ']' && isWhitespace(source[i - 1], true)) return i;
+        if (source[i + 1] === ']' && isWhitespace(source[i - 1])) return i;
         continue;
       case ':':
         if (source[i + 1] === '/' && source[i + 2] === '/') return i;
@@ -217,30 +203,14 @@ function seek(source: string, position: number, state: number): number {
       case '&':
         if (source[i + 1] !== ' ') return i;
         continue;
-      case ' ':
-      case '\t':
-      case '　':
-        if (i + 1 === source.length) return i;
-        switch (source[i + 1]) {
-          case ' ':
-          case '\t':
-          case '\r':
-          case '\n':
-          case '　':
-            return i;
-          case '\\':
-            if (i + 2 === source.length) return i;
-            switch (source[i + 2]) {
-              case ' ':
-              case '\t':
-              case '\r':
-              case '\n':
-              case '　':
-                return i;
-            }
-        }
-        continue;
       default:
+        if (!isWhitespace(char)) continue;
+        if (space) return i;
+        if (i + 1 === source.length) return i;
+        if (isWhitespace(source[i + 1])) return i;
+        if (source[i + 1] !== '\\') continue;
+        if (i + 2 === source.length) return i;
+        if (isWhitespace(source[i + 2])) return i;
         continue;
     }
     assert(false);