securemark 0.299.3 → 0.300.0

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

@@ -1,7 +1,6 @@
 import { ruby } from './ruby';
 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/ruby', () => {
@@ -9,57 +8,57 @@ describe('Unit: parser/inline/ruby', () => {
     const parser = some(ruby);
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser, input('', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('[(b)', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('[]()', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('[](b)', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('[ ](b)', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('[ a](b)', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('[	a](b)', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('[	 a](b)', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('[&a;](b)', new Context())), [['<ruby>&amp;a;<rp>(</rp><rt>b</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[a](&a;)', new Context())), [['<ruby>a<rp>(</rp><rt>&amp;a;</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[<wbr>](a)', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('[a](<wbr>)', 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\nb](c)', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('[a](b\nc)', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input(' [a](b)', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[(b)')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[]()')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[](b)')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[ ](b)')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[ a](b)')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[&Tab;a](b)')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[&Tab; a](b)')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[&a;](b)')), [['<ruby>&amp;a;<rp>(</rp><rt>b</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[a](&a;)')), [['<ruby>a<rp>(</rp><rt>&amp;a;</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[<wbr>](a)')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[a](<wbr>)')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[a]()')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[a]( )')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[a\nb](c)')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[a](b\nc)')), undefined);
+      assert.deepStrictEqual(inspect(parser, input(' [a](b)')), undefined);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser, input('[A](a)', new Context())), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[A](ab)', new Context())), [['<ruby>A<rp>(</rp><rt>ab</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[A](a b)', new Context())), [['<ruby>A<rp>(</rp><rt>a b</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[A ](a)', new Context())), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[A ](a b)', new Context())), [['<ruby>A<rp>(</rp><rt>a b</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[A ](a b )', new Context())), [['<ruby>A<rp>(</rp><rt>a b</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[A  ](a)', new Context())), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp><rt></rt></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[A \\ ](a)', new Context())), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp> <rt></rt></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[AB](a)', new Context())), [['<ruby>AB<rp>(</rp><rt>a</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[AB](a )', new Context())), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rt></rt></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[AB]( b)', new Context())), [['<ruby>A<rt></rt>B<rp>(</rp><rt>b</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[AB](ab)', new Context())), [['<ruby>AB<rp>(</rp><rt>ab</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[AB](a b)', new Context())), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rp>(</rp><rt>b</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[AB](a b )', new Context())), [['<ruby>AB<rp>(</rp><rt>a b</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[AB](a b c)', new Context())), [['<ruby>AB<rp>(</rp><rt>a b c</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[A B](ab)', new Context())), [['<ruby>A<rp>(</rp><rt>ab</rt><rp>)</rp>B<rt></rt></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[A B](a b)', new Context())), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rp>(</rp><rt>b</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[A B](a b )', new Context())), [['<ruby>A B<rp>(</rp><rt>a b</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[ABC](a )', new Context())), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rt></rt>C<rt></rt></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[ABC](a  )', new Context())), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rt></rt>C<rt></rt></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[ABC]( b)', new Context())), [['<ruby>A<rt></rt>B<rp>(</rp><rt>b</rt><rp>)</rp>C<rt></rt></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[ABC]( b )', new Context())), [['<ruby>A<rt></rt>B<rp>(</rp><rt>b</rt><rp>)</rp>C<rt></rt></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[ABC](  c)', new Context())), [['<ruby>A<rt></rt>B<rt></rt>C<rp>(</rp><rt>c</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[ABC](a  c)', new Context())), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rt></rt>C<rp>(</rp><rt>c</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[東方](とう　ほう)', new Context())), [['<ruby>東<rp>(</rp><rt>とう</rt><rp>)</rp>方<rp>(</rp><rt>ほう</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[秦　\\　　こころ](はた　の　こころ)', new Context())), [['<ruby>秦<rp>(</rp><rt>はた</rt><rp>)</rp>　<rp>(</rp><rt>の</rt><rp>)</rp>こころ<rp>(</rp><rt>こころ</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[秦　&nbsp;　こころ](はた　の　こころ)', new Context())), [['<ruby>秦<rp>(</rp><rt>はた</rt><rp>)</rp>&nbsp;<rp>(</rp><rt>の</rt><rp>)</rp>こころ<rp>(</rp><rt>こころ</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[&&](&&)', new Context())), [['<ruby>&amp;&amp;<rp>(</rp><rt>&amp;&amp;</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[&copy;](&copy;)', new Context())), [['<ruby>©<rp>(</rp><rt>©</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[&amp;copy;](&amp;copy;)', new Context())), [['<ruby>&amp;copy;<rp>(</rp><rt>&amp;copy;</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[*A*](*a*)', new Context())), [['<ruby>*A*<rp>(</rp><rt>*a*</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[A](a)')), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[A](ab)')), [['<ruby>A<rp>(</rp><rt>ab</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[A](a b)')), [['<ruby>A<rp>(</rp><rt>a b</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[A ](a)')), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[A ](a b)')), [['<ruby>A<rp>(</rp><rt>a b</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[A ](a b )')), [['<ruby>A<rp>(</rp><rt>a b</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[A  ](a)')), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp><rt></rt></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[A \\ ](a)')), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp> <rt></rt></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[AB](a)')), [['<ruby>AB<rp>(</rp><rt>a</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[AB](a )')), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rt></rt></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[AB]( b)')), [['<ruby>A<rt></rt>B<rp>(</rp><rt>b</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[AB](ab)')), [['<ruby>AB<rp>(</rp><rt>ab</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[AB](a b)')), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rp>(</rp><rt>b</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[AB](a b )')), [['<ruby>AB<rp>(</rp><rt>a b</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[AB](a b c)')), [['<ruby>AB<rp>(</rp><rt>a b c</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[A B](ab)')), [['<ruby>A<rp>(</rp><rt>ab</rt><rp>)</rp>B<rt></rt></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[A B](a b)')), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rp>(</rp><rt>b</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[A B](a b )')), [['<ruby>A B<rp>(</rp><rt>a b</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[ABC](a )')), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rt></rt>C<rt></rt></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[ABC](a  )')), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rt></rt>C<rt></rt></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[ABC]( b)')), [['<ruby>A<rt></rt>B<rp>(</rp><rt>b</rt><rp>)</rp>C<rt></rt></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[ABC]( b )')), [['<ruby>A<rt></rt>B<rp>(</rp><rt>b</rt><rp>)</rp>C<rt></rt></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[ABC](  c)')), [['<ruby>A<rt></rt>B<rt></rt>C<rp>(</rp><rt>c</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[ABC](a  c)')), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rt></rt>C<rp>(</rp><rt>c</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[東方](とう　ほう)')), [['<ruby>東<rp>(</rp><rt>とう</rt><rp>)</rp>方<rp>(</rp><rt>ほう</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[秦　\\　　こころ](はた　の　こころ)')), [['<ruby>秦<rp>(</rp><rt>はた</rt><rp>)</rp>　<rp>(</rp><rt>の</rt><rp>)</rp>こころ<rp>(</rp><rt>こころ</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[秦　&nbsp;　こころ](はた　の　こころ)')), [['<ruby>秦<rp>(</rp><rt>はた</rt><rp>)</rp>&nbsp;<rp>(</rp><rt>の</rt><rp>)</rp>こころ<rp>(</rp><rt>こころ</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[&&](&&)')), [['<ruby>&amp;&amp;<rp>(</rp><rt>&amp;&amp;</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[&copy;](&copy;)')), [['<ruby>©<rp>(</rp><rt>©</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[&amp;copy;](&amp;copy;)')), [['<ruby>&amp;copy;<rp>(</rp><rt>&amp;copy;</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[*A*](*a*)')), [['<ruby>*A*<rp>(</rp><rt>*a*</rt><rp>)</rp></ruby>'], '']);
     });
 
   });

