securemark 0.263.0 → 0.264.0

package/src/parser/inline/annotation.ts

@@ -1,4 +1,3 @@
-import { undefined } from 'spica/global';
 import { AnnotationParser } from '../inline';
 import { union, some, context, syntax, constraint, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
@@ -9,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

@@ -1,4 +1,3 @@
-import { undefined } from 'spica/global';
 import { BracketParser } from '../inline';
 import { union, some, syntax, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
@@ -25,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

@@ -1,4 +1,3 @@
-import { undefined } from 'spica/global';
 import { ExtensionParser } from '../../inline';
 import { union, some, syntax, creation, precedence, constraint, validate, surround, open, lazy, fmap } from '../../../combinator';
 import { inline } from '../../inline';
@@ -33,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

@@ -1,4 +1,3 @@
-import { undefined } from 'spica/global';
 import { MarkdownParser } from '../../../../markdown';
 import { Parser } from '../../../combinator/data/parser';
 import { fmap } from '../../../combinator';
@@ -9,14 +8,23 @@ 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'));
@@ -25,9 +33,9 @@ export function text(source: HTMLElement | DocumentFragment, optional = false):
   if (!indexer && optional) return '';
   const index = indexer?.getAttribute('data-index');
   if (index) return index;
-  assert(!source.querySelector('.annotation, br'));
+  assert(!source.querySelector('br'));
   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) {
@@ -40,6 +48,9 @@ export function text(source: HTMLElement | DocumentFragment, optional = false):
       case 'OL':
         el.remove();
         continue;
+      case 'BR':
+        el.replaceWith('\n');
+        continue;
     }
     switch (el.className) {
       case 'math':
@@ -47,11 +58,9 @@ export function text(source: HTMLElement | DocumentFragment, optional = false):
         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/label.ts

@@ -1,4 +1,3 @@
-import { Array } from 'spica/global';
 import { ExtensionParser } from '../../inline';
 import { union, constraint, creation, validate, surround, clear, fmap } from '../../../combinator';
 import { str } from '../../source';

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

@@ -1,4 +1,3 @@
-import { undefined, Object } from 'spica/global';
 import { HTMLParser } from '../inline';
 import { union, subsequence, some, syntax, validate, focus, surround, open, match, lazy } from '../../combinator';
 import { inline } from '../inline';
@@ -6,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';
 
@@ -60,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/htmlentity.ts

@@ -1,4 +1,3 @@
-import { undefined } from 'spica/global';
 import { HTMLEntityParser, UnsafeHTMLEntityParser } from '../inline';
 import { union, creation, validate, focus, fmap } from '../../combinator';
 import { html } from 'typed-dom/dom';

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>'], '+']);
     });

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

