securemark 0.263.1 → 0.265.0

package/src/parser/block/ulist.test.ts

@@ -28,51 +28,51 @@ describe('Unit: parser/block/ulist', () => {
       // filled
       assert.deepStrictEqual(inspect(parser('- \\')), [['<ul><li></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- \\\n')), [['<ul><li></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- -')), [['<ul><li>-</li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- -\n')), [['<ul><li>-</li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- -')), [['<ul><li id="index:-">-</li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- -\n')), [['<ul><li id="index:-">-</li></ul>'], '']);
     });
 
     it('multiple', () => {
       // pending
       assert.deepStrictEqual(inspect(parser('-\n-')), [['<ul><li></li><li></li></ul>'], '']);
       // filled
-      assert.deepStrictEqual(inspect(parser('- 1\n- 2')), [['<ul><li>1</li><li>2</li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- 1\n- 2\n- 3')), [['<ul><li>1</li><li>2</li><li>3</li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- 1\n- 2')), [['<ul><li id="index:1">1</li><li id="index:2">2</li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- 1\n- 2\n- 3')), [['<ul><li id="index:1">1</li><li id="index:2">2</li><li id="index:3">3</li></ul>'], '']);
       // invalid
-      assert.deepStrictEqual(inspect(parser('-\n+')), [['<ul><li></li><li><span class="invalid">+</span></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('-\n0')), [['<ul><li></li><li><span class="invalid">0</span></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('-\n+')), [['<ul><li></li><li id="index:+"><span class="invalid">+</span></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('-\n0')), [['<ul><li></li><li id="index:0"><span class="invalid">0</span></li></ul>'], '']);
     });
 
     it('nest', () => {
       assert.deepStrictEqual(inspect(parser('-\n -')), [['<ul><li><br><ul><li></li></ul></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- 1\n - 2')), [['<ul><li>1<ul><li>2</li></ul></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- 1\n - 2\n- 3')), [['<ul><li>1<ul><li>2</li></ul></li><li>3</li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- 1\n - 2\n - 3')), [['<ul><li>1<ul><li>2</li><li>3</li></ul></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- 1\n - 2\n  - 3')), [['<ul><li>1<ul><li>2<ul><li>3</li></ul></li></ul></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- 1\n  - 2\n - 3')), [['<ul><li>1<ul><li>2</li></ul></li><li><span class="invalid"> - 3</span></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('-\n -\n +\n -\n +\n+')), [['<ul><li><br><ul><li></li><li><span class="invalid">+</span></li><li></li><li><span class="invalid">+</span></li></ul></li><li><span class="invalid">+</span></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- 1\n + 2')), [['<ul><li>1<ul class="invalid"><li>2</li></ul></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- 1\n 0')), [['<ul><li>1<ol><li></li></ol></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- 1\n 0.')), [['<ul><li>1<ol><li></li></ol></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- 1\n 0. ')), [['<ul><li>1<ol><li></li></ol></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- 1\n 0. 2')), [['<ul><li>1<ol><li>2</li></ol></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- !http://host')), [['<ul><li>!<a class="url" href="http://host" target="_blank">http://host</a></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- 1\n - 2')), [['<ul><li id="index:1">1<ul><li id="index:2">2</li></ul></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- 1\n - 2\n- 3')), [['<ul><li id="index:1">1<ul><li id="index:2">2</li></ul></li><li id="index:3">3</li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- 1\n - 2\n - 3')), [['<ul><li id="index:1">1<ul><li id="index:2">2</li><li id="index:3">3</li></ul></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- 1\n - 2\n  - 3')), [['<ul><li id="index:1">1<ul><li id="index:2">2<ul><li id="index:3">3</li></ul></li></ul></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- 1\n  - 2\n - 3')), [['<ul><li id="index:1">1<ul><li id="index:2">2</li></ul></li><li id="index:-_3"><span class="invalid"> - 3</span></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('-\n -\n +\n -\n +\n+')), [['<ul><li><br><ul><li></li><li id="index:+"><span class="invalid">+</span></li><li></li><li id="index:+"><span class="invalid">+</span></li></ul></li><li id="index:+"><span class="invalid">+</span></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- 1\n + 2')), [['<ul><li id="index:1">1<ul class="invalid"><li>2</li></ul></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- 1\n 0')), [['<ul><li id="index:1">1<ol><li></li></ol></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- 1\n 0.')), [['<ul><li id="index:1">1<ol><li></li></ol></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- 1\n 0. ')), [['<ul><li id="index:1">1<ol><li></li></ol></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- 1\n 0. 2')), [['<ul><li id="index:1">1<ol><li id="index:2">2</li></ol></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- !http://host')), [['<ul><li id="index:!http://host">!<a class="url" href="http://host" target="_blank">http://host</a></li></ul>'], '']);
     });
 
     it('checkbox', () => {
       assert.deepStrictEqual(inspect(parser('- [ ]')), [['<ul class="checklist"><li><span class="checkbox">☐</span></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- [x]')), [['<ul class="checklist"><li><span class="checkbox">☑</span></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- [X]')), [['<ul class="checklist"><li><span class="checkbox">☑</span></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- [X] 1')), [['<ul class="checklist"><li><span class="checkbox">☑</span>1</li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- [X] 1')), [['<ul class="checklist"><li id="index:1"><span class="checkbox">☑</span>1</li></ul>'], '']);
     });
 
     it('indexer', () => {
-      assert.deepStrictEqual(inspect(parser('- [#a]')), [['<ul><li><a class="index" href="#index:a">a</a></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- a [#]')), [['<ul><li id="index:a">a<span class="indexer" data-index=""></span></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- [#a]')), [['<ul><li id="index:a"><a class="index" href="#index:a">a</a></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- a [#]')), [['<ul><li>a<span class="indexer" data-index=""></span></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- a [#b]')), [['<ul><li id="index:b">a<span class="indexer" data-index="b"></span></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- [ ] [#a]')), [['<ul class="checklist"><li><span class="checkbox">☐</span><a class="index" href="#index:a">a</a></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- [ ] [#a]')), [['<ul class="checklist"><li id="index:a"><span class="checkbox">☐</span><a class="index" href="#index:a">a</a></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- [ ] a [#b]')), [['<ul class="checklist"><li id="index:b"><span class="checkbox">☐</span>a<span class="indexer" data-index="b"></span></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- a [#]\n - c [#d]')), [['<ul><li id="index:a">a<span class="indexer" data-index=""></span><ul><li id="index:d">c<span class="indexer" data-index="d"></span></li></ul></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- a [#]\n - c [#d]')), [['<ul><li>a<span class="indexer" data-index=""></span><ul><li id="index:d">c<span class="indexer" data-index="d"></span></li></ul></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- a [#b]\n - c [#d]')), [['<ul><li id="index:b">a<span class="indexer" data-index="b"></span><ul><li id="index:d">c<span class="indexer" data-index="d"></span></li></ul></li></ul>'], '']);
     });
 

package/src/parser/context.ts

@@ -1,28 +1,23 @@
 export const enum Syntax {
-  reference = 1 << 13,
-  comment = 1 << 12,
-  index = 1 << 11,
-  placeholder = 1 << 10,
-  ruby = 1 << 9,
-  link = 1 << 8,
-  bracket = 1 << 7,
-  media = 1 << 6,
-  annotation = 1 << 5,
-  mathbracket = 1 << 4,
-  html = 1 << 3,
-  math = 1 << 2,
+  reference = 1 << 8,
+  index = 1 << 7,
+  placeholder = 1 << 6,
+  ruby = 1 << 5,
+  link = 1 << 4,
+  bracket = 1 << 3,
+  media = 1 << 2,
   autolink = 1 << 1,
-  quote = 1 << 0,
   none = 0,
 }
 
 export const enum State {
-  annotation = 1 << 7,
-  reference = 1 << 6,
-  index = 1 << 5,
-  label = 1 << 4,
-  link = 1 << 3,
-  media = 1 << 2,
+  annotation = 1 << 8,
+  reference = 1 << 7,
+  index = 1 << 6,
+  label = 1 << 5,
+  link = 1 << 4,
+  media = 1 << 3,
+  mark = 1 << 2,
   autolink = 1 << 1,
   shortcut = 1 << 0,
   none = 0,
@@ -33,6 +28,7 @@ export const enum State {
     | State.index
     | State.label
     | State.link
+    | State.mark
     | State.autolink,
   backtrackers = 0
     | State.annotation

package/src/parser/inline/annotation.ts

@@ -8,7 +8,7 @@ import { html, defrag } from 'typed-dom/dom';
 export const annotation: AnnotationParser = lazy(() => surround(
   '((',
   constraint(State.annotation, false,
-  syntax(Syntax.annotation, 6, 1, State.annotation | State.media,
+  syntax(Syntax.none, 6, 1, State.annotation | State.media,
   startLoose(
   context({ delimiters: undefined },
   some(union([inline]), ')', [[/^\\?\n/, 9], [')', 2], ['))', 6]])), ')'))),

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

@@ -78,7 +78,7 @@ describe('Unit: parser/inline/bracket', () => {
       assert.deepStrictEqual(inspect(parser('"(("')), [['"', '', '(', '', '(', '"'], '']);
       assert.deepStrictEqual(inspect(parser('"(\\")"')), [['"', '<span class="paren">(")</span>', '"'], '']);
       assert.deepStrictEqual(inspect(parser('"(\n)"')), [['"', '<span class="paren">(<br>)</span>', '"'], '']);
-      assert.deepStrictEqual(inspect(parser('"(\\\n)"')), [['"', '<span class="paren">(<span class="linebreak"> </span>)</span>', '"'], '']);
+      assert.deepStrictEqual(inspect(parser('"(\\\n)"')), [['"', '<span class="paren">(<br>)</span>', '"'], '']);
     });
 
   });

package/src/parser/inline/bracket.ts

@@ -24,7 +24,7 @@ export const bracket: BracketParser = lazy(() => union([
     undefined,
     ([as, bs = []], rest) => [unshift(as, bs), rest]),
   // Control media blinking in editing rather than control confusion of pairs of quote marks.
-  surround(str('"'), syntax(Syntax.quote, 8, 1, State.none, some(inline, '"', [['"', 8]])), str('"'), true,
+  surround(str('"'), syntax(Syntax.none, 8, 1, State.none, some(inline, '"', [['"', 8]])), str('"'), true,
     undefined,
     ([as, bs = []], rest) => [unshift(as, bs), rest]),
 ]));

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

@@ -23,7 +23,7 @@ describe('Unit: parser/inline/deletion', () => {
       assert.deepStrictEqual(inspect(parser('~~ a ~~')), [['<del> a </del>'], '']);
       assert.deepStrictEqual(inspect(parser('~~  a  ~~')), [['<del>  a  </del>'], '']);
       assert.deepStrictEqual(inspect(parser('~~\na~~')), [['<del><br>a</del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~\\\na~~')), [['<del><span class="linebreak"> </span>a</del>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~\\\na~~')), [['<del><br>a</del>'], '']);
       assert.deepStrictEqual(inspect(parser('~~<wbr>a~~')), [['<del><wbr>a</del>'], '']);
       assert.deepStrictEqual(inspect(parser('~~a ~~')), [['<del>a </del>'], '']);
       assert.deepStrictEqual(inspect(parser('~~a \n ~~')), [['<del>a </del>'], '']);
@@ -31,7 +31,7 @@ describe('Unit: parser/inline/deletion', () => {
       assert.deepStrictEqual(inspect(parser('~~a\n ~~')), [['<del>a </del>'], '']);
       assert.deepStrictEqual(inspect(parser('~~a\n<wbr>~~')), [['<del>a<wbr></del>'], '']);
       assert.deepStrictEqual(inspect(parser('~~a\nb~~')), [['<del>a<br>b</del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~a\\\nb~~')), [['<del>a<span class="linebreak"> </span>b</del>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~a\\\nb~~')), [['<del>a<br>b</del>'], '']);
       assert.deepStrictEqual(inspect(parser('~~\\~~~')), [['<del>~</del>'], '']);
       assert.deepStrictEqual(inspect(parser('~~a~~~')), [['<del>a</del>'], '~']);
     });

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

@@ -12,8 +12,10 @@ describe('Unit: parser/inline/emphasis', () => {
       assert.deepStrictEqual(inspect(parser('_a _')), [['_', 'a'], ' _']);
       assert.deepStrictEqual(inspect(parser('_a  _')), [['_', 'a', ' '], ' _']);
       assert.deepStrictEqual(inspect(parser('_a\n_')), [['_', 'a'], '\n_']);
+      assert.deepStrictEqual(inspect(parser('_a\nb_')), [['_', 'a'], '\nb_']);
       assert.deepStrictEqual(inspect(parser('_a\\ _')), [['_', 'a'], '\\ _']);
       assert.deepStrictEqual(inspect(parser('_a\\\n_')), [['_', 'a'], '\\\n_']);
+      assert.deepStrictEqual(inspect(parser('_a\\\nb_')), [['_', 'a'], '\\\nb_']);
       assert.deepStrictEqual(inspect(parser('_ _')), undefined);
       assert.deepStrictEqual(inspect(parser('_ a_')), undefined);
       assert.deepStrictEqual(inspect(parser('_ a _')), undefined);
@@ -28,8 +30,6 @@ describe('Unit: parser/inline/emphasis', () => {
     it('basic', () => {
       assert.deepStrictEqual(inspect(parser('_a_')), [['<em>a</em>'], '']);
       assert.deepStrictEqual(inspect(parser('_ab_')), [['<em>ab</em>'], '']);
-      assert.deepStrictEqual(inspect(parser('_a\nb_')), [['<em>a<br>b</em>'], '']);
-      assert.deepStrictEqual(inspect(parser('_a\\\nb_')), [['<em>a<span class="linebreak"> </span>b</em>'], '']);
     });
 
     it('nest', () => {

package/src/parser/inline/emphasis.ts

@@ -11,8 +11,8 @@ export const emphasis: EmphasisParser = lazy(() => surround(
   str('_', '_'),
   syntax(Syntax.none, 1, 1, State.none,
   startTight(some(union([
-    some(inline, blankWith('_')),
-    open(some(inline, '_'), emphasis),
+    some(inline, blankWith('_'), [[/^\\?\n/, 9]]),
+    open(some(inline, '_', [[/^\\?\n/, 9]]), emphasis),
   ])))),
   str('_'), false,
   ([, bs], rest) => [[html('em', defrag(bs))], rest],

package/src/parser/inline/extension/index.test.ts

@@ -20,19 +20,17 @@ describe('Unit: parser/inline/extension/index', () => {
       assert.deepStrictEqual(inspect(parser('[#\\]')), undefined);
       assert.deepStrictEqual(inspect(parser('[#a')), undefined);
       assert.deepStrictEqual(inspect(parser('[#*a\nb*]')), undefined);
-      assert.deepStrictEqual(inspect(parser('[#a\n|#b]')), undefined);
-      assert.deepStrictEqual(inspect(parser('[#a|#\n]')), undefined);
-      assert.deepStrictEqual(inspect(parser('[#a|#\\\n]')), undefined);
-      assert.deepStrictEqual(inspect(parser('[#a|#(\n)]')), undefined);
-      assert.deepStrictEqual(inspect(parser('[#a|#(\\\n)]')), undefined);
+      assert.deepStrictEqual(inspect(parser('[#a\n|b]')), undefined);
+      assert.deepStrictEqual(inspect(parser('[#a|\n]')), undefined);
+      assert.deepStrictEqual(inspect(parser('[#a|\\\n]')), undefined);
+      assert.deepStrictEqual(inspect(parser('[#a|(\n)]')), undefined);
+      assert.deepStrictEqual(inspect(parser('[#a|(\\\n)]')), undefined);
       assert.deepStrictEqual(inspect(parser('[# |]')), undefined);
-      assert.deepStrictEqual(inspect(parser('[# |#]')), undefined);
-      assert.deepStrictEqual(inspect(parser('[# |#b]')), undefined);
+      assert.deepStrictEqual(inspect(parser('[# |b]')), undefined);
       assert.deepStrictEqual(inspect(parser('[# a|]')), undefined);
-      assert.deepStrictEqual(inspect(parser('[# a|#]')), undefined);
-      assert.deepStrictEqual(inspect(parser('[# a|#b]')), undefined);
-      assert.deepStrictEqual(inspect(parser('[# a|# ]')), undefined);
-      assert.deepStrictEqual(inspect(parser('[# a|# b]')), undefined);
+      assert.deepStrictEqual(inspect(parser('[# a|b]')), undefined);
+      assert.deepStrictEqual(inspect(parser('[# a| ]')), undefined);
+      assert.deepStrictEqual(inspect(parser('[# a| b]')), undefined);
       assert.deepStrictEqual(inspect(parser(' [#a]')), undefined);
     });
 
@@ -70,28 +68,26 @@ describe('Unit: parser/inline/extension/index', () => {
 
     it('indexer', () => {
       assert.deepStrictEqual(inspect(parser('[#|]')), [['<a class="index" href="#index:|">|</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#|#]')), [['<a class="index" href="#index:|#">|#</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#|#b]')), [['<a class="index" href="#index:|#b">|#b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#|b]')), [['<a class="index" href="#index:|b">|b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a|]')), [['<a class="index" href="#index:a|">a|</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a|#]')), [['<a class="index" href="#index:a|#">a|#</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a|# ]')), [['<a class="index" href="#index:a|#">a|#</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a|#\\ ]')), [['<a class="index" href="#index:a|#">a|#</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a|#b]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a|#b ]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a|#b  ]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a|#\\b]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a|#_b_]')), [['<a class="index" href="#index:_b_">a<span class="indexer" data-index="_b_"></span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a|#b c]')), [['<a class="index" href="#index:b_c">a<span class="indexer" data-index="b_c"></span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a|#b  c]')), [['<a class="index" href="#index:b_c">a<span class="indexer" data-index="b_c"></span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a|#[]]')), [['<a class="index" href="#index:[]">a<span class="indexer" data-index="[]"></span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a|#&copy;]')), [['<a class="index" href="#index:&amp;copy;">a<span class="indexer" data-index="&amp;copy;"></span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a |#b]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a  |#b]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a \\ |#b]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a &nbsp;|#b]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a <wbr>|#b]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a [% b %]|#c]')), [['<a class="index" href="#index:c">a <span class="comment"><input type="checkbox"><span>[% b %]</span></span><span class="indexer" data-index="c"></span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a\\ |#b]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a| ]')), [['<a class="index" href="#index:a|">a|</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a|\\ ]')), [['<a class="index" href="#index:a|">a|</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a|b]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a|b ]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a|b  ]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a|\\b]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a|_b_]')), [['<a class="index" href="#index:_b_">a<span class="indexer" data-index="_b_"></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a|b c]')), [['<a class="index" href="#index:b_c">a<span class="indexer" data-index="b_c"></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a|b  c]')), [['<a class="index" href="#index:b_c">a<span class="indexer" data-index="b_c"></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a|[]]')), [['<a class="index" href="#index:[]">a<span class="indexer" data-index="[]"></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a|&copy;]')), [['<a class="index" href="#index:&amp;copy;">a<span class="indexer" data-index="&amp;copy;"></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a |b]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a  |b]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a \\ |b]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a &nbsp;|b]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a <wbr>|b]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a [% b %]|c]')), [['<a class="index" href="#index:c">a <span class="comment"><input type="checkbox"><span>[% b %]</span></span><span class="indexer" data-index="c"></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a\\ |b]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
     });
 
   });

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

@@ -32,7 +32,7 @@ export const index: IndexParser = lazy(() => validate('[#', fmap(indexee(surroun
   ])));
 
 const signature: IndexParser.SignatureParser = lazy(() => creation(fmap(open(
-  '|#',
+  '|',
   startTight(some(union([bracket, txt]), ']'))),
   ns => [
     html('span', { class: 'indexer', 'data-index': identity(ns.join('')).slice(6) }),

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

@@ -8,33 +8,43 @@ export function indexee(parser: Parser<HTMLElement, MarkdownParser.Context>, opt
   return fmap(parser, ([el], _, { id }) => [define(el, { id: id !== '' && identity(text(el, optional)) || undefined })]);
 }
 
-export function identity(text: string): string {
+export function identity(text: string, name: 'index' | 'mark' = 'index'): string {
   assert(!text.includes('\n'));
-  text &&= text.trim();
-  return text && `index:${text.replace(/\s+/g, '_').slice(0, 101).replace(/^(.{97}).{4}$/, '$1...')}`;
+  text &&= text.trim().replace(/\s+/g, '_');
+  if (text.length <= 100) return text && `${name}:${text}`;
+  switch (name) {
+    case 'index':
+      return `${name}:${text.slice(0, 97)}...`;
+    case 'mark':
+      return `${name}:${text.slice(0, 50)}...${text.slice(-47)}`;
+  }
 }
-assert(identity('0'.repeat(100)).slice(6) === '0'.repeat(100));
-assert(identity('0'.repeat(101)).slice(6) === '0'.repeat(97) + '...');
-assert(identity('0'.repeat(200)).slice(6) === '0'.repeat(97) + '...');
+assert(identity('0'.repeat(100 - 1) + 1).slice(6) === '0'.repeat(100 - 1) + 1);
+assert(identity('0'.repeat(100) + 1).slice(6) === '0'.repeat(97) + '...');
+assert(identity('0'.repeat(200) + 1).slice(6) === '0'.repeat(97) + '...');
+assert(identity('0'.repeat(100 - 1) + 1, 'mark').slice(5) === '0'.repeat(100 - 1) + 1);
+assert(identity('0'.repeat(100) + 1, 'mark').slice(5) === '0'.repeat(50) + '...' + '0'.repeat(47 - 1) + 1);
+assert(identity('0'.repeat(200) + 1, 'mark').slice(5) === '0'.repeat(50) + '...' + '0'.repeat(47 - 1) + 1);
 
 export function text(source: HTMLElement | DocumentFragment, optional = false): string {
   assert(source instanceof DocumentFragment || !source.matches('.indexer'));
   assert(source.querySelectorAll(':scope > .indexer').length <= 1);
   const indexer = source.querySelector(':scope > .indexer');
-  if (!indexer && optional) return '';
   const index = indexer?.getAttribute('data-index');
   if (index) return index;
-  assert(!source.querySelector('.annotation, br'));
+  if (index === '' && optional) return '';
+  assert(!navigator.userAgent.includes('Chrome') || !source.querySelector('br:not(:has(+ :is(ul, ol)))'));
   const target = source.cloneNode(true) as typeof source;
-  for (let es = target.querySelectorAll('code[data-src], .math[data-src], .comment, rt, rp, .reference, .checkbox, ul, ol'),
+  for (let es = target.querySelectorAll('code[data-src], .math[data-src], .comment, rt, rp, br, .annotation, .reference, .checkbox, ul, ol'),
            len = es.length, i = 0; i < len; ++i) {
     const el = es[i];
     switch (el.tagName) {
       case 'CODE':
-        define(el, el.getAttribute('data-src')!);
+        el.replaceWith(el.getAttribute('data-src')!);
         continue;
       case 'RT':
       case 'RP':
+      case 'BR':
       case 'UL':
       case 'OL':
         el.remove();
@@ -42,15 +52,13 @@ export function text(source: HTMLElement | DocumentFragment, optional = false):
     }
     switch (el.className) {
       case 'math':
-        define(el, el.getAttribute('data-src')!);
+        el.replaceWith(el.getAttribute('data-src')!);
         continue;
       case 'comment':
       case 'checkbox':
-        el.remove();
-        continue;
+      case 'annotation':
       case 'reference':
-        assert(el.firstElementChild?.hasAttribute('hidden'));
-        el.firstChild!.remove();
+        el.remove();
         continue;
     }
   }

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

@@ -22,12 +22,6 @@ describe('Unit: parser/inline/extension/placeholder', () => {
       assert.deepStrictEqual(inspect(parser('[^\\\na]')), undefined);
       assert.deepStrictEqual(inspect(parser('[^ !http://host]')), undefined);
       assert.deepStrictEqual(inspect(parser('[^a')), [['[^', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('[^a\n]')), [['[^', 'a'], '\n]']);
-      assert.deepStrictEqual(inspect(parser('[^a\n\n]')), [['[^', 'a'], '\n\n]']);
-      assert.deepStrictEqual(inspect(parser('[^a\\\n]')), [['[^', 'a'], '\\\n]']);
-      assert.deepStrictEqual(inspect(parser('[^a\\\n\\\n]')), [['[^', 'a'], '\\\n\\\n]']);
-      assert.deepStrictEqual(inspect(parser('[^a\nb]')), [['[^', 'a'], '\nb]']);
-      assert.deepStrictEqual(inspect(parser('[^a\\\nb]')), [['[^', 'a'], '\\\nb]']);
       assert.deepStrictEqual(inspect(parser('[[]')), undefined);
       assert.deepStrictEqual(inspect(parser('[]]')), undefined);
       assert.deepStrictEqual(inspect(parser('[[]]')), undefined);
@@ -39,12 +33,16 @@ describe('Unit: parser/inline/extension/placeholder', () => {
     it('valid', () => {
       assert.deepStrictEqual(inspect(parser('[^a]')), [['<span class="invalid">a</span>'], '']);
       assert.deepStrictEqual(inspect(parser('[^a b]')), [['<span class="invalid">a b</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^a ]')), [['<span class="invalid">a </span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^a  ]')), [['<span class="invalid">a  </span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^a\\ ]')), [['<span class="invalid">a </span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^a\\ \\ ]')), [['<span class="invalid">a  </span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^a<wbr>]')), [['<span class="invalid">a<wbr></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^a<wbr><wbr>]')), [['<span class="invalid">a<wbr><wbr></span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[^a ]')), [['<span class="invalid">a</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[^a  ]')), [['<span class="invalid">a</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[^a\\ ]')), [['<span class="invalid">a</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[^a\\ \\ ]')), [['<span class="invalid">a</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[^a\n]')), [['<span class="invalid">a</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[^a\\\n]')), [['<span class="invalid">a</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[^a\nb]')), [['<span class="invalid">a<br>b</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[^a\\\nb]')), [['<span class="invalid">a<br>b</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[^a<wbr>]')), [['<span class="invalid">a</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[^a<wbr><wbr>]')), [['<span class="invalid">a</span>'], '']);
       assert.deepStrictEqual(inspect(parser('[^==]')), [['<span class="invalid">==</span>'], '']);
       assert.deepStrictEqual(inspect(parser('[^a[% b %]]')), [['<span class="invalid">a<span class="comment"><input type="checkbox"><span>[% b %]</span></span></span>'], '']);
       assert.deepStrictEqual(inspect(parser('[^a[% b %][% c %]]')), [['<span class="invalid">a<span class="comment"><input type="checkbox"><span>[% b %]</span></span><span class="comment"><input type="checkbox"><span>[% c %]</span></span></span>'], '']);

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

@@ -3,25 +3,25 @@ import { union, some, syntax, validate, surround, lazy } from '../../../combinat
 import { inline } from '../../inline';
 import { str } from '../../source';
 import { Syntax, State } from '../../context';
-import { startTight } from '../../visibility';
+import { startTight, trimBlankEnd } from '../../visibility';
 import { unshift } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
-// Don't use the symbols already used: !#$%@&*+~=
+// Don't use the symbols already used: !#$%@&*+~=|
 
 // All syntax surrounded by square brackets shouldn't contain line breaks.
 
-export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => validate(['[:', '[^'], surround(
-  str(/^\[[:^]/),
+export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => validate('[', surround(
+  str(/^\[[:^|]/),
   syntax(Syntax.placeholder, 2, 1, State.none,
-  startTight(some(union([inline]), ']', [[/^\\?\n/, 9], [']', 2]]))),
+  startTight(trimBlankEnd(some(union([inline]), ']', [[']', 2]])))),
   str(']'), false,
-  ([as, bs], rest) => [[
+  ([, bs], rest) => [[
     html('span', {
       class: 'invalid',
       'data-invalid-syntax': 'extension',
       'data-invalid-type': 'syntax',
-      'data-invalid-message': `Reserved start symbol "${as[0][1]}" cannot be used in "[]"`,
+      'data-invalid-message': `Invalid start symbol or linebreak`,
     }, defrag(bs)),
   ], rest],
   ([as, bs], rest) => [unshift(as, bs), rest])));

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

@@ -34,7 +34,7 @@ describe('Unit: parser/inline/html', () => {
       assert.deepStrictEqual(inspect(parser('<bdi><wbr></bdi>')), [['<span class="invalid">&lt;bdi&gt;<wbr>&lt;/bdi&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>\n</bdi>')), [['<span class="invalid">&lt;bdi&gt;<br>&lt;/bdi&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>\na</bdi>')), [['<span class="invalid">&lt;bdi&gt;<br>a&lt;/bdi&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>\\\na</bdi>')), [['<span class="invalid">&lt;bdi&gt;<span class="linebreak"> </span>a&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('<bdi>\\\na</bdi>')), [['<span class="invalid">&lt;bdi&gt;<br>a&lt;/bdi&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>a')), [['<span class="invalid">&lt;bdi&gt;a</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>a</BDO>')), [['<span class="invalid">&lt;bdi&gt;a&lt;/BDO&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<BDI>a</BDI>')), [['<span class="invalid">&lt;BDI&gt;a&lt;/BDI&gt;</span>'], '']);

package/src/parser/inline/html.ts

@@ -5,7 +5,7 @@ import { str } from '../source';
 import { Syntax, State } from '../context';
 import { isStartLooseNodes, blankWith } from '../visibility';
 import { memoize } from 'spica/memoize';
-import { Cache } from 'spica/cache';
+import { Clock } from 'spica/clock';
 import { unshift, push, splice } from 'spica/array';
 import { html as h, defrag } from 'typed-dom/dom';
 
@@ -59,7 +59,7 @@ export const html: HTMLParser = lazy(() => validate('<', validate(/^<[a-z]+(?=[^
         ([as, bs = []], rest) =>
           [[elem(tag, as, bs, [])], rest]),
     ([, tag]) => tag,
-    new Cache(10000))),
+    new Clock(10000))),
 ])))));
 
 export const attribute: HTMLParser.AttributeParser = union([

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

@@ -23,7 +23,7 @@ describe('Unit: parser/inline/insertion', () => {
       assert.deepStrictEqual(inspect(parser('++ a ++')), [['<ins> a </ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++  a  ++')), [['<ins>  a  </ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++\na++')), [['<ins><br>a</ins>'], '']);
-      assert.deepStrictEqual(inspect(parser('++\\\na++')), [['<ins><span class="linebreak"> </span>a</ins>'], '']);
+      assert.deepStrictEqual(inspect(parser('++\\\na++')), [['<ins><br>a</ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++<wbr>a++')), [['<ins><wbr>a</ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++a ++')), [['<ins>a </ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++a \n ++')), [['<ins>a </ins>'], '']);
@@ -31,7 +31,7 @@ describe('Unit: parser/inline/insertion', () => {
       assert.deepStrictEqual(inspect(parser('++a\n ++')), [['<ins>a </ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++a\n<wbr>++')), [['<ins>a<wbr></ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++a\nb++')), [['<ins>a<br>b</ins>'], '']);
-      assert.deepStrictEqual(inspect(parser('++a\\\nb++')), [['<ins>a<span class="linebreak"> </span>b</ins>'], '']);
+      assert.deepStrictEqual(inspect(parser('++a\\\nb++')), [['<ins>a<br>b</ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++\\+++')), [['<ins>+</ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++a+++')), [['<ins>a</ins>'], '+']);
     });