package/src/parser/inline/ruby.ts

@@ -1,31 +1,33 @@
 import { RubyParser } from '../inline';
-import { Backtrack } from '../context';
-import { List, Node } from '../../combinator/data/parser';
-import { inits, surround, setBacktrack, dup, lazy, bind } from '../../combinator';
+import { Input, Backtrack } from '../context';
+import { Parser, Result, List, Node } from '../../combinator/parser';
+import { union, inits, always, backtrack, surround, setBacktrack, dup, lazy, bind } from '../../combinator';
 import { unsafehtmlentity } from './htmlentity';
 import { txt } from '../source';
 import { isNonblankNodeStart } from '../visibility';
 import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
-export const ruby: RubyParser = lazy(() => bind(
+export const ruby: RubyParser = lazy(() => backtrack(bind(
   inits([
     dup(surround(
       '[', text, ']',
       false,
       [1 | Backtrack.common, 3 | Backtrack.ruby],
-      ([, ns]) => {
+      ([, ns], _, output) => {
         ns && ns.last?.value === '' && ns.pop();
-        return isNonblankNodeStart(ns) ? ns : undefined;
+        return isNonblankNodeStart(ns)
+          ? output.import(ns)
+          : Result.fail;
       })),
     dup(surround(
       '(', text, ')',
       false)),
   ]),
-  ([{ value: texts }, { value: rubies = undefined } = {}], context) => {
+  ([{ value: texts }, { value: rubies = undefined } = {}], input) => {
     if (rubies === undefined) {
-      const head = context.position - context.range;
-      return void setBacktrack(context, 2 | Backtrack.link | Backtrack.ruby, head);
+      const head = input.position - input.range;
+      return void setBacktrack(input, 2 | Backtrack.link | Backtrack.ruby, head);
     }
     switch (true) {
       case texts.length >= rubies.length:
@@ -59,51 +61,60 @@ export const ruby: RubyParser = lazy(() => bind(
           ]))))),
         ]);
     }
-  }));
+  })));
 
 const delimiter = /[$"`\[\](){}<>（）［］｛｝|]|\\?\r?\n/y;
 
-const text: RubyParser.TextParser = input => {
-  const context = input;
-  const { source } = context;
-  const acc = new List([new Node('')]);
-  let state = false;
-  context.sequential = true;
-  for (let { position } = context; position < source.length; position = context.position) {
-    delimiter.lastIndex = position;
-    if (delimiter.test(source)) break;
-    assert(source[position] !== '\n');
-    switch (source[position]) {
-      case '&': {
-        const result = source[position + 1] !== ' '
-          ? unsafehtmlentity(input) ?? txt(input)!
-          : txt(input)!;
-        assert(result);
-        acc.last!.value += result.head!.value;
-        continue;
-      }
-      default: {
-        if (source[position].trimStart() === '') {
-          state ||= acc.last!.value.trimStart() !== '';
-          acc.push(new Node(''));
-          context.position += 1;
-          continue;
-        }
-        const result = txt(input)!;
-        assert(result);
-        acc.last!.value += result.head?.value ?? '';
-        continue;
-      }
+interface Memory {
+  position: number;
+  state: boolean;
+  nodes: List<Node<string>>;
+}
+const text: RubyParser.TextParser = always<Parser<string, Input<Memory>>>([
+  (input, output) => {
+    input.sequential = true;
+    input.memory = {
+      position: 0,
+      state: false,
+      nodes: new List([new Node('')]),
+    };
+    return output.context;
+  },
+  () => loop,
+  (input, output) => {
+    const { memory } = input;
+    input.sequential = false;
+    return memory.state || memory.nodes.last!.value.trimStart() !== ''
+      ? output.import(memory.nodes)
+      : undefined;
+  },
+]);
+const loop: Result<string, Input<Memory>> = [
+  (input, output) => {
+    const { source, memory } = input;
+    for (let { position } = input; ; position = input.position) {
+      if (position === source.length) return Result.skip;
+      delimiter.lastIndex = position;
+      if (delimiter.test(source)) return Result.skip;
+      assert(source[position] !== '\n');
+      if (source[position].trimStart() !== '') break;
+      memory.state ||= memory.nodes.last!.value.trimStart() !== '';
+      memory.nodes.push(new Node(''));
+      input.position += 1;
     }
-  }
-  context.sequential = false;
-  state ||= acc.last!.value.trimStart() !== '';
-  return state
-    ? acc
-    : undefined;
-};
+    memory.position = input.position;
+    return output.context;
+  },
+  union([unsafehtmlentity, txt]),
+  (input, output) => {
+    assert(output.state);
+    input.memory.nodes.last!.value += output.peek().pop()?.value ?? '';
+    assert(output.peek().length === 0);
+    return loop;
+  },
+];
 
-function* zip<N extends List.Node>(a: List<N>, b: List<N>): Iterable<[N | undefined, N | undefined]> {
+function* zip<N extends Node<unknown>>(a: List<N>, b: List<N>): Iterable<[N | undefined, N | undefined]> {
   const ia = a[Symbol.iterator]();
   const ib = b[Symbol.iterator]();
   for (; ;) {

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

@@ -1,7 +1,6 @@
 import { shortmedia } from './shortmedia';
 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/shortmedia', () => {
@@ -9,17 +8,17 @@ describe('Unit: parser/inline/shortmedia', () => {
     const parser = some(shortmedia);
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser, input('', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('!http', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('!ttp', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('!http://', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('!Http://host', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input(' !http://host', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('!http')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('!ttp')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('!http://')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('!Http://host')), undefined);
+      assert.deepStrictEqual(inspect(parser, input(' !http://host')), undefined);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser, input('!http://host', new Context())), [['<a href="http://host" target="_blank"><img class="media" data-src="http://host" alt="http://host"></a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('!https://host', new Context())), [['<a href="https://host" target="_blank"><img class="media" data-src="https://host" alt="https://host"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('!http://host')), [['<a href="http://host" target="_blank"><img class="media" data-src="http://host" alt="http://host"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('!https://host')), [['<a href="https://host" target="_blank"><img class="media" data-src="https://host" alt="https://host"></a>'], '']);
     });
 
   });

package/src/parser/inline/shortmedia.ts

@@ -1,17 +1,19 @@
 import { ShortMediaParser } from '../inline';
 import { State } from '../context';
-import { union, constraint, focus, rewrite, open, convert } from '../../combinator';
+import { union, constraint, scope, focus, rewrite, open, lazy } from '../../combinator';
 import { url } from './autolink/url';
 import { media } from './media';
 
-export const shortmedia: ShortMediaParser = constraint(State.media, rewrite(
+export const shortmedia: ShortMediaParser = lazy(() => constraint(State.media, rewrite(
   open('!', url),
-  convert(
-    source => `!{ ${source.slice(1)} }`,
-    union([media]))));
+  scope(
+    ({ source }) => `!{ ${source.slice(1)} }`,
+    union([media]),
+    true))));
 
-export const lineshortmedia: ShortMediaParser.LineShortMediaParser = constraint(State.media, focus(
+export const lineshortmedia: ShortMediaParser.LineShortMediaParser = lazy(() => constraint(State.media, focus(
   /(?<=^|[\r\n])!https?:\/\/\S+(?=[^\S\r\n]*(?:$|\r?\n))/y,
-  convert(
-    source => `!{ ${source.slice(1)} }`,
-    union([media]))));
+  scope(
+    ({ source }) => `!{ ${source.slice(1)} }`,
+    union([media]),
+    true))));

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

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

package/src/parser/inline/strong.ts

@@ -1,7 +1,7 @@
 import { StrongParser } 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 { emphasis } from './emphasis';
 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 strong: StrongParser = lazy(() => surround(
+export const strong: StrongParser = lazy(() => backtrack(surround(
   str('**', beforeNonblankWith(/(?!\*)/)),
   precedence(0, recursion(Recursion.inline,
   some(union([
@@ -18,5 +18,5 @@ export const strong: StrongParser = lazy(() => surround(
   ])))),
   str('**'),
   false, [],
-  ([, bs]) => new List([new Node(html('strong', defrag(unwrap(bs))))]),
-  ([as, bs]) => bs && as.import(bs as List<Node<string>>)));
+  ([, bs], _, output) => output.append(new Node(html('strong', defrag(unwrap(bs))))),
+  ([as, bs], _, output) => bs && output.import(as.import(bs as List<Node<string>>)))));

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

@@ -1,7 +1,6 @@
 import { template } from './template';
 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/template', () => {
@@ -9,33 +8,33 @@ describe('Unit: parser/inline/template', () => {
     const parser = some(template);
 
     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())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('{{', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('{{\\}}', new Context())), [['<span class="invalid">{{\\}</span>'], '}']);
-      assert.deepStrictEqual(inspect(parser, input('{{a}b}', new Context())), [['<span class="invalid">{{a</span>'], '}b}']);
-      assert.deepStrictEqual(inspect(parser, input('{{{a}}', new Context())), [['<span class="invalid">{{{a}</span>'], '}']);
-      assert.deepStrictEqual(inspect(parser, input(' {{}}', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('{')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('{}')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('{{')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('{{\\}}')), [['<span class="invalid">{{\\}</span>'], '}']);
+      assert.deepStrictEqual(inspect(parser, input('{{a}b}')), [['<span class="invalid">{{a</span>'], '}b}']);
+      assert.deepStrictEqual(inspect(parser, input('{{{a}}')), [['<span class="invalid">{{{a}</span>'], '}']);
+      assert.deepStrictEqual(inspect(parser, input(' {{}}')), undefined);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser, input('{{}}', new Context())), [['<span class="template">{{}}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('{{}}}', new Context())), [['<span class="template">{{}}</span>'], '}']);
-      assert.deepStrictEqual(inspect(parser, input('{{ }}', new Context())), [['<span class="template">{{ }}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('{{ a }}', new Context())), [['<span class="template">{{ a }}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('{{\n}}', new Context())), [['<span class="template">{{<br>}}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('{{\\\n}}', new Context())), [['<span class="template">{{\\<br>}}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('{{a}}', new Context())), [['<span class="template">{{a}}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('{{a b}}', new Context())), [['<span class="template">{{a b}}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('{{\\}}}', new Context())), [['<span class="template">{{\\}}}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('{{<a>}}', new Context())), [['<span class="template">{{&lt;a&gt;}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('{{}}')), [['<span class="template">{{}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('{{}}}')), [['<span class="template">{{}}</span>'], '}']);
+      assert.deepStrictEqual(inspect(parser, input('{{ }}')), [['<span class="template">{{ }}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('{{ a }}')), [['<span class="template">{{ a }}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('{{\n}}')), [['<span class="template">{{<br>}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('{{\\\n}}')), [['<span class="template">{{\\<br>}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('{{a}}')), [['<span class="template">{{a}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('{{a b}}')), [['<span class="template">{{a b}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('{{\\}}}')), [['<span class="template">{{\\}}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('{{<a>}}')), [['<span class="template">{{&lt;a&gt;}}</span>'], '']);
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser, input('{{`a`}}', new Context())), [['<span class="template">{{`a`}}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('{{{a}}}', new Context())), [['<span class="template">{{{a}}}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('{{{{a}}}}', new Context())), [['<span class="template">{{{{a}}}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('{{`a`}}')), [['<span class="template">{{`a`}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('{{{a}}}')), [['<span class="template">{{{a}}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('{{{{a}}}}')), [['<span class="template">{{{{a}}}}</span>'], '']);
     });
 
   });

package/src/parser/inline/template.ts

@@ -1,42 +1,39 @@
 import { TemplateParser } 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 { escsource, str } from '../source';
 import { unwrap, invalid } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
-export const template: TemplateParser = lazy(() => surround(
+export const template: TemplateParser = lazy(() => backtrack(surround(
   str('{{'),
   precedence(1,
   some(union([bracket, escsource]), '}')),
   str('}}'),
   true, [],
-  ([as, bs = new List(), cs]) => new List([
-    new Node(html('span', { class: 'template' }, defrag(unwrap(as.import(bs as List<Node<string>>).import(cs)))))
-  ]),
-  ([, bs], context) =>
-    bs && new List([
+  ([as, bs = new List(), cs], _, output) =>
+    output.append(new Node(
+      html('span', { class: 'template' }, defrag(unwrap(as.import(bs as List<Node<string>>).import(cs)))))),
+  ([, bs], input, output) =>
+    bs && output.append(
       new Node(html('span',
         {
           class: 'invalid',
           ...invalid('template', 'syntax', `Missing the closing symbol "}}"`),
         },
-        context.source.slice(context.position - context.range, context.position)))
-    ])));
+        input.source.slice(input.position - input.range, input.position)))))));
 
 const bracket: TemplateParser.BracketParser = lazy(() => union([
   surround(str('('), recursion(Recursion.terminal, some(union([bracket, escsource]), ')')), str(')'),
-    true, [], undefined, ([as, bs]) => bs && as.import(bs as List<Node<string>>)),
+    true, [], undefined, ([as, bs], _, output) => bs && output.import(as.import(bs as List<Node<string>>))),
   surround(str('['), recursion(Recursion.terminal, some(union([bracket, escsource]), ']')), str(']'),
-    true, [], undefined, ([as, bs]) => bs && as.import(bs as List<Node<string>>)),
+    true, [], undefined, ([as, bs], _, output) => bs && output.import(as.import(bs as List<Node<string>>))),
   surround(str('{'), recursion(Recursion.terminal, some(union([bracket, escsource]), '}')), str('}'),
-    true, [], undefined, ([as, bs]) => bs && as.import(bs as List<Node<string>>)),
+    true, [], undefined, ([as, bs], _, output) => bs && output.import(as.import(bs as List<Node<string>>))),
   surround(
     str('"'),
     precedence(2, recursion(Recursion.terminal, some(escsource, /["\n]/y, [['"', 2], ['\n', 3]]))),
     str('"'),
-    true, [],
-    undefined,
-    ([as, bs]) => bs && as.import(bs as List<Node<string>>)),
+    true, [], undefined, ([as, bs], _, output) => bs && output.import(as.import(bs as List<Node<string>>))),
 ]));