securemark 0.299.4 → 0.300.1

package/src/parser/source/unescapable.test.ts

@@ -1,7 +1,6 @@
 import { unescsource } from './unescapable';
 import { some } from '../../combinator';
-import { input } from '../../combinator/data/parser';
-import { Context } from '../context';
+import { input } from '../context';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/source/unescapable', () => {
@@ -9,40 +8,40 @@ describe('Unit: parser/source/unescapable', () => {
     const parser = some(unescsource);
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser, input('', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('')), undefined);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser, input('a', new Context())), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser, input('ab', new Context())), [['ab'], '']);
-      assert.deepStrictEqual(inspect(parser, input('a b c', new Context())), [['a', ' b c'], '']);
-      assert.deepStrictEqual(inspect(parser, input('09あいAZaz', new Context())), [['09', 'あいAZaz'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a')), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('ab')), [['ab'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a b c')), [['a', ' b c'], '']);
+      assert.deepStrictEqual(inspect(parser, input('09あいAZaz')), [['09', 'あいAZaz'], '']);
     });
 
     it('space', () => {
-      assert.deepStrictEqual(inspect(parser, input(' ', new Context())), [[' '], '']);
-      assert.deepStrictEqual(inspect(parser, input('  ', new Context())), [['  '], '']);
-      assert.deepStrictEqual(inspect(parser, input('   ', new Context())), [['   '], '']);
-      assert.deepStrictEqual(inspect(parser, input(' \n', new Context())), [[' ', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('  \n', new Context())), [['  ', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('   \n', new Context())), [['   ', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input(' ')), [[' '], '']);
+      assert.deepStrictEqual(inspect(parser, input('  ')), [['  '], '']);
+      assert.deepStrictEqual(inspect(parser, input('   ')), [['   '], '']);
+      assert.deepStrictEqual(inspect(parser, input(' \n')), [[' ', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('  \n')), [['  ', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('   \n')), [['   ', '<br>'], '']);
     });
 
     it('linebreak', () => {
-      assert.deepStrictEqual(inspect(parser, input('\n\n', new Context())), [['<br>', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\n\n')), [['<br>', '<br>'], '']);
     });
 
     it('\\', () => {
-      assert.deepStrictEqual(inspect(parser, input('\\', new Context())), [['\\'], '']);
-      assert.deepStrictEqual(inspect(parser, input('\\\\', new Context())), [['\\', '\\'], '']);
-      assert.deepStrictEqual(inspect(parser, input('\\\\\\', new Context())), [['\\', '\\', '\\'], '']);
-      assert.deepStrictEqual(inspect(parser, input('\\ ', new Context())), [['\\', ' '], '']);
-      assert.deepStrictEqual(inspect(parser, input('\\_', new Context())), [['\\', '_'], '']);
-      assert.deepStrictEqual(inspect(parser, input('\\0', new Context())), [['\\0'], '']);
-      assert.deepStrictEqual(inspect(parser, input('\\a', new Context())), [['\\a'], '']);
-      assert.deepStrictEqual(inspect(parser, input('\\`', new Context())), [['\\', '`'], '']);
-      assert.deepStrictEqual(inspect(parser, input('\\　', new Context())), [['\\', '　'], '']);
-      assert.deepStrictEqual(inspect(parser, input('\\\n', new Context())), [['\\', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\')), [['\\'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\\\')), [['\\', '\\'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\\\\\')), [['\\', '\\', '\\'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\ ')), [['\\', ' '], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\_')), [['\\', '_'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\0')), [['\\0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\a')), [['\\a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\`')), [['\\', '`'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\　')), [['\\', '　'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\\n')), [['\\', '<br>'], '']);
     });
 
   });

package/src/parser/source/unescapable.ts

@@ -1,30 +1,29 @@
 import { UnescapableSourceParser } from '../source';
+import { Result, Node } from '../../combinator/parser';
+import { spend } from '../../combinator';
 import { State, Command } from '../context';
 import { Flag } from '../node';
-import { List, Node } from '../../combinator/data/parser';
-import { spend } from '../../combinator';
 import { nonWhitespace, canSkip, backToUrlHead, backToEmailHead } from './text';
 import { html } from 'typed-dom/dom';
 
-export const unescsource: UnescapableSourceParser = context => {
-  const { source, position, state } = context;
+export const unescsource: UnescapableSourceParser = (input, output) => {
+  const { source, position, state } = input;
   if (position === source.length) return;
   const char = source[position];
-  spend(context, 1);
-  context.position += 1;
+  spend(input, output, 1);
+  input.position += 1;
   switch (char) {
     case Command.Escape:
-      spend(context, 1);
-      context.position += 1;
-      return new List([new Node(source.slice(position + 1, position + 2))]);
+      spend(input, output, 1);
+      input.position += 1;
+      return output.append(new Node(source.slice(position + 1, position + 2)));
     case '\r':
-      return new List();
+      return Result.succ;
     case '\n':
-      context.linebreak ||= source.length - position;
-      return new List([new Node(html('br'), Flag.blank)]);
+      input.linebreak ||= source.length - position;
+      return output.append(new Node(html('br'), Flag.blank));
     default:
       assert(char !== '\n');
-      if (context.sequential) return new List([new Node(char)]);
       nonWhitespace.lastIndex = position + 1;
       let i = canSkip(source, position)
         ? nonWhitespace.test(source)
@@ -33,9 +32,9 @@ export const unescsource: UnescapableSourceParser = context => {
         : next(source, position, state);
       assert(i > position);
       i -= position;
-      spend(context, i - 1);
-      context.position += i - 1;
-      return new List([new Node(source.slice(position, context.position))]);
+      spend(input, output, i - 1);
+      input.position += i - 1;
+      return output.append(new Node(source.slice(position, input.position)));
   }
 };
 

package/src/parser/source/whitespace.ts

@@ -0,0 +1,36 @@
+// https://util.unicode.org/UnicodeJsps/list-unicodeset.jsp?a=%5Cp%7BWhite_Space%7D&g=&i=
+// https://en.wikipedia.org/wiki/Whitespace_character
+// https://en.wikipedia.org/wiki/Newline
+export function isWhitespace(char: string, linebreak: boolean = true): boolean {
+  switch (char) {
+    case '\u0009':
+    case '\u000B':
+    case '\u000C':
+    case '\u0020':
+    case '\u0085':
+    case '\u00A0':
+    case '\u1680':
+    case '\u2000':
+    case '\u2001':
+    case '\u2002':
+    case '\u2003':
+    case '\u2004':
+    case '\u2005':
+    case '\u2006':
+    case '\u2007':
+    case '\u2008':
+    case '\u2009':
+    case '\u200A':
+    case '\u2028':
+    case '\u2029':
+    case '\u202F':
+    case '\u205F':
+    case '\u3000':
+      return true;
+    case '\u000A':
+    case '\u000D':
+      return linebreak;
+    default:
+      return false;
+  }
+}

package/src/parser/source.ts

@@ -15,4 +15,5 @@ export { text, txt } from './source/text';
 export { escsource } from './source/escapable';
 export { unescsource } from './source/unescapable';
 export { str, strs } from './source/str';
+export { isWhitespace } from './source/whitespace';
 export { contentline, emptyline, emptysegment, anyline } from './source/line';

package/src/parser/util.ts

@@ -1,4 +1,4 @@
-import { List, Node } from '../combinator/data/parser';
+import { List, Node } from '../combinator/parser';
 import { rnd0Z } from 'spica/random';
 import { define } from 'typed-dom/dom';
 

package/src/parser/visibility.ts

@@ -1,8 +1,9 @@
-import { Parser, List, Node } from '../combinator/data/parser';
-import { Command } from './context';
+import { Parser, List, Node } from '../combinator/parser';
+import { Input, Command } from './context';
 import { Flag } from './node';
-import { convert, fmap } from '../combinator';
+import { always, fmap } from '../combinator';
 import { invisibleBlankHTMLEntityNames } from '../api/normalize';
+import { isWhitespace } from './source';
 
 namespace blank {
   export const line = new RegExp(
@@ -19,10 +20,32 @@ namespace blank {
     'y');
 }
 
-export function visualize<P extends Parser>(parser: P): P {
-  return convert(
-    source => source.replace(blank.line, `$1${Command.Escape}$2`),
-    parser);
+export function visualize<P extends Parser>(parser: P): P;
+export function visualize<T>(parser: Parser<T>): Parser<T> {
+  interface Memory {
+    readonly scope: boolean;
+  }
+  return always<Parser<T, Input<Memory>>>([
+    (input, output) => {
+      const { source, position } = input;
+      const src = source.slice(position).replace(blank.line, `$1${Command.Escape}$2`);
+      input.memory = {
+        scope: src.length !== source.length - position,
+      };
+      if (input.memory.scope) {
+        input.scope.push(src);
+      }
+      return output.context;
+    },
+    parser,
+    (input, output) => {
+      if (input.memory.scope) {
+        input = input.scope.pop();
+      }
+      input.position = input.source.length;
+      return output.context;
+    },
+  ]);
 }
 
 export const beforeNonblank = beforeNonblankWith('');
@@ -80,7 +103,7 @@ function isNonblank({ value: node, flags }: Node<HTMLElement | string>, strpos?:
     case '\n':
       return false;
     default:
-      return str.trimStart() !== '';
+      return !isWhitespace(str.trimStart());
   }
 }
 
@@ -91,17 +114,16 @@ export function trimBlank<N extends HTMLElement | string>(parser: Parser<N>): Pa
 }
 function trimBlankStart<P extends Parser>(parser: P): P;
 function trimBlankStart<N>(parser: Parser<N>): Parser<N> {
-  return input => {
-    const context = input;
-    const { source, position } = context;
+  return (input, output) => {
+    const { source, position } = input;
     if (position === source.length) return;
     const reg = blank.start;
     reg.lastIndex = position;
     reg.test(source);
-    context.position = reg.lastIndex || position;
-    return context.position === source.length
-      ? new List()
-      : parser(input);
+    input.position = reg.lastIndex || position;
+    return input.position === source.length
+      ? output.context
+      : parser(input, output);
   };
 }
 export function trimBlankEnd<P extends Parser<HTMLElement | string>>(parser: P): P;

package/src/processor/figure.test.ts

@@ -1,6 +1,6 @@
 import { figure } from './figure';
 import { ParserOptions } from '../..';
-import { parse as parse_ } from '../api';
+import { run, parse as parse_ } from '../api';
 import { html } from 'typed-dom/dom';
 import { normalize } from '../debug.test';
 
@@ -9,7 +9,7 @@ const parse = (s: string, o?: ParserOptions) => parse_(s, { test: true, ...o });
 describe('Unit: processor/figure', () => {
   describe('figure', () => {
     it('empty', () => {
-      const target = parse('');
+      const target = run(parse(''));
       for (let i = 0; i < 3; ++i) {
         [...figure(target)];
         assert.deepStrictEqual(
@@ -19,12 +19,12 @@ describe('Unit: processor/figure', () => {
     });
 
     it('one', () => {
-      const target = parse([
+      const target = run(parse([
         '$test-a\n> ',
         '$test-a',
         '$test-b',
         '$test-a',
-      ].join('\n\n'));
+      ].join('\n\n')));
       for (let i = 0; i < 3; ++i) {
         [...figure(target)];
         assert.deepStrictEqual(
@@ -39,14 +39,14 @@ describe('Unit: processor/figure', () => {
     });
 
     it('some', () => {
-      const target = parse([
+      const target = run(parse([
         '$test-a\n> ',
         '## 0',
         '$test-b\n> ',
         '$quote-a\n> ',
         '$test-b\n> ',
         '$test-c\n> ',
-      ].join('\n\n'));
+      ].join('\n\n')));
       for (let i = 0; i < 3; ++i) {
         [...figure(target)];
         assert.deepStrictEqual(
@@ -63,10 +63,10 @@ describe('Unit: processor/figure', () => {
     });
 
     it('number', () => {
-      const target = parse([
+      const target = run(parse([
         '$-a\n$$\n$$',
         '$-a',
-      ].join('\n\n'));
+      ].join('\n\n')));
       for (let i = 0; i < 3; ++i) {
         [...figure(target)];
         assert.deepStrictEqual(
@@ -79,7 +79,7 @@ describe('Unit: processor/figure', () => {
     });
 
     it('fixed', () => {
-      const target = parse([
+      const target = run(parse([
         '$test-2\n> ',
         '$test-3.1\n> ',
         '$-4.1.1\n$$\n$$',
@@ -88,7 +88,7 @@ describe('Unit: processor/figure', () => {
         '$test-2',
         '$-4.1.1',
         '$test-1',
-      ].join('\n\n'));
+      ].join('\n\n')));
       for (let i = 0; i < 3; ++i) {
         [...figure(target)];
         assert.deepStrictEqual(
@@ -107,12 +107,12 @@ describe('Unit: processor/figure', () => {
     });
 
     it('separation', () => {
-      const target = html('blockquote', parse([
+      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'))).children);
       for (let i = 0; i < 3; ++i) {
         [...figure(target)];
         assert.deepStrictEqual(
@@ -127,7 +127,7 @@ describe('Unit: processor/figure', () => {
     });
 
     it('base', () => {
-      const target = parse([
+      const target = run(parse([
         '# 0',
         '$-0.0',
         '## 0',
@@ -163,7 +163,7 @@ describe('Unit: processor/figure', () => {
         '$test-i\n> ',
         '# 0',
         '$test-j\n> ',
-      ].join('\n\n'));
+      ].join('\n\n')));
       for (let i = 0; i < 3; ++i) {
         [...figure(target)];
         assert.deepStrictEqual(
@@ -209,7 +209,7 @@ describe('Unit: processor/figure', () => {
     });
 
     it('concat', () => {
-      const target = parse([
+      const target = run(parse([
         '$-0.0',
         '## 0',
         '$-0.0',
@@ -229,7 +229,7 @@ describe('Unit: processor/figure', () => {
         '## 0',
         '$-9.0',
         '$test-e\n> ',
-      ].join('\n\n'));
+      ].join('\n\n')));
       for (let i = 0; i < 3; ++i) {
         [...figure(target)];
         assert.deepStrictEqual(
@@ -259,11 +259,11 @@ describe('Unit: processor/figure', () => {
     });
 
     it('verbose', () => {
-      const target = parse([
+      const target = run(parse([
         '~~~figure [$test-a]\n> \n\n~~~',
         '[$test-a]',
         '[$test-a]',
-      ].join('\n\n'));
+      ].join('\n\n')));
       for (let i = 0; i < 3; ++i) {
         [...figure(target)];
         assert.deepStrictEqual(
@@ -277,11 +277,11 @@ describe('Unit: processor/figure', () => {
     });
 
     it('id', () => {
-      const target = parse([
+      const target = run(parse([
         '$test-a\n> ',
         '==$test-a==',
         '- $test-a',
-      ].join('\n\n'), { id: '0' });
+      ].join('\n\n'), { id: '0' }));
       for (let i = 0; i < 3; ++i) {
         [...figure(target, undefined, { id: '0' })];
         assert.deepStrictEqual(

package/src/processor/figure.ts

@@ -3,7 +3,6 @@ import { markInvalid, unmarkInvalid } from '../parser/util';
 import { MultiQueue } from 'spica/queue';
 import { push } from 'spica/array';
 import { define } from 'typed-dom/dom';
-import { querySelectorAll } from 'typed-dom/query';
 
 export function* figure(
   target: ParentNode & Node,
@@ -14,19 +13,26 @@ export function* figure(
   } = {},
 ): Generator<HTMLAnchorElement | undefined, undefined, undefined> {
   const selector = ':is(figure[data-label], h1, h2)';
-  const refs = new MultiQueue<string, HTMLAnchorElement>(push(
-    querySelectorAll(target, 'a.label:not(.local)[data-label]'),
-    notes && querySelectorAll(notes.references, 'a.label:not(.local)') || [])
-    .map(el => [el.getAttribute('data-label')!, el]));
+  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)));
   const labels = new Set<string>();
   const numbers = new Map<string, string>();
   let base = '0';
   let bases: readonly string[] = base.split('.');
-  let index: readonly string[] = bases;
   for (
     let defs = target instanceof Element
           ? target.querySelectorAll(`:scope > ${selector}`)
-          : target.querySelectorAll(`${selector}:not(* > *)`),
+          : target.querySelectorAll(`:not(* > *)${selector}`),
         len = defs.length, i = 0; i < len; ++i) {
     yield;
     const def = defs[i];
@@ -36,7 +42,7 @@ export function* figure(
     assert(base === '0' || bases.length > 1);
     const label = tagName === 'FIGURE'
       ? def.getAttribute('data-label')!
-      : `$-${increment(index, def as HTMLHeadingElement)}`;
+      : `$-${increment(bases, def as HTMLHeadingElement)}`;
     if (label.endsWith('-')) continue;
     if (label.endsWith('-0')) {
       markInvalid(def, 'figure', 'argument', 'Invalid base index');
@@ -76,7 +82,7 @@ export function* figure(
       if (group !== '$' || tagName === 'FIGURE' && def.firstChild) continue;
       if (number.startsWith('0.')) {
         assert(number.endsWith('.0'));
-        number = index.slice(0)
+        number = bases.slice(0)
           .reduce((ns, _, i, xs) => {
             i === ns.length
               ? xs.length = i
@@ -90,7 +96,7 @@ export function* figure(
           .join('.');
       }
       base = number;
-      bases = index = base.split('.');
+      bases = base.split('.');
       tagName !== 'FIGURE' && numbers.clear();
       assert(def.tagName !== 'FIGURE' || !+def.setAttribute('data-number', number));
       continue;
@@ -135,6 +141,8 @@ export function* figure(
     }
     yield ref;
   }
+  assert(opts.id !== '' || !target.querySelector('[id], .index[href], .label[href], .annotation > a[href], .reference > a[href]'));
+  assert(opts.id !== '' || !notes?.references.querySelector('[id], .index[href], .label[href]'));
 }
 
 const messages = {

package/src/processor/note.test.ts

@@ -1,5 +1,5 @@
 import { note } from './note';
-import { parse as parse_ } from '../api';
+import { run, parse as parse_ } from '../api';
 import { html } from 'typed-dom/dom';
 import { normalize } from '../debug.test';
 
@@ -8,7 +8,7 @@ const parse = (s: string) => parse_(s, { test: true });
 describe('Unit: processor/note', () => {
   describe('annotation', () => {
     it('empty', () => {
-      const target = parse('');
+      const target = run(parse(''));
       [...note(target)];
       assert.deepStrictEqual(
         [...target.children].map(el => normalize(el.outerHTML)),
@@ -16,7 +16,7 @@ describe('Unit: processor/note', () => {
     });
 
     it('1', () => {
-      const target = parse('((a b))');
+      const target = run(parse('((a b))'));
       for (let i = 0; i < 3; ++i) {
         assert.deepStrictEqual([...note(target)].length, i === 0 ? 2 : 3);
         assert.deepStrictEqual(
@@ -38,7 +38,7 @@ describe('Unit: processor/note', () => {
     });
 
     it('2', () => {
-      const target = parse('((1))((12345678901234567890))');
+      const target = run(parse('((1))((12345678901234567890))'));
       for (let i = 0; i < 3; ++i) {
         assert.deepStrictEqual([...note(target)].length, i === 0 ? 4 : 6);
         assert.deepStrictEqual(
@@ -67,7 +67,7 @@ describe('Unit: processor/note', () => {
     });
 
     it('unify', () => {
-      const target = parse('((1))((2))((3))((2))((4))');
+      const target = run(parse('((1))((2))((3))((2))((4))'));
       for (let i = 0; i < 3; ++i) {
         [...note(target)];
         assert.deepStrictEqual(
@@ -116,11 +116,11 @@ describe('Unit: processor/note', () => {
     });
 
     it('separation', () => {
-      const target = parse([
+      const target = run(parse([
         '!>> ((1))\n> ((2))\n~~~',
         '~~~~example/markdown\n((3))\n~~~~',
         '((4))',
-      ].join('\n\n'));
+      ].join('\n\n')));
       for (let i = 0; i < 3; ++i) {
         [...note(target)];
         assert.deepStrictEqual(
@@ -135,7 +135,7 @@ describe('Unit: processor/note', () => {
     });
 
     it('split', () => {
-      const target = parse('((1))\n\n## a\n\n((2))((1))((3))((2))\n\n## b\n\n((2))');
+      const target = run(parse('((1))\n\n## a\n\n((2))((1))((3))((2))\n\n## b\n\n((2))'));
       for (let i = 0; i < 3; ++i) {
         [...note(target)];
         assert.deepStrictEqual(
@@ -201,7 +201,7 @@ describe('Unit: processor/note', () => {
     });
 
     it('id', () => {
-      const target = parse('((a b))');
+      const target = run(parse('((a b))'));
       for (let i = 0; i < 3; ++i) {
         assert.deepStrictEqual([...note(target, undefined, { id: '0' })].length, i === 0 ? 2 : 3);
         assert.deepStrictEqual(
@@ -223,7 +223,7 @@ describe('Unit: processor/note', () => {
     });
 
     it('nest', () => {
-      const target = parse('((a((b))))((a))((b))');
+      const target = run(parse('((a((b))))((a))((b))'));
       for (let i = 0; i < 3; ++i) {
         [...note(target)];
         assert.deepStrictEqual(
@@ -278,7 +278,7 @@ describe('Unit: processor/note', () => {
 
   describe('reference', () => {
     it('1', () => {
-      const target = parse('[[a b]]');
+      const target = run(parse('[[a b]]'));
       const notes = { references: html('ol') };
       for (let i = 0; i < 3; ++i) {
         [...note(target, notes)];
@@ -305,7 +305,7 @@ describe('Unit: processor/note', () => {
     });
 
     it('abbr', () => {
-      const target = parse('[[^A 1]][[^A 1|b]][[^A 1]]');
+      const target = run(parse('[[^A 1]][[^A 1|b]][[^A 1]]'));
       const notes = { references: html('ol') };
       for (let i = 0; i < 3; ++i) {
         [...note(target, notes)];
@@ -342,7 +342,7 @@ describe('Unit: processor/note', () => {
     });
 
     it('nest', () => {
-      const target = parse('((a[[^B]]))[[^B|c]]');
+      const target = run(parse('((a[[^B]]))[[^B|c]]'));
       const notes = { references: html('ol') };
       for (let i = 0; i < 3; ++i) {
         [...note(target, notes)];

package/src/processor/note.ts

@@ -52,7 +52,7 @@ const annotation = build(
   'annotations',
   '.annotation:not(:is(.annotations, .references) &, .local)',
   n => `*${n}`,
-  'h1, h2, h3, h4, h5, h6, aside.aside, hr');
+  'h1, h2, h3, h4, h5, h6, aside.aside, hr, .references');
 const reference = build(
   'reference',
   'references',
@@ -112,7 +112,7 @@ function build(
     const splitters = splitter
       ? target instanceof Element
         ? target.querySelectorAll(`:scope > :is(${splitter}, .${list})`)
-        : target.querySelectorAll(`:is(${splitter}, .${list}):not(* > *)`)
+        : target.querySelectorAll(`:not(* > *):is(${splitter}, .${list})`)
       : [];
     let iSplitters = 0;
     let total = 0;
@@ -226,6 +226,8 @@ function build(
         splitter.remove();
       }
     }
+    assert(opts.id !== '' || !target.querySelector('[id], .index[href], .label[href], .annotation > a[href], .reference > a[href]'));
+    assert(opts.id !== '' || !note?.querySelector('[id], .index[href], .label[href]'));
   };
 }
 

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

@@ -1,4 +1,4 @@
-import { parse } from '../../../api';
+import { run, parse } from '../../../api';
 import { html, define } from 'typed-dom/dom';
 
 const extensions = [
@@ -13,7 +13,7 @@ export function pdf(source: HTMLImageElement, url: URL): HTMLElement | undefined
       data: source.getAttribute('data-src'),
     }),
     html('div', [
-      define(parse(`{ ${source.getAttribute('data-src')} }`).querySelector('a')!, {
+      define(run(parse(`{ ${source.getAttribute('data-src')} }`)).querySelector('a')!, {
         class: null,
         target: '_blank',
       }),

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

@@ -1,4 +1,4 @@
-import { parse } from '../../../api';
+import { run, parse } from '../../../api';
 import { html as h, define } from 'typed-dom/dom';
 import DOMPurify from 'dompurify';
 
@@ -37,7 +37,7 @@ export function twitter(source: HTMLImageElement, url: URL): HTMLElement | undef
     error({ status, statusText }) {
       assert(Number.isSafeInteger(status));
       define(el, [
-        define(parse(`{ ${source.getAttribute('data-src')} }`).querySelector('a')!, {
+        define(run(parse(`{ ${source.getAttribute('data-src')} }`)).querySelector('a')!, {
           class: null,
           target: '_blank',
         }),