securemark 0.263.1 → 0.264.0

package/markdown.d.ts

@@ -779,8 +779,8 @@ export namespace MarkdownParser {
         }
       }
       export interface IndexerParser extends
-        // [#]
         // [#index]
+        // [#]
         Inline<'extension/indexer'>,
         Parser<HTMLElement, Context, [
           Parser<HTMLAnchorElement, Context, []>,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securemark",
-  "version": "0.263.1",
+  "version": "0.264.0",
   "description": "Secure markdown renderer working on browsers for user input data.",
   "private": false,
   "homepage": "https://github.com/falsandtru/securemark",
@@ -28,35 +28,35 @@
     "LICENSE"
   ],
   "devDependencies": {
-    "@types/dompurify": "2.3.4",
-    "@types/jquery": "3.5.14",
+    "@types/dompurify": "2.4.0",
+    "@types/jquery": "3.5.16",
     "@types/mathjax": "0.0.37",
-    "@types/mocha": "10.0.0",
+    "@types/mocha": "10.0.1",
     "@types/power-assert": "1.5.8",
     "@types/prismjs": "1.26.0",
-    "@typescript-eslint/parser": "^5.39.0",
-    "babel-loader": "^8.2.5",
+    "@typescript-eslint/parser": "^5.49.0",
+    "babel-loader": "^9.1.2",
     "babel-plugin-unassert": "^3.2.0",
-    "concurrently": "^7.4.0",
-    "eslint": "^8.25.0",
-    "eslint-plugin-redos": "^4.4.1",
+    "concurrently": "^7.6.0",
+    "eslint": "^8.32.0",
+    "eslint-plugin-redos": "^4.4.3",
     "eslint-webpack-plugin": "^3.2.0",
-    "glob": "^8.0.3",
+    "glob": "^8.1.0",
     "karma": "^6.4.1",
     "karma-chrome-launcher": "^3.1.1",
     "karma-coverage": "^2.2.0",
     "karma-firefox-launcher": "^2.1.2",
     "karma-mocha": "^2.0.1",
     "karma-power-assert": "^1.0.0",
-    "mocha": "^10.0.0",
-    "npm-check-updates": "^16.3.10",
+    "mocha": "^10.2.0",
+    "npm-check-updates": "^16.6.3",
     "semver": "^7.3.8",
-    "spica": "0.0.656",
-    "ts-loader": "^9.4.1",
-    "typed-dom": "^0.0.312",
-    "typescript": "4.8.4",
-    "webpack": "^5.74.0",
-    "webpack-cli": "^4.10.0",
+    "spica": "0.0.719",
+    "ts-loader": "^9.4.2",
+    "typed-dom": "^0.0.315",
+    "typescript": "4.9.4",
+    "webpack": "^5.75.0",
+    "webpack-cli": "^5.0.1",
     "webpack-merge": "^5.8.0"
   },
   "scripts": {

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

@@ -1,5 +1,5 @@
 import { hasOwnProperty, ObjectCreate } from 'spica/alias';
-import { Parser, Result, Ctx, Context, eval, exec, Tree } from '../../data/parser';
+import { Parser, Result, Ctx, Tree, Context, eval, exec } from '../../data/parser';
 import { Memo } from './context/memo';
 
 export function reset<P extends Parser<unknown>>(base: Context<P>, parser: P): P;
@@ -38,10 +38,11 @@ function apply<T>(parser: Parser<T>, source: string, context: Ctx, changes: [str
         if (prop in context && !hasOwnProperty(context, prop)) break;
         context[prop as string] = ObjectCreate(change[1]);
         break;
+      // @ts-expect-error
       case 'memo':
         if (!reset) break;
         context.memo = new Memo({ targets: context.memo?.targets });
-        break;
+        // fallthrough
       default:
         values[i] = context[prop];
         context[prop] = change[1];

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

@@ -126,7 +126,7 @@ describe('Unit: parser/api/bind', () => {
     });
 
     it('normalize', () => {
-      assert.deepStrictEqual(inspect(bind(html('div'), cfgs).parse('a\\\r\nb')), ['<p>a<span class="linebreak"> </span>b</p>']);
+      assert.deepStrictEqual(inspect(bind(html('div'), cfgs).parse('a\\\r\nb')), ['<p>a<br>b</p>']);
     });
 
     it('reentrant', () => {

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

@@ -71,7 +71,7 @@ describe('Unit: parser/api/parse', () => {
         ['<p>a <br>b</p>']);
       assert.deepStrictEqual(
         [...parse('a\\\nb').children].map(el => el.outerHTML),
-        ['<p>a<span class="linebreak"> </span>b</p>']);
+        ['<p>a<br>b</p>']);
       assert.deepStrictEqual(
         [...parse('a\n\\ \nb').children].map(el => el.outerHTML),
         ['<p>a<br>\\<br>b</p>']);
@@ -209,7 +209,7 @@ describe('Unit: parser/api/parse', () => {
         [...parse('$-a\n$$\n$$\n\n(($-a[[b]][[c_d_]]))', { footnotes }).children].map(el => el.outerHTML),
         [
           '<figure data-type="math" data-label="$-a" data-group="$" data-number="1" id="label:$-a"><figcaption><span class="figindex">(1)</span><span class="figtext"></span></figcaption><div><div class="math" translate="no">$$\n$$</div></div></figure>',
-          '<p><sup class="annotation" id="annotation:ref:1" title="(1)[1][2]"><span hidden=""><a class="label" data-label="$-a" href="#label:$-a">(1)</a><sup class="reference" id="reference:ref:1" title="b"><span hidden="">b</span><a href="#reference:def:1">[1]</a></sup><sup class="reference" id="reference:ref:2" title="cd"><span hidden="">c<em>d</em></span><a href="#reference:def:2">[2]</a></sup></span><a href="#annotation:def:1">*1</a></sup></p>',
+          '<p><sup class="annotation" id="annotation:ref:1" title="(1)"><span hidden=""><a class="label" data-label="$-a" href="#label:$-a">(1)</a><sup class="reference" id="reference:ref:1" title="b"><span hidden="">b</span><a href="#reference:def:1">[1]</a></sup><sup class="reference" id="reference:ref:2" title="cd"><span hidden="">c<em>d</em></span><a href="#reference:def:2">[2]</a></sup></span><a href="#annotation:def:1">*1</a></sup></p>',
           '<ol class="annotations"><li id="annotation:def:1" data-marker="*1"><a class="label" data-label="$-a" href="#label:$-a">(1)</a><sup class="reference" id="reference:ref:1" title="b"><span hidden="">b</span><a href="#reference:def:1">[1]</a></sup><sup class="reference" id="reference:ref:2" title="cd"><span hidden="">c<em>d</em></span><a href="#reference:def:2">[2]</a></sup><sup><a href="#annotation:ref:1">^1</a></sup></li></ol>',
         ]);
       assert.deepStrictEqual(
@@ -220,7 +220,7 @@ describe('Unit: parser/api/parse', () => {
     it('normalize', () => {
       assert.deepStrictEqual(
         [...parse('a\\\r\nb').children].map(el => el.outerHTML),
-        ['<p>a<span class="linebreak"> </span>b</p>']);
+        ['<p>a<br>b</p>']);
     });
 
     it('backtrack', () => {

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

@@ -69,9 +69,9 @@ describe('Unit: parser/block/blockquote', () => {
       assert.deepStrictEqual(inspect(parser('!> \\\n')), [['<blockquote><section><p>\\</p><h2>References</h2><ol class="references"></ol></section></blockquote>'], '']);
       assert.deepStrictEqual(inspect(parser('!> a')), [['<blockquote><section><p>a</p><h2>References</h2><ol class="references"></ol></section></blockquote>'], '']);
       assert.deepStrictEqual(inspect(parser('!> a\n')), [['<blockquote><section><p>a</p><h2>References</h2><ol class="references"></ol></section></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser('!> a\\\nb')), [['<blockquote><section><p>a<span class="linebreak"> </span>b</p><h2>References</h2><ol class="references"></ol></section></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser('!> _a\nb_')), [['<blockquote><section><p><em>a<br>b</em></p><h2>References</h2><ol class="references"></ol></section></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser('!> _a\n> b_')), [['<blockquote><section><p><em>a<br>b</em></p><h2>References</h2><ol class="references"></ol></section></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('!> a\\\nb')), [['<blockquote><section><p>a<br>b</p><h2>References</h2><ol class="references"></ol></section></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('!> ++a\nb++')), [['<blockquote><section><p><ins>a<br>b</ins></p><h2>References</h2><ol class="references"></ol></section></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('!> ++a\n> b++')), [['<blockquote><section><p><ins>a<br>b</ins></p><h2>References</h2><ol class="references"></ol></section></blockquote>'], '']);
       assert.deepStrictEqual(inspect(parser('!>  a \n b  c ')), [['<blockquote><section><p> a<br> b  c</p><h2>References</h2><ol class="references"></ol></section></blockquote>'], '']);
       assert.deepStrictEqual(inspect(parser('!>> a')), [['<blockquote><blockquote><section><p>a</p><h2>References</h2><ol class="references"></ol></section></blockquote></blockquote>'], '']);
       assert.deepStrictEqual(inspect(parser('!>> a\n> b')), [['<blockquote><blockquote><section><p>a</p><h2>References</h2><ol class="references"></ol></section></blockquote><section><p>b</p><h2>References</h2><ol class="references"></ol></section></blockquote>'], '']);

package/src/parser/block/dlist.ts

@@ -3,19 +3,18 @@ import { union, inits, some, creation, state, block, line, validate, rewrite, op
 import { inline, indexee, indexer } from '../inline';
 import { anyline } from '../source';
 import { State } from '../context';
-import { localize } from '../locale';
 import { visualize, trimBlank } from '../visibility';
 import { push } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
-export const dlist: DListParser = lazy(() => block(localize(fmap(validate(
+export const dlist: DListParser = lazy(() => block(fmap(validate(
   /^~[^\S\n]+(?=\S)/,
   some(inits([
     state(State.annotation | State.reference | State.index | State.label | State.link | State.media,
     some(term)),
     some(desc),
   ]))),
-  es => [html('dl', fillTrailingDescription(es))]))));
+  es => [html('dl', fillTrailingDescription(es))])));
 
 const term: DListParser.TermParser = creation(1, false, line(indexee(fmap(open(
   /^~[^\S\n]+(?=\S)/,

package/src/parser/block/extension/example.test.ts

@@ -18,7 +18,7 @@ describe('Unit: parser/block/extension/example', () => {
       assert.deepStrictEqual(inspect(parser('~~~example/markdown\n~~~')), [['<aside class="example" data-type="markdown"><pre translate="no"></pre><hr><section><h2>References</h2><ol class="references"></ol></section></aside>'], '']);
       assert.deepStrictEqual(inspect(parser('~~~example/markdown\n\n~~~')), [['<aside class="example" data-type="markdown"><pre translate="no"></pre><hr><section><h2>References</h2><ol class="references"></ol></section></aside>'], '']);
       assert.deepStrictEqual(inspect(parser('~~~example/markdown\na\n~~~')), [['<aside class="example" data-type="markdown"><pre translate="no">a</pre><hr><section><p>a</p><h2>References</h2><ol class="references"></ol></section></aside>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~~example/markdown\n_a\nb_\n~~~')), [['<aside class="example" data-type="markdown"><pre translate="no">_a\nb_</pre><hr><section><p><em>a<br>b</em></p><h2>References</h2><ol class="references"></ol></section></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~~example/markdown\n++a\nb++\n~~~')), [['<aside class="example" data-type="markdown"><pre translate="no">++a\nb++</pre><hr><section><p><ins>a<br>b</ins></p><h2>References</h2><ol class="references"></ol></section></aside>'], '']);
       assert.deepStrictEqual(inspect(parser('~~~example/markdown\n$fig-a\n!https://host\n~~~')), [['<aside class="example" data-type="markdown"><pre translate="no">$fig-a\n!https://host</pre><hr><section><figure data-type="media" data-label="fig-a" data-group="fig" data-number="1"><figcaption><span class="figindex">Fig. 1. </span><span class="figtext"></span></figcaption><div><a href="https://host" target="_blank"><img class="media" data-src="https://host" alt=""></a></div></figure><h2>References</h2><ol class="references"></ol></section></aside>'], '']);
       assert.deepStrictEqual(inspect(parser('~~~example/markdown\n[$fig-a]\n!https://host\n~~~')), [['<aside class="example" data-type="markdown"><pre translate="no">[$fig-a]\n!https://host</pre><hr><section><figure data-type="media" data-label="fig-a" data-group="fig" data-number="1"><figcaption><span class="figindex">Fig. 1. </span><span class="figtext"></span></figcaption><div><a href="https://host" target="_blank"><img class="media" data-src="https://host" alt=""></a></div></figure><h2>References</h2><ol class="references"></ol></section></aside>'], '']);
       assert.deepStrictEqual(inspect(parser('~~~example/markdown\n## a\n~~~')), [['<aside class="example" data-type="markdown"><pre translate="no">## a</pre><hr><section><h2>a</h2><h2>References</h2><ol class="references"></ol></section></aside>'], '']);

package/src/parser/block/extension/fig.ts

@@ -27,7 +27,8 @@ export const segment: FigParser.SegmentParser = block(validate(['[$', '$'],
 
 export const fig: FigParser = block(rewrite(segment, verify(convert(
   (source, context) => {
-    const fence = (/^[^\n]*\n!?>+\s/.test(source) && source.match(/^~{3,}(?=[^\S\n]*$)/mg) || [])
+    // Bug: TypeScript
+    const fence = (/^[^\n]*\n!?>+\s/.test(source) && source.match(/^~{3,}(?=[^\S\n]*$)/mg) as string[] || [])
       .reduce((max, fence) => fence > max ? fence : max, '~~') + '~';
     return parser({ source, context })
       ? `${fence}figure ${source.replace(/^(.+\n.+\n)([\S\s]+?)\n?$/, '$1\n$2')}\n${fence}`

package/src/parser/block/extension/figure.ts

@@ -13,7 +13,6 @@ import { blockquote, segment as seg_blockquote } from '../blockquote';
 import { placeholder, segment_ as seg_placeholder } from './placeholder';
 import { inline, media, shortmedia } from '../../inline';
 import { State } from '../../context';
-import { localize } from '../../locale';
 import { visualize, trimBlank } from '../../visibility';
 import { memoize } from 'spica/memoize';
 import { html, defrag } from 'typed-dom/dom';
@@ -65,9 +64,9 @@ export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
         line(shortmedia),
       ])),
       emptyline,
-      block(localize(
+      block(
         state(State.media,
-        visualize(trimBlank(trimEnd(some(inline))))))),
+        visualize(trimBlank(trimEnd(some(inline)))))),
     ]),
   ])),
   ([label, param, content, ...caption]: [HTMLAnchorElement, string, ...HTMLElement[]]) => [

package/src/parser/block/extension/table.ts

@@ -4,7 +4,6 @@ import { Tree, eval } from '../../../combinator/data/parser';
 import { union, subsequence, inits, some, creation, block, line, validate, fence, rewrite, open, clear, convert, trim, dup, lazy, fmap } from '../../../combinator';
 import { inline } from '../../inline';
 import { str, anyline, emptyline, contentline } from '../../source';
-import { localize } from '../../locale';
 import { visualize } from '../../visibility';
 import { unshift, splice } from 'spica/array';
 import { html, define, defrag } from 'typed-dom/dom';
@@ -52,9 +51,9 @@ export const table: TableParser = block(validate('~~~', fmap(
     }
   })));
 
-const parser: TableParser = lazy(() => block(localize(fmap(
+const parser: TableParser = lazy(() => block(fmap(
   some(union([row])),
-  rows => [html('table', format(rows))]))));
+  rows => [html('table', format(rows))])));
 
 const row: RowParser = lazy(() => dup(fmap(
   subsequence([

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

@@ -75,7 +75,7 @@ describe('Unit: parser/block/heading', () => {
       assert.deepStrictEqual(inspect(parser('# a [#!http://host]')), [['<h1 id="index:!http://host">a<span class="indexer" data-index="!http://host"></span></h1>'], '']);
       assert.deepStrictEqual(inspect(parser('# a [#a((b))]')), [['<h1 id="index:a((b))">a<span class="indexer" data-index="a((b))"></span></h1>'], '']);
       assert.deepStrictEqual(inspect(parser('# a [#a[[b]]]')), [['<h1 id="index:a[[b]]">a<span class="indexer" data-index="a[[b]]"></span></h1>'], '']);
-      assert.deepStrictEqual(inspect(parser('# a [#b |#c]')), [['<h1 id="index:c">a<span class="indexer" data-index="c"></span></h1>'], '']);
+      assert.deepStrictEqual(inspect(parser('# a [#b |c]')), [['<h1 id="index:c">a<span class="indexer" data-index="c"></span></h1>'], '']);
       assert.deepStrictEqual(inspect(parser('# a [#b] [#c]')), [['<h1 id="index:c">a [#b]<span class="indexer" data-index="c"></span></h1>'], '']);
       assert.deepStrictEqual(inspect(parser('# a  [#b] \n')), [['<h1 id="index:b">a<span class="indexer" data-index="b"></span></h1>'], '']);
       assert.deepStrictEqual(inspect(parser('# a \\[#b]')), [['<h1 id="index:a_[#b]">a [#b]</h1>'], '']);

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

@@ -19,7 +19,7 @@ describe('Unit: parser/block/paragraph', () => {
       assert.deepStrictEqual(inspect(parser('a\\ ')), [['<p>a</p>'], '']);
       assert.deepStrictEqual(inspect(parser('a\\ \n')), [['<p>a</p>'], '']);
       assert.deepStrictEqual(inspect(parser('a\\\n')), [['<p>a</p>'], '']);
-      assert.deepStrictEqual(inspect(parser('a\\\nb')), [['<p>a<span class="linebreak"> </span>b</p>'], '']);
+      assert.deepStrictEqual(inspect(parser('a\\\nb')), [['<p>a<br>b</p>'], '']);
       assert.deepStrictEqual(inspect(parser('a&NewLine;b')), [['<p>a b</p>'], '']);
       assert.deepStrictEqual(inspect(parser('&Tab;&NewLine;')), [['<p>&amp;Tab;&amp;NewLine;</p>'], '']);
       assert.deepStrictEqual(inspect(parser('<wbr>')), [['<p>&lt;wbr&gt;</p>'], '']);

package/src/parser/block/paragraph.ts

@@ -1,10 +1,9 @@
 import { ParagraphParser } from '../block';
 import { union, some, block, trimEnd, fmap } from '../../combinator';
 import { inline } from '../inline';
-import { localize } from '../locale';
 import { visualize } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 
-export const paragraph: ParagraphParser = block(localize(fmap(
+export const paragraph: ParagraphParser = block(fmap(
   visualize(trimEnd(some(union([inline])))),
-  ns => [html('p', defrag(ns))])));
+  ns => [html('p', defrag(ns))]));

package/src/parser/block/reply.ts

@@ -4,7 +4,6 @@ import { cite } from './reply/cite';
 import { quote, syntax as delimiter } from './reply/quote';
 import { inline } from '../inline';
 import { anyline } from '../source';
-import { localize } from '../locale';
 import { visualize } from '../visibility';
 import { push, pop } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
@@ -16,7 +15,7 @@ import { html, defrag } from 'typed-dom/dom';
 対象と引用は1:N(分割)、N:1(統合)のみ可能、N:N(混合)は不可能
 */
 
-export const reply: ReplyParser = block(validate('>', localize(fmap(
+export const reply: ReplyParser = block(validate('>', fmap(
   inits([
     some(inits([
       cite,
@@ -30,4 +29,4 @@ export const reply: ReplyParser = block(validate('>', localize(fmap(
         ns => push(ns, [html('br')])),
     ])),
   ]),
-  ns => [html('p', defrag(pop(ns)[0]))]))));
+  ns => [html('p', defrag(pop(ns)[0]))])));

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,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'));
@@ -24,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) {
@@ -39,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':
@@ -46,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;
     }
   }