securemark 0.298.1 → 0.298.3

package/src/parser/inline/annotation.ts

@@ -3,7 +3,7 @@ import { State, Recursion } from '../context';
 import { List, Node } from '../../combinator/data/parser';
 import { union, some, recursions, precedence, constraint, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
-import { indexA } from './bracket';
+import { bracketname, indexA } from './bracket';
 import { beforeNonblank, trimBlankNodeEnd } from '../visibility';
 import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
@@ -34,14 +34,20 @@ export const annotation: AnnotationParser = lazy(() => constraint(State.annotati
     if (linebreak !== 0) {
       ns.unshift(new Node('('));
       ns.push(new Node(')'));
-      return new List([new Node(html('span', { class: 'bracket' }, ['(', html('span', { class: 'bracket' }, defrag(unwrap(ns))), ')']))]);
+      return new List([
+        new Node(html('span',
+          { class: 'bracket' },
+          ['(', html('span', { class: 'bracket' }, defrag(unwrap(ns))), ')']))
+      ]);
     }
     const depth = MAX_DEPTH - (resources?.recursions[Recursion.annotation] ?? resources?.recursions.at(-1) ?? MAX_DEPTH);
     recursion.add(depth);
-    return new List([new Node(html('sup', { class: 'annotation' }, [html('span', defrag(unwrap(trimBlankNodeEnd(ns))))]))]);
+    return new List([
+      new Node(html('sup', { class: 'annotation' }, [html('span', defrag(unwrap(trimBlankNodeEnd(ns))))]))
+    ]);
   },
   ([, bs], context) => {
-    const { source, position, range, linebreak, recursion, resources } = context;
+    const { source, position, linebreak, recursion, resources } = context;
     const depth = MAX_DEPTH - (resources?.recursions[Recursion.annotation] ?? resources?.recursions.at(-1) ?? MAX_DEPTH);
     if (linebreak === 0 && bs && bs.length === 1 && source[position] === ')' && typeof bs.head?.value === 'object') {
       const { className } = bs.head.value;
@@ -63,12 +69,20 @@ export const annotation: AnnotationParser = lazy(() => constraint(State.annotati
         }
         context.position += 1;
         recursion.add(depth);
-        return new List([new Node(html('span', { class: 'bracket' }, ['(', html('sup', { class: 'annotation' }, [html('span', bs.head.value.childNodes)])]))]);
+        return new List([
+          new Node(html('span',
+            { class: 'bracket' },
+            ['(', html('sup', { class: 'annotation' }, [html('span', bs.head.value.childNodes)])]))
+        ]);
       }
       if (className === 'annotation' && deepunwrap(bs)) {
         context.position += 1;
         recursion.add(depth);
-        return new List([new Node(html('span', { class: 'bracket' }, ['(', html('sup', { class: 'annotation' }, [html('span', [bs.head.value])])]))]);
+        return new List([
+          new Node(html('span',
+            { class: 'bracket' },
+            ['(', html('sup', { class: 'annotation' }, [html('span', [bs.head.value])])]))
+        ]);
       }
     }
     bs ??= new List();
@@ -76,11 +90,13 @@ export const annotation: AnnotationParser = lazy(() => constraint(State.annotati
     if (source[context.position] === ')') {
       bs.push(new Node(')'));
       context.position += 1;
+      context.range += 1;
     }
-    const str = linebreak === 0 ? source.slice(position - range + 2, position) : '';
-    bs = linebreak === 0 && (str === '' || indexA.test(str))
-      ? new List([new Node(html('span', { class: 'paren' }, defrag(unwrap(bs))))])
-      : new List([new Node(html('span', { class: 'bracket' }, defrag(unwrap(bs))))]);
+    bs = new List([
+      new Node(html('span',
+        { class: bracketname(context, indexA, 2, context.position - position) },
+        defrag(unwrap(bs))))
+    ]);
     bs.unshift(new Node('('));
     const cs = parser(context);
     if (source[context.position] === ')') {

package/src/parser/inline/autolink.ts

@@ -14,8 +14,8 @@ export const autolink: AutolinkParser = lazy(() =>
   input => {
     const { source, position } = input;
     if (position === source.length) return;
-    const fst = source[position];
-    switch (fst) {
+    const char = source[position];
+    switch (char) {
       case '@':
         return account(input);
       case '#':
@@ -41,6 +41,6 @@ export const autolink: AutolinkParser = lazy(() =>
         }
         return url(input) || email(input);
       default:
-        if (isAlphanumeric(fst)) return email(input);
+        if (isAlphanumeric(char)) return email(input);
     }
   }));

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

@@ -20,9 +20,10 @@ describe('Unit: parser/inline/bracket', () => {
       assert.deepStrictEqual(inspect(parser, input('(0)-1', new Context())), [['<span class="paren">(0)</span>'], '-1']);
       assert.deepStrictEqual(inspect(parser, input('(0.1)', new Context())), [['<span class="paren">(0.1)</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('(0.1.2)', new Context())), [['<span class="paren">(0.1.2)</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('(1.1, 1.2-1.3, 1.4)', new Context())), [['<span class="paren">(1.1, 1.2-1.3, 1.4)</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('(1 2)', new Context())), [['<span class="bracket">(1 2)</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('(1, 2)', new Context())), [['<span class="paren">(1, 2)</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(1.1-1.2)', new Context())), [['<span class="paren">(1.1-1.2)</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(1.1, 1.2)', new Context())), [['<span class="paren">(1.1, 1.2)</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(1 2)', new Context())), [['<span class="bracket">(1 2)</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('(1a)', new Context())), [['<span class="paren">(1a)</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('(a)', new Context())), [['<span class="paren">(a)</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('(a1)', new Context())), [['<span class="paren">(a1)</span>'], '']);
@@ -39,6 +40,8 @@ describe('Unit: parser/inline/bracket', () => {
       assert.deepStrictEqual(inspect(parser, input('(Name, Name)', new Context())), [['<span class="paren">(Name, Name)</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('(ABBR)', new Context())), [['<span class="paren">(ABBR)</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('(ABBR, ABBR)', new Context())), [['<span class="paren">(ABBR, ABBR)</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input(`(${'0'.repeat(16)})`, new Context())), [[`<span class="paren">(${'0'.repeat(16)})</span>`], '']);
+      assert.deepStrictEqual(inspect(parser, input(`(${'0'.repeat(17)})`, new Context())), [[`<span class="bracket">(${'0'.repeat(17)})</span>`], '']);
       assert.deepStrictEqual(inspect(parser, input('(\\a)', new Context())), [['<span class="bracket">(a)</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('(==)', new Context())), [['<span class="bracket">(==)</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('(()', new Context())), [['<span class="bracket">(<span class="paren">()</span></span>'], '']);

package/src/parser/inline/bracket.ts

@@ -1,5 +1,5 @@
 import { BracketParser } from '../inline';
-import { State, Recursion, Backtrack } from '../context';
+import { Context, State, Recursion, Backtrack } from '../context';
 import { List, Node } from '../../combinator/data/parser';
 import { union, some, recursion, precedence, surround, isBacktrack, setBacktrack, lazy } from '../../combinator';
 import { inline } from '../inline';
@@ -9,8 +9,20 @@ import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const indexA = /^[0-9A-Za-z]+(?:(?:[.-]|, )[0-9A-Za-z]+)*$/;
-const indexF = new RegExp(indexA.source.replace(', ', '[，、]')
-  .replace(/[09AZaz.]|\-(?!\w)/g, c => String.fromCodePoint(c.codePointAt(0)! + 0xFEE0)));
+const indexF = new RegExp(
+  indexA.source.replace(', ', '[，、]')
+    .replace(/[09AZaz.]|\-(?!\w)/g, c => String.fromCodePoint(c.codePointAt(0)! + 0xFEE0)),
+  '');
+export function bracketname(context: Context, syntax: RegExp, opener: number, closer: number): string {
+  const { source, position, range, linebreak } = context;
+  syntax.lastIndex = position - range + opener;
+  return range - opener - closer === 0
+      || linebreak === 0 &&
+         range - opener - closer <= 16 &&
+         syntax.test(source.slice(position - range + opener, position - closer))
+    ? 'paren'
+    : 'bracket';
+}
 
 export const bracket: BracketParser = lazy(() => union([
   input => {
@@ -32,45 +44,39 @@ export const bracket: BracketParser = lazy(() => union([
         return d1(input);
     }
   }
-])) as any;
+]));
 
 const p1 = lazy(() => surround(
   str('('),
   precedence(1, recursion(Recursion.bracket, some(inline, ')', [[')', 1]]))),
   str(')'),
   true, [],
-  ([as, bs = [], cs], { source, position, range, linebreak }) => {
-    const str = linebreak === 0 ? source.slice(position - range + 1, position - 1) : '';
-    return linebreak === 0 && (str === '' || indexA.test(str))
-      ? new List([new Node(html('span', { class: 'paren' }, `(${str})`))])
-      : new List([new Node(html('span', { class: 'bracket' }, defrag(unwrap(as.import(bs as List<Node<string>>).import(cs)))))]);
-  },
-  ([as, bs = new List()], context) => {
-    const { source, position, range, linebreak } = context;
-    const str = linebreak === 0 ? source.slice(position - range + 1, position) : '';
-    return linebreak === 0 && (str === '' || indexA.test(str))
-      ? new List([new Node(html('span', { class: 'paren' }, `(${str}`))])
-      : new List([new Node(html('span', { class: 'bracket' }, defrag(unwrap(as.import(bs as List<Node<string>>)))))]);
-  }));
+  ([as, bs = new List(), cs], context) => new List([
+    new Node(html('span',
+      { class: bracketname(context, indexA, 1, 1) },
+      defrag(unwrap(as.import(bs as List<Node<string>>).import(cs)))))
+  ]),
+  ([as, bs = new List()], context) => new List([
+    new Node(html('span',
+      { class: bracketname(context, indexA, 1, 0) },
+      defrag(unwrap(as.import(bs as List<Node<string>>)))))
+  ])));
 
 const p2 = lazy(() => surround(
   str('（'),
   precedence(1, recursion(Recursion.bracket, some(inline, '）', [['）', 1]]))),
   str('）'),
   true, [],
-  ([as, bs = [], cs], { source, position, range, linebreak }) => {
-    const str = linebreak === 0 ? source.slice(position - range + 1, position - 1) : '';
-    return linebreak === 0 && (str === '' || indexF.test(str))
-      ? new List([new Node(html('span', { class: 'paren' }, `（${str}）`))])
-      : new List([new Node(html('span', { class: 'bracket' }, defrag(unwrap(as.import(bs as List<Node<string>>).import(cs)))))]);
-  },
-  ([as, bs = new List()], context) => {
-    const { source, position, range, linebreak } = context;
-    const str = linebreak === 0 ? source.slice(position - range + 1, position) : '';
-    return linebreak === 0 && (str === '' || indexF.test(str))
-      ? new List([new Node(html('span', { class: 'paren' }, `（${str}`))])
-      : new List([new Node(html('span', { class: 'bracket' }, defrag(unwrap(as.import(bs as List<Node<string>>)))))]);
-  }));
+  ([as, bs = new List(), cs], context) => new List([
+    new Node(html('span',
+      { class: bracketname(context, indexF, 1, 1) },
+      defrag(unwrap(as.import(bs as List<Node<string>>).import(cs)))))
+  ]),
+  ([as, bs = new List()], context) => new List([
+    new Node(html('span',
+      { class: bracketname(context, indexF, 1, 0) },
+      defrag(unwrap(as.import(bs as List<Node<string>>)))))
+  ])));
 
 const s1 = lazy(() => surround(
   str('['),

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

@@ -1,4 +1,4 @@
-import { html } from './html';
+import { html, TAGS } from './html';
 import { some } from '../../combinator';
 import { input } from '../../combinator/data/parser';
 import { Context } from '../context';
@@ -8,6 +8,10 @@ describe('Unit: parser/inline/html', () => {
   describe('html', () => {
     const parser = some(html);
 
+    it('hash', () => {
+      assert(TAGS.every(tag => parser(input(`<${tag}>`, new Context()))));
+    });
+
     it('xss', () => {
       assert.deepStrictEqual(inspect(parser, input('<script>', new Context())), [['<span class="invalid">&lt;script&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('<script>alert()<script>', new Context())), [['<span class="invalid">&lt;script&gt;alert()&lt;script&gt;</span>'], '']);

package/src/parser/inline/html.ts

@@ -2,7 +2,7 @@ import { HTMLParser } from '../inline';
 import { Recursion } from '../context';
 import { List, Node, Context } from '../../combinator/data/parser';
 import { Flag } from '../node';
-import { union, some, recursion, precedence, validate, surround, open, match, lazy } from '../../combinator';
+import { union, some, recursion, precedence, surround, open, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
 import { isNonblankFirstLine, blankWith } from '../visibility';
@@ -20,58 +20,57 @@ const attrspecs = {
 Object.setPrototypeOf(attrspecs, null);
 Object.values(attrspecs).forEach(o => Object.setPrototypeOf(o, null));
 
-export const html: HTMLParser = lazy(() => validate(/<[a-z]+(?=[ >])/yi,
-  union([
-    surround(
-      // https://html.spec.whatwg.org/multipage/syntax.html#void-elements
-      str(/<(?:area|base|br|col|embed|hr|img|input|link|meta|source|track|wbr)(?=[ >])/y),
-      precedence(9, some(union([attribute]))),
-      open(str(/ ?/y), str('>'), true),
-      true, [],
-      ([as, bs = new List(), cs], context) =>
-        new List([new Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs).import(cs))], new List(), new List(), context), as.head!.value === '<wbr' ? Flag.blank : Flag.none)]),
-      ([as, bs = new List()], context) =>
-        new List([new Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs))], new List(), new List(), context))])),
-    match(
-      new RegExp(String.raw`<(${TAGS.join('|')})(?=[ >])`, 'y'),
-      memoize(
-      ([, tag]) =>
-        surround<HTMLParser.TagParser, string>(
-          surround(
-            str(`<${tag}`),
-            precedence(9, some(attribute)),
-            open(str(/ ?/y), str('>'), true),
-            true, [],
-            ([as, bs = new List(), cs]) => as.import(bs).import(cs),
-            ([as, bs = new List()]) => as.import(bs)),
-          // 不可視のHTML構造が可視構造を変化させるべきでない。
-          // 可視のHTMLは優先度変更を検討する。
-          // このため`<>`記号は将来的に共通構造を変化させる可能性があり
-          // 共通構造を変化させない非構造文字列としては依然としてエスケープを要する。
-          precedence(0, recursion(Recursion.inline,
-          some(union([
-            some(inline, blankWith('\n', `</${tag}>`)),
-            open('\n', some(inline, `</${tag}>`), true),
-          ])))),
-          str(`</${tag}>`),
+export const html: HTMLParser = lazy(() => union([
+  surround(
+    // https://html.spec.whatwg.org/multipage/syntax.html#void-elements
+    str(/<(?:area|base|br|col|embed|hr|img|input|link|meta|source|track|wbr)(?=[ >])/y),
+    precedence(9, some(union([attribute]))),
+    open(str(/ ?/y), str('>'), true),
+    true, [],
+    ([as, bs = new List(), cs], context) =>
+      new List([new Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs).import(cs))], new List(), new List(), context), as.head!.value === '<wbr' ? Flag.blank : Flag.none)]),
+    ([as, bs = new List()], context) =>
+      new List([new Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs))], new List(), new List(), context))])),
+  match(
+    new RegExp(String.raw`<(${TAGS.join('|')})(?=[ >])`, 'y'),
+    memoize(
+    ([, tag]) =>
+      surround<HTMLParser.TagParser, string>(
+        surround(
+          str(`<${tag}`),
+          precedence(9, some(attribute)),
+          open(str(/ ?/y), str('>'), true),
           true, [],
-          ([as, bs = new List(), cs], context) =>
-            new List([new Node(elem(tag, true, [...unwrap(as)], bs, cs, context))]),
-          ([as, bs = new List()], context) =>
-            new List([new Node(elem(tag, true, [...unwrap(as)], bs, new List(), context))])),
-      ([, tag]) => tag,
-      new Map())),
-    surround(
-      // https://html.spec.whatwg.org/multipage/syntax.html#void-elements
-      str(/<[a-z]+(?=[ >])/yi),
-      precedence(9, some(union([attribute]))),
-      open(str(/ ?/y), str('>'), true),
-      true, [],
-      ([as, bs = new List(), cs], context) =>
-        new List([new Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs).import(cs))], new List(), new List(), context))]),
-      ([as, bs = new List()], context) =>
-        new List([new Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs))], new List(), new List(), context))])),
-  ])));
+          ([as, bs = new List(), cs]) => as.import(bs).import(cs),
+          ([as, bs = new List()]) => as.import(bs)),
+        // 不可視のHTML構造が可視構造を変化させるべきでない。
+        // 可視のHTMLは優先度変更を検討する。
+        // このため`<>`記号は将来的に共通構造を変化させる可能性があり
+        // 共通構造を変化させない非構造文字列としては依然としてエスケープを要する。
+        precedence(0, recursion(Recursion.inline,
+        some(union([
+          some(inline, blankWith('\n', `</${tag}>`)),
+          open('\n', some(inline, `</${tag}>`), true),
+        ])))),
+        str(`</${tag}>`),
+        true, [],
+        ([as, bs = new List(), cs], context) =>
+          new List([new Node(elem(tag, true, [...unwrap(as)], bs, cs, context))]),
+        ([as, bs = new List()], context) =>
+          new List([new Node(elem(tag, true, [...unwrap(as)], bs, new List(), context))])),
+    ([, tag]) => tag2index(tag),
+    Array(TAGS.length))),
+  surround(
+    // https://html.spec.whatwg.org/multipage/syntax.html#void-elements
+    str(/<[a-z]+(?=[ >])/yi),
+    precedence(9, some(union([attribute]))),
+    open(str(/ ?/y), str('>'), true),
+    true, [],
+    ([as, bs = new List(), cs], context) =>
+      new List([new Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs).import(cs))], new List(), new List(), context))]),
+    ([as, bs = new List()], context) =>
+      new List([new Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs))], new List(), new List(), context))])),
+]));
 
 export const attribute: HTMLParser.AttributeParser = union([
   str(/ [a-z]+(?:-[a-z]+)*(?:="(?:\\[^\n]|[^\\\n"])*")?(?=[ >])/yi),
@@ -146,7 +145,7 @@ export function attributes(
 
 // https://developer.mozilla.org/en-US/docs/Web/HTML/Element
 // [...document.querySelectorAll('tbody > tr > td:first-child')].map(el => el.textContent.slice(1, -1))
-const TAGS: readonly string[] = [
+export const TAGS: readonly string[] = [
   "html",
   "base",
   "head",
@@ -284,3 +283,12 @@ const TAGS: readonly string[] = [
   "tt",
   "xmp",
 ];
+
+const tag2index: (tag: string) => number = eval([
+  'tag => {',
+  'switch(tag){',
+  TAGS.map((tag, i) => `case '${tag}':return ${i};`).join(''),
+  'default: throw new Error();',
+  '}',
+  '}',
+].join(''));

package/src/parser/inline.ts

@@ -92,7 +92,8 @@ export const inline: InlineParser = lazy(() => union([
       case '｛':
         return bracket(input);
       case '<':
-        return html(input);
+        if (isAlphabet(source[position + 1])) return html(input);
+        break;
       case '$':
         if (source[position + 1] === '{') return math(input);
         return label(input)
@@ -123,7 +124,7 @@ export const inline: InlineParser = lazy(() => union([
   },
   autolink,
   text
-])) as any;
+]));
 
 export { indexee } from './inline/extension/indexee';
 export { indexer } from './inline/extension/indexer';
@@ -131,3 +132,8 @@ export { dataindex } from './inline/extension/index';
 export { medialink } from './inline/link';
 export { media } from './inline/media';
 export { shortmedia, lineshortmedia } from './inline/shortmedia';
+
+function isAlphabet(char: string): boolean {
+  assert(char.length === 1);
+  return 'a' <= char && char <= 'z';
+}

package/src/parser/processor/figure.ts

@@ -13,22 +13,24 @@ export function* figure(
     readonly local?: boolean;
   } = {},
 ): 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 labels = new Set<string>();
   const numbers = new Map<string, string>();
-  const scope = target instanceof Element ? ':scope > ' : '';
   let base = '0';
   let bases: readonly string[] = base.split('.');
   let index: readonly string[] = bases;
   for (
-    let defs = target.querySelectorAll(`${scope}:is(figure[data-label], h1, h2)`),
+    let defs = target instanceof Element
+          ? target.querySelectorAll(`:scope > ${selector}`)
+          : target.querySelectorAll(`${selector}:not(* > *)`),
         len = defs.length, i = 0; i < len; ++i) {
     yield;
     const def = defs[i];
-    if (!scope && def.parentNode !== target) continue;
+    assert(def.parentNode === target || !def.parentNode);
     const { tagName } = def;
     if (bases.length === 1 && tagName[0] === 'H') continue;
     assert(base === '0' || bases.length > 1);

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

@@ -116,11 +116,11 @@ describe('Unit: parser/processor/note', () => {
     });
 
     it('separation', () => {
-      const target = html('blockquote', parse([
+      const target = parse([
         '!>> ((1))\n> ((2))\n~~~',
         '~~~~example/markdown\n((3))\n~~~~',
         '((4))',
-      ].join('\n\n')).children);
+      ].join('\n\n'));
       for (let i = 0; i < 3; ++i) {
         [...note(target)];
         assert.deepStrictEqual(

package/src/parser/processor/note.ts

@@ -50,19 +50,19 @@ const referenceRefsMemoryCaller = memoize((target: Node) =>
 const annotation = build(
   'annotation',
   'annotations',
-  '.annotation:not(:is(.annotations, .references) .annotation, .local)',
+  '.annotation:not(:is(.annotations, .references) &, .local)',
   n => `*${n}`,
   'h1, h2, h3, h4, h5, h6, aside.aside, hr');
 const reference = build(
   'reference',
   'references',
-  '.reference:not(:is(.annotations, .references) .reference, .local)',
+  '.reference:not(:is(.annotations, .references) &, .local)',
   (n, abbr) => `[${abbr || n}]`);
 
 function build(
   syntax: string,
   list: string,
-  query: string,
+  selector: string,
   marker: (index: number, abbr: string) => string,
   splitter: string = '',
 ) {
@@ -101,7 +101,7 @@ function build(
       };
     }, memory);
     const defs = new Map<string, HTMLLIElement>();
-    const refs = target.querySelectorAll<HTMLElement>(query);
+    const refs = target.querySelectorAll<HTMLElement>(selector);
     const identifierInfoCaller = memoize((identifier: string) => ({
       defIndex: 0,
       defSubindex: 0,
@@ -109,8 +109,11 @@ function build(
       title: '' && identifier,
       queue: [] as HTMLElement[],
     }));
-    const scope = target instanceof Element ? ':scope > ' : '';
-    const splitters = splitter ? target.querySelectorAll(`${scope}:is(${splitter})`) : [];
+    const splitters = splitter
+      ? target instanceof Element
+        ? target.querySelectorAll(`:scope > :is(${splitter}, .${list})`)
+        : target.querySelectorAll(`:is(${splitter}, .${list}):not(* > *)`)
+      : [];
     let iSplitters = 0;
     let total = 0;
     let format: 'number' | 'abbr';
@@ -118,11 +121,12 @@ function build(
     for (let len = refs.length, i = 0; i < len; ++i) {
       const ref = refs[i];
       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 (~iSplitters << 32 - 8 === 0) yield;
-        if (splitter.classList.contains(list) && defs.size === 0) {
-          assert(splitter.matches(`.${list}`));
+        if (splitter.classList.contains(list) && splitter.nextElementSibling !== splitters[iSplitters + 1]) {
+          yield* proc(splitter as HTMLOListElement);
           splitter.remove();
           continue;
         }
@@ -133,7 +137,7 @@ function build(
             ? splitter as HTMLOListElement
             : target.insertBefore(html('ol', { class: list }), splitter);
           assert(note.parentNode);
-          yield* proc(defs, note);
+          yield* proc(note, defs);
           assert(defs.size === 0);
         }
       }
@@ -209,25 +213,27 @@ function build(
     }
     if (note || defs.size > 0) {
       const splitter = splitters[iSplitters++];
-      yield* proc(defs, note ?? (splitter?.classList.contains(list)
+      note ??= splitter?.classList.contains(list)
         ? splitter as HTMLOListElement
-        : target.insertBefore(html('ol', { class: list }), splitter ?? bottom)));
+        : target.insertBefore(html('ol', { class: list }), splitter ?? bottom);
+      yield* proc(note, defs);
       assert(defs.size === 0);
     }
     if (splitter) for (let splitter; splitter = splitters[iSplitters]; ++iSplitters) {
       if (~iSplitters << 32 - 8 === 0) yield;
       if (splitter.classList.contains(list)) {
+        yield* proc(splitter as HTMLOListElement);
         splitter.remove();
       }
     }
-  }
+  };
 }
 
-function* proc(defs: Map<string, HTMLLIElement>, note: HTMLOListElement): Generator<HTMLLIElement | undefined, undefined, undefined> {
-  const { children } = note;
+function* proc(note: HTMLOListElement, defs?: Map<string, HTMLLIElement>): Generator<HTMLLIElement | undefined, undefined, undefined> {
   for (let defs = note.children, i = defs.length; i--;) {
-    yield note.removeChild(children[i] as HTMLLIElement);
+    yield note.removeChild(defs[i] as HTMLLIElement);
   }
+  if (!defs) return;
   for (const [, def] of defs) {
     yield note.appendChild(def);
   }

package/src/parser/segment.ts

@@ -6,6 +6,7 @@ import { segment as codeblock } from './block/codeblock';
 import { segment as mathblock } from './block/mathblock';
 import { segment as extension } from './block/extension';
 import { contentline, emptysegment } from './source';
+import { normalize } from './api';
 
 import SegmentParser = MarkdownParser.SegmentParser;
 
@@ -35,10 +36,10 @@ const parser: SegmentParser = union([
     }
   },
   some(contentline, MAX_SEGMENT_SIZE + 1),
-]) as any;
+]);
 
-export function* segment(source: string): Generator<readonly [string, Segment], undefined, undefined> {
-  if (!validate(source, MAX_INPUT_SIZE)) return yield [`${Command.Error}Too large input over ${MAX_INPUT_SIZE.toLocaleString('en')} bytes.\n${source.slice(0, 1001)}`, Segment.unknown];
+export function* segment(source: string, initial = true): Generator<readonly [string, Segment], undefined, undefined> {
+  if (initial && !validate(source, MAX_INPUT_SIZE)) return yield [`${Command.Error}Too large input over ${MAX_INPUT_SIZE.toLocaleString('en')} bytes.\n${source.slice(0, 1001)}`, Segment.unknown];
   assert(source.length < Number.MAX_SAFE_INTEGER);
   for (let position = 0; position < source.length;) {
     const context = new Context({ source, position });
@@ -52,14 +53,14 @@ export function* segment(source: string): Generator<readonly [string, Segment],
     position = context.position;
     for (let i = 0; i < segs.length; ++i) {
       const seg = segs[i];
-      validate(seg, MAX_SEGMENT_SIZE)
-        ? yield [seg, context.segment]
-        : yield [`${Command.Error}Too large segment over ${MAX_SEGMENT_SIZE.toLocaleString('en')} bytes.\n${seg}`, Segment.unknown];
+      initial && !validate(seg, MAX_SEGMENT_SIZE)
+        ? yield [`${Command.Error}Too large segment over ${MAX_SEGMENT_SIZE.toLocaleString('en')} bytes.\n${seg}`, Segment.unknown]
+        : yield [initial ? normalize(seg) : seg, context.segment];
     }
   }
 }
 
 export function validate(source: string, size: number): boolean {
-  return source.length <= size / 4
+  return source.length <= size / 2
       || source.length <= size && new Blob([source]).size <= size;
 }

package/src/parser/source/escapable.ts

@@ -31,7 +31,6 @@ export const escsource: EscapableSourceParser = context => {
           return new List([new Node(source.slice(position, position + 2))]);
       }
     case '\r':
-      consume(-1, context);
       return new List();
     case '\n':
       context.linebreak ||= source.length - position;

package/src/parser/source/line.ts

@@ -10,7 +10,7 @@ export const anyline: AnyLineParser = input => {
   return new List();
 };
 
-const regEmptyline = /[^\S\n]*(?:$|\n)/y;
+const regEmptyline = /[^\S\r\n]*(?:$|\r?\n)/y;
 export const emptyline: EmptyLineParser = input => {
   const context = input;
   const { source, position } = context;
@@ -36,18 +36,20 @@ export const emptysegment: EmptySegmentParser = input => {
   return new List();
 };
 function eoel(source: string, position: number): number {
-  if (source[position] === '\n') return position + 1;
+  const char = source[position];
+  if (char === '\n' || char === '\r' && source[position + 1] === '\n') return position + 1;
   regEmptyline.lastIndex = position;
   regEmptyline.test(source);
   return regEmptyline.lastIndex || position;
 }
 
-const regContentline = /[^\S\n]*\S[^\n]*(?:$|\n)/y;
+const regContentline = /[^\S\r\n]*\S[^\r\n]*(?:$|\r?\n)/y;
 export const contentline: ContentLineParser = input => {
   const context = input;
   const { source, position } = context;
   if (position === source.length) return;
-  if (source[position] === '\n') return;
+  const char = source[position];
+  if (char === '\n' || char === '\r' && source[position + 1] === '\n') return;
   regContentline.lastIndex = position;
   regContentline.test(source);
   const i = regContentline.lastIndex;