securemark 0.300.4 → 0.300.6

package/src/processor/figure.test.ts

@@ -1,17 +1,19 @@
 import { figure } from './figure';
-import { ParserOptions } from '../..';
 import { run, parse as parse_ } from '../api';
+import { Opts } from '../api/parse';
+import { List, Node } from '../combinator/parser';
 import { html } from 'typed-dom/dom';
 import { normalize } from '../debug.test';
 
-const parse = (s: string, o?: ParserOptions) => parse_(s, { test: true, ...o });
+const parse = (s: string, o?: Opts) => parse_(s, { test: true, ...o });
 
 describe('Unit: processor/figure', () => {
   describe('figure', () => {
     it('empty', () => {
-      const target = run(parse(''));
+      const labels = new List<Node<HTMLAnchorElement>>();
+      const target = run(parse('', { labels }));
       for (let i = 0; i < 3; ++i) {
-        [...figure(target)];
+        [...figure(target, labels)];
         assert.deepStrictEqual(
           [...target.children].map(el => normalize(el.outerHTML)),
           []);
@@ -19,14 +21,15 @@ describe('Unit: processor/figure', () => {
     });
 
     it('one', () => {
+      const labels = new List<Node<HTMLAnchorElement>>();
       const target = run(parse([
         '$test-a\n> ',
         '$test-a',
         '$test-b',
         '$test-a',
-      ].join('\n\n')));
+      ].join('\n\n'), { labels }));
       for (let i = 0; i < 3; ++i) {
-        [...figure(target)];
+        [...figure(target, labels)];
         assert.deepStrictEqual(
           [...target.children].map(el => normalize(el.outerHTML)),
           [
@@ -39,6 +42,7 @@ describe('Unit: processor/figure', () => {
     });
 
     it('some', () => {
+      const labels = new List<Node<HTMLAnchorElement>>();
       const target = run(parse([
         '$test-a\n> ',
         '## 0',
@@ -46,9 +50,9 @@ describe('Unit: processor/figure', () => {
         '$quote-a\n> ',
         '$test-b\n> ',
         '$test-c\n> ',
-      ].join('\n\n')));
+      ].join('\n\n'), { labels }));
       for (let i = 0; i < 3; ++i) {
-        [...figure(target)];
+        [...figure(target, labels)];
         assert.deepStrictEqual(
           [...target.children].map(el => normalize(el.outerHTML)),
           [
@@ -63,12 +67,13 @@ describe('Unit: processor/figure', () => {
     });
 
     it('number', () => {
+      const labels = new List<Node<HTMLAnchorElement>>();
       const target = run(parse([
         '$-a\n$$\n$$',
         '$-a',
-      ].join('\n\n')));
+      ].join('\n\n'), { labels }));
       for (let i = 0; i < 3; ++i) {
-        [...figure(target)];
+        [...figure(target, labels)];
         assert.deepStrictEqual(
           [...target.children].map(el => normalize(el.outerHTML)),
           [
@@ -79,6 +84,7 @@ describe('Unit: processor/figure', () => {
     });
 
     it('fixed', () => {
+      const labels = new List<Node<HTMLAnchorElement>>();
       const target = run(parse([
         '$test-2\n> ',
         '$test-3.1\n> ',
@@ -88,9 +94,9 @@ describe('Unit: processor/figure', () => {
         '$test-2',
         '$-4.1.1',
         '$test-1',
-      ].join('\n\n')));
+      ].join('\n\n'), { labels }));
       for (let i = 0; i < 3; ++i) {
-        [...figure(target)];
+        [...figure(target, labels)];
         assert.deepStrictEqual(
           [...target.children].map(el => normalize(el.outerHTML)),
           [
@@ -107,19 +113,20 @@ describe('Unit: processor/figure', () => {
     });
 
     it('separation', () => {
+      const labels = new List<Node<HTMLAnchorElement>>();
       const target = html('blockquote', run(parse([
         '!>> ~~~figure $test-a\n>> > \n>>\n~~~\n> ~~~figure $test-a\n> > \n>\n~~~',
         '~~~~example/markdown\n~~~figure $test-a\n> \n\n~~~\n\n$test-a\n~~~~',
         '~~~figure $test-b\n> \n\n~~~',
         '~~~figure $test-a\n> \n\n~~~',
-      ].join('\n\n'))).children);
+      ].join('\n\n'), { labels })).children);
       for (let i = 0; i < 3; ++i) {
-        [...figure(target)];
+        [...figure(target, labels)];
         assert.deepStrictEqual(
           [...target.children].map(el => normalize(el.outerHTML)),
           [
             '<blockquote><blockquote><section><figure data-type="quote" data-label="test-a" data-group="test" data-number="1" id="label:random:test-a"><figcaption><span class="figindex">Test 1. </span><span class="figtext"></span></figcaption><div><blockquote></blockquote></div></figure><h2>References</h2><ol class="references"></ol></section></blockquote><section><figure data-type="quote" data-label="test-a" data-group="test" data-number="1" id="label:random:test-a"><figcaption><span class="figindex">Test 1. </span><span class="figtext"></span></figcaption><div><blockquote></blockquote></div></figure><h2>References</h2><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" id="label:random:test-a"><figcaption><span class="figindex">Test 1. </span><span class="figtext"></span></figcaption><div><blockquote></blockquote></div></figure><p><a class="label local" data-label="test-a" href="#label:random:test-a">Test 1</a></p><h2>References</h2><ol class="references"></ol></section></aside>',
+            '<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" id="label:random:test-a"><figcaption><span class="figindex">Test 1. </span><span class="figtext"></span></figcaption><div><blockquote></blockquote></div></figure><p><a class="label" data-label="test-a" href="#label:random:test-a">Test 1</a></p><h2>References</h2><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><span class="figtext"></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><span class="figtext"></span></figcaption><div><blockquote></blockquote></div></figure>',
           ]);
@@ -127,6 +134,7 @@ describe('Unit: processor/figure', () => {
     });
 
     it('base', () => {
+      const labels = new List<Node<HTMLAnchorElement>>();
       const target = run(parse([
         '# 0',
         '$-0.0',
@@ -163,9 +171,9 @@ describe('Unit: processor/figure', () => {
         '$test-i\n> ',
         '# 0',
         '$test-j\n> ',
-      ].join('\n\n')));
+      ].join('\n\n'), { labels }));
       for (let i = 0; i < 3; ++i) {
-        [...figure(target)];
+        [...figure(target, labels)];
         assert.deepStrictEqual(
           [...target.children].map(el => normalize(el.outerHTML)),
           [
@@ -174,7 +182,7 @@ describe('Unit: 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><span class="figtext"></span></figcaption><div><blockquote></blockquote></div></figure>',
             '<h2 id="index::0">0</h2>',
-            '<blockquote><section><h2 id="index:random:0" class="local">0</h2><h2>References</h2><ol class="references"></ol></section></blockquote>',
+            '<blockquote><section><h2 id="index:random:0">0</h2><h2>References</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><span class="figtext"></span></figcaption><div><blockquote></blockquote></div></figure>',
             '<h2 id="index::0">0</h2>',
             '<figure data-label="$-0.0.0" data-group="$" class="invalid"></figure>',
@@ -209,6 +217,7 @@ describe('Unit: processor/figure', () => {
     });
 
     it('concat', () => {
+      const labels = new List<Node<HTMLAnchorElement>>();
       const target = run(parse([
         '$-0.0',
         '## 0',
@@ -229,9 +238,9 @@ describe('Unit: processor/figure', () => {
         '## 0',
         '$-9.0',
         '$test-e\n> ',
-      ].join('\n\n')));
+      ].join('\n\n'), { labels }));
       for (let i = 0; i < 3; ++i) {
-        [...figure(target)];
+        [...figure(target, labels)];
         assert.deepStrictEqual(
           [...target.children].map(el => normalize(el.outerHTML)),
           [
@@ -259,13 +268,14 @@ describe('Unit: processor/figure', () => {
     });
 
     it('verbose', () => {
+      const labels = new List<Node<HTMLAnchorElement>>();
       const target = run(parse([
         '~~~figure [$test-a]\n> \n\n~~~',
         '[$test-a]',
         '[$test-a]',
-      ].join('\n\n')));
+      ].join('\n\n'), { labels }));
       for (let i = 0; i < 3; ++i) {
-        [...figure(target)];
+        [...figure(target, labels)];
         assert.deepStrictEqual(
           [...target.children].map(el => normalize(el.outerHTML)),
           [
@@ -277,13 +287,14 @@ describe('Unit: processor/figure', () => {
     });
 
     it('id', () => {
+      const labels = new List<Node<HTMLAnchorElement>>();
       const target = run(parse([
         '$test-a\n> ',
         '==$test-a==',
         '- $test-a',
-      ].join('\n\n'), { id: '0' }));
+      ].join('\n\n'), { id: '0', labels }));
       for (let i = 0; i < 3; ++i) {
-        [...figure(target, undefined, { id: '0' })];
+        [...figure(target, labels, undefined, { id: '0' })];
         assert.deepStrictEqual(
           [...target.children].map(el => normalize(el.outerHTML)),
           [

package/src/processor/figure.ts

@@ -1,38 +1,26 @@
+import { List, Node } from '../combinator/parser';
 import { number as calculate, isFixed } from '../parser/inline/extension/label';
-import { markInvalid, unmarkInvalid } from '../parser/util';
+import { markInvalid, unmarkInvalid, collect } from '../parser/util';
 import { MultiQueue } from 'spica/queue';
-import { push } from 'spica/array';
 import { define } from 'typed-dom/dom';
 
 export function* figure(
-  target: ParentNode & Node,
+  target: ParentNode & global.Node,
+  list: List<Node<HTMLAnchorElement>>,
   notes?: { readonly references: HTMLOListElement; },
   opts: {
     readonly id?: string;
-    readonly local?: boolean;
   } = {},
 ): Generator<undefined, undefined, undefined> {
-  const selector = ':is(figure[data-label], h1, h2)';
   const refs = new MultiQueue<string, HTMLAnchorElement>(
-    !notes || notes.references.parentNode === target
-      ? Array.from(
-          target.querySelectorAll('a.label:not(.local)[data-label]'),
-          el => [el.getAttribute('data-label')!, el])
-      : push(
-          Array.from(
-            target.querySelectorAll('a.label:not(.local)[data-label]'),
-            el => [el.getAttribute('data-label')!, el] as const),
-          Array.from(
-            notes.references.querySelectorAll('a.label:not(.local)'),
-            el => [el.getAttribute('data-label')!, el] as const)));
+    list.foldl<[string, HTMLAnchorElement][]>((acc, { value: el }) =>
+      (acc.push([el.getAttribute('data-label')!, el] as const), acc), []));
   const labels = new Set<string>();
   const numbers = new Map<string, string>();
   let base = '0';
   let bases: readonly string[] = base.split('.');
   for (
-    let defs = target instanceof Element
-          ? target.querySelectorAll(`:scope > ${selector}`)
-          : target.querySelectorAll(`:not(* > *)${selector}`),
+    let defs = collect(target,  'figure[data-label], h1, h2'),
         len = defs.length, i = 0; i < len; ++i) {
     if (~i << 32 - 8 === 0) yield;
     const def = defs[i];
@@ -128,10 +116,7 @@ export function* figure(
       }
       if (ref.hash.slice(1) === def.id && ref.innerText === figindex) continue;
       define(ref,
-        {
-          class: opts.local ? `${ref.className} local` : undefined,
-          href: opts.id !== '' ? `#${def.id}` : undefined,
-        },
+        { href: opts.id !== '' ? `#${def.id}` : undefined, },
         figindex);
     }
   }

package/src/processor/note.test.ts

@@ -1,24 +1,34 @@
 import { note } from './note';
 import { run, parse as parse_ } from '../api';
+import { Opts } from '../api/parse';
+import { List, Node } from '../combinator/parser';
 import { html } from 'typed-dom/dom';
 import { normalize } from '../debug.test';
 
-const parse = (s: string) => parse_(s, { test: true });
+const parse = (s: string, o?: Opts) => parse_(s, { test: true, ...o });
 
 describe('Unit: processor/note', () => {
   describe('annotation', () => {
     it('empty', () => {
-      const target = run(parse(''));
-      [...note(target)];
+      const lists = {
+        annotations: new List<Node<HTMLElement>>(),
+        references: new List<Node<HTMLElement>>(),
+      };
+      const target = run(parse('', lists));
+      [...note(target, lists)];
       assert.deepStrictEqual(
         [...target.children].map(el => normalize(el.outerHTML)),
         []);
     });
 
     it('1', () => {
-      const target = run(parse('((a b))'));
+      const lists = {
+        annotations: new List<Node<HTMLElement>>(),
+        references: new List<Node<HTMLElement>>(),
+      };
+      const target = run(parse('((a b))', lists));
       for (let i = 0; i < 3; ++i) {
-        assert.deepStrictEqual([...note(target)].length, 1);
+        assert.deepStrictEqual([...note(target, lists)].length, 1);
         assert.deepStrictEqual(
           [...target.children].map(el => normalize(el.outerHTML)),
           [
@@ -38,9 +48,13 @@ describe('Unit: processor/note', () => {
     });
 
     it('2', () => {
-      const target = run(parse('((1))((12345678901234567890))'));
+      const lists = {
+        annotations: new List<Node<HTMLElement>>(),
+        references: new List<Node<HTMLElement>>(),
+      };
+      const target = run(parse('((1))((12345678901234567890))', lists));
       for (let i = 0; i < 3; ++i) {
-        assert.deepStrictEqual([...note(target)].length, 1);
+        assert.deepStrictEqual([...note(target, lists)].length, 1);
         assert.deepStrictEqual(
           [...target.children].map(el => normalize(el.outerHTML)),
           [
@@ -67,9 +81,13 @@ describe('Unit: processor/note', () => {
     });
 
     it('unify', () => {
-      const target = run(parse('((1))((2))((3))((2))((4))'));
+      const lists = {
+        annotations: new List<Node<HTMLElement>>(),
+        references: new List<Node<HTMLElement>>(),
+      };
+      const target = run(parse('((1))((2))((3))((2))((4))', lists));
       for (let i = 0; i < 3; ++i) {
-        [...note(target)];
+        [...note(target, lists)];
         assert.deepStrictEqual(
           [...target.children].map(el => normalize(el.outerHTML)),
           [
@@ -116,18 +134,22 @@ describe('Unit: processor/note', () => {
     });
 
     it('separation', () => {
+      const lists = {
+        annotations: new List<Node<HTMLElement>>(),
+        references: new List<Node<HTMLElement>>(),
+      };
       const target = run(parse([
         '!>> ((1))\n> ((2))\n~~~',
         '~~~~example/markdown\n((3))\n~~~~',
         '((4))',
-      ].join('\n\n')));
+      ].join('\n\n'), lists));
       for (let i = 0; i < 3; ++i) {
-        [...note(target)];
+        [...note(target, lists)];
         assert.deepStrictEqual(
           [...target.children].map(el => normalize(el.outerHTML)),
           [
-            '<blockquote><blockquote><section><p><sup class="annotation local" id="annotation:random:ref:1:1" title="1"><a href="#annotation:random:def:1:1">*1</a></sup></p><ol class="annotations"><li id="annotation:random:def:1:1" data-marker="*1"><span>1</span><sup><a href="#annotation:random:ref:1:1">^1</a></sup></li></ol><h2>References</h2><ol class="references"></ol></section></blockquote><section><p><sup class="annotation local" id="annotation:random:ref:2:1" title="2"><a href="#annotation:random:def:2:1">*1</a></sup><br>~~~</p><ol class="annotations"><li id="annotation:random:def:2:1" data-marker="*1"><span>2</span><sup><a href="#annotation:random:ref:2:1">^1</a></sup></li></ol><h2>References</h2><ol class="references"></ol></section></blockquote>',
-            '<aside class="example" data-type="markdown"><pre translate="no">((3))</pre><hr><section><p><sup class="annotation local" id="annotation:random:ref:3:1" title="3"><a href="#annotation:random:def:3:1">*1</a></sup></p><ol class="annotations"><li id="annotation:random:def:3:1" data-marker="*1"><span>3</span><sup><a href="#annotation:random:ref:3:1">^1</a></sup></li></ol><h2>References</h2><ol class="references"></ol></section></aside>',
+            '<blockquote><blockquote><section><p><sup class="annotation" id="annotation:random:ref:1:1" title="1"><a href="#annotation:random:def:1:1">*1</a></sup></p><ol class="annotations"><li id="annotation:random:def:1:1" data-marker="*1"><span>1</span><sup><a href="#annotation:random:ref:1:1">^1</a></sup></li></ol><h2>References</h2><ol class="references"></ol></section></blockquote><section><p><sup class="annotation" id="annotation:random:ref:2:1" title="2"><a href="#annotation:random:def:2:1">*1</a></sup><br>~~~</p><ol class="annotations"><li id="annotation:random:def:2:1" data-marker="*1"><span>2</span><sup><a href="#annotation:random:ref:2:1">^1</a></sup></li></ol><h2>References</h2><ol class="references"></ol></section></blockquote>',
+            '<aside class="example" data-type="markdown"><pre translate="no">((3))</pre><hr><section><p><sup class="annotation" id="annotation:random:ref:3:1" title="3"><a href="#annotation:random:def:3:1">*1</a></sup></p><ol class="annotations"><li id="annotation:random:def:3:1" data-marker="*1"><span>3</span><sup><a href="#annotation:random:ref:3:1">^1</a></sup></li></ol><h2>References</h2><ol class="references"></ol></section></aside>',
             '<p><sup class="annotation" id="annotation::ref:4:1" title="4"><a href="#annotation::def:4:1">*1</a></sup></p>',
             '<ol class="annotations"><li id="annotation::def:4:1" data-marker="*1"><span>4</span><sup><a href="#annotation::ref:4:1">^1</a></sup></li></ol>',
           ]);
@@ -135,9 +157,13 @@ describe('Unit: processor/note', () => {
     });
 
     it('split', () => {
-      const target = run(parse('((1))\n\n## a\n\n((2))((1))((3))((2))\n\n## b\n\n((2))'));
+      const lists = {
+        annotations: new List<Node<HTMLElement>>(),
+        references: new List<Node<HTMLElement>>(),
+      };
+      const target = run(parse('((1))\n\n## a\n\n((2))((1))((3))((2))\n\n## b\n\n((2))', lists));
       for (let i = 0; i < 3; ++i) {
-        [...note(target)];
+        [...note(target, lists)];
         assert.deepStrictEqual(
           [...target.children].map(el => normalize(el.outerHTML)),
           [
@@ -201,9 +227,13 @@ describe('Unit: processor/note', () => {
     });
 
     it('id', () => {
-      const target = run(parse('((a b))'));
+      const lists = {
+        annotations: new List<Node<HTMLElement>>(),
+        references: new List<Node<HTMLElement>>(),
+      };
+      const target = run(parse('((a b))', lists));
       for (let i = 0; i < 3; ++i) {
-        assert.deepStrictEqual([...note(target, undefined, { id: '0' })].length, 1);
+        assert.deepStrictEqual([...note(target, lists, undefined, { id: '0' })].length, 1);
         assert.deepStrictEqual(
           [...target.children].map(el => normalize(el.outerHTML)),
           [
@@ -223,9 +253,13 @@ describe('Unit: processor/note', () => {
     });
 
     it('nest', () => {
-      const target = run(parse('((a((b))))((a))((b))'));
+      const lists = {
+        annotations: new List<Node<HTMLElement>>(),
+        references: new List<Node<HTMLElement>>(),
+      };
+      const target = run(parse('((a((b))))((a))((b))', lists));
       for (let i = 0; i < 3; ++i) {
-        [...note(target)];
+        [...note(target, lists)];
         assert.deepStrictEqual(
           [...target.children].map(el => normalize(el.outerHTML)),
           [
@@ -278,10 +312,14 @@ describe('Unit: processor/note', () => {
 
   describe('reference', () => {
     it('1', () => {
-      const target = run(parse('[[a b]]'));
+      const lists = {
+        annotations: new List<Node<HTMLElement>>(),
+        references: new List<Node<HTMLElement>>(),
+      };
+      const target = run(parse('[[a b]]', lists));
       const notes = { references: html('ol') };
       for (let i = 0; i < 3; ++i) {
-        [...note(target, notes)];
+        [...note(target, lists, notes)];
         assert.deepStrictEqual(
           [...target.children].map(el => normalize(el.outerHTML)),
           [
@@ -305,10 +343,14 @@ describe('Unit: processor/note', () => {
     });
 
     it('abbr', () => {
-      const target = run(parse('[[^A 1]][[^A 1|b]][[^A 1]]'));
+      const lists = {
+        annotations: new List<Node<HTMLElement>>(),
+        references: new List<Node<HTMLElement>>(),
+      };
+      const target = run(parse('[[^A 1]][[^A 1|b]][[^A 1]]', lists));
       const notes = { references: html('ol') };
       for (let i = 0; i < 3; ++i) {
-        [...note(target, notes)];
+        [...note(target, lists, notes)];
         assert.deepStrictEqual(
           [...target.children].map(el => normalize(el.outerHTML)),
           [
@@ -342,10 +384,14 @@ describe('Unit: processor/note', () => {
     });
 
     it('nest', () => {
-      const target = run(parse('((a[[^B]]))[[^B|c]]'));
+      const lists = {
+        annotations: new List<Node<HTMLElement>>(),
+        references: new List<Node<HTMLElement>>(),
+      };
+      const target = run(parse('((a[[^B]]))[[^B|c]]', lists));
       const notes = { references: html('ol') };
       for (let i = 0; i < 3; ++i) {
-        [...note(target, notes)];
+        [...note(target, lists, notes)];
         assert.deepStrictEqual(
           [...target.children].map(el => normalize(el.outerHTML)),
           [

package/src/processor/note.ts

@@ -1,19 +1,23 @@
+import { List, Node } from '../combinator/parser';
 import { identity, signature, text } from '../parser/inline/extension/indexee';
-import { markInvalid, unmarkInvalid } from '../parser/util';
+import { markInvalid, unmarkInvalid, collect } from '../parser/util';
 import { memoize } from 'spica/memoize';
 import { html, define } from 'typed-dom/dom';
 
 export function* note(
-  target: ParentNode & Node,
+  target: ParentNode & global.Node,
+  lists: {
+    readonly annotations: List<Node<HTMLElement>>;
+    readonly references: List<Node<HTMLElement>>;
+  },
   notes?: {
     readonly annotations?: HTMLOListElement;
     readonly references: HTMLOListElement;
   },
   opts: {
     readonly id?: string;
-    readonly local?: boolean;
   } = {},
-  bottom: Node | null = null,
+  bottom: global.Node | null = null,
 ): Generator<HTMLOListElement | undefined, undefined, undefined> {
   const referenceRefMemory = referenceRefsMemoryCaller(target);
   const annotationRefMemory = annotationRefsMemoryCaller(target);
@@ -23,8 +27,18 @@ export function* note(
     }
     memory.clear();
   }
-  yield* reference(referenceRefMemory, target, notes?.references, opts, bottom);
-  yield* annotation(annotationRefMemory, target, notes?.annotations, opts, bottom);
+  yield* reference(
+    referenceRefMemory,
+    target,
+    lists.references.foldl<HTMLElement[]>((acc, { value: el }) =>
+      (acc.push(el), acc), []),
+    notes?.references, opts, bottom);
+  yield* annotation(
+    annotationRefMemory,
+    target,
+    lists.annotations.foldl<HTMLElement[]>((acc, { value: el }) =>
+      (acc.push(el), acc), []),
+    notes?.annotations, opts, bottom);
 }
 
 interface RefMemory {
@@ -34,11 +48,11 @@ interface RefMemory {
   readonly text: string;
 }
 
-const annotationRefsMemoryCaller = memoize((target: Node) =>
+const annotationRefsMemoryCaller = memoize((target: global.Node) =>
   new Map<HTMLElement, RefMemory>() ?? target,
   new WeakMap());
 
-const referenceRefsMemoryCaller = memoize((target: Node) =>
+const referenceRefsMemoryCaller = memoize((target: global.Node) =>
   new Map<HTMLElement, {
     readonly content: Element;
     readonly identifier: string;
@@ -50,19 +64,16 @@ const referenceRefsMemoryCaller = memoize((target: Node) =>
 const annotation = build(
   'annotation',
   'annotations',
-  '.annotation:not(:is(.annotations, .references) &, .local)',
   n => `*${n}`,
   'h1, h2, h3, h4, h5, h6, aside.aside, hr, .references');
 const reference = build(
   'reference',
   'references',
-  '.reference:not(:is(.annotations, .references) &, .local)',
   (n, abbr) => `[${abbr || n}]`);
 
 function build(
   syntax: string,
   list: string,
-  selector: string,
   marker: (index: number, abbr: string) => string,
   splitter: string = '',
 ) {
@@ -70,13 +81,13 @@ function build(
   splitter &&= `${splitter}, .${list}`;
   return function* (
     memory: Map<HTMLElement, RefMemory>,
-    target: ParentNode & Node,
+    target: ParentNode & global.Node,
+    refs: readonly HTMLElement[],
     note?: HTMLOListElement,
     opts: {
       readonly id?: string;
-      readonly local?: boolean;
     } = {},
-    bottom: Node | null = null,
+    bottom: global.Node | null = null,
   ): Generator<HTMLOListElement | undefined, undefined, undefined> {
     const refInfoCaller = memoize((ref: HTMLElement) => {
       const content = ref.firstElementChild!;
@@ -101,7 +112,6 @@ function build(
       };
     }, memory);
     const defs = new Map<string, HTMLLIElement>();
-    const refs = target.querySelectorAll<HTMLElement>(selector);
     const identifierInfoCaller = memoize((identifier: string) => ({
       defIndex: 0,
       defSubindex: 0,
@@ -110,9 +120,7 @@ function build(
       queue: [] as HTMLElement[],
     }));
     const splitters = splitter
-      ? target instanceof Element
-        ? target.querySelectorAll(`:scope > :is(${splitter}, .${list})`)
-        : target.querySelectorAll(`:not(* > *):is(${splitter}, .${list})`)
+      ? collect(target, `${splitter}, .${list}`)
       : [];
     let iSplitters = 0;
     let total = 0;
@@ -124,7 +132,7 @@ function build(
       if (splitter) for (let splitter; splitter = splitters[iSplitters]; ++iSplitters) {
         assert(splitter.parentNode === target || !splitter.parentNode);
         const pos = splitter?.compareDocumentPosition(ref) ?? 0;
-        if (pos & (Node.DOCUMENT_POSITION_PRECEDING | Node.DOCUMENT_POSITION_DISCONNECTED)) break;
+        if (pos & (global.Node.DOCUMENT_POSITION_PRECEDING | global.Node.DOCUMENT_POSITION_DISCONNECTED)) break;
         if (~iSplitters << 32 - 8 === 0) yield;
         if (splitter.classList.contains(list) && splitter.nextElementSibling !== splitters[iSplitters + 1]) {
           const note = splitter as HTMLOListElement;
@@ -176,11 +184,7 @@ function build(
         : info.defIndex;
       const title = info.title ||= text;
       assert(syntax !== 'annotation' || title);
-      define(ref, {
-        id: refId,
-        class: opts.local ? `${ref.className} local` : undefined,
-        title,
-      }, []);
+      define(ref, { id: refId, title, }, []);
       if (title && info.queue.length > 0) {
         for (const ref of info.queue) {
           define(ref, { title });

package/src/util/toc.ts

@@ -1,11 +1,10 @@
+import { collect } from '../parser/util';
 import { push } from 'spica/array';
 import { html } from 'typed-dom/dom';
 
-const selector = ':is(h1, h2, h3, h4, h5, h6, aside.aside)[id]:not(.local)';
-
 export function toc(source: DocumentFragment | HTMLElement | ShadowRoot): HTMLUListElement {
   const hs: HTMLHeadingElement[] = [];
-  for (let es = source.querySelectorAll(selector),
+  for (let es = collect(source, ':is(h1, h2, h3, h4, h5, h6, aside.aside)[id]'),
            len = es.length, i = 0; i < len; ++i) {
     const el = es[i];
     assert(el.parentNode === source);