securemark 0.250.0 → 0.253.0

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,14 @@ import { push } from 'spica/array';
 
 export function* figure(
   target: ParentNode & Node,
-  footnotes?: Readonly<{ annotations: HTMLOListElement; references: HTMLOListElement; }>,
+  footnotes?: Readonly<{ annotations?: HTMLOListElement; references: HTMLOListElement; }>,
   opts: Readonly<{
     id?: string;
   }> = {},
 ): Generator<HTMLAnchorElement | undefined, undefined, undefined> {
   const refs = new MultiMap<string, HTMLAnchorElement>(push(push(push([],
     target.querySelectorAll('a.label:not(.disabled)[data-label]')),
-    footnotes?.annotations.querySelectorAll('a.label:not(.disabled)') ?? []),
+    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,64 @@
-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; }>,
+  footnotes?: Readonly<{ annotations?: HTMLOListElement; references: HTMLOListElement; }>,
   opts: Readonly<{ id?: string; }> = {},
 ): 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);
+  yield* annotation(target, footnotes?.annotations, opts);
   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[] = [],
   ): Generator<HTMLAnchorElement | HTMLLIElement | undefined, undefined, undefined> {
+    //assert(syntax !== 'annotation' || !footnote);
     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 +68,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 +88,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 +101,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 +122,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 +147,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] ?? target.querySelector(':scope > :is(#annotations, #references)')));
+    }
+    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/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,30 +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(' \ta')), undefined);
-      assert.deepStrictEqual(inspect(parser('  a\nb')), undefined);
-      assert.deepStrictEqual(inspect(parser('  a\n b')), 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('\ta')), [['<pre class="text">a</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('\t a')), [['<pre class="text"> a</pre>'], '']);
-    });
-
-  });
-
-});

package/src/parser/block/indentblock.ts

@@ -1,13 +0,0 @@
-import { IndentBlockParser } from '../block';
-import { union, block, validate, indent, convert } from '../../combinator';
-import { codeblock } from './codeblock';
-
-// 空行を含むインデントブロックはインデントの違いによるセグメント分割の境界が視認不能となるため採用しない
-
-export const indentblock: IndentBlockParser = block(validate(/^(?:  |\t)/, indent(convert(
-  source => {
-    const fence = (source.match(/^`{3,}(?=[^\S\n]*$)/mg) ?? [])
-      .reduce((max, fence) => fence > max ? fence : max, '``') + '`';
-    return `${fence}\n${source}\n${fence}`;
-  },
-  union([codeblock])), true)));