@@ -32,11 +32,11 @@ describe('Unit: parser/inline/link', () => {
       assert.deepStrictEqual(inspect(parser('[mailto:á]{http://evil}')), undefined);
       assert.deepStrictEqual(inspect(parser('[file:///]{http://evil}')), undefined);
       assert.deepStrictEqual(inspect(parser('[.http://á]{http://evil}')), undefined);
-      assert.deepStrictEqual(inspect(parser('[0987654321]{tel:1234567890}')), undefined);
-      assert.deepStrictEqual(inspect(parser('[1234567890-]{tel:1234567890}')), undefined);
-      assert.deepStrictEqual(inspect(parser('[-1234567890]{tel:1234567890}')), undefined);
-      assert.deepStrictEqual(inspect(parser('[123456789a]{tel:1234567890}')), undefined);
-      assert.deepStrictEqual(inspect(parser('[1234567890]{tel:ttel:1234567890}')), undefined);
+      assert.deepStrictEqual(inspect(parser('[0987654321]{tel:1234567890}')), [['<a class="invalid">0987654321</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[1234567890-]{tel:1234567890}')), [['<a class="invalid">1234567890-</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[-1234567890]{tel:1234567890}')), [['<a class="invalid">-1234567890</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[123456789a]{tel:1234567890}')), [['<a class="invalid">123456789a</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[1234567890]{tel:ttel:1234567890}')), [['<a class="invalid">1234567890</a>'], '']);
       //assert.deepStrictEqual(inspect(parser('[#a]{b}')), undefined);
       //assert.deepStrictEqual(inspect(parser('[\\#a]{b}')), undefined);
       //assert.deepStrictEqual(inspect(parser('[c #a]{b}')), undefined);
@@ -145,6 +145,7 @@ describe('Unit: parser/inline/link', () => {
       assert.deepStrictEqual(inspect(parser('{tel:+1234567890}')), [[`<a class="tel" href="tel:+1234567890">tel:+1234567890</a>`], '']);
       assert.deepStrictEqual(inspect(parser('{tel:+12-345-67-890}')), [[`<a class="tel" href="tel:+12-345-67-890">tel:+12-345-67-890</a>`], '']);
       assert.deepStrictEqual(inspect(parser('[1234567890]{tel:1234567890}')), [[`<a class="tel" href="tel:1234567890">1234567890</a>`], '']);
+      assert.deepStrictEqual(inspect(parser('[1234567890]{tel:12-3456-7890}')), [[`<a class="tel" href="tel:12-3456-7890">1234567890</a>`], '']);
       assert.deepStrictEqual(inspect(parser('[12-3456-7890]{tel:1234567890}')), [[`<a class="tel" href="tel:1234567890">12-3456-7890</a>`], '']);
       assert.deepStrictEqual(inspect(parser('[+12-34567-890]{tel:+12-345-67890}')), [[`<a class="tel" href="tel:+12-345-67890">+12-34567-890</a>`], '']);
     });

package/src/parser/inline/link.ts

@@ -1,4 +1,3 @@
-import { undefined, location, encodeURI, decodeURI, Location } from 'spica/global';
 import { MarkdownParser } from '../../../markdown';
 import { LinkParser } from '../inline';
 import { Result, eval, exec } from '../../combinator/data/parser';
@@ -99,22 +98,6 @@ function parse(
   const uri = new ReadonlyURL(
     resolve(INSECURE_URI, context.host ?? location, context.url ?? context.host ?? location),
     context.host?.href || location.href);
-  switch (uri.protocol) {
-    case 'tel:': {
-      const tel = content.length === 0
-        ? INSECURE_URI
-        : content[0];
-      const pattern = /^(?:tel:)?(?:\+(?!0))?\d+(?:-\d+)*$/i;
-      if (content.length <= 1 &&
-          typeof tel === 'string' &&
-          pattern.test(tel) &&
-          pattern.test(INSECURE_URI) &&
-          tel.replace(/[^+\d]/g, '') === INSECURE_URI.replace(/[^+\d]/g, '')) {
-        break;
-      }
-      return;
-    }
-  }
   const el = elem(
     INSECURE_URI,
     content,
@@ -136,35 +119,52 @@ function elem(
     case 'http:':
     case 'https:':
       assert(uri.host);
-      if (INSECURE_URI.slice(0, 2) === '^/' &&
-          /\/\.\.?(?:\/|$)/.test(INSECURE_URI.slice(0, INSECURE_URI.search(/[?#]|$/)))) {
-        type = 'argument';
-        message = 'Dot-segments cannot be used in subresource paths';
-        break;
+      switch (true) {
+        case INSECURE_URI.slice(0, 2) === '^/'
+          && /\/\.\.?(?:\/|$)/.test(INSECURE_URI.slice(0, INSECURE_URI.search(/[?#]|$/))):
+          type = 'argument';
+          message = 'Dot-segments cannot be used in subresource paths';
+          break;
+        default:
+          return html('a',
+            {
+              class: content.length === 0 ? 'url' : 'link',
+              href: uri.source,
+              target: undefined
+                || uri.origin !== origin
+                || typeof content[0] === 'object' && content[0].classList.contains('media')
+                  ? '_blank'
+                  : undefined,
+            },
+            content.length === 0
+              ? decode(INSECURE_URI)
+              : content);
       }
-      return html('a',
-        {
-          class: content.length === 0 ? 'url' : 'link',
-          href: uri.source,
-          target: undefined
-            || uri.origin !== origin
-            || typeof content[0] === 'object' && content[0].classList.contains('media')
-              ? '_blank'
-              : undefined,
-        },
-        content.length === 0
-          ? decode(INSECURE_URI)
-          : content);
+      break;
     case 'tel:':
       assert(content.length <= 1);
-      return html('a',
-        {
-          class: 'tel',
-          href: uri.source,
-        },
-        content.length === 0
-          ? [INSECURE_URI]
-          : content);
+      const tel = content.length === 0
+        ? INSECURE_URI
+        : content[0];
+      const pattern = /^(?:tel:)?(?:\+(?!0))?\d+(?:-\d+)*$/i;
+      switch (true) {
+        case content.length <= 1
+          && pattern.test(INSECURE_URI)
+          && typeof tel === 'string'
+          && pattern.test(tel)
+          && tel.replace(/[^+\d]/g, '') === INSECURE_URI.replace(/[^+\d]/g, ''):
+          return html('a',
+            {
+              class: 'tel',
+              href: uri.source,
+            },
+            content.length === 0
+              ? [INSECURE_URI]
+              : content);
+        default:
+          type = 'content';
+          message = 'Invalid content';
+      }
   }
   return html('a',
     {

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

@@ -15,8 +15,10 @@ describe('Unit: parser/inline/mark', () => {
       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);
@@ -27,20 +29,18 @@ describe('Unit: parser/inline/mark', () => {
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser('==a==')), [['<mark>a</mark>'], '']);
-      assert.deepStrictEqual(inspect(parser('==a=b==')), [['<mark>a=b</mark>'], '']);
-      assert.deepStrictEqual(inspect(parser('==a\nb==')), [['<mark>a<br>b</mark>'], '']);
-      assert.deepStrictEqual(inspect(parser('==a\\\nb==')), [['<mark>a<span class="linebreak"> </span>b</mark>'], '']);
-      assert.deepStrictEqual(inspect(parser('==\\===')), [['<mark>=</mark>'], '']);
-      assert.deepStrictEqual(inspect(parser('==a===')), [['<mark>a</mark>'], '=']);
+      assert.deepStrictEqual(inspect(parser('==a==')), [['<mark id="mark:a">a</mark>', '<a href="#mark:a"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('==a=b==')), [['<mark id="mark:a=b">a=b</mark>', '<a href="#mark:a=b"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('==\\===')), [['<mark id="mark:=">=</mark>', '<a href="#mark:="></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('==a===')), [['<mark id="mark:a">a</mark>', '<a href="#mark:a"></a>'], '=']);
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser('==a ==b====')), [['<mark>a <mark>b</mark></mark>'], '']);
-      assert.deepStrictEqual(inspect(parser('==a\\ ==b====')), [['<mark>a <mark>b</mark></mark>'], '']);
-      assert.deepStrictEqual(inspect(parser('==a&Tab;==b====')), [['<mark>a\t<mark>b</mark></mark>'], '']);
-      assert.deepStrictEqual(inspect(parser('==a<wbr>==b====')), [['<mark>a<wbr><mark>b</mark></mark>'], '']);
-      assert.deepStrictEqual(inspect(parser('==_==a==_==')), [['<mark><em><mark>a</mark></em></mark>'], '']);
+      assert.deepStrictEqual(inspect(parser('==a ==b====')), [['<mark id="mark:a_b">a <mark id="mark:b">b</mark><a href="#mark:b"></a></mark>', '<a href="#mark:a_b"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('==a\\ ==b====')), [['<mark id="mark:a_b">a <mark id="mark:b">b</mark><a href="#mark:b"></a></mark>', '<a href="#mark:a_b"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('==a&Tab;==b====')), [['<mark id="mark:a_b">a\t<mark id="mark:b">b</mark><a href="#mark:b"></a></mark>', '<a href="#mark:a_b"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('==a<wbr>==b====')), [['<mark id="mark:ab">a<wbr><mark id="mark:b">b</mark><a href="#mark:b"></a></mark>', '<a href="#mark:ab"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('==_==a==_==')), [['<mark id="mark:a"><em><mark id="mark:a">a</mark><a href="#mark:a"></a></em></mark>', '<a href="#mark:a"></a>'], '']);
     });
 
   });