securemark 0.251.0 → 0.253.1

package/src/parser/inline.test.ts

@@ -101,11 +101,11 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('*++  a  ++*')), [['<em><ins>  a  </ins></em>'], '']);
       assert.deepStrictEqual(inspect(parser('*<small>`a`</small>*')), [['<em><small><code data-src="`a`">a</code></small></em>'], '']);
       assert.deepStrictEqual(inspect(parser('<small>*<bdi>a</bdi>*</small>')), [['<small><em><bdi>a</bdi></em></small>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>((<bdi>((a))</bdi>))</bdi>')), [['<bdi><sup class="annotation"><bdi><span class="paren">((a))</span></bdi></sup></bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>[[<bdi>[[a]]</bdi>]]</bdi>')), [['<bdi><sup class="reference"><bdi>[[a]]</bdi></sup></bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser('<bdi>((<bdi>((a))</bdi>))</bdi>')), [['<bdi><sup class="annotation"><span><bdi><span class="paren">((a))</span></bdi></span></sup></bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser('<bdi>[[<bdi>[[a]]</bdi>]]</bdi>')), [['<bdi><sup class="reference"><span><bdi>[[a]]</bdi></span></sup></bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('*[*]')), [['*', '[', '*', ']'], '']);
       assert.deepStrictEqual(inspect(parser('*<*>')), [['<em>&lt;</em>', '>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a((b))*')), [['<em>a<sup class="annotation">b</sup></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('*a((b))*')), [['<em>a<sup class="annotation"><span>b</span></sup></em>'], '']);
       assert.deepStrictEqual(inspect(parser('``a`')), [['``', 'a', '`'], '']);
       assert.deepStrictEqual(inspect(parser('[@a]')), [['[', '<a href="/@a" class="account">@a</a>', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[#1][#2]')), [['<a class="index" href="#index:1">1</a>', '<a class="index" href="#index:2">2</a>'], '']);
@@ -115,10 +115,10 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('$-1, $-2')), [['<a class="label" data-label="$-1">$-1</a>', ',', ' ', '<a class="label" data-label="$-2">$-2</a>'], '']);
       assert.deepStrictEqual(inspect(parser('$-1 and $-2')), [['<a class="label" data-label="$-1">$-1</a>', ' ', 'and', ' ', '<a class="label" data-label="$-2">$-2</a>'], '']);
       assert.deepStrictEqual(inspect(parser('$$-1')), [['$', '<a class="label" data-label="$-1">$-1</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[#a]]')), [['<sup class="reference"><a href="/hashtags/a" class="hashtag">#a</a></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[$-1]]')), [['<sup class="reference"><a class="label" data-label="$-1">$-1</a></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[#-1]]{b}')), [['<sup class="reference">#-1</sup>', '<a href="b">b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[#-1]](b)')), [['<sup class="reference">#-1</sup>', '(', 'b', ')'], '']);
+      assert.deepStrictEqual(inspect(parser('[[#a]]')), [['<sup class="reference"><span><a href="/hashtags/a" class="hashtag">#a</a></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[$-1]]')), [['<sup class="reference"><span><a class="label" data-label="$-1">$-1</a></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[#-1]]{b}')), [['<sup class="reference"><span>#-1</span></sup>', '<a href="b">b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[#-1]](b)')), [['<sup class="reference"><span>#-1</span></sup>', '(', 'b', ')'], '']);
       assert.deepStrictEqual(inspect(parser('[[#-1]a]{b}')), [['<a href="b">[#-1]a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[[#-1]a](b)')), [['[', '<a class="index" href="#index:-1">-1</a>', 'a', ']', '(', 'b', ')'], '']);
       assert.deepStrictEqual(inspect(parser('[#a]{b}')), [['<a class="index" href="#index:a">a</a>', '<a href="b">b</a>'], '']);
@@ -142,18 +142,18 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('${{{a}}}')), [['$', '<span class="template">{{{a}}}</span>'], '']);
       assert.deepStrictEqual(inspect(parser('Di$ney Micro$oft')), [['Di', '$', 'ney', ' ', 'Micro', '$', 'oft'], '']);
       assert.deepStrictEqual(inspect(parser('Di$ney, Micro$oft')), [['Di', '$', 'ney', ',', ' ', 'Micro', '$', 'oft'], '']);
-      assert.deepStrictEqual(inspect(parser('(((a))')), [['(', '<sup class="annotation">a</sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('((((a))')), [['(', '(', '<sup class="annotation">a</sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('((((a))))')), [['<sup class="annotation"><span class="paren">((a))</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('"((""))')), [['"', '<sup class="annotation">""</sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[[a]]')), [['[', '<sup class="reference">a</sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[[[a]]')), [['[', '[', '<sup class="reference">a</sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[[[a]]]]')), [['<sup class="reference">[[a]]</sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[[$-1]]]')), [['<sup class="reference"><a class="label" data-label="$-1">$-1</a></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[[]{a}]]')), [['<sup class="reference"><a href="a">a</a></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[[a]{b}]]')), [['<sup class="reference"><a href="b">a</a></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('(((a))')), [['(', '<sup class="annotation"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('((((a))')), [['(', '(', '<sup class="annotation"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('((((a))))')), [['<sup class="annotation"><span><span class="paren">((a))</span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('"((""))')), [['"', '<sup class="annotation"><span>""</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[[a]]')), [['[', '<sup class="reference"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[[[a]]')), [['[', '[', '<sup class="reference"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[[[a]]]]')), [['<sup class="reference"><span>[[a]]</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[[$-1]]]')), [['<sup class="reference"><span><a class="label" data-label="$-1">$-1</a></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[[]{a}]]')), [['<sup class="reference"><span><a href="a">a</a></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[[a]{b}]]')), [['<sup class="reference"><span><a href="b">a</a></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[(([a]{#}))]{#}')), [['<a href="#"><span class="paren">(<span class="paren">([a]{#})</span>)</span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('"[[""]]')), [['"', '<sup class="reference">""</sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('"[[""]]')), [['"', '<sup class="reference"><span>""</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('<http://host>')), [['<', '<a href="http://host" target="_blank">http://host</a>', '>'], '']);
       assert.deepStrictEqual(inspect(parser('<<small>a<</small>')), [['<', '<small>a&lt;</small>'], '']);
       assert.deepStrictEqual(inspect(parser('<sup><sub>a</sub>')), [['<', 'sup', '>', '<sub>a</sub>'], '']);
@@ -229,8 +229,8 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('a\n#b')), [['a', '<br>', '<a href="/hashtags/b" class="hashtag">#b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('a\\\n#b')), [['a', '<span class="linebreak"> </span>', '<a href="/hashtags/b" class="hashtag">#b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('*a*#b')), [['<em>a</em>', '<a href="/hashtags/b" class="hashtag">#b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('((a))#b')), [['<sup class="annotation">a</sup>', '<a href="/hashtags/b" class="hashtag">#b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[a]]#b')), [['<sup class="reference">a</sup>', '<a href="/hashtags/b" class="hashtag">#b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('((a))#b')), [['<sup class="annotation"><span>a</span></sup>', '<a href="/hashtags/b" class="hashtag">#b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[a]]#b')), [['<sup class="reference"><span>a</span></sup>', '<a href="/hashtags/b" class="hashtag">#b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a')), [['[', '<a href="/hashtags/a" class="hashtag">#a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('|#a')), [['|', '<a href="/hashtags/a" class="hashtag">#a</a>'], '']);
       assert.deepStrictEqual(inspect(parser(' #a')), [[' ', '<a href="/hashtags/a" class="hashtag">#a</a>'], '']);

package/src/parser/locale.test.ts

@@ -10,7 +10,7 @@ describe('Unit: parser/locale', () => {
       assert.deepStrictEqual(inspect(parser('。\\\n0')), [['<p>。<span class="linebreak"></span>0</p>'], '']);
       assert.deepStrictEqual(inspect(parser('。 \\\n0')), [['<p>。<span class="linebreak"></span>0</p>'], '']);
       assert.deepStrictEqual(inspect(parser('*。*\\\n0')), [['<p><em>。</em><span class="linebreak"></span>0</p>'], '']);
-      assert.deepStrictEqual(inspect(parser('!> 。\\\n0')), [['<blockquote><section><p>。<span class="linebreak"></span>0</p><ol class="annotations"></ol><ol class="references"></ol></section></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('!> 。\\\n0')), [['<blockquote><section><p>。<span class="linebreak"></span>0</p><ol class="references"></ol></section></blockquote>'], '']);
       assert.deepStrictEqual(inspect(parser('[。](a)\\\n0')), [['<p><ruby>。<rp>(</rp><rt>a</rt><rp>)</rp></ruby><span class="linebreak"></span>0</p>'], '']);
       assert.deepStrictEqual(inspect(parser('[。　](a )\\\n0')), [['<p><ruby>。<rp>(</rp><rt>a</rt><rp>)</rp></ruby><span class="linebreak"></span>0</p>'], '']);
       assert.deepStrictEqual(inspect(parser('。<wbr>\\\n0')), [['<p>。<wbr><span class="linebreak"></span>0</p>'], '']);

package/src/parser/processor/figure.test.ts

@@ -117,8 +117,8 @@ describe('Unit: parser/processor/figure', () => {
         assert.deepStrictEqual(
           [...target.children].map(el => el.outerHTML),
           [
-            '<blockquote><blockquote><section><figure data-type="quote" data-label="test-a" data-group="test" data-number="1"><figcaption><span class="figindex">Test 1. </span></figcaption><div><blockquote></blockquote></div></figure><ol class="annotations"></ol><ol class="references"></ol></section></blockquote><section><figure data-type="quote" data-label="test-a" data-group="test" data-number="1"><figcaption><span class="figindex">Test 1. </span></figcaption><div><blockquote></blockquote></div></figure><ol class="annotations"></ol><ol class="references"></ol></section></blockquote>',
-            '<aside class="example" data-type="markdown"><pre translate="no">~~~figure $test-a\n&gt; \n\n~~~\n\n$test-a</pre><hr><section><figure data-type="quote" data-label="test-a" data-group="test" data-number="1"><figcaption><span class="figindex">Test 1. </span></figcaption><div><blockquote></blockquote></div></figure><p><a class="label disabled" data-label="test-a">Test 1</a></p><ol class="annotations"></ol><ol class="references"></ol></section></aside>',
+            '<blockquote><blockquote><section><figure data-type="quote" data-label="test-a" data-group="test" data-number="1"><figcaption><span class="figindex">Test 1. </span></figcaption><div><blockquote></blockquote></div></figure><ol class="references"></ol></section></blockquote><section><figure data-type="quote" data-label="test-a" data-group="test" data-number="1"><figcaption><span class="figindex">Test 1. </span></figcaption><div><blockquote></blockquote></div></figure><ol class="references"></ol></section></blockquote>',
+            '<aside class="example" data-type="markdown"><pre translate="no">~~~figure $test-a\n&gt; \n\n~~~\n\n$test-a</pre><hr><section><figure data-type="quote" data-label="test-a" data-group="test" data-number="1"><figcaption><span class="figindex">Test 1. </span></figcaption><div><blockquote></blockquote></div></figure><p><a class="label disabled" data-label="test-a">Test 1</a></p><ol class="references"></ol></section></aside>',
             '<figure data-type="quote" data-label="test-b" data-group="test" data-number="1" id="label:test-b"><figcaption><span class="figindex">Test 1. </span></figcaption><div><blockquote></blockquote></div></figure>',
             '<figure data-type="quote" data-label="test-a" data-group="test" data-number="2" id="label:test-a"><figcaption><span class="figindex">Test 2. </span></figcaption><div><blockquote></blockquote></div></figure>',
           ]);
@@ -173,7 +173,7 @@ describe('Unit: parser/processor/figure', () => {
             '<h2 id="index:0">0</h2>',
             '<figure data-type="quote" data-label="test-1" data-group="test" data-number="1" id="label:test-1"><figcaption><span class="figindex">Test 1. </span></figcaption><div><blockquote></blockquote></div></figure>',
             '<h2 id="index:0">0</h2>',
-            '<blockquote><section><h2>0</h2><ol class="annotations"></ol><ol class="references"></ol></section></blockquote>',
+            '<blockquote><section><h2>0</h2><ol class="references"></ol></section></blockquote>',
             '<figure data-type="quote" data-label="test-b" data-group="test" data-number="2.1" id="label:test-b"><figcaption><span class="figindex">Test 2.1. </span></figcaption><div><blockquote></blockquote></div></figure>',
             '<h2 id="index:0">0</h2>',
             '<figure data-label="$-0.0.0" data-group="$" class="invalid" data-invalid-syntax="figure" data-invalid-type="argument" data-invalid-message="Base index must be $-x.0 format"></figure>',

package/src/parser/processor/figure.ts

@@ -6,14 +6,11 @@ import { push } from 'spica/array';
 
 export function* figure(
   target: ParentNode & Node,
-  footnotes?: Readonly<{ annotations: HTMLOListElement; references: HTMLOListElement; }>,
-  opts: Readonly<{
-    id?: string;
-  }> = {},
+  footnotes?: { readonly references: HTMLOListElement; },
+  opts: { readonly id?: string; } = {},
 ): Generator<HTMLAnchorElement | undefined, undefined, undefined> {
-  const refs = new MultiMap<string, HTMLAnchorElement>(push(push(push([],
+  const refs = new MultiMap<string, HTMLAnchorElement>(push(push([],
     target.querySelectorAll('a.label:not(.disabled)[data-label]')),
-    footnotes?.annotations.querySelectorAll('a.label:not(.disabled)') ?? []),
     footnotes?.references.querySelectorAll('a.label:not(.disabled)') ?? [])
     .map(el => [el.getAttribute('data-label')!, el]));
   const labels = new Set<string>();

package/src/parser/processor/footnote.test.ts

@@ -151,8 +151,8 @@ describe('Unit: parser/processor/footnote', () => {
         assert.deepStrictEqual(
           [...target.children].map(el => el.outerHTML),
           [
-            '<blockquote><blockquote><section><p><sup class="annotation disabled" title="a"><span hidden="">a</span><a>*1</a></sup></p><ol class="annotations"><li>a<sup><a>^1</a></sup></li></ol><ol class="references"></ol></section></blockquote><section><p><sup class="annotation disabled" title="a"><span hidden="">a</span><a>*1</a></sup><br>~~~</p><ol class="annotations"><li>a<sup><a>^1</a></sup></li></ol><ol class="references"></ol></section></blockquote>',
-            '<aside class="example" data-type="markdown"><pre translate="no">((a))</pre><hr><section><p><sup class="annotation disabled" title="a"><span hidden="">a</span><a>*1</a></sup></p><ol class="annotations"><li>a<sup><a>^1</a></sup></li></ol><ol class="references"></ol></section></aside>',
+            '<blockquote><blockquote><section><p><sup class="annotation disabled" title="a"><span hidden="">a</span><a>*1</a></sup></p><ol class="annotations"><li data-marker="*1">a<sup><a>^1</a></sup></li></ol><ol class="references"></ol></section></blockquote><section><p><sup class="annotation disabled" title="a"><span hidden="">a</span><a>*1</a></sup><br>~~~</p><ol class="annotations"><li data-marker="*1">a<sup><a>^1</a></sup></li></ol><ol class="references"></ol></section></blockquote>',
+            '<aside class="example" data-type="markdown"><pre translate="no">((a))</pre><hr><section><p><sup class="annotation disabled" title="a"><span hidden="">a</span><a>*1</a></sup></p><ol class="annotations"><li data-marker="*1">a<sup><a>^1</a></sup></li></ol><ol class="references"></ol></section></aside>',
             '<p><sup class="annotation" id="annotation:ref:1" title="a"><span hidden="">a</span><a href="#annotation:def:1">*1</a></sup></p>',
           ]);
         assert.deepStrictEqual(
@@ -187,6 +187,64 @@ describe('Unit: parser/processor/footnote', () => {
       }
     });
 
+    it('split', () => {
+      const target = parse('((1))\n\n## a\n\n## b\n\n((2))((3))\n\n## c\n\n((4))');
+      for (let i = 0; i < 3; ++i) {
+        [...annotation(target)];
+        assert.deepStrictEqual(
+          [...target.children].map(el => el.outerHTML),
+          [
+            html('p', [
+              html('sup', { class: "annotation", id: "annotation:ref:1", title: "1" }, [
+                html('span', { hidden: '' }, '1'),
+                html('a', { href: "#annotation:def:1" }, '*1')
+              ]),
+            ]).outerHTML,
+            html('ol', { class: 'annotations' }, [
+              html('li', { id: 'annotation:def:1', 'data-marker': '*1' }, [
+                '1',
+                html('sup', [html('a', { href: '#annotation:ref:1' }, '^1')])
+              ]),
+            ]).outerHTML,
+            html('h2', { id: 'index:a' }, 'a').outerHTML,
+            html('h2', { id: 'index:b' }, 'b').outerHTML,
+            html('p', [
+              html('sup', { class: "annotation", id: "annotation:ref:2", title: "2" }, [
+                html('span', { hidden: '' }, '2'),
+                html('a', { href: "#annotation:def:2" }, '*2')
+              ]),
+              html('sup', { class: "annotation", id: "annotation:ref:3", title: "3" }, [
+                html('span', { hidden: '' }, '3'),
+                html('a', { href: "#annotation:def:3" }, '*3')
+              ]),
+            ]).outerHTML,
+            html('ol', { class: 'annotations' }, [
+              html('li', { id: 'annotation:def:2', 'data-marker': '*2' }, [
+                '2',
+                html('sup', [html('a', { href: '#annotation:ref:2' }, '^2')])
+              ]),
+              html('li', { id: 'annotation:def:3', 'data-marker': '*3' }, [
+                '3',
+                html('sup', [html('a', { href: '#annotation:ref:3' }, '^3')])
+              ]),
+            ]).outerHTML,
+            html('h2', { id: 'index:c' }, 'c').outerHTML,
+            html('p', [
+              html('sup', { class: "annotation", id: "annotation:ref:4", title: "4" }, [
+                html('span', { hidden: '' }, '4'),
+                html('a', { href: "#annotation:def:4" }, '*4')
+              ]),
+            ]).outerHTML,
+            html('ol', { class: 'annotations' }, [
+              html('li', { id: 'annotation:def:4', 'data-marker': '*4' }, [
+                '4',
+                html('sup', [html('a', { href: '#annotation:ref:4' }, '^4')])
+              ]),
+            ]).outerHTML,
+          ]);
+      }
+    });
+
   });
 
   describe('reference', () => {

package/src/parser/processor/footnote.ts

@@ -1,55 +1,65 @@
-import { undefined, Infinity, Map, WeakMap } from 'spica/global';
+import { undefined, Infinity, Map, Node } from 'spica/global';
 import { text } from '../inline/extension/indexee';
 import { frag, html, define } from 'typed-dom/dom';
 import { MultiMap } from 'spica/multimap';
-import { memoize } from 'spica/memoize';
+import { push } from 'spica/array';
 
 export function* footnote(
   target: ParentNode & Node,
-  footnotes?: Readonly<{ annotations: HTMLOListElement; references: HTMLOListElement; }>,
-  opts: Readonly<{ id?: string; }> = {},
+  footnotes?: { readonly annotations?: HTMLOListElement; readonly references: HTMLOListElement; },
+  opts: { readonly id?: string; } = {},
+  bottom: Node | null = null,
 ): Generator<HTMLAnchorElement | HTMLLIElement | undefined, undefined, undefined> {
-  yield* reference(target, footnotes?.references, opts, footnotes?.annotations && [footnotes.annotations]);
-  yield* annotation(target, footnotes?.annotations, opts, []);
+  yield* reference(target, footnotes?.references, opts, bottom);
+  yield* annotation(target, footnotes?.annotations, opts, bottom);
   return;
 }
 
-export const annotation = build('annotation', n => `*${n}`);
+export const annotation = build('annotation', n => `*${n}`, 'h1, h2, h3, h4, h5, h6, aside.aside, hr');
 export const reference = build('reference', (n, abbr) => `[${abbr || n}]`);
 
 function build(
-  syntax: string,
+  syntax: 'annotation' | 'reference',
   marker: (index: number, abbr: string | undefined) => string,
+  splitter?: string,
 ) {
   assert(syntax.match(/^[a-z]+$/));
   // Referenceを含むAnnotationの重複排除は両構文が互いに処理済みであることを必要とするため
   // 構文ごとに各1回の処理では不可能
-  const identify = memoize<HTMLElement, string>(
-    ref => `${+!ref.querySelector('.label')}:${ref.getAttribute('data-abbr') || '_' + ref.innerHTML}`,
-    new WeakMap());
-  const contentify = memoize<HTMLElement, DocumentFragment>(
-    ref => frag(ref.cloneNode(true).childNodes),
-    new WeakMap());
   return function* (
     target: ParentNode & Node,
     footnote?: HTMLOListElement,
-    opts: Readonly<{ id?: string }> = {},
-    footnotes: readonly HTMLOListElement[] = [],
+    opts: { readonly id?: string } = {},
+    bottom: Node | null = null,
   ): Generator<HTMLAnchorElement | HTMLLIElement | undefined, undefined, undefined> {
     const defs = new Map<string, HTMLLIElement>();
     const buffer = new MultiMap<string, HTMLElement>();
     const titles = new Map<string, string>();
-    const check = footnotes.some(el => target.contains(el));
+    // Bug: Firefox
+    //const splitters = push([], target.querySelectorAll(`:scope > :is(${splitter ?? '_'})`));
+    const splitters = push([], target.querySelectorAll(splitter ?? '_'))
+      .filter(el => el.parentNode === target);
+    // Bug: Firefox
+    //target.querySelectorAll(`:scope > .${syntax}s`).forEach(el => el.remove());
+    target.querySelectorAll(`.${syntax}s`).forEach(el => el.parentNode === target && el.remove());
+    let offset = 0;
     let style: 'count' | 'abbr';
     for (
       let refs = target.querySelectorAll(`sup.${syntax}:not(.disabled)`),
           i = 0, len = refs.length; i < len; ++i) {
       yield;
       const ref = refs[i];
-      if (check && footnotes.some(el => el.contains(ref))) continue;
-      const identifier = identify(ref);
+      while (+splitters[0]?.compareDocumentPosition(ref) & Node.DOCUMENT_POSITION_FOLLOWING) {
+        if (defs.size > 0) {
+          offset += defs.size;
+          yield* proc(defs, target.insertBefore(html('ol', { class: `${syntax}s` }), splitters[0] ?? null));
+        }
+        splitters.shift();
+      }
+      if (syntax === 'annotation' && ref.closest('#annotations, .annotations, #references, .references')) continue;
+      const identifier = `${+!ref.querySelector('.label')}:${ref.getAttribute('data-abbr') || '_' + ref.firstElementChild!.innerHTML}`;
       const abbr = ref.getAttribute('data-abbr') || undefined;
-      const content = contentify(ref);
+      const content = frag(ref.firstElementChild!.cloneNode(true).childNodes);
       style ??= abbr ? 'abbr' : 'count';
       if (style === 'count' ? abbr : !abbr) {
         define(ref, {
@@ -59,8 +69,16 @@ function build(
           'data-invalid-message': `${syntax[0].toUpperCase() + syntax.slice(1)} style must be consistent`,
         });
       }
-      if (ref.firstElementChild?.getAttribute('hidden') !== '') {
-        ref.replaceChildren(html('span', { hidden: '' }, ref.childNodes));
+      else if (ref.getAttribute('data-invalid-type') === 'style') {
+        define(ref, {
+          class: void ref.classList.remove('invalid'),
+          'data-invalid-syntax': null,
+          'data-invalid-type': null,
+          'data-invalid-message': null,
+        });
+      }
+      if (!ref.firstElementChild!.hasAttribute('hidden')) {
+        ref.firstElementChild!.setAttribute('hidden', '');
       }
       else {
         ref.lastChild?.remove();
@@ -71,9 +89,11 @@ function build(
         || text(content).trim()
         || content.textContent!.trim()
         || undefined;
+      assert(syntax !== 'annotation' || title);
       title
         ? !titles.has(identifier) && titles.set(identifier, title)
         : buffer.set(identifier, ref);
+      assert(syntax !== 'annotation' || !buffer.has(identifier));
       const blank = !!abbr && !content.firstChild;
       const refIndex = i + 1;
       const refId = opts.id !== ''
@@ -82,7 +102,10 @@ function build(
       const def = undefined
         || defs.get(identifier)
         || defs.set(identifier, html('li',
-            { id: opts.id !== '' ? `${syntax}:${opts.id ? `${opts.id}:` : ''}def:${defs.size + 1}` : undefined },
+            {
+              id: opts.id !== '' ? `${syntax}:${opts.id ? `${opts.id}:` : ''}def:${defs.size + offset + 1}` : undefined,
+              'data-marker': !footnote ? marker(defs.size + offset + 1, abbr) : undefined,
+            },
             [content.cloneNode(true), html('sup')]))
             .get(identifier)!;
       assert(def.lastChild);
@@ -100,7 +123,7 @@ function build(
           });
         }
       }
-      const defIndex = +def.id.slice(def.id.lastIndexOf(':') + 1) || defs.size;
+      const defIndex = +def.id.slice(def.id.lastIndexOf(':') + 1) || defs.size + offset;
       const defId = def.id || undefined;
       define(ref, {
         id: refId,
@@ -125,13 +148,20 @@ function build(
           },
           `^${refIndex}`));
     }
-    if (!footnote) return;
+    if (defs.size > 0 || footnote) {
+      yield* proc(defs, footnote ?? target.insertBefore(html('ol', { class: `${syntax}s` }), splitters[0] ?? bottom));
+    }
+    return;
+  }
+
+  function* proc(defs: Map<string, HTMLLIElement>, footnote: HTMLOListElement): Generator<HTMLLIElement | undefined, undefined, undefined> {
     const { children } = footnote;
     const size = defs.size;
     let count = 0;
     let length = children.length;
     I:
-    for (const def of defs.values()) {
+    for (const [key, def] of defs) {
+      defs.delete(key);
       ++count;
       while (length > size) {
         const node = children[count - 1] as HTMLLIElement;

package/src/parser/source/str.ts

@@ -30,13 +30,13 @@ export function stropt(pattern: string | RegExp): Parser<string, Context<StrPars
         if (source === '') return;
         return source.slice(0, pattern.length) === pattern
           ? [[pattern], source.slice(pattern.length)]
-          : [[], source];
+          : undefined;
       })
     : creator(source => {
         if (source === '') return;
         const m = source.match(pattern);
         return m
           ? [[m[0]], source.slice(m[0].length)]
-          : [[], source];
+          : undefined;
       });
 }

package/src/parser/util.ts

@@ -8,8 +8,8 @@ import { invisibleHTMLEntityNames } from './api/normalize';
 import { reduce } from 'spica/memoize';
 import { push } from 'spica/array';
 
-export const regBlankStart = new RegExp(String.raw
-  `^(?:\\?[^\S\n]|&(?:${invisibleHTMLEntityNames.join('|')});|<wbr>)+`);
+export const regBlankStart = new RegExp(
+  /^(?:\\?[^\S\n]|&IHN;|<wbr>)+/.source.replace('IHN', `(?:${invisibleHTMLEntityNames.join('|')})`));
 
 export function blankWith(delimiter: string | RegExp): RegExp;
 export function blankWith(starting: '' | '\n', delimiter: string | RegExp): RegExp;
@@ -25,8 +25,8 @@ export function blankWith(starting: '' | '\n', delimiter?: string | RegExp): Reg
 
 export function visualize<P extends Parser<HTMLElement | string>>(parser: P): P;
 export function visualize<T extends HTMLElement | string>(parser: Parser<T>): Parser<T> {
-  const blankline = new RegExp(String.raw
-    `^(?:\\$|\\?[^\S\n]|&(?:${invisibleHTMLEntityNames.join('|')});|<wbr>)+$`,
+  const blankline = new RegExp(
+    /^(?:\\$|\\?[^\S\n]|&IHN;|<wbr>)+$/.source.replace('IHN', `(?:${invisibleHTMLEntityNames.join('|')})`),
     'gm');
   return union([
     convert(
@@ -139,16 +139,20 @@ function isVisible(node: HTMLElement | string, strpos?: number): boolean {
 
 export function trimBlank<P extends Parser<HTMLElement | string>>(parser: P): P;
 export function trimBlank<T extends HTMLElement | string>(parser: Parser<T>): Parser<T> {
-  return fmap(
-    trimBlankStart(parser),
-    trimNodeEnd);
+  return trimBlankStart(trimBlankEnd(parser));
 }
-function trimBlankStart<P extends Parser<unknown>>(parser: P): P;
-function trimBlankStart<T>(parser: Parser<T>): Parser<T> {
+export function trimBlankStart<P extends Parser<unknown>>(parser: P): P;
+export function trimBlankStart<T>(parser: Parser<T>): Parser<T> {
   return convert(
     reduce(source => source.replace(regBlankStart, '')),
     parser);
 }
+export function trimBlankEnd<P extends Parser<HTMLElement | string>>(parser: P): P;
+export function trimBlankEnd<T extends HTMLElement | string>(parser: Parser<T>): Parser<T> {
+  return fmap(
+    parser,
+    trimNodeEnd);
+}
 //export function trimNode(nodes: (HTMLElement | string)[]): (HTMLElement | string)[] {
 //  return trimNodeStart(trimNodeEnd(nodes));
 //}
@@ -166,7 +170,7 @@ function trimBlankStart<T>(parser: Parser<T>): Parser<T> {
 //  }
 //  return nodes;
 //}
-export function trimNodeEnd<T extends HTMLElement | string>(nodes: T[]): T[] {
+function trimNodeEnd<T extends HTMLElement | string>(nodes: T[]): T[] {
   const skip = nodes.length > 0 &&
     typeof nodes[nodes.length - 1] === 'object' &&
     nodes[nodes.length - 1]['className'] === 'indexer'

package/src/renderer/render/code.ts

@@ -1,7 +1,7 @@
 import Prism from 'prismjs';
-import { Collection } from 'spica/collection';
+import { Dict } from 'spica/dict';
 
-export function code(target: HTMLElement, cache?: Collection<string, HTMLElement>): void {
+export function code(target: HTMLElement, cache?: Dict<string, HTMLElement>): void {
   assert(target.children.length === 0);
   const source = target.textContent!;
   Prism.highlightElement(target, false, () =>

package/src/renderer/render/math.ts

@@ -1,8 +1,8 @@
 import { undefined } from 'spica/global';
-import { Collection } from 'spica/collection';
+import { Dict } from 'spica/dict';
 import { html, define } from 'typed-dom/dom';
 
-export function math(target: HTMLElement, cache?: Collection<string, HTMLElement>): void {
+export function math(target: HTMLElement, cache?: Dict<string, HTMLElement>): void {
   assert(target.children.length === 0);
   const source = target.textContent!;
   queue(target, () => {

package/src/renderer/render/media/image.ts

@@ -1,8 +1,8 @@
 import { Object } from 'spica/global';
-import { Collection } from 'spica/collection';
+import { Dict } from 'spica/dict';
 import { define } from 'typed-dom/dom';
 
-export function image(source: HTMLImageElement, url: URL, cache?: Collection<string, HTMLElement>): HTMLImageElement {
+export function image(source: HTMLImageElement, url: URL, cache?: Dict<string, HTMLElement>): HTMLImageElement {
   if (cache?.has(url.href)) return define(
     cache.get(url.href)!.cloneNode(true) as HTMLImageElement,
     Object.fromEntries([...source.attributes]

package/src/renderer/render/media.ts

@@ -5,7 +5,7 @@ import { pdf } from './media/pdf';
 import { video } from './media/video';
 import { audio } from './media/audio';
 import { image } from './media/image';
-import { Collection } from 'spica/collection';
+import { Dict } from 'spica/dict';
 import { ReadonlyURL } from 'spica/url';
 import { reduce } from 'spica/memoize';
 
@@ -14,7 +14,7 @@ type MediaOptions = NonNullable<RenderingOptions['media']>;
 const extend = reduce((opts: MediaOptions): MediaOptions =>
   ({ twitter, youtube, pdf, video, audio, image, ...opts }));
 
-export function media(base: string, source: HTMLImageElement, opts: MediaOptions, cache?: Collection<string, HTMLElement>): HTMLElement | undefined {
+export function media(base: string, source: HTMLImageElement, opts: MediaOptions, cache?: Dict<string, HTMLElement>): HTMLElement | undefined {
   assert(source.matches('img:not([src])[data-src]'));
   opts = extend(opts);
   const url = new ReadonlyURL(source.getAttribute('data-src')!, base);

package/src/util/info.ts

@@ -1,13 +1,13 @@
 import { Info } from '../..';
 import { scope } from './scope';
-import { querySelectorAll } from 'typed-dom/query';
+import { push } from 'spica/array';
 
 export function info(source: DocumentFragment | HTMLElement | ShadowRoot): Info {
   const match = scope(source, '.invalid');
   return {
-    url: find<HTMLAnchorElement>('a:not(.email):not(.account):not(.channel):not(.hashtag):not(.hashnum):not(.anchor)')
+    url: find<HTMLAnchorElement>('a:not(:is(.email, .account, .channel, .hashtag, .hashnum, .anchor))')
       .filter(el => ['http:', 'https:'].includes(el.protocol)),
-    tel: find<HTMLAnchorElement>('a:not(.email):not(.account):not(.channel):not(.hashtag):not(.hashnum):not(.anchor)')
+    tel: find<HTMLAnchorElement>('a:not(:is(.email, .account, .channel, .hashtag, .hashnum, .anchor))')
       .filter(el => ['tel:'].includes(el.protocol)),
     email: find('a.email'),
     account: find('a.account'),
@@ -20,7 +20,7 @@ export function info(source: DocumentFragment | HTMLElement | ShadowRoot): Info
   };
 
   function find<T extends HTMLElement>(selector: string): T[] {
-    return querySelectorAll<T>(source, selector)
+    return push([], source.querySelectorAll<T>(selector))
       .filter(match);
   }
 }

package/src/util/toc.ts

@@ -1,26 +1,22 @@
-import { undefined, Array } from 'spica/global';
+import { undefined } from 'spica/global';
 import { html } from 'typed-dom/dom';
 import { push } from 'spica/array';
 
 // Bug: Firefox
 //const selector = 'h1 h2 h3 h4 h5 h6 aside.aside'.split(' ').map(s => `:scope > ${s}[id]`).join();
-const selector = 'h1 h2 h3 h4 h5 h6 aside.aside'.split(' ').map(s => `${s}[id]`).join();
+const selector = ':is(h1, h2, h3, h4, h5, h6, aside.aside)[id]';
 
 export function toc(source: DocumentFragment | HTMLElement | ShadowRoot): HTMLUListElement {
-  const es = source.querySelectorAll(selector);
-  const hs: HTMLHeadingElement[] = Array(es.length);
-  for (let i = 0; i < hs.length; ++i) {
-    const el = es[i];
-    assert(el.parentNode === source);
-    switch (el.tagName) {
-      case 'ASIDE':
-        hs[i] = html(el.firstElementChild!.tagName.toLowerCase() as 'h1', { id: el.id, class: 'aside' }, el.firstElementChild!.cloneNode(true).childNodes);
-        continue;
-      default:
-        hs[i] = el as HTMLHeadingElement;
-        continue;
-    }
-  }
+  const hs = push([], source.querySelectorAll(selector))
+    .map(el => {
+      assert(el.parentNode === source);
+      switch (el.tagName) {
+        case 'ASIDE':
+          return html(el.firstElementChild!.tagName.toLowerCase() as 'h1', { id: el.id, class: 'aside' }, el.firstElementChild!.cloneNode(true).childNodes);
+        default:
+          return el as HTMLHeadingElement;
+      }
+    });
   return parse(cons(hs));
 }
 

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

@@ -1,37 +0,0 @@
-import { indentblock } from './indentblock';
-import { some } from '../../combinator';
-import { inspect } from '../../debug.test';
-
-describe('Unit: parser/block/indentblock', () => {
-  describe('indentblock', () => {
-    const parser = (source: string) => some(indentblock)(source, {});
-
-    it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser('')), undefined);
-      assert.deepStrictEqual(inspect(parser('\na')), undefined);
-      assert.deepStrictEqual(inspect(parser('a')), undefined);
-      assert.deepStrictEqual(inspect(parser('  a')), undefined);
-      assert.deepStrictEqual(inspect(parser('   a')), undefined);
-      assert.deepStrictEqual(inspect(parser('   \ta')), undefined);
-      assert.deepStrictEqual(inspect(parser('    a\nb')), undefined);
-      assert.deepStrictEqual(inspect(parser('    a\n b')), undefined);
-      assert.deepStrictEqual(inspect(parser('    a\n\tb')), undefined);
-    });
-
-    it('valid', () => {
-      assert.deepStrictEqual(inspect(parser('    a')), [['<pre class="text">a</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('    a ')), [['<pre class="text">a </pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('    a \n')), [['<pre class="text">a </pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('    a \n       b')), [['<pre class="text">a <br>   b</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('    a \\\n       b')), [['<pre class="text">a \\<br>   b</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('       a')), [['<pre class="text">   a</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('        a')), [['<pre class="text">a</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('    \ta')), [['<pre class="text">\ta</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('\ta')), [['<pre class="text">a</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('\t\ta')), [['<pre class="text">a</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('\t    a')), [['<pre class="text">    a</pre>'], '']);
-    });
-
-  });
-
-});