securemark 0.298.5 → 0.298.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securemark",
-  "version": "0.298.5",
+  "version": "0.298.7",
   "description": "Secure markdown renderer working on browsers for user input data.",
   "private": false,
   "homepage": "https://github.com/falsandtru/securemark",

package/src/combinator/data/delimiter.ts

@@ -161,13 +161,20 @@ export function matcher(pattern: string | RegExp, advance: boolean, after?: Pars
   const count = typeof pattern === 'object'
     ? /[^^\\*+][*+]|{\d+,}/.test(pattern.source)
     : false;
+  let sid = 0, pos = 0, index = -1;
   switch (typeof pattern) {
     case 'string':
       if (pattern === '') return () => new List([new Node(pattern)]);
       return input => {
         const context = input;
-        const { source, position } = context;
-        if (!source.startsWith(pattern, position)) return;
+        const { SID, source, position } = context;
+        const hit = SID === sid && position === pos;
+        index = hit
+          ? index
+          : source.startsWith(pattern, position) ? position : -1;
+        sid = SID;
+        pos = position;
+        if (index === -1) return;
         if (advance) {
           context.position += pattern.length;
         }
@@ -180,13 +187,19 @@ export function matcher(pattern: string | RegExp, advance: boolean, after?: Pars
       assert(pattern.sticky);
       return input => {
         const context = input;
-        const { source, position } = context;
+        const { SID, source, position } = context;
+        const hit = SID === sid && position === pos;
         pattern.lastIndex = position;
-        if (!pattern.test(source)) return;
-        const src = source.slice(position, pattern.lastIndex);
-        count && consume(src.length, context);
+        index = hit
+          ? index
+          : pattern.test(source) ? pattern.lastIndex : -1;
+        sid = SID;
+        pos = position;
+        if (index === -1) return;
+        const src = source.slice(position, index);
+        count && !hit && consume(src.length, context);
         if (advance) {
-          context.position += src.length;
+          context.position = index;
         }
         const next = after?.(input);
         return after
@@ -201,13 +214,20 @@ export function tester(pattern: string | RegExp, advance: boolean, after?: Parse
   const count = typeof pattern === 'object'
     ? /[^^\\*+][*+]|{\d+,}/.test(pattern.source)
     : false;
+  let sid = 0, pos = 0, index = -1;
   switch (typeof pattern) {
     case 'string':
       if (pattern === '') return () => new List();
       return input => {
         const context = input;
-        const { source, position } = context;
-        if (!source.startsWith(pattern, position)) return;
+        const { SID, source, position } = context;
+        const hit = SID === sid && position === pos;
+        index = hit
+          ? index
+          : source.startsWith(pattern, position) ? position : -1;
+        sid = SID;
+        pos = position;
+        if (index === -1) return;
         if (advance) {
           context.position += pattern.length;
         }
@@ -218,13 +238,19 @@ export function tester(pattern: string | RegExp, advance: boolean, after?: Parse
       assert(pattern.sticky);
       return input => {
         const context = input;
-        const { source, position } = context;
+        const { SID, source, position } = context;
+        const hit = SID === sid && position === pos;
         pattern.lastIndex = position;
-        if (!pattern.test(source)) return;
-        const len = pattern.lastIndex - position;
-        count && consume(len, context);
+        index = hit
+          ? index
+          : pattern.test(source) ? pattern.lastIndex : -1;
+        sid = SID;
+        pos = position;
+        if (index === -1) return;
+        const len = index - position;
+        count && !hit && consume(len, context);
         if (advance) {
-          context.position += len;
+          context.position = index;
         }
         if (after && after(input) === undefined) return;
         return new List();

package/src/combinator/data/parser/context.ts

@@ -122,13 +122,15 @@ export function recursions(rs: readonly number[], parser: Parser): Parser {
     assert(recursions.length > 0);
     for (const recursion of rs) {
       const rec = min(recursion, recursions.length - 1);
-      if (rec >= 0 && recursions[rec] < 1) throw new Error('Too much recursion');
-      rec >= 0 && --recursions[rec];
+      if (rec === -1) continue;
+      if (recursions[rec] < 1) throw new Error('Too much recursion');
+      --recursions[rec];
     }
     const result = parser(input);
     for (const recursion of rs) {
       const rec = min(recursion, recursions.length - 1);
-      rec >= 0 && ++recursions[rec];
+      if (rec === -1) continue;
+      ++recursions[rec];
     }
     return result;
   };

package/src/combinator/data/parser/some.ts

@@ -38,8 +38,10 @@ export function some<N>(parser: Parser<N>, delimiter?: number | string | RegExp
     for (const len = source.length; context.position < len;) {
       if (match(input)) break;
       if (context.delimiters.test(input)) break;
+      const pos = context.position;
       const result = parser(input);
       if (result === undefined) break;
+      if (context.position === pos) break;
       nodes = nodes?.import(result) ?? result;
       if (limit >= 0 && context.position - position > limit) break;
     }

package/src/combinator/data/parser/union.ts

@@ -10,12 +10,9 @@ export function union<N, D extends Parser<N>[]>(parsers: D): Parser<N, Context,
       return parsers[0];
     default:
       return eval([
-        '((',
-        parsers.map((_, i) => `parser${i},`).join(''),
-        ') =>',
+        '(', parsers.map((_, i) => `parser${i},`).join(''), ') =>',
         'input =>',
         parsers.map((_, i) => `|| parser${i}(input)`).join('').slice(2),
-        ')',
       ].join(''))(...parsers);
   }
 }

package/src/combinator/data/parser.ts

@@ -26,6 +26,10 @@ export class Node<N> implements List.Node {
   public next?: this = undefined;
   public prev?: this = undefined;
 }
+let SID = 0;
+function sid(): number {
+  return SID = ++SID >>> 0 || 1;
+}
 export class Context {
   constructor(
     {
@@ -54,6 +58,7 @@ export class Context {
     this.offset = offset ?? 0;
     this.backtracks = backtracks ?? {};
   }
+  public SID: number = sid();
   public source: string;
   public position: number;
   public segment: number;
@@ -110,6 +115,7 @@ export const enum Segment {
 }
 
 export function input<C extends Context>(source: string, context: C): Input<C> {
+  context.SID = sid();
   context.source = source;
   context.position = 0;
   return context;
@@ -118,6 +124,7 @@ export function input<C extends Context>(source: string, context: C): Input<C> {
 export function subinput<C extends Context>(source: string, context: C): Input<C> {
   return {
     ...context,
+    SID: sid(),
     source,
     position: 0,
     offset: 0,

package/src/parser/api/parse.test.ts

@@ -297,15 +297,6 @@ describe('Unit: parser/api/parse', () => {
     });
 
     it('recursion', () => {
-      //assert.deepStrictEqual(
-      //  [...parse(`${'{ '.repeat(20)}0`).children].map(el => el.tagName),
-      //  ['P']);
-      //assert.deepStrictEqual(
-      //  [...parse(`${'{ '.repeat(21)}0`).children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
-      //  [
-      //    '<h1 id="error:rnd" class="error">Error: Too much recursion</h1>',
-      //    `<pre class="error" translate="no">${'{ '.repeat(21)}0</pre>`,
-      //  ]);
       assert.deepStrictEqual(
         [...parse(`${'['.repeat(20)}0`).children].map(el => el.outerHTML),
         [`<p>${'['.repeat(20)}0</p>`]);
@@ -327,24 +318,12 @@ describe('Unit: parser/api/parse', () => {
       assert.deepStrictEqual(
         [...parse(`${'(('.repeat(3)}0${'))'.repeat(3)}`).children].map(el => el.tagName),
         ['H1', 'PRE']);
-      assert.deepStrictEqual(
-        [...parse(`${'(('.repeat(2)}!${'))'.repeat(2)}`).children].map(el => el.tagName),
-        ['P', 'OL']);
-      assert.deepStrictEqual(
-        [...parse(`${'(('.repeat(3)}!${'))'.repeat(3)}`).children].map(el => el.tagName),
-        ['H1', 'PRE']);
       assert.deepStrictEqual(
         [...parse(`(${'(('.repeat(2)}0${'))'.repeat(2)}`).children].map(el => el.tagName),
         ['P', 'OL']);
       assert.deepStrictEqual(
         [...parse(`(${'(('.repeat(3)}0${'))'.repeat(3)}`).children].map(el => el.tagName),
         ['H1', 'PRE']);
-      assert.deepStrictEqual(
-        [...parse(`(${'(('.repeat(2)}!${'))'.repeat(2)}`).children].map(el => el.tagName),
-        ['P', 'OL']);
-      assert.deepStrictEqual(
-        [...parse(`(${'(('.repeat(3)}!${'))'.repeat(3)}`).children].map(el => el.tagName),
-        ['H1', 'PRE']);
       assert.deepStrictEqual(
         [...parse(`${'(('.repeat(2)}0${'))'.repeat(2)}${'(('.repeat(2)}0${'))'.repeat(2)}`).children].map(el => el.tagName),
         ['P', 'OL']);
@@ -357,6 +336,9 @@ describe('Unit: parser/api/parse', () => {
       assert.deepStrictEqual(
         [...parse(`${'(('.repeat(2)}0${'))'.repeat(2)}${'(('.repeat(9)}0${'))'.repeat(3)}`).children].map(el => el.tagName),
         ['H1', 'PRE']);
+      assert.deepStrictEqual(
+        [...parse(`${'(('.repeat(3)}0))((1))))))`).children].map(el => el.tagName),
+        ['H1', 'PRE']);
     });
 
     it('recovery', () => {

package/src/parser/context.ts

@@ -28,7 +28,6 @@ export class Context extends Ctx {
         20 || Recursion.blockquote,
         40 || Recursion.listitem,
         20 || Recursion.inline,
-        20 || Recursion.annotation,
         20 || Recursion.bracket,
         20 || Recursion.terminal,
       ],
@@ -116,7 +115,6 @@ export const enum Recursion {
   blockquote,
   listitem,
   inline,
-  annotation,
   bracket,
   terminal,
 }

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

@@ -10,18 +10,15 @@ describe('Unit: parser/inline/annotation', () => {
 
     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="paren">(</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('()', new Context())), [ [ '<span class="paren">()</span>' ], '' ]);
+      assert.deepStrictEqual(inspect(parser, input('((', new Context())), [ [ '<span class="paren">(<span class="paren">(</span></span>' ], '' ]);
       assert.deepStrictEqual(inspect(parser, input('(())', new Context())), [['<span class="paren">(<span class="paren">()</span>)</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('(()))', new Context())), [['<span class="paren">(<span class="paren">()</span>)</span>'], ')']);
       assert.deepStrictEqual(inspect(parser, input('(("))', new Context())), [['<span class="paren">(<span class="paren">("))</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('((a', new Context())), [['<span class="paren">(<span class="paren">(a</span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('((!', new Context())), [['<span class="paren">(<span class="paren">(!</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('((a)', new Context())), [['<span class="paren">(<span class="paren">(a)</span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('((!)', new Context())), [['<span class="paren">(<span class="paren">(!)</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('((a)b)', new Context())), [['<span class="paren">(<span class="paren">(a)</span>b)</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('((!)b)', new Context())), [['<span class="paren">(<span class="paren">(!)</span>b)</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('(([))', new Context())), [['<span class="paren">(<span class="paren">([))</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('(([%))', new Context())), [['<span class="paren">(<span class="paren">([%))</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('(( ))', new Context())), undefined);
@@ -39,11 +36,10 @@ describe('Unit: parser/inline/annotation', () => {
       assert.deepStrictEqual(inspect(parser, input('((*a\nb*))', new Context())), [['<span class="bracket">(<span class="bracket">(<em>a<br>b</em>)</span>)</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('((\\))', new Context())), [['<span class="paren">(<span class="paren">())</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('(((a))', new Context())), [['<span class="paren">(<sup class="annotation"><span>a</span></sup></span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('(((!))', new Context())), [['<span class="paren">(<sup class="annotation"><span>!</span></sup></span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('(((*a*))', new Context())), [['<span class="paren">(<sup class="annotation"><span><em>a</em></span></sup></span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('((((a)))', new Context())), [['<span class="paren">(<sup class="annotation"><span><span class="paren">(a)</span></span></sup></span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('(((((a))))', new Context())), [['<span class="paren">(<sup class="annotation"><span><sup class="annotation"><span>a</span></sup></span></sup></span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('(((((!))))', new Context())), [['<span class="paren">(<sup class="annotation"><span><sup class="annotation"><span>!</span></sup></span></sup></span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('(((((*a*))))', new Context())), [['<span class="paren">(<sup class="annotation"><span><sup class="annotation"><span><em>a</em></span></sup></span></sup></span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('((((((a)))b)))', new Context())), [['<sup class="annotation"><span><span class="paren">(<sup class="annotation"><span><span class="paren">(a)</span></span></sup>b)</span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(((((((a)))b)))', new Context())), [['<span class="paren">(<sup class="annotation"><span><span class="paren">(<sup class="annotation"><span><span class="paren">(a)</span></span></sup>b)</span></span></sup></span>'], '']);
       assert.deepStrictEqual(inspect(parser, input(' ((a))', new Context())), undefined);
     });
 

package/src/parser/inline/annotation.ts

@@ -1,9 +1,10 @@
 import { AnnotationParser } from '../inline';
-import { State, Recursion } from '../context';
+import { State, Recursion, Command } from '../context';
 import { List, Node } from '../../combinator/data/parser';
-import { union, some, recursions, precedence, constraint, surround, open, lazy } from '../../combinator';
+import { union, some, precedence, constraint, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { bracketname } from './bracket';
+import { repeat } from '../repeat';
 import { beforeNonblank, trimBlankNodeEnd } from '../visibility';
 import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
@@ -23,118 +24,35 @@ import { html, defrag } from 'typed-dom/dom';
 // 修正する必要があるためほぼ完全な二重処理が必要になり三重以上の注釈という不適切な使用のために
 // 常に非常に非効率な処理を行い常時低速化するより三重以上の注釈を禁止して効率性を維持するのが妥当である。
 const MAX_DEPTH = 20;
-export const annotation: AnnotationParser = lazy(() => constraint(State.annotation, surround(
-  open('((', beforeNonblank),
-  precedence(1, recursions([Recursion.annotation, Recursion.inline, Recursion.bracket, Recursion.bracket],
-  some(union([inline]), ')', [[')', 1]]))),
-  '))',
-  false, [],
-  ([, ns], context) => {
-    const { linebreak, recursion, resources } = context;
-    if (linebreak !== 0) {
-      ns.unshift(new Node('('));
-      ns.push(new Node(')'));
-      return new List([
-        new Node(html('span',
-          { class: bracketname(context, 1, 1) },
-          ['(', html('span', { class: bracketname(context, 2, 2) }, defrag(unwrap(ns))), ')']))
-      ]);
-    }
-    const depth = MAX_DEPTH - (resources?.recursions[Recursion.annotation] ?? resources?.recursions.at(-1) ?? MAX_DEPTH);
-    recursion.add(depth);
-    return new List([
-      new Node(html('sup', { class: 'annotation' }, [html('span', defrag(unwrap(trimBlankNodeEnd(ns))))]))
-    ]);
-  },
-  ([, bs], context) => {
-    const { source, position, linebreak, recursion, resources } = context;
-    const depth = MAX_DEPTH - (resources?.recursions[Recursion.annotation] ?? resources?.recursions.at(-1) ?? MAX_DEPTH);
-    if (linebreak === 0 && bs && bs.length === 1 && source[position] === ')' && typeof bs.head?.value === 'object') {
-      const { className } = bs.head.value;
-      if (className === 'paren' || className === 'bracket') {
-        const { firstChild, lastChild } = bs.head.value;
-        assert(firstChild instanceof Text);
-        if (firstChild!.nodeValue!.length === 1) {
-          firstChild!.remove();
-        }
-        else {
-          firstChild!.nodeValue = firstChild!.nodeValue!.slice(1);
-        }
-        assert(lastChild instanceof Text);
-        if (lastChild!.nodeValue!.length === 1) {
-          lastChild!.remove();
-        }
-        else {
-          lastChild!.nodeValue = lastChild!.nodeValue!.slice(0, -1);
-        }
-        context.position += 1;
-        recursion.add(depth);
-        return new List([
-          new Node(html('span',
-            { class: 'paren' },
-            ['(', html('sup', { class: 'annotation' }, [html('span', bs.head.value.childNodes)])]))
-        ]);
-      }
-      if (className === 'annotation' && deepunwrap(bs)) {
-        context.position += 1;
-        recursion.add(depth);
+export const annotation: AnnotationParser = lazy(() => constraint(State.annotation,
+  repeat('(', beforeNonblank, ')', [Recursion.bracket], precedence(1, surround(
+    '',
+    some(union([inline]), ')', [[')', 1]]),
+    ')',
+    false, [],
+    ([, bs], { buffer }) => buffer.import(bs),
+    ([, bs], { buffer }) => bs && buffer.import(bs).push(new Node(Command.Cancel)) && buffer)),
+    (nodes, context, lead, follow) => {
+      const { linebreak, recursion, resources } = context;
+      if (linebreak !== 0 || nodes.length === 0 || lead === 0 || follow % 2 === 0) {
+        nodes.unshift(new Node('('));
+        nodes.push(new Node(')'));
         return new List([
-          new Node(html('span',
-            { class: 'paren' },
-            ['(', html('sup', { class: 'annotation' }, [html('span', [bs.head.value])])]))
+          new Node(html('span', { class: bracketname(context, 1, 1) }, defrag(unwrap(nodes))))
         ]);
       }
-    }
-    bs ??= new List();
-    bs.unshift(new Node('('));
-    if (source[context.position] === ')') {
-      bs.push(new Node(')'));
-      context.position += 1;
-      context.range += 1;
-    }
-    bs = new List([
-      new Node(html('span',
-        { class: bracketname(context, 2, context.position - position) },
-        defrag(unwrap(bs))))
-    ]);
-    bs.unshift(new Node('('));
-    const cs = parser(context);
-    if (source[context.position] === ')') {
-      cs && bs.import(cs);
-      bs.push(new Node(')'));
+      recursion.add(MAX_DEPTH - (resources?.recursions[Recursion.bracket] ?? resources?.recursions.at(-1) ?? MAX_DEPTH));
       context.position += 1;
-      context.range += 1;
-    }
-    return new List([new Node(html('span',
-      { class: bracketname(context, 1, context.position - position) },
-      defrag(unwrap(bs))))]);
-  })));
-
-const parser = lazy(() => precedence(1, some(inline, ')', [[')', 1]])));
-
-function deepunwrap(list: List<Node<string | HTMLElement>>): boolean {
-  let bottom = list.head!.value as HTMLElement;
-  for (; bottom;) {
-    const el = bottom.firstChild!.firstChild;
-    if (el !== el?.parentNode?.lastChild) break;
-    if (el instanceof HTMLElement === false) break;
-    if (el?.className !== 'annotation') break;
-    bottom = el;
-  }
-  const el = bottom.firstChild!.firstChild;
-  if (el instanceof Element === false) return false;
-  if (el === el?.parentNode?.lastChild) {
-    const { className, firstChild, lastChild } = el;
-    if (className === 'paren' || className === 'bracket') {
-      firstChild!.nodeValue!.length === 1
-        ? firstChild!.remove()
-        : firstChild!.nodeValue = firstChild!.nodeValue!.slice(1);
-      lastChild!.nodeValue!.length === 1
-        ? lastChild!.remove()
-        : lastChild!.nodeValue = lastChild!.nodeValue!.slice(0, -1);
-      el.replaceWith(...el.childNodes);
-      return true;
-    }
-  }
-  return false;
-}
+      return new List([
+        new Node(html('sup', { class: 'annotation' }, [html('span', defrag(unwrap(trimBlankNodeEnd(nodes))))]))
+      ]);
+    },
+    (nodes, context, prefix, postfix) => {
+      assert(postfix === 0);
+      for (let i = 0; i < prefix; ++i) {
+        nodes.unshift(new Node('('));
+        nodes = new List([new Node(html('span', { class: bracketname(context, 1, 0) }, defrag(unwrap(nodes))))]);
+        context.range += 1;
+      }
+      return nodes;
+    })));

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

@@ -83,6 +83,7 @@ describe('Unit: parser/inline/autolink/url', () => {
       assert.deepStrictEqual(inspect(parser, input(' http://host>', new Context())), [['<a class="url" href="http://host" target="_blank">http://host</a>'], '>']);
       assert.deepStrictEqual(inspect(parser, input(' http://host（', new Context())), [['<a class="url" href="http://host" target="_blank">http://host</a>'], '（']);
       assert.deepStrictEqual(inspect(parser, input(' http://host）', new Context())), [['<a class="url" href="http://host" target="_blank">http://host</a>'], '）']);
+      assert.deepStrictEqual(inspect(parser, input(` http://host${'+'.repeat(5e5)}`, new Context())), [['<a class="url" href="http://host" target="_blank">http://host</a>'], '+'.repeat(5e5)]);
     });
 
     it('trailing entities', () => {

package/src/parser/inline/deletion.ts

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

package/src/parser/inline/emstrong.ts

@@ -1,13 +1,14 @@
 import { EmStrongParser, EmphasisParser, StrongParser } from '../inline';
 import { Recursion, Command } from '../context';
 import { Parser, Result, List, Node } from '../../combinator/data/parser';
-import { union, some, recursion, precedence, surround, lazy, bind } from '../../combinator';
+import { union, some, precedence, surround, lazy, bind } from '../../combinator';
 import { inline } from '../inline';
 import { strong } from './strong';
 import { emphasis } from './emphasis';
 import { strs } from '../source';
+import { repeat } from '../repeat';
 import { beforeNonblank, afterNonblank } from '../visibility';
-import { unwrap, repeat } from '../util';
+import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 const substrong: Parser.IntermediateParser<StrongParser> = lazy(() => some(union([
@@ -23,7 +24,7 @@ const subemphasis: Parser.IntermediateParser<EmphasisParser> = lazy(() => some(u
 // 可能な限り早く閉じるよう解析しなければならない。
 // このため終端記号の後ろを見て終端を中止し同じ構文を再帰的に適用してはならない。
 export const emstrong: EmStrongParser = lazy(() =>
-  precedence(0, repeat('***', beforeNonblank, recursion(Recursion.inline, surround(
+  repeat('***', beforeNonblank, '***', [Recursion.inline], precedence(0, surround(
     '',
     some(union([some(inline, '*', afterNonblank)])),
     strs('*', 1, 3),
@@ -80,6 +81,7 @@ export const emstrong: EmStrongParser = lazy(() =>
     nodes => new List([new Node(html('em', [html('strong', defrag(unwrap(nodes)))]))]),
     (nodes, context, prefix, postfix, state) => {
       context.position += postfix;
+      context.range += postfix;
       assert(postfix < 3);
       if (state) {
         switch (postfix) {
@@ -96,6 +98,7 @@ export const emstrong: EmStrongParser = lazy(() =>
         }
         prefix -= postfix;
         postfix -= postfix;
+        context.range += postfix;
         switch (prefix) {
           case 0:
             break;
@@ -114,6 +117,7 @@ export const emstrong: EmStrongParser = lazy(() =>
               })
               (context) ?? prepend('*', nodes);
             prefix -= 1;
+            context.range += 1;
             break;
           case 2:
             nodes = bind<StrongParser>(
@@ -130,14 +134,17 @@ export const emstrong: EmStrongParser = lazy(() =>
               })
               (context) ?? prepend('**', nodes);
             prefix -= 2;
+            context.range += 2;
             break;
         }
       }
       if (prefix > postfix) {
         nodes = prepend('*'.repeat(prefix - postfix), nodes);
+        prefix = 0;
+        context.range += prefix - postfix;
       }
       return nodes;
-    })));
+    }));
 
 function prepend<N>(prefix: string, nodes: List<Node<N>>): List<Node<N>> {
   if (typeof nodes.head?.value === 'string') {

package/src/parser/inline/extension/placeholder.ts

@@ -15,7 +15,7 @@ import { html } from 'typed-dom/dom';
 export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => surround(
   // ^はabbrで使用済みだが^:などのようにして分離使用可能
   str(/\[[:^|]/y, beforeNonblank),
-  precedence(1, recursion(Recursion.inline,
+  precedence(1, recursion(Recursion.bracket,
   some(union([inline]), ']', [[']', 1]]))),
   str(']'),
   false,

package/src/parser/inline/insertion.ts

@@ -1,14 +1,15 @@
 import { InsertionParser } from '../inline';
 import { Recursion, Command } from '../context';
 import { List, Node } from '../../combinator/data/parser';
-import { union, some, recursion, precedence, surround, open, lazy } from '../../combinator';
+import { union, some, precedence, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
+import { repeat } from '../repeat';
 import { blankWith } from '../visibility';
-import { unwrap, repeat } from '../util';
+import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const insertion: InsertionParser = lazy(() =>
-  precedence(0, repeat('++', '', recursion(Recursion.inline, surround(
+  repeat('++', '', '++', [Recursion.inline], precedence(0, surround(
     '',
     some(union([
       some(inline, blankWith('\n', '++')),
@@ -18,4 +19,4 @@ export const insertion: InsertionParser = lazy(() =>
     false, [],
     ([, bs], { buffer }) => buffer.import(bs),
     ([, bs], { buffer }) => bs && buffer.import(bs).push(new Node(Command.Cancel)) && buffer)),
-    nodes => new List([new Node(html('ins', defrag(unwrap(nodes))))]))));
+    nodes => new List([new Node(html('ins', defrag(unwrap(nodes))))])));

package/src/parser/inline/italic.ts

@@ -1,21 +1,22 @@
 import { ItalicParser } from '../inline';
 import { Recursion, Command } from '../context';
 import { List, Node } from '../../combinator/data/parser';
-import { union, some, recursion, precedence, surround, lazy } from '../../combinator';
+import { union, some, precedence, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
+import { repeat } from '../repeat';
 import { beforeNonblank, afterNonblank } from '../visibility';
-import { unwrap, repeat } from '../util';
+import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 // 可読性のため実際にはオブリーク体を指定する。
 // 斜体は単語に使うとかえって見づらく読み飛ばしやすくなるため使わないべきであり
 // ある程度の長さのある文に使うのが望ましい。
 export const italic: ItalicParser = lazy(() =>
-  precedence(0, repeat('///', beforeNonblank, recursion(Recursion.inline, surround(
+  repeat('///', beforeNonblank, '///', [Recursion.inline], precedence(0, surround(
     '',
     some(union([inline]), '///', afterNonblank),
     '///',
     false, [],
     ([, bs], { buffer }) => buffer.import(bs),
     ([, bs], { buffer }) => bs && buffer.import(bs).push(new Node(Command.Cancel)) && buffer)),
-    nodes => new List([new Node(html('i', defrag(unwrap(nodes))))]))));
+    nodes => new List([new Node(html('i', defrag(unwrap(nodes))))])));