securemark 0.300.4 → 0.300.6

package/src/parser/block.ts

@@ -1,16 +1,16 @@
-import { MarkdownParser } from '../../markdown';
+import { DocumentParser } from '../../markdown';
 import { Segment } from './context';
 import { List, Node } from '../combinator/parser';
 import { union, lazy, always } from '../combinator';
-import { header } from './header';
+import { header } from './block/header';
 import { emptysegment } from './source';
-import { pagebreak } from './block/pagebreak';
 import { heading } from './block/heading';
 import { ulist } from './block/ulist';
 import { olist } from './block/olist';
 import { ilist } from './block/ilist';
 import { dlist } from './block/dlist';
 import { table } from './block/table';
+import { pagebreak } from './block/pagebreak';
 import { codeblock } from './block/codeblock';
 import { mathblock } from './block/mathblock';
 import { extension } from './block/extension';
@@ -25,14 +25,15 @@ import { paragraph } from './block/paragraph';
 import { rnd0Z } from 'spica/random';
 import { html } from 'typed-dom/dom';
 
-export import BlockParser = MarkdownParser.BlockParser;
-export import PagebreakParser = BlockParser.PagebreakParser;
+export import BlockParser = DocumentParser.BlockParser;
+export import HeaderParser = BlockParser.HeaderParser;
 export import HeadingParser = BlockParser.HeadingParser;
 export import UListParser = BlockParser.UListParser;
 export import OListParser = BlockParser.OListParser;
 export import IListParser = BlockParser.IListParser;
 export import DListParser = BlockParser.DListParser;
 export import TableParser = BlockParser.TableParser;
+export import PagebreakParser = BlockParser.PagebreakParser;
 export import CodeBlockParser = BlockParser.CodeBlockParser;
 export import MathBlockParser = BlockParser.MathBlockParser;
 export import ExtensionParser = BlockParser.ExtensionParser;

package/src/parser/context.ts

