securemark 0.299.4 → 0.300.0

package/src/parser/inline/bracket.ts

@@ -1,6 +1,6 @@
-import { BracketParser } from '../inline';
-import { Context, State, Recursion, Backtrack } from '../context';
-import { List, Node } from '../../combinator/data/parser';
+import { BracketParser, InlineParser } from '../inline';
+import { Input, State, Recursion, Backtrack } from '../context';
+import { List, Node, Result } from '../../combinator/parser';
 import { union, some, recursion, precedence, surround, isBacktrack, setBacktrack, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { textlink } from './link';
@@ -8,127 +8,152 @@ import { str } from '../source';
 import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
-export function bracketname(context: Context, opener: number, closer: number): string {
-  const { range, linebreak } = context;
+export function bracketname(input: Input, opener: number, closer: number): string {
+  const { range, linebreak } = input;
   return range - opener - closer === 0 || linebreak === 0 && range - opener - closer <= 16
     ? 'paren'
     : 'bracket';
 }
 
 export const bracket: BracketParser = lazy(() => union([
-  input => {
+  (input, output) => {
     const { source, position } = input;
     switch (source[position]) {
       case '(':
-        return p1(input);
+        return p1(input, output);
       case '（':
-        return p2(input);
+        return p2(input, output);
       case '[':
-        return s1(input);
+        return s1(input, output);
       case '［':
-        return s2(input);
+        return s2(input, output);
       case '{':
-        return c1(input);
+        return c1(input, output);
       case '｛':
-        return c2(input);
+        return c2(input, output);
       case '"':
-        return d1(input);
+        return d1(input, output);
     }
   }
 ]));
 
-const p1 = lazy(() => surround(
+const p1 = lazy(() => surround<InlineParser>(
   str('('),
-  precedence(1, recursion(Recursion.bracket, some(inline, ')', [[')', 1]]))),
+  precedence(1, recursion(Recursion.inline, some(inline, ')', [[')', 1]]))),
   str(')'),
   true, [],
-  ([as, bs = new List(), cs], context) => new List([
-    new Node(html('span',
-      { class: bracketname(context, 1, 1) },
-      defrag(unwrap(as.import(bs as List<Node<string>>).import(cs)))))
-  ]),
-  ([as, bs = new List()], context) => new List([
-    new Node(html('span',
-      { class: bracketname(context, 1, 0) },
-      defrag(unwrap(as.import(bs as List<Node<string>>)))))
-  ])));
+  ([as, bs = new List(), cs], input, output) =>
+    output.append(new Node(html('span',
+      { class: bracketname(input, 1, 1) },
+      defrag(unwrap(as.import(bs as List<Node<string>>).import(cs)))))),
+  ([as, bs = new List()], input, output) =>
+    output.append(new Node(html('span',
+      { class: bracketname(input, 1, 0) },
+      defrag(unwrap(as.import(bs as List<Node<string>>))))))));
 
-const p2 = lazy(() => surround(
+const p2 = lazy(() => surround<InlineParser>(
   str('（'),
-  precedence(1, recursion(Recursion.bracket, some(inline, '）', [['）', 1]]))),
+  precedence(1, recursion(Recursion.inline, some(inline, '）', [['）', 1]]))),
   str('）'),
   true, [],
-  ([as, bs = new List(), cs], context) => new List([
-    new Node(html('span',
-      { class: bracketname(context, 1, 1) },
-      defrag(unwrap(as.import(bs as List<Node<string>>).import(cs)))))
-  ]),
-  ([as, bs = new List()], context) => new List([
-    new Node(html('span',
-      { class: bracketname(context, 1, 0) },
-      defrag(unwrap(as.import(bs as List<Node<string>>)))))
-  ])));
+  ([as, bs = new List(), cs], input, output) =>
+    output.append(new Node(html('span',
+      { class: bracketname(input, 1, 1) },
+      defrag(unwrap(as.import(bs as List<Node<string>>).import(cs)))))),
+  ([as, bs = new List()], input, output) =>
+    output.append(new Node(html('span',
+      { class: bracketname(input, 1, 0) },
+      defrag(unwrap(as.import(bs as List<Node<string>>))))))));
 
-const s1 = lazy(() => surround(
+const s1 = lazy(() => surround<InlineParser>(
   str('['),
-  precedence(1, recursion(Recursion.bracket, some(inline, ']', [[']', 1]]))),
+  precedence(1, recursion(Recursion.inline, some(inline, ']', [[']', 1]]))),
   str(']'),
   true,
   [2 | Backtrack.common],
-  ([as, bs = new List(), cs], context) => {
-    const { source, position, range, linebreak } = context;
+  ([as, bs = new List(), cs], input, output) => {
+    output.import(as.import(bs as List<Node<string>>).import(cs));
+    const { source, position, range, linebreak } = input;
     const head = position - range;
     if (source[head + 1] === '[' && (linebreak !== 0 || source[position - 2] !== ']')) {
-      setBacktrack(context, 2 | Backtrack.doublebracket, head);
+      setBacktrack(input, 2 | Backtrack.doublebracket, head);
     }
-    if (context.state & State.link) {
+    if (input.state & State.link) {
       if (linebreak !== 0) {
-        setBacktrack(context, 2 | Backtrack.link | Backtrack.ruby, head);
+        setBacktrack(input, 2 | Backtrack.link | Backtrack.ruby, head);
       }
       else if (source[position] !== '{') {
-        setBacktrack(context, 2 | Backtrack.link, head);
+        setBacktrack(input, 2 | Backtrack.link, head);
       }
       else {
-        if (!isBacktrack(context, 1 | Backtrack.link) && !textlink(context)) {
-          setBacktrack(context, 2 | Backtrack.link, head);
+        if (!isBacktrack(input, 1 | Backtrack.link)) {
+          input.memory = {
+            position,
+            range,
+            head,
+          };
+          return cont;
         }
-        context.position = position;
-        context.range = range;
+        input.position = position;
+        input.range = range;
       }
     }
-    return as.import(bs as List<Node<string>>).import(cs);
+    return output.context;
   },
-  ([as, bs = new List()]) => as.import(bs as List<Node<string>>)));
+  ([as, bs = new List()], _, output) => output.import(as.import(bs as List<Node<string>>))));
 
-const s2 = lazy(() => surround(
+interface Memory {
+  readonly position: number;
+  readonly range: number;
+  readonly head: number;
+}
+const cont: Result<HTMLElement | string, Input<Memory>> = [
+  (_, output) => {
+    output.push();
+    return output.context;
+  },
+  lazy(() => textlink),
+  (input, output) => {
+    const { memory: { position, range, head } } = input;
+    if (output.state) {
+      setBacktrack(input, 2 | Backtrack.link, head);
+    }
+    input.position = position;
+    input.range = range;
+    output.pop();
+    return output.context;
+  },
+];
+
+const s2 = lazy(() => surround<InlineParser>(
   str('［'),
-  precedence(1, recursion(Recursion.bracket, some(inline, '］', [['］', 1]]))),
+  precedence(1, recursion(Recursion.inline, some(inline, '］', [['］', 1]]))),
   str('］'),
   true, [],
   undefined,
-  ([as, bs = new List()]) => as.import(bs as List<Node<string>>)));
+  ([as, bs = new List()], _, output) => output.import(as.import(bs as List<Node<string>>))));
 
-const c1 = lazy(() => surround(
+const c1 = lazy(() => surround<InlineParser>(
   str('{'),
-  precedence(1, recursion(Recursion.bracket, some(inline, '}', [['}', 1]]))),
+  precedence(1, recursion(Recursion.inline, some(inline, '}', [['}', 1]]))),
   str('}'),
   true, [],
   undefined,
-  ([as, bs = new List()]) => as.import(bs as List<Node<string>>)));
+  ([as, bs = new List()], _, output) => output.import(as.import(bs as List<Node<string>>))));
 
-const c2 = lazy(() => surround(
+const c2 = lazy(() => surround<InlineParser>(
   str('｛'),
-  precedence(1, recursion(Recursion.bracket, some(inline, '｝', [['｝', 1]]))),
+  precedence(1, recursion(Recursion.inline, some(inline, '｝', [['｝', 1]]))),
   str('｝'),
   true, [],
   undefined,
-  ([as, bs = new List()]) => as.import(bs as List<Node<string>>)));
+  ([as, bs = new List()], _, output) => output.import(as.import(bs as List<Node<string>>))));
 
-const d1 = lazy(() => surround(
+const d1 = lazy(() => surround<InlineParser>(
   str('"'),
   // 改行の優先度を構文ごとに変える場合シグネチャの優先度対応が必要
-  precedence(2, recursion(Recursion.bracket, some(inline, /["\n]/y, [['"', 2], ['\n', 3]]))),
+  precedence(2, recursion(Recursion.inline, some(inline, /["\n]/y, [['"', 2], ['\n', 3]]))),
   str('"'),
   true, [],
   undefined,
-  ([as, bs = new List()]) => as.import(bs as List<Node<string>>)));
+  ([as, bs = new List()], _, output) => output.import(as.import(bs as List<Node<string>>))));

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

@@ -1,7 +1,6 @@
 import { code } from './code';
 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/inline/code', () => {
@@ -9,47 +8,47 @@ describe('Unit: parser/inline/code', () => {
     const parser = some(code);
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser, input('', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('`', new Context())), [['`'], '']);
-      assert.deepStrictEqual(inspect(parser, input('``', new Context())), [['``'], '']);
-      assert.deepStrictEqual(inspect(parser, input('``a`', new Context())), [['<code class="invalid">``a`</code>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('`a``', new Context())), [ [ '<code class="invalid">`a``</code>' ], '' ]);
-      assert.deepStrictEqual(inspect(parser, input('`\n`', new Context())), [['`'], '\n`']);
-      assert.deepStrictEqual(inspect(parser, input('`a\nb`', new Context())), [['<code class="invalid">`a</code>'], '\nb`']);
-      assert.deepStrictEqual(inspect(parser, input('`a\\\nb`', new Context())), [['<code class="invalid">`a\\</code>'], '\nb`']);
-      assert.deepStrictEqual(inspect(parser, input(' ` `', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('`')), [['`'], '']);
+      assert.deepStrictEqual(inspect(parser, input('``')), [['``'], '']);
+      assert.deepStrictEqual(inspect(parser, input('``a`')), [['<code class="invalid">``a`</code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('`a``')), [ [ '<code class="invalid">`a``</code>' ], '' ]);
+      assert.deepStrictEqual(inspect(parser, input('`\n`')), [['`'], '\n`']);
+      assert.deepStrictEqual(inspect(parser, input('`a\nb`')), [['<code class="invalid">`a</code>'], '\nb`']);
+      assert.deepStrictEqual(inspect(parser, input('`a\\\nb`')), [['<code class="invalid">`a\\</code>'], '\nb`']);
+      assert.deepStrictEqual(inspect(parser, input(' ` `')), undefined);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser, input('` `', new Context())), [['<code data-src="` `"> </code>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('`  `', new Context())), [['<code data-src="`  `">  </code>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('`   `', new Context())), [['<code data-src="`   `">   </code>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('`a`', new Context())), [['<code data-src="`a`">a</code>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('`ab`', new Context())), [['<code data-src="`ab`">ab</code>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('`a`b', new Context())), [['<code data-src="`a`">a</code>'], 'b']);
-      assert.deepStrictEqual(inspect(parser, input('`a`b`', new Context())), [['<code data-src="`a`">a</code>'], 'b`']);
-      assert.deepStrictEqual(inspect(parser, input('`a`\n', new Context())), [['<code data-src="`a`">a</code>'], '\n']);
+      assert.deepStrictEqual(inspect(parser, input('` `')), [['<code data-src="` `"> </code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('`  `')), [['<code data-src="`  `">  </code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('`   `')), [['<code data-src="`   `">   </code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('`a`')), [['<code data-src="`a`">a</code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('`ab`')), [['<code data-src="`ab`">ab</code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('`a`b')), [['<code data-src="`a`">a</code>'], 'b']);
+      assert.deepStrictEqual(inspect(parser, input('`a`b`')), [['<code data-src="`a`">a</code>'], 'b`']);
+      assert.deepStrictEqual(inspect(parser, input('`a`\n')), [['<code data-src="`a`">a</code>'], '\n']);
     });
 
     it('escape', () => {
-      assert.deepStrictEqual(inspect(parser, input('`\\`', new Context())), [['<code data-src="`\\`">\\</code>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('`\\\\`', new Context())), [['<code data-src="`\\\\`">\\\\</code>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('`&nbsp;`', new Context())), [['<code data-src="`&amp;nbsp;`">&amp;nbsp;</code>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('` `` `', new Context())), [['<code data-src="` `` `">``</code>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('`` ` ``', new Context())), [['<code data-src="`` ` ``">`</code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('`\\`')), [['<code data-src="`\\`">\\</code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('`\\\\`')), [['<code data-src="`\\\\`">\\\\</code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('`&nbsp;`')), [['<code data-src="`&amp;nbsp;`">&amp;nbsp;</code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('` `` `')), [['<code data-src="` `` `">``</code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('`` ` ``')), [['<code data-src="`` ` ``">`</code>'], '']);
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser, input('`<wbr>`', new Context())), [['<code data-src="`&lt;wbr&gt;`">&lt;wbr&gt;</code>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('`*u*`', new Context())), [['<code data-src="`*u*`">*u*</code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('`<wbr>`')), [['<code data-src="`&lt;wbr&gt;`">&lt;wbr&gt;</code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('`*u*`')), [['<code data-src="`*u*`">*u*</code>'], '']);
     });
 
     it('trim', () => {
-      assert.deepStrictEqual(inspect(parser, input('`a `', new Context())), [['<code data-src="`a `">a </code>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('` a`', new Context())), [['<code data-src="` a`"> a</code>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('` a `', new Context())), [['<code data-src="` a `"> a </code>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('`  a  `', new Context())), [['<code data-src="`  a  `">  a  </code>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('`\ta\t`', new Context())), [['<code data-src="`\ta\t`">\ta\t</code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('`a `')), [['<code data-src="`a `">a </code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('` a`')), [['<code data-src="` a`"> a</code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('` a `')), [['<code data-src="` a `"> a </code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('`  a  `')), [['<code data-src="`  a  `">  a  </code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('`\ta\t`')), [['<code data-src="`\ta\t`">\ta\t</code>'], '']);
     });
 
   });

package/src/parser/inline/code.ts

@@ -1,20 +1,20 @@
 import { CodeParser } from '../inline';
-import { List, Node } from '../../combinator/data/parser';
+import { Node } from '../../combinator/parser';
 import { match } from '../../combinator';
 import { invalid } from '../util';
 import { html } from 'typed-dom/dom';
 
 export const code: CodeParser = match(
   /(`+)(?!`)([^\r\n]*?)(?:((?<!`)\1(?!`))|(?=$|\r?\n))/y,
-  ([whole, opener, body, closer]) => () =>
+  ([whole, opener, body, closer]) => (_, output) =>
     closer
-      ? new List([new Node(html('code', { 'data-src': whole }, format(body)))])
+      ? output.append(new Node(html('code', { 'data-src': whole }, format(body))))
       : body
-        ? new List([new Node(html('code', {
+        ? output.append(new Node(html('code', {
             class: 'invalid',
             ...invalid('code', 'syntax', `Missing the closing symbol "${opener}"`)
-          }, whole))])
-        : new List([new Node(opener)]));
+          }, whole)))
+        : output.append(new Node(opener)));
 
 function format(text: string): string {
   return text.length > 2

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

@@ -1,7 +1,6 @@
 import { deletion } from './deletion';
 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/inline/deletion', () => {
@@ -9,38 +8,38 @@ describe('Unit: parser/inline/deletion', () => {
     const parser = some(deletion);
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser, input('', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('~', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('~~', new Context())), [['~~'], '']);
-      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())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('~')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('~~')), [['~~'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~a')), [['~~', 'a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~a~')), [['~~', 'a~'], '']);
+      assert.deepStrictEqual(inspect(parser, input(' ~~a~~')), undefined);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser, input('~~a~~', new Context())), [['<del>a</del>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~a~b~~', new Context())), [['<del>a~b</del>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~ ~~', new Context())), [['<del> </del>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~ a~~', new Context())), [['<del> a</del>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~ a ~~', new Context())), [['<del> a </del>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~  a  ~~', new Context())), [['<del> a </del>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~\na~~', new Context())), [['<del><br>a</del>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~\\\na~~', new Context())), [['<del><br>a</del>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~<wbr>a~~', new Context())), [['<del><wbr>a</del>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~a ~~', new Context())), [['<del>a </del>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~a \n ~~', new Context())), [['<del>a </del>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~a\n~~', new Context())), [['<del>a</del>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~a\n ~~', new Context())), [['<del>a </del>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~a\n<wbr>~~', new Context())), [['<del>a<wbr></del>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~a\nb~~', new Context())), [['<del>a<br>b</del>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~a\\\nb~~', new Context())), [['<del>a<br>b</del>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~\\~~~', new Context())), [['<del>~</del>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~a~~~', new Context())), [['<del>a</del>'], '~']);
+      assert.deepStrictEqual(inspect(parser, input('~~a~~')), [['<del>a</del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~a~b~~')), [['<del>a~b</del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~ ~~')), [['<del> </del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~ a~~')), [['<del> a</del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~ a ~~')), [['<del> a </del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~  a  ~~')), [['<del> a </del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~\na~~')), [['<del><br>a</del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~\\\na~~')), [['<del><br>a</del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~<wbr>a~~')), [['<del><wbr>a</del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~a ~~')), [['<del>a </del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~a \n ~~')), [['<del>a </del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~a\n~~')), [['<del>a</del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~a\n ~~')), [['<del>a </del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~a\n<wbr>~~')), [['<del>a<wbr></del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~a\nb~~')), [['<del>a<br>b</del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~a\\\nb~~')), [['<del>a<br>b</del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~\\~~~')), [['<del>~</del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~a~~~')), [['<del>a</del>'], '~']);
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser, input('~~*~~a~~*~~', new Context())), [['<del><em><del>a</del></em></del>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~*++a++*~~', new Context())), [['<del><em><ins>a</ins></em></del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~*~~a~~*~~')), [['<del><em><del>a</del></em></del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~*++a++*~~')), [['<del><em><ins>a</ins></em></del>'], '']);
     });
 
   });

package/src/parser/inline/deletion.ts

@@ -1,7 +1,7 @@
 import { DeletionParser } from '../inline';
 import { Recursion, Command } from '../context';
-import { List, Node } from '../../combinator/data/parser';
-import { union, some, precedence, surround, open, lazy } from '../../combinator';
+import { List, Node } from '../../combinator/parser';
+import { union, some, precedence, backtrack, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { repeat } from '../repeat';
 import { blankWith } from '../visibility';
@@ -9,7 +9,7 @@ import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const deletion: DeletionParser = lazy(() =>
-  repeat('~~', '', '~~', Recursion.inline, precedence(0, surround(
+  repeat('~~', '', '~~', Recursion.inline, precedence(0, backtrack(surround(
     '',
     some(union([
       some(inline, blankWith('\n', '~~')),
@@ -17,6 +17,6 @@ export const deletion: DeletionParser = lazy(() =>
     ])),
     '~~',
     false, [],
-    ([, bs], { buffer }) => buffer.import(bs),
-    ([, bs], { buffer }) => bs && buffer.import(bs).push(new Node(Command.Cancel)) && buffer)),
+    ([, bs], _, output) => output.import(bs),
+    ([, bs], _, output) => bs && output.import(bs.push(new Node(Command.Cancel)))))),
     nodes => new List([new Node(html('del', defrag(unwrap(nodes))))])));

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

@@ -1,7 +1,6 @@
 import { emphasis } from './emphasis';
 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/inline/emphasis', () => {
@@ -9,50 +8,50 @@ describe('Unit: parser/inline/emphasis', () => {
     const parser = some(emphasis);
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser, input('*', new Context())), undefined);
-      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\\ *', new Context())), [['*', 'a', ' ', '*'], '']);
-      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('* *', 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('*\n*', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('*\na*', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('*\\ a*', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('*\\\na*', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('*<wbr>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('*')), undefined);
+      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\\ *')), [['*', 'a', ' ', '*'], '']);
+      assert.deepStrictEqual(inspect(parser, input('*a\\\n*')), [['*', 'a', '<br>', '*'], '']);
+      assert.deepStrictEqual(inspect(parser, input('*a**b')), [['*', 'a', '**', 'b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('* *')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('* a*')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('* a *')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('*\n*')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('*\na*')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('*\\ a*')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('*\\\na*')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('*<wbr>a*')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('**a**')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('***a***')), undefined);
+      assert.deepStrictEqual(inspect(parser, input(' *a*')), undefined);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser, input('*a*', new Context())), [['<em>a</em>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('*ab*', new Context())), [['<em>ab</em>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('*a**', new Context())), [['<em>a</em>'], '*']);
-      assert.deepStrictEqual(inspect(parser, input('*a\nb*', new Context())), [['<em>a<br>b</em>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('*a\\\nb*', new Context())), [['<em>a<br>b</em>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('*a*')), [['<em>a</em>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('*ab*')), [['<em>ab</em>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('*a**')), [['<em>a</em>'], '*']);
+      assert.deepStrictEqual(inspect(parser, input('*a\nb*')), [['<em>a<br>b</em>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('*a\\\nb*')), [['<em>a<br>b</em>'], '']);
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser, input('*a *b**', new Context())), [['<em>a <em>b</em></em>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('*- *b**', new Context())), [['<em>- <em>b</em></em>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('*a **b***', new Context())), [['<em>a <strong>b</strong></em>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('*a\\ *b**', new Context())), [['<em>a <em>b</em></em>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('*a&Tab;*b**', new Context())), [['<em>a\t<em>b</em></em>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('*a<wbr>*b**', new Context())), [['<em>a<wbr><em>b</em></em>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('*a**b*', new Context())), [['<em>a**b</em>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('*a**b**', new Context())), [[ '*', 'a', '<strong>b</strong>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('*a**b**c', new Context())), [['*', 'a', '<strong>b</strong>', 'c'], '']);
-      assert.deepStrictEqual(inspect(parser, input('*a**b**c*', new Context())), [['<em>a<strong>b</strong>c</em>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('*a**b**c*d', new Context())), [['<em>a<strong>b</strong>c</em>'], 'd']);
-      assert.deepStrictEqual(inspect(parser, input('*`a`*', new Context())), [['<em><code data-src="`a`">a</code></em>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('*(*a*)*', new Context())), [['<em><span class="paren">(<em>a</em>)</span></em>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('*(**a**)*', new Context())), [['<em><span class="paren">(<strong>a</strong>)</span></em>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('*a *b**')), [['<em>a <em>b</em></em>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('*- *b**')), [['<em>- <em>b</em></em>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('*a **b***')), [['<em>a <strong>b</strong></em>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('*a\\ *b**')), [['<em>a <em>b</em></em>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('*a&Tab;*b**')), [['<em>a\t<em>b</em></em>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('*a<wbr>*b**')), [['<em>a<wbr><em>b</em></em>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('*a**b*')), [['<em>a**b</em>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('*a**b**')), [[ '*', 'a', '<strong>b</strong>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('*a**b**c')), [['*', 'a', '<strong>b</strong>', 'c'], '']);
+      assert.deepStrictEqual(inspect(parser, input('*a**b**c*')), [['<em>a<strong>b</strong>c</em>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('*a**b**c*d')), [['<em>a<strong>b</strong>c</em>'], 'd']);
+      assert.deepStrictEqual(inspect(parser, input('*`a`*')), [['<em><code data-src="`a`">a</code></em>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('*(*a*)*')), [['<em><span class="paren">(<em>a</em>)</span></em>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('*(**a**)*')), [['<em><span class="paren">(<strong>a</strong>)</span></em>'], '']);
     });
 
   });

package/src/parser/inline/emphasis.ts

@@ -1,7 +1,7 @@
 import { EmphasisParser } from '../inline';
 import { Recursion } from '../context';
-import { List, Node } from '../../combinator/data/parser';
-import { union, some, recursion, precedence, surround, lazy } from '../../combinator';
+import { List, Node } from '../../combinator/parser';
+import { union, some, recursion, precedence, backtrack, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { strong } from './strong';
 import { str } from '../source';
@@ -9,7 +9,7 @@ import { beforeNonblankWith, afterNonblank } from '../visibility';
 import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
-export const emphasis: EmphasisParser = lazy(() => surround(
+export const emphasis: EmphasisParser = lazy(() => backtrack(surround(
   str('*', beforeNonblankWith(/(?!\*)/)),
   precedence(0, recursion(Recursion.inline,
   some(union([
@@ -18,5 +18,5 @@ export const emphasis: EmphasisParser = lazy(() => surround(
   ])))),
   str('*'),
   false, [],
-  ([, bs]) => new List([new Node(html('em', defrag(unwrap(bs))))]),
-  ([as, bs]) => bs && as.import(bs as List<Node<string>>)));
+  ([, bs], _, output) => output.append(new Node(html('em', defrag(unwrap(bs))))),
+  ([as, bs], _, output) => bs && output.import(as.import(bs as List<Node<string>>)))));