@@ -28,7 +28,9 @@ export class Input<M extends object = object> extends Ipt<M> {
       clock: -1,
       interval: 200,
       recursions: [
-        20 || Recursion.document,
+        // DOMの垂直的追加の繰り返しが加速的に異常に重くなる。
+        // ブラウザの問題でありアルゴリズムの計算量は問題ない。
+        10 || Recursion.document,
         100 || Recursion.block,
         100 || Recursion.inline,
         100 || Recursion.bracket,
@@ -77,13 +79,13 @@ class RecursionCounter {
   }
   private readonly stack: number[] = [];
   private index = 0;
-  public add(depth: number): Error | undefined {
+  public add(depth: number): boolean {
     const { stack } = this
     for (; this.index > 0 && stack[this.index - 1] >= depth; --this.index);
-    // 内側から数えるので無効化処理できずエラーを投げるしかない。
-    if (this.index === this.limit) return new Error(`Too much recursion`);
     stack[this.index] = depth;
     ++this.index;
+    // 内側から数えるので無効化処理できない。
+    return this.index <= this.limit;
   }
 }
 

package/src/parser/document.ts

@@ -1,6 +1,6 @@
-import { MarkdownParser } from '../../markdown';
+import { DocumentParser } from '../../markdown';
 import { Input, Recursion } from './context';
-import { Parser, Result, Node } from '../combinator/parser';
+import { Parser, Result, List, Node } from '../combinator/parser';
 import { always, force, recursion } from '../combinator';
 import { build } from './parser';
 import { parser as segment } from './segment';
@@ -10,14 +10,14 @@ import { figure } from '../processor/figure';
 import { note } from '../processor/note';
 import { frag, html } from 'typed-dom/dom';
 
-export const document: MarkdownParser = (() => {
+export const document: DocumentParser = (() => {
   interface Memory {
     readonly interpolation: boolean;
     readonly references: HTMLOListElement;
-    doc?: DocumentFragment;
     orphan?: boolean;
+    doc?: DocumentFragment;
   }
-  const loop = build(segment, block);
+  const document = build(segment, block);
   return always<Parser<DocumentFragment | HTMLElement, Input<Memory>>>([
     (input, output) => {
       input.id =
@@ -29,24 +29,35 @@ export const document: MarkdownParser = (() => {
         references: input.notes?.references ?? html('ol', { class: 'references' }),
       };
       output.push();
+      output.labels.push(new List());
+      output.annotations.push(new List());
+      output.references.push(new List());
       return output.context;
     },
-    recursion(Recursion.document, force(() => loop)),
+    recursion(Recursion.document, force(() => document)),
     (input, output) => {
       assert(input.position === input.source.length);
       const { memory } = input;
       const doc = memory.doc = frag(unwrap(output.pop()));
       output.append(new Node(doc));
       assert(input.id !== '' || !doc.querySelector('[id], .index[href], .label[href], .annotation > a[href], .reference > a[href]'));
-      if (input.test && !input.local) return Result.skip;
+      if (input.test && !input.local) {
+        output.labels.at(-2)!.import(output.labels.pop()!);
+        output.annotations.at(-2)!.import(output.annotations.pop()!);
+        output.references.at(-2)!.import(output.references.pop()!);
+        return Result.skip;
+      }
       memory.orphan = !memory.references.parentNode;
       memory.orphan && doc.appendChild(memory.references);
       return output.context;
     },
-    input =>
-      conv(figure(input.memory.doc!, input.memory, input)),
-    input =>
-      conv(note(input.memory.doc!, input.memory, input)),
+    (input, output) =>
+      conv(figure(input.memory.doc!, output.labels.pop()!, input.memory, input)),
+    (input, output) =>
+      conv(note(input.memory.doc!, {
+        annotations: output.annotations.pop()!,
+        references: output.references.pop()!,
+      }, input.memory, input)),
     (input, output) => {
       const { memory } = input;
       memory.orphan && !memory.interpolation && memory.references.remove();

package/src/parser/inline/annotation.test.ts

@@ -62,6 +62,30 @@ describe('Unit: parser/inline/annotation', () => {
       assert.deepStrictEqual(inspect(parser, input('(((a)))')), [['<sup class="annotation"><span><span class="paren">(a)</span></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser, input('((((a))))')), [['<sup class="annotation"><span><sup class="annotation"><span>a</span></sup></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser, input('(([[a]]))')), [['<sup class="annotation"><span><sup class="reference"><span>a</span></sup></span></sup>'], '']);
+      assert.deepStrictEqual(
+        inspect(parser, input(`${'(('.repeat(2)}0${'))'.repeat(2)}`)),
+        [['<sup class="annotation"><span><sup class="annotation"><span>0</span></sup></span></sup>'], '']);
+      assert.deepStrictEqual(
+        inspect(parser, input(`${'(('.repeat(3)}0${'))'.repeat(3)}`)),
+        [['<span class="invalid"><sup class="annotation"><span><sup class="annotation"><span>0</span></sup></span></sup></span>'], '']);
+      assert.deepStrictEqual(
+        inspect(parser, input(`(${'(('.repeat(2)}0${'))'.repeat(2)}`)),
+        [['<span class="paren">(<sup class="annotation"><span><sup class="annotation"><span>0</span></sup></span></sup></span>'], '']);
+      assert.deepStrictEqual(
+        inspect(parser, input(`(${'(('.repeat(3)}0${'))'.repeat(3)}`)),
+        [['<span class="paren">(<span class="invalid"><sup class="annotation"><span><sup class="annotation"><span>0</span></sup></span></sup></span></span>'], '']);
+      assert.deepStrictEqual(
+        inspect(parser, input(`${'(('.repeat(2)}0${'))'.repeat(2)}${'(('.repeat(2)}0${'))'.repeat(2)}`)),
+        [['<sup class="annotation"><span><sup class="annotation"><span>0</span></sup></span></sup>', '<sup class="annotation"><span><sup class="annotation"><span>0</span></sup></span></sup>'], '']);
+      assert.deepStrictEqual(
+        inspect(parser, input(`${'(('.repeat(2)}0${'))'.repeat(2)}${'(('.repeat(3)}0${'))'.repeat(2)}`)),
+        [['<sup class="annotation"><span><sup class="annotation"><span>0</span></sup></span></sup>', '<span class="paren">(<span class="paren">(<sup class="annotation"><span><sup class="annotation"><span>0</span></sup></span></sup></span></span>'], '']);
+      assert.deepStrictEqual(
+        inspect(parser, input(`${'(('.repeat(2)}0${'))'.repeat(2)}${'(('.repeat(3)}0${'))'.repeat(3)}`)),
+        [['<sup class="annotation"><span><sup class="annotation"><span>0</span></sup></span></sup>', '<span class="invalid"><sup class="annotation"><span><sup class="annotation"><span>0</span></sup></span></sup></span>'], '']);
+      assert.deepStrictEqual(
+        inspect(parser, input(`${'(('.repeat(3)}0))((1))))))`)),
+        [['<span class="invalid"><sup class="annotation"><span><sup class="annotation"><span>0</span></sup><sup class="annotation"><span>1</span></sup></span></sup></span>'], '']);
     });
 
   });

package/src/parser/inline/annotation.ts

@@ -6,7 +6,7 @@ import { inline } from '../inline';
 import { bracketname } from './bracket';
 import { repeat } from '../repeat';
 import { beforeNonblank, trimBlankNodeEnd } from '../visibility';
-import { unwrap } from '../util';
+import { unwrap, invalid } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 // シグネチャ等生成のために構文木のツリーウォークを再帰的に行い指数計算量にならないよう
@@ -32,7 +32,7 @@ export const annotation: AnnotationParser = lazy(() => constraint(State.annotati
     ([, bs], _, output) => output.import(bs),
     ([, bs], _, output) => bs && output.import(bs.push(new Node(Command.Cancel)))))),
     (nodes, input, output, lead, follow) => {
-      const { linebreak, recursion, resources } = input;
+      const { position, linebreak, range, recursion, resources } = input;
       if (linebreak !== 0 || nodes.length === 0 || lead === 0 || follow % 2 === 0) {
         nodes.unshift(new Node('('));
         nodes.push(new Node(')'));
@@ -40,13 +40,26 @@ export const annotation: AnnotationParser = lazy(() => constraint(State.annotati
           new Node(html('span', { class: bracketname(input, 1, 1) }, defrag(unwrap(nodes))))
         ]);
       }
-      output.error ??= recursion.add(resources?.recursions[Recursion.inline] ?? resources?.recursions.at(-1));
       input.position += 1;
-      return new List([
-        new Node(html('sup', { class: 'annotation' }, [
-          html('span', defrag(unwrap(trimBlankNodeEnd(nodes))))
-        ]))
+      if (!recursion.add(resources?.recursions[Recursion.inline] ?? resources?.recursions.at(-1))) {
+        return new List([new Node(html('span',
+          {
+            class: 'invalid',
+            ...invalid('annotation', 'syntax', 'Recursions must be two or fewer')
+          },
+          defrag(unwrap(trimBlankNodeEnd(nodes)))))]);
+      }
+      const el = html('sup', { class: 'annotation' }, [
+        html('span', defrag(unwrap(trimBlankNodeEnd(nodes))))
       ]);
+      for (let list = output.annotations.at(-1)!, node = list.last, pos = position - range, i = 0; ; node = node!.prev, ++i) {
+        if (node && node.position > pos) continue;
+        i === list.length
+          ? list.unshift(new Node(el, pos))
+          : list.insert(new Node(el, pos), node?.next);
+        break;
+      }
+      return new List([new Node(el)]);
     },
     (nodes, input, output, prefix, postfix) => {
       assert(postfix === 0);

package/src/parser/inline/extension/index.ts

@@ -1,6 +1,5 @@
 import { ExtensionParser } from '../../inline';
 import { State, Backtrack } from '../../context';
-import { Flag } from '../../node';
 import { List, Node } from '../../../combinator/parser';
 import { union, inits, some, precedence, state, constraint, backtrack, validate, surround, setBacktrack, lazy, fmap } from '../../../combinator';
 import { inline } from '../../inline';
@@ -53,7 +52,7 @@ export const signature: IndexParser.SignatureParser = lazy(() => validate('|', b
     const { position, range, linebreak } = input;
     const head = position - range;
     const index = identity('index', undefined, ns.foldl((acc, { value }) => acc + value, ''))?.slice(7);
-    if (linebreak !== 0 || ns.head!.flags & Flag.blank || !index) {
+    if (linebreak !== 0 || ns.head!.flags & Node.Flag.blank || !index) {
       return void setBacktrack(input, 2 | Backtrack.escapable, head);
     }
     return output.append(new Node(html('span', { class: 'indexer', 'data-index': index })));

package/src/parser/inline/extension/indexee.ts

@@ -5,11 +5,10 @@ import { define } from 'typed-dom/dom';
 
 export function indexee<P extends Parser<HTMLElement, Input>>(parser: P): P;
 export function indexee(parser: Parser<HTMLElement, Input>): Parser<HTMLElement, Input> {
-  return fmap(parser, (ns, { id, local }) =>
+  return fmap(parser, (ns, { id }) =>
     ns.length === 1
       ? new List([new Node(define(ns.head!.value, {
           id: identity('index', id, ns.head!.value),
-          class: local ? `${ns.head!.value.className} local`.trimStart() : undefined,
           'data-index': null
         }))])
       : ns);

package/src/parser/inline/extension/label.ts

@@ -26,12 +26,16 @@ export const label: ExtensionParser.LabelParser = constraint(State.label, fmap(
     backtrack(surround('[', body, ']', false, [1 | Backtrack.common])),
     body,
   ]),
-  ([{ value }]) => new List([
-    new Node(html('a', {
-      class: 'label',
-      'data-label': value.slice(value[1] === '-' ? 0 : 1).toLowerCase(),
-    }, value)),
-  ])));
+  ([{ value }], _, output) => {
+    const label = html('a',
+      {
+        class: 'label',
+        'data-label': value.slice(value[1] === '-' ? 0 : 1).toLowerCase(),
+      },
+      value);
+    output.labels.at(-1)!.push(new Node(label));
+    return new List([new Node(label)]);
+  }));
 
 export function number(label: string, base: string): string {
   return isFixed(label)

package/src/parser/inline/html.ts

@@ -1,7 +1,6 @@
 import { HTMLParser } from '../inline';
 import { Input, Recursion } from '../context';
 import { List, Node } from '../../combinator/parser';
-import { Flag } from '../node';
 import { union, some, recursion, precedence, surround, open, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
@@ -28,7 +27,7 @@ export const html: HTMLParser = lazy(() => union([
     open(str(/ ?/y), str('>'), true),
     true, [],
     ([as, bs = new List(), cs], input, output) =>
-      output.append(new Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs).import(cs))], new List(), new List(), input), as.head!.value === '<wbr' ? Flag.blank : Flag.none)),
+      output.append(new Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs).import(cs))], new List(), new List(), input), as.head!.position, as.head!.value === '<wbr' ? Node.Flag.blank : Node.Flag.none)),
     ([as, bs = new List()], input, output) =>
       output.append(new Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs))], new List(), new List(), input)))),
   match(

package/src/parser/inline/htmlentity.ts

@@ -1,6 +1,6 @@
 import { HTMLEntityParser, UnsafeHTMLEntityParser } from '../inline';
 import { Backtrack } from '../context';
-import { Flag, isBlankHTMLEntityName } from '../node';
+import { isBlankHTMLEntityName } from '../node';
 import { List, Node } from '../../combinator/parser';
 import { union, surround, fmap } from '../../combinator';
 import { str } from '../source';
@@ -15,15 +15,16 @@ export const unsafehtmlentity: UnsafeHTMLEntityParser = surround(
     output.append(
       new Node(
         parser(as.head!.value + bs.head!.value + cs.head!.value),
-        isBlankHTMLEntityName(bs.head!.value) ? Flag.blank : Flag.none)),
+        as.head!.position,
+        isBlankHTMLEntityName(bs.head!.value) ? Node.Flag.blank : Node.Flag.none)),
   ([as, bs], _, output) =>
     output.append(new Node(as.head!.value + (bs?.head?.value ?? ''))));
 
 export const htmlentity: HTMLEntityParser = fmap(
   union([unsafehtmlentity]),
-  ([{ value, flags }]) => new List([
+  ([{ value, position, flags }]) => new List([
     value.length === 1 || value.at(-1) !== ';'
-      ? new Node(value, flags)
+      ? new Node(value, position, flags)
       : new Node(html('span', {
           class: 'invalid',
           ...invalid('htmlentity', 'syntax', 'Invalid HTML entity'),

package/src/parser/inline/media.ts

@@ -1,7 +1,6 @@
 import { MediaParser } from '../inline';
 import { State, Recursion, Backtrack, Command } from '../context';
 import { Result, List, Node } from '../../combinator/parser';
-import { Flag } from '../node';
 import { union, inits, tails, some, recursion, precedence, constraint, backtrack, surround, open, setBacktrack, dup, lazy, fmap, bind } from '../../combinator';
 import { uri, option as linkoption, resolve, decode, parse } from './link';
 import { attributes } from './html';
@@ -33,7 +32,7 @@ export const media: MediaParser = lazy(() => constraint(State.media, backtrack(o
       true,
       [3 | Backtrack.escapable, 2 | Backtrack.ruby],
       ([, ns = new List()], input, output) => {
-        if (input.linebreak !== 0 || ns.head?.flags! & Flag.blank || ns.head?.value?.[0].trimStart() === '') {
+        if (input.linebreak !== 0 || ns.head?.flags! & Node.Flag.blank || ns.head?.value?.[0].trimStart() === '') {
           const head = input.position - input.range;
           return void setBacktrack(input, 2 | Backtrack.escapable | Backtrack.ruby, head);
         }
@@ -51,7 +50,7 @@ export const media: MediaParser = lazy(() => constraint(State.media, backtrack(o
   nodes =>
     nodes.length === 1
       ? new List<Node<List<Node<string>>>>([new Node(new List([new Node('')])), nodes.delete(nodes.head!)])
-      : new List<Node<List<Node<string>>>>([new Node(new List([new Node(nodes.head!.value.foldl((acc, { value }) => acc + value, '').trimEnd(), nodes.head!.value.head?.flags)])), nodes.delete(nodes.last!)])),
+      : new List<Node<List<Node<string>>>>([new Node(new List([new Node(nodes.head!.value.foldl((acc, { value }) => acc + value, '').trimEnd(), nodes.head!.position, nodes.head!.value.head?.flags)])), nodes.delete(nodes.last!)])),
   ([{ value: [{ value: text }] }, { value: params }], input) => {
     assert(text === text.trim());
     if (params.last!.value === Command.Cancel) {

package/src/parser/inline/reference.ts

@@ -26,9 +26,9 @@ export const reference: ReferenceParser = lazy(() => constraint(State.reference,
       setBacktrack(input, 2 | Backtrack.link, head, 2);
       return;
     }
-    return output.import(new List([
-      new Node(html('sup', attributes(ns), [html('span', defrag(unwrap(trimBlankNodeEnd(ns))))]))
-    ]));
+    const el = html('sup', attributes(ns), [html('span', defrag(unwrap(trimBlankNodeEnd(ns))))]);
+    output.references.at(-1)!.push(new Node(el));
+    return output.import(new List([new Node(el)]));
   },
   (_, input) => {
     const { source, position, range, linebreak } = input;

package/src/parser/inline.ts

@@ -1,4 +1,4 @@
-import { MarkdownParser } from '../../markdown';
+import { DocumentParser } from '../../markdown';
 import { union, lazy } from '../combinator';
 import { annotation } from './inline/annotation';
 import { reference } from './inline/reference';
@@ -23,7 +23,7 @@ import { bracket } from './inline/bracket';
 import { autolink } from './inline/autolink';
 import { text, strs } from './source';
 
-export import InlineParser = MarkdownParser.InlineParser;
+export import InlineParser = DocumentParser.InlineParser;
 export import AnnotationParser = InlineParser.AnnotationParser;
 export import ReferenceParser = InlineParser.ReferenceParser;
 export import TemplateParser = InlineParser.TemplateParser;

package/src/parser/node.ts

@@ -1,10 +1,5 @@
 import { invisibleBlankHTMLEntityNames } from '../api/normalize';
 
-export const enum Flag {
-  none,
-  blank,
-}
-
 export const isBlankHTMLEntityName: (name: string) => boolean = eval([
   'name => {',
   'switch(name){',

package/src/parser/segment.ts

@@ -1,4 +1,4 @@
-import { MarkdownParser } from '../../markdown';
+import { DocumentParser } from '../../markdown';
 import { Input, Segment } from './context';
 import { Output, List, Node, run } from '../combinator/parser';
 import { union, some } from '../combinator';
@@ -8,7 +8,7 @@ import { segment as mathblock } from './block/mathblock';
 import { segment as extension } from './block/extension';
 import { contentline, emptysegment } from './source';
 
-import SegmentParser = MarkdownParser.SegmentParser;
+import SegmentParser = DocumentParser.SegmentParser;
 
 export const parser: SegmentParser = union([
   some(emptysegment),

package/src/parser/source/escapable.ts

@@ -2,7 +2,6 @@ import { EscapableSourceParser } from '../source';
 import { Result, Node } from '../../combinator/parser';
 import { spend } from '../../combinator';
 import { Command } from '../context';
-import { Flag } from '../node';
 import { html } from 'typed-dom/dom';
 
 export const escsource: EscapableSourceParser = (input, output) => {
@@ -15,23 +14,23 @@ export const escsource: EscapableSourceParser = (input, output) => {
     case Command.Escape:
       spend(input, output, 1);
       input.position += 1;
-      return output.append(new Node(source.slice(position + 1, position + 2)));
+      return output.append(new Node(source.slice(position + 1, position + 2), position));
     case '\\':
       switch (source[position + 1]) {
         case undefined:
         case '\r':
         case '\n':
-          return output.append(new Node(char));
+          return output.append(new Node(char, position));
         default:
           spend(input, output, 1);
           input.position += 1;
-          return output.append(new Node(source.slice(position, position + 2)));
+          return output.append(new Node(source.slice(position, position + 2), position));
       }
     case '\r':
       return Result.succ;
     case '\n':
       input.linebreak ||= source.length - position;
-      return output.append(new Node(html('br'), Flag.blank));
+      return output.append(new Node(html('br'), position, Node.Flag.blank));
     default:
       assert(char !== '\n');
       let i = seek(source, position);
@@ -39,7 +38,7 @@ export const escsource: EscapableSourceParser = (input, output) => {
       i -= position;
       spend(input, output, i - 1);
       input.position += i - 1;
-      return output.append(new Node(source.slice(position, input.position)));
+      return output.append(new Node(source.slice(position, input.position), position));
   }
 };
 

package/src/parser/source/str.ts

@@ -6,9 +6,10 @@ export function str(pattern: string | RegExp, after?: string | RegExp): StrParse
 export function str(pattern: string | RegExp, after?: string | RegExp): Parser<string> {
   const match = matcher(pattern, true, after ? tester(after, false) : undefined);
   return (input, output) => {
+    const { position } = input;
     const src = match(input, output);
     if (src === undefined) return;
-    return output.append(new Node(src));
+    return output.append(new Node(src, position));
   };
 }
 
@@ -25,6 +26,6 @@ export function strs(char: string, min: number = 1, max: number = -1): Parser<st
     }
     if (cnt < min) return;
     input.position = pos;
-    return output.append(new Node(source.slice(position, input.position)));
+    return output.append(new Node(source.slice(position, input.position), position));
   };
 }

package/src/parser/source/text.ts

@@ -2,7 +2,6 @@ import { TextParser, TxtParser } from '../source';
 import { Result, Node } from '../../combinator/parser';
 import { union, spend } from '../../combinator';
 import { State, Command } from '../context';
-import { Flag } from '../node';
 import { isWhitespace } from './whitespace';
 import { html } from 'typed-dom/dom';
 
@@ -27,13 +26,13 @@ export const text: TextParser = (input, output) => {
         default:
           spend(input, output, 1);
           input.position += 1;
-          return output.append(new Node(source.slice(position + 1, input.position)));
+          return output.append(new Node(source.slice(position + 1, input.position), position));
       }
     case '\r':
       return Result.succ;
     case '\n':
       input.linebreak ||= source.length - position;
-      return output.append(new Node(html('br'), Flag.blank));
+      return output.append(new Node(html('br'), position, Node.Flag.blank));
     default:
       assert(char !== '\n');
       nonWhitespace.lastIndex = position + 1;
@@ -54,7 +53,7 @@ export const text: TextParser = (input, output) => {
       input.position += i - 1;
       const linestart = position === 0 || source[position - 1] === '\n';
       if (position === input.position || s && !linestart || lineend) return Result.succ;
-      return output.append(new Node(source.slice(position, input.position)));
+      return output.append(new Node(source.slice(position, input.position), position));
   }
 };
 

package/src/parser/source/unescapable.ts

@@ -2,7 +2,6 @@ import { UnescapableSourceParser } from '../source';
 import { Result, Node } from '../../combinator/parser';
 import { spend } from '../../combinator';
 import { State, Command } from '../context';
-import { Flag } from '../node';
 import { nonWhitespace, canSkip, backToUrlHead, backToEmailHead } from './text';
 import { html } from 'typed-dom/dom';
 
@@ -16,12 +15,12 @@ export const unescsource: UnescapableSourceParser = (input, output) => {
     case Command.Escape:
       spend(input, output, 1);
       input.position += 1;
-      return output.append(new Node(source.slice(position + 1, position + 2)));
+      return output.append(new Node(source.slice(position + 1, position + 2), position));
     case '\r':
       return Result.succ;
     case '\n':
       input.linebreak ||= source.length - position;
-      return output.append(new Node(html('br'), Flag.blank));
+      return output.append(new Node(html('br'), position, Node.Flag.blank));
     default:
       assert(char !== '\n');
       nonWhitespace.lastIndex = position + 1;
@@ -34,7 +33,7 @@ export const unescsource: UnescapableSourceParser = (input, output) => {
       i -= position;
       spend(input, output, i - 1);
       input.position += i - 1;
-      return output.append(new Node(source.slice(position, input.position)));
+      return output.append(new Node(source.slice(position, input.position), position));
   }
 };
 

package/src/parser/source.ts

@@ -1,6 +1,6 @@
-import { MarkdownParser } from '../../markdown';
+import { DocumentParser } from '../../markdown';
 
-import SourceParser = MarkdownParser.SourceParser;
+import SourceParser = DocumentParser.SourceParser;
 export import TextParser = SourceParser.TextParser;
 export import TxtParser = SourceParser.TxtParser;
 export import EscapableSourceParser = SourceParser.EscapableSourceParser;

package/src/parser/util.ts

@@ -64,3 +64,12 @@ export function stringify(nodes: Iterable<HTMLElement | string>): string {
 export function randomID(): string {
   return `random-${rnd0Z(6)}`;
 }
+
+export function collect(target: ParentNode, selector:string): HTMLElement[] {
+  const acc = [];
+  for (let el = target.firstElementChild; el; el = el?.nextElementSibling) {
+    if (!el.matches(selector)) continue;
+    acc.push(el as HTMLElement);
+  }
+  return acc;
+}

package/src/parser/visibility.ts

@@ -1,6 +1,5 @@
 import { Parser, List, Node } from '../combinator/parser';
 import { Input, Command } from './context';
-import { Flag } from './node';
 import { always, fmap } from '../combinator';
 import { invisibleBlankHTMLEntityNames } from '../api/normalize';
 import { isWhitespace } from './source';
@@ -81,7 +80,7 @@ export function isNonblankFirstLine(nodes: List<Node<HTMLElement | string>>): bo
   if (nodes.length === 0) return true;
   for (const node of nodes) {
     if (isNonblank(node)) return true;
-    if (node.flags & Flag.blank && typeof node.value === 'object' && node.value.tagName === 'BR') break;
+    if (node.flags & Node.Flag.blank && typeof node.value === 'object' && node.value.tagName === 'BR') break;
   }
   return false;
 }
@@ -90,7 +89,7 @@ export function isNonblankNodeStart(nodes: List<Node<HTMLElement | string>>): bo
   return isNonblank(nodes.head!, 0);
 }
 function isNonblank({ value: node, flags }: Node<HTMLElement | string>, strpos?: number): boolean {
-  if (flags & Flag.blank) return false;
+  if (flags & Node.Flag.blank) return false;
   if (typeof node !== 'string') return true;
   const str = node && strpos !== undefined
     ? node[strpos >= 0 ? strpos : node.length + strpos]
@@ -131,11 +130,11 @@ export function trimBlankEnd<N extends HTMLElement>(parser: Parser<N>): Parser<s
   return fmap(parser, trimBlankNodeEnd);
 }
 export function trimBlankNodeEnd<N extends HTMLElement>(nodes: List<Node<string | N>>): List<Node<string | N>> {
-  const skip = nodes.last && ~nodes.last.flags & Flag.blank && typeof nodes.last.value === 'object'
+  const skip = nodes.last && ~nodes.last.flags & Node.Flag.blank && typeof nodes.last.value === 'object'
     ? nodes.last.value.className === 'indexer'
     : false;
   for (let node = skip ? nodes.last?.prev : nodes.last; node;) {
-    if (~node.flags & Flag.blank) {
+    if (~node.flags & Node.Flag.blank) {
       if (typeof node.value === 'string') {
         const str = node.value.trimEnd();
         if (str.length > 0) {