securemark 0.261.0 → 0.262.0

package/src/parser/inline/comment.ts

@@ -3,9 +3,9 @@ import { union, some, syntax, validate, surround, open, close, match, lazy } fro
 import { inline } from '../inline';
 import { text, str } from '../source';
 import { Syntax, State } from '../context';
-import { html, defrag } from 'typed-dom/dom';
 import { memoize } from 'spica/memoize';
 import { unshift, push } from 'spica/array';
+import { html, defrag } from 'typed-dom/dom';
 
 export const comment: CommentParser = lazy(() => validate('[%', syntax(Syntax.none, 4, 1, State.none, match(
   /^\[(%+)\s/,

package/src/parser/inline/deletion.ts

@@ -4,11 +4,11 @@ import { inline } from '../inline';
 import { str } from '../source';
 import { Syntax, State } from '../context';
 import { blankWith } from '../visibility';
-import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
+import { html, defrag } from 'typed-dom/dom';
 
 export const deletion: DeletionParser = lazy(() => surround(
-  str('~~'),
+  str('~~', '~'),
   syntax(Syntax.none, 1, 1, State.none,
   some(union([
     some(inline, blankWith('\n', '~~')),

package/src/parser/inline/emphasis.ts

@@ -4,16 +4,16 @@ import { inline } from '../inline';
 import { str } from '../source';
 import { Syntax, State } from '../context';
 import { startTight, blankWith } from '../visibility';
-import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
+import { html, defrag } from 'typed-dom/dom';
 
 export const emphasis: EmphasisParser = lazy(() => surround(
-  str('_'),
+  str('_', '_'),
   syntax(Syntax.none, 1, 1, State.none,
   startTight(some(union([
     some(inline, blankWith('_')),
     open(some(inline, '_'), emphasis),
-  ])), '_')),
+  ])))),
   str('_'), false,
   ([, bs], rest) => [[html('em', defrag(bs))], rest],
   ([as, bs], rest) => [unshift(as, bs), rest]));

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

@@ -3,7 +3,7 @@ import { MarkdownParser } from '../../../../markdown';
 import { Parser } from '../../../combinator/data/parser';
 import { fmap } from '../../../combinator';
 import { define } from 'typed-dom/dom';
-import { duffEach } from 'spica/duff';
+import { querySelectorAll } from 'typed-dom/query';
 
 export function indexee<P extends Parser<unknown, MarkdownParser.Context>>(parser: P, optional?: boolean): P;
 export function indexee(parser: Parser<HTMLElement, MarkdownParser.Context>, optional?: boolean): Parser<HTMLElement> {
@@ -28,32 +28,33 @@ export function text(source: HTMLElement | DocumentFragment, optional = false):
   if (index) return index;
   assert(!source.querySelector('.annotation, br'));
   const target = source.cloneNode(true) as typeof source;
-  duffEach(target.querySelectorAll('code[data-src], .math[data-src], .comment, rt, rp, .reference, .checkbox, ul, ol'), el => {
+  for (let es = querySelectorAll(target, 'code[data-src], .math[data-src], .comment, rt, rp, .reference, .checkbox, ul, ol'), i = 0; i < es.length; ++i) {
+    const el = es[i];
     switch (el.tagName) {
       case 'CODE':
         define(el, el.getAttribute('data-src')!);
-        return;
+        continue;
       case 'RT':
       case 'RP':
       case 'UL':
       case 'OL':
         el.remove();
-        return;
+        continue;
     }
     switch (el.className) {
       case 'math':
         define(el, el.getAttribute('data-src')!);
-        return;
+        continue;
       case 'comment':
       case 'checkbox':
         el.remove();
-        return;
+        continue;
       case 'reference':
         assert(el.firstElementChild?.hasAttribute('hidden'));
         el.firstChild!.remove();
-        return;
+        continue;
     }
-  });
+  }
   // Better:
   //return target.innerText;
   return target.textContent!;

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

@@ -4,8 +4,8 @@ import { inline } from '../../inline';
 import { str } from '../../source';
 import { Syntax, State } from '../../context';
 import { startTight } from '../../visibility';
-import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
+import { html, defrag } from 'typed-dom/dom';
 
 // Don't use the symbols already used: !#$%@&*+~=
 

package/src/parser/inline/html.ts

@@ -5,10 +5,10 @@ import { inline } from '../inline';
 import { str } from '../source';
 import { Syntax, State } from '../context';
 import { isStartLooseNodes, blankWith } from '../visibility';
-import { html as h, defrag } from 'typed-dom/dom';
 import { memoize } from 'spica/memoize';
 import { Cache } from 'spica/cache';
 import { unshift, push, splice } from 'spica/array';
+import { html as h, defrag } from 'typed-dom/dom';
 
 const tags = Object.freeze(['bdo', 'bdi']);
 const attrspecs = {

package/src/parser/inline/insertion.ts

@@ -4,11 +4,11 @@ import { inline } from '../inline';
 import { str } from '../source';
 import { Syntax, State } from '../context';
 import { blankWith } from '../visibility';
-import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
+import { html, defrag } from 'typed-dom/dom';
 
 export const insertion: InsertionParser = lazy(() => surround(
-  str('++'),
+  str('++', '+'),
   syntax(Syntax.none, 1, 1, State.none,
   some(union([
     some(inline, blankWith('\n', '++')),

package/src/parser/inline/link.ts

@@ -10,8 +10,8 @@ import { unescsource, str } from '../source';
 import { Syntax, State } from '../context';
 import { trimNode } from '../visibility';
 import { stringify } from '../util';
-import { html, define, defrag } from 'typed-dom/dom';
 import { ReadonlyURL } from 'spica/url';
+import { html, define, defrag } from 'typed-dom/dom';
 
 const optspec = {
   rel: ['nofollow'],

package/src/parser/inline/mark.ts

@@ -4,11 +4,11 @@ import { inline } from '../inline';
 import { str } from '../source';
 import { startTight, blankWith } from '../visibility';
 import { Syntax, State } from '../context';
-import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
+import { html, defrag } from 'typed-dom/dom';
 
 export const mark: MarkParser = lazy(() => surround(
-  str('=='),
+  str('==', '='),
   syntax(Syntax.none, 1, 1, State.none,
   startTight(some(union([
     some(inline, blankWith('==')),

package/src/parser/inline/media.ts

@@ -6,9 +6,9 @@ import { attributes } from './html';
 import { unsafehtmlentity } from './htmlentity';
 import { txt, str } from '../source';
 import { Syntax, State } from '../context';
-import { html, define } from 'typed-dom/dom';
 import { ReadonlyURL } from 'spica/url';
 import { unshift, push } from 'spica/array';
+import { html, define } from 'typed-dom/dom';
 
 const optspec = {
   'width': [],

package/src/parser/inline/ruby.ts

@@ -6,8 +6,8 @@ import { unsafehtmlentity } from './htmlentity';
 import { text as txt, str } from '../source';
 import { Syntax, State } from '../context';
 import { isStartTightNodes } from '../visibility';
-import { html, defrag } from 'typed-dom/dom';
 import { unshift, push } from 'spica/array';
+import { html, defrag } from 'typed-dom/dom';
 
 export const ruby: RubyParser = lazy(() => validate('[', syntax(Syntax.ruby, 2, 1, State.all, fmap(verify(fmap(
   sequence([

package/src/parser/inline/strong.ts

@@ -4,16 +4,16 @@ import { inline } from '../inline';
 import { str } from '../source';
 import { Syntax, State } from '../context';
 import { startTight, blankWith } from '../visibility';
-import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
+import { html, defrag } from 'typed-dom/dom';
 
 export const strong: StrongParser = lazy(() => surround(
-  str('*'),
+  str('*', '*'),
   syntax(Syntax.none, 1, 1, State.none,
   startTight(some(union([
     some(inline, blankWith('*')),
     open(some(inline, '*'), strong),
-  ])), '*')),
+  ])))),
   str('*'), false,
   ([, bs], rest) => [[html('strong', defrag(bs))], rest],
   ([as, bs], rest) => [unshift(as, bs), rest]));

package/src/parser/inline/template.ts

@@ -3,8 +3,8 @@ import { TemplateParser } from '../inline';
 import { union, some, syntax, creation, precedence, surround, lazy } from '../../combinator';
 import { escsource, str } from '../source';
 import { Syntax, State } from '../context';
-import { html } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
+import { html } from 'typed-dom/dom';
 
 export const template: TemplateParser = lazy(() => surround(
   '{{', syntax(Syntax.none, 2, 1, State.all, some(union([bracket, escsource]), '}')), '}}', true,

package/src/parser/inline.ts

@@ -1,6 +1,5 @@
 import { MarkdownParser } from '../../markdown';
 import { union } from '../combinator';
-import { escape } from './inline/escape';
 import { annotation } from './inline/annotation';
 import { reference } from './inline/reference';
 import { template } from './inline/template';
@@ -24,7 +23,6 @@ import { bracket } from './inline/bracket';
 import { text } from './source';
 
 export import InlineParser = MarkdownParser.InlineParser;
-export import EscapeParser = InlineParser.EscapeParser;
 export import AnnotationParser = InlineParser.AnnotationParser;
 export import ReferenceParser = InlineParser.ReferenceParser;
 export import TemplateParser = InlineParser.TemplateParser;
@@ -48,7 +46,6 @@ export import AutolinkParser = InlineParser.AutolinkParser;
 export import BracketParser = InlineParser.BracketParser;
 
 export const inline: InlineParser = union([
-  escape,
   annotation,
   reference,
   template,

package/src/parser/locale/ja.ts

@@ -1,3 +1,3 @@
 export function japanese(char: string): boolean {
-  return /^[\p{Ideo}\p{Script_Extensions=Hiragana}\p{Script_Extensions=Katakana}～！？]/u.test(char);
+  return /^[\p{Ideo}\p{scx=Hiragana}\p{scx=Katakana}～！？]/u.test(char);
 }

package/src/parser/locale.test.ts

@@ -10,7 +10,7 @@ describe('Unit: parser/locale', () => {
       assert.deepStrictEqual(inspect(parser('。\\\n0')), [['<p>。<span class="linebreak"></span>0</p>'], '']);
       assert.deepStrictEqual(inspect(parser('。 \\\n0')), [['<p>。<span class="linebreak"></span>0</p>'], '']);
       assert.deepStrictEqual(inspect(parser('_。_\\\n0')), [['<p><em>。</em><span class="linebreak"></span>0</p>'], '']);
-      assert.deepStrictEqual(inspect(parser('!> 。\\\n0')), [['<blockquote><section><p>。<span class="linebreak"></span>0</p><ol class="references"></ol></section></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('!> 。\\\n0')), [['<blockquote><section><p>。<span class="linebreak"></span>0</p><h2>References</h2><ol class="references"></ol></section></blockquote>'], '']);
       assert.deepStrictEqual(inspect(parser('[。](a)\\\n0')), [['<p><ruby>。<rp>(</rp><rt>a</rt><rp>)</rp></ruby><span class="linebreak"></span>0</p>'], '']);
       assert.deepStrictEqual(inspect(parser('[。　](a )\\\n0')), [['<p><ruby>。<rp>(</rp><rt>a</rt><rp>)</rp></ruby><span class="linebreak"></span>0</p>'], '']);
       assert.deepStrictEqual(inspect(parser('。<wbr>\\\n0')), [['<p>。<wbr><span class="linebreak"></span>0</p>'], '']);

package/src/parser/locale.ts

@@ -2,7 +2,7 @@ import { Parser } from '../combinator/data/parser';
 import { fmap } from '../combinator';
 import { japanese } from './locale/ja';
 import { html } from 'typed-dom/dom';
-import { duffEach } from 'spica/duff';
+import { querySelectorAll } from 'typed-dom/query';
 
 export function localize<P extends Parser<HTMLElement | string>>(parser: P): P;
 export function localize(parser: Parser<HTMLElement | string>): Parser<HTMLElement | string> {
@@ -11,11 +11,12 @@ export function localize(parser: Parser<HTMLElement | string>): Parser<HTMLEleme
     const el = ns.length === 1 && typeof ns[0] === 'object'
       ? ns[0]
       : html('div', ns);
-    duffEach(el.querySelectorAll('.linebreak:not(:empty)'), el => {
+    for (let es = querySelectorAll(el, '.linebreak:not(:empty)'), i = 0; i < es.length; ++i) {
+      const el = es[i];
       assert(el.firstChild!.textContent === ' ');
-      if (!check(el)) return;
+      if (!check(el)) continue;
       el.firstChild!.remove();
-    });
+    }
     return ns;
   });
 }

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

@@ -117,8 +117,8 @@ describe('Unit: parser/processor/figure', () => {
         assert.deepStrictEqual(
           [...target.children].map(el => el.outerHTML),
           [
-            '<blockquote><blockquote><section><figure data-type="quote" data-label="test-a" data-group="test" data-number="1"><figcaption><span class="figindex">Test 1. </span><span class="figtext"></span></figcaption><div><blockquote></blockquote></div></figure><ol class="references"></ol></section></blockquote><section><figure data-type="quote" data-label="test-a" data-group="test" data-number="1"><figcaption><span class="figindex">Test 1. </span><span class="figtext"></span></figcaption><div><blockquote></blockquote></div></figure><ol class="references"></ol></section></blockquote>',
-            '<aside class="example" data-type="markdown"><pre translate="no">~~~figure $test-a\n&gt; \n\n~~~\n\n$test-a</pre><hr><section><figure data-type="quote" data-label="test-a" data-group="test" data-number="1"><figcaption><span class="figindex">Test 1. </span><span class="figtext"></span></figcaption><div><blockquote></blockquote></div></figure><p><a class="label disabled" data-label="test-a">Test 1</a></p><ol class="references"></ol></section></aside>',
+            '<blockquote><blockquote><section><figure data-type="quote" data-label="test-a" data-group="test" data-number="1"><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"><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"><figcaption><span class="figindex">Test 1. </span><span class="figtext"></span></figcaption><div><blockquote></blockquote></div></figure><p><a class="label disabled" data-label="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>',
           ]);
@@ -173,7 +173,7 @@ describe('Unit: parser/processor/figure', () => {
             '<h2 id="index:0">0</h2>',
             '<figure data-type="quote" data-label="test-1" data-group="test" data-number="1" id="label:test-1"><figcaption><span class="figindex">Test 1. </span><span class="figtext"></span></figcaption><div><blockquote></blockquote></div></figure>',
             '<h2 id="index:0">0</h2>',
-            '<blockquote><section><h2>0</h2><ol class="references"></ol></section></blockquote>',
+            '<blockquote><section><h2>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" data-invalid-syntax="figure" data-invalid-type="argument" data-invalid-message="Base index must be $-x.0 format"></figure>',

package/src/parser/processor/figure.ts

@@ -1,17 +1,18 @@
 import { Infinity, Set, Map } from 'spica/global';
 import { number as calculate, isFixed } from '../inline/extension/label';
-import { define } from 'typed-dom/dom';
 import { MultiMap } from 'spica/multimap';
 import { push } from 'spica/array';
+import { define } from 'typed-dom/dom';
+import { querySelectorAll } from 'typed-dom/query';
 
 export function* figure(
   target: ParentNode & Node,
   footnotes?: { readonly references: HTMLOListElement; },
   opts: { readonly id?: string; } = {},
 ): Generator<HTMLAnchorElement | undefined, undefined, undefined> {
-  const refs = new MultiMap<string, HTMLAnchorElement>(push(push([],
-    target.querySelectorAll('a.label:not(.disabled)[data-label]')),
-    footnotes?.references.querySelectorAll('a.label:not(.disabled)') ?? [])
+  const refs = new MultiMap<string, HTMLAnchorElement>(push(
+    querySelectorAll(target, 'a.label:not(.disabled)[data-label]'),
+    footnotes && querySelectorAll(footnotes.references, 'a.label:not(.disabled)') || [])
     .map(el => [el.getAttribute('data-label')!, el]));
   const labels = new Set<string>();
   const numbers = new Map<string, string>();
@@ -19,10 +20,10 @@ export function* figure(
   let bases: readonly string[] = base.split('.');
   let index: readonly string[] = bases;
   // Bug: Firefox
-  //for (let defs = target.querySelectorAll(':scope > figure[data-label], :scope > h1, :scope > h2'), i = 0, len = defs.length; i < len; ++i) {
+  //for (let defs = querySelectorAll(target, ':scope > figure[data-label], :scope > h1, :scope > h2'), len = defs.length, i = 0; i < len; ++i) {
   for (
-    let defs = target.querySelectorAll('figure[data-label], h1, h2'),
-        i = 0, len = defs.length; i < len; ++i) {
+    let defs = querySelectorAll(target, 'figure[data-label], h1, h2'),
+        len = defs.length, i = 0; i < len; ++i) {
     yield;
     const def = defs[i];
     if (def.parentNode !== target) continue;
@@ -141,7 +142,8 @@ export function* figure(
     }
     labels.add(label);
     opts.id !== '' && def.setAttribute('id', `label:${opts.id ? `${opts.id}:` : ''}${label}`);
-    for (const ref of refs.take(label, Infinity)) {
+    for (let rs = refs.take(label, Infinity), i = 0; i < rs.length; ++i) {
+      const ref = rs[i];
       if (ref.getAttribute('data-invalid-message') === messages.reference) {
         define(ref, {
           class: void ref.classList.remove('invalid'),

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

@@ -151,8 +151,8 @@ describe('Unit: parser/processor/footnote', () => {
         assert.deepStrictEqual(
           [...target.children].map(el => el.outerHTML),
           [
-            '<blockquote><blockquote><section><p><sup class="annotation disabled" title="a"><span hidden="">a</span><a>*1</a></sup></p><ol class="annotations"><li data-marker="*1">a<sup><a>^1</a></sup></li></ol><ol class="references"></ol></section></blockquote><section><p><sup class="annotation disabled" title="a"><span hidden="">a</span><a>*1</a></sup><br>~~~</p><ol class="annotations"><li data-marker="*1">a<sup><a>^1</a></sup></li></ol><ol class="references"></ol></section></blockquote>',
-            '<aside class="example" data-type="markdown"><pre translate="no">((a))</pre><hr><section><p><sup class="annotation disabled" title="a"><span hidden="">a</span><a>*1</a></sup></p><ol class="annotations"><li data-marker="*1">a<sup><a>^1</a></sup></li></ol><ol class="references"></ol></section></aside>',
+            '<blockquote><blockquote><section><p><sup class="annotation disabled" title="a"><span hidden="">a</span><a>*1</a></sup></p><ol class="annotations"><li data-marker="*1">a<sup><a>^1</a></sup></li></ol><h2>References</h2><ol class="references"></ol></section></blockquote><section><p><sup class="annotation disabled" title="a"><span hidden="">a</span><a>*1</a></sup><br>~~~</p><ol class="annotations"><li data-marker="*1">a<sup><a>^1</a></sup></li></ol><h2>References</h2><ol class="references"></ol></section></blockquote>',
+            '<aside class="example" data-type="markdown"><pre translate="no">((a))</pre><hr><section><p><sup class="annotation disabled" title="a"><span hidden="">a</span><a>*1</a></sup></p><ol class="annotations"><li data-marker="*1">a<sup><a>^1</a></sup></li></ol><h2>References</h2><ol class="references"></ol></section></aside>',
             '<p><sup class="annotation" id="annotation:ref:1" title="a"><span hidden="">a</span><a href="#annotation:def:1">*1</a></sup></p>',
           ]);
         assert.deepStrictEqual(

package/src/parser/processor/footnote.ts

@@ -1,9 +1,8 @@
 import { undefined, Infinity, Map, Node } from 'spica/global';
 import { text } from '../inline/extension/indexee';
-import { frag, html, define } from 'typed-dom/dom';
 import { MultiMap } from 'spica/multimap';
-import { duffEach, duffReduce } from 'spica/duff';
-import { push } from 'spica/array';
+import { frag, html, define } from 'typed-dom/dom';
+import { querySelectorAll } from 'typed-dom/query';
 
 export function* footnote(
   target: ParentNode & Node,
@@ -12,8 +11,11 @@ export function* footnote(
   bottom: Node | null = null,
 ): Generator<HTMLAnchorElement | HTMLLIElement | undefined, undefined, undefined> {
   // Bug: Firefox
-  //target.querySelectorAll(`:scope > .annotations`).forEach(el => el.remove());
-  duffEach(target.querySelectorAll(`.annotations`), el => el.parentNode === target && el.remove());
+  //querySelectorAll(target, `:scope > .annotations`).forEach(el => el.remove());
+  for (let es = querySelectorAll(target, `.annotations`), i = 0; i < es.length; ++i) {
+    const el = es[i];
+    el.parentNode === target && el.remove();
+  }
   yield* reference(target, footnotes?.references, opts, bottom);
   yield* annotation(target, footnotes?.annotations, opts, bottom);
   return;
@@ -40,16 +42,18 @@ function build(
     const buffer = new MultiMap<string, HTMLElement>();
     const titles = new Map<string, string>();
     // Bug: Firefox
-    //const splitters = push([], target.querySelectorAll(`:scope > :is(${splitter ?? '_'})`));
-    const splitters = duffReduce(target.querySelectorAll(splitter ?? '_'), (acc, el) =>
-      el.parentNode === target ? push(acc, [el]) : acc
-    , [] as Element[]);
+    //const splitters = push([], querySelectorAll(target, `:scope > :is(${splitter ?? '_'})`));
+    const splitters: Element[] = [];
+    for (let es = querySelectorAll(target, splitter ?? '_'), i = 0; i < es.length; ++i) {
+      const el = es[i];
+      el.parentNode === target && splitters.push(el);
+    }
     let count = 0;
     let total = 0;
     let style: 'count' | 'abbr';
     for (
-      let refs = target.querySelectorAll(`sup.${syntax}:not(.disabled)`),
-          i = 0, len = refs.length; i < len; ++i) {
+      let refs = querySelectorAll(target, `sup.${syntax}:not(.disabled)`),
+          len = refs.length, i = 0; i < len; ++i) {
       yield;
       const ref = refs[i];
       while (+splitters[0]?.compareDocumentPosition(ref) & Node.DOCUMENT_POSITION_FOLLOWING) {
@@ -114,7 +118,8 @@ function build(
       if (title && !blank && def.childNodes.length === 1) {
         def.insertBefore(content.cloneNode(true), def.lastChild);
         assert(def.childNodes.length > 1);
-        for (const ref of buffer.take(identifier, Infinity)) {
+        for (let refs = buffer.take(identifier, Infinity), i = 0; i < refs.length; ++i) {
+          const ref = refs[i];
           if (ref.getAttribute('data-invalid-type') !== 'content') continue;
           define(ref, {
             title,

package/src/parser/source/str.ts

@@ -3,12 +3,13 @@ import { StrParser } from '../source';
 import { Parser, Context } from '../../combinator/data/parser';
 import { creation } from '../../combinator';
 
-export function str(pattern: string | RegExp): StrParser;
-export function str(pattern: string | RegExp): Parser<string, Context<StrParser>, []> {
+export function str(pattern: string | RegExp, not?: string): StrParser;
+export function str(pattern: string | RegExp, not?: string): Parser<string, Context<StrParser>, []> {
   assert(pattern);
   return typeof pattern === 'string'
     ? creation(1, false, ({ source }) => {
         if (source === '') return;
+        if (not && source.slice(pattern.length, pattern.length + not.length) === not) return;
         return source.slice(0, pattern.length) === pattern
           ? [[pattern], source.slice(pattern.length)]
           : undefined;
@@ -16,6 +17,7 @@ export function str(pattern: string | RegExp): Parser<string, Context<StrParser>
     : creation(1, false, ({ source }) => {
         if (source === '') return;
         const m = source.match(pattern);
+        if (m && not && source.slice(m[0].length, m[0].length + not.length) === not) return;
         return m && m[0].length > 0
           ? [[m[0]], source.slice(m[0].length)]
           : undefined;

package/src/parser/source/text.ts

@@ -4,10 +4,10 @@ import { union, creation, focus } from '../../combinator';
 import { str } from './str';
 import { html } from 'typed-dom/dom';
 
-export const delimiter = /[\s\x00-\x7F]|\S[#>]|[\p{Ideo}\p{Script_Extensions=Hiragana}\p{Script_Extensions=Katakana}～！？][^\S\n]*(?=\\\n)/u;
+export const delimiter = /[\s\x00-\x7F]|\S[#>]|[\p{Ideo}\p{scx=Hiragana}\p{scx=Katakana}～！？][^\S\n]*(?=\\\n)/u;
 export const nonWhitespace = /[\S\n]|$/;
 export const nonAlphanumeric = /[^0-9A-Za-z]|\S[#>]|$/;
-const nssb = /^[\p{Ideo}\p{Script_Extensions=Hiragana}\p{Script_Extensions=Katakana}～！？][^\S\n]*(?=\\\n)/u;
+const nssb = /^[\p{Ideo}\p{scx=Hiragana}\p{scx=Katakana}～！？][^\S\n]*(?=\\\n)/u;
 const repeat = str(/^(.)\1*/);
 
 export const text: TextParser = creation(1, false, ({ source, context }) => {

package/src/renderer/render.ts

@@ -3,8 +3,8 @@ import { RenderingOptions } from '../../';
 import { code } from './render/code';
 import { math } from './render/math';
 import { media } from './render/media';
-import { querySelectorAll } from 'typed-dom/query';
 import { reduce } from 'spica/memoize';
+import { querySelectorAllWith } from 'typed-dom/query';
 
 const selector = 'img.media:not(.invalid):not([src])[data-src], a > :not(img).media:not(.invalid), pre.code:not(.invalid), .math:not(.invalid)';
 
@@ -14,8 +14,8 @@ const extend = reduce((opts: RenderingOptions): RenderingOptions =>
 export function render(source: HTMLElement, opts: RenderingOptions = {}): void {
   opts = extend(opts);
   const base = location.href;
-  for (const el of querySelectorAll<HTMLElement>(source, selector)) {
-    render_(base, el, opts);
+  for (let es = querySelectorAllWith<HTMLElement>(source, selector), i = 0; i < es.length; ++i) {
+    render_(base, es[i], opts);
   }
 }
 

package/src/util/info.ts

@@ -1,7 +1,6 @@
 import { Info } from '../..';
 import { scope } from './scope';
-import { duffReduce } from 'spica/duff';
-import { push } from 'spica/array';
+import { querySelectorAll } from 'typed-dom/query';
 
 export function info(source: DocumentFragment | HTMLElement | ShadowRoot): Info {
   const match = scope(source, '.invalid');
@@ -19,8 +18,11 @@ export function info(source: DocumentFragment | HTMLElement | ShadowRoot): Info
   };
 
   function find<T extends HTMLElement>(selector: string): T[] {
-    return duffReduce(source.querySelectorAll<T>(selector), (acc, el) =>
-      match(el) ? push(acc, [el]) : acc
-    , [] as T[]);
+    const acc: T[] = [];
+    for (let es = querySelectorAll<T>(source, selector), i = 0; i < es.length; ++i) {
+      const el = es[i];
+      match(el) && acc.push(el);
+    }
+    return acc;
   }
 }

package/src/util/quote.ts

@@ -2,30 +2,31 @@ import { Element } from 'spica/global';
 import { exec } from '../combinator/data/parser';
 import { cite } from '../parser/block/reply/cite';
 import { define } from 'typed-dom/dom';
-import { duffEach } from 'spica/duff';
+import { querySelectorAll } from 'typed-dom/query';
 
 export function quote(anchor: string, range: Range): string {
   if (exec(cite({ source: `>>${anchor}`, context: {} })) !== '') throw new Error(`Invalid anchor: ${anchor}`);
   fit(range);
   const node = trim(range.cloneContents());
   if (!node.firstChild) return '';
-  duffEach(node.querySelectorAll('code[data-src], .math[data-src], .media[data-src], rt, rp'), el => {
+  for (let es = querySelectorAll(node, 'code[data-src], .math[data-src], .media[data-src], rt, rp'), i = 0; i < es.length; ++i) {
+    const el = es[i];
     switch (true) {
       case el.matches('code'):
       case el.matches('.math'):
         define(el, el.getAttribute('data-src')!);
-        return;
+        continue;
       case el.matches('.media'):
         el.replaceWith(
           /[\s{}]/.test(el.getAttribute('data-src')!)
             ? `!{ ${el.getAttribute('data-src')} }`
             : `!{${el.getAttribute('data-src')}}`);
-        return;
+        continue;
       case el.matches('rt, rp'):
         el.remove();
-        return;
+        continue;
     }
-  });
+  }
   if (range.startOffset === 0 &&
       range.startContainer.parentElement?.matches('.cite, .quote') &&
       (!range.startContainer.previousSibling || range.startContainer.previousSibling.nodeName === 'BR')) {
@@ -35,25 +36,26 @@ export function quote(anchor: string, range: Range): string {
     node.prepend(`>>${anchor}\n> `);
     anchor = '';
   }
-  duffEach(node.querySelectorAll('br'), el => {
+  for (let es = querySelectorAll(node, 'br'), i = 0; i < es.length; ++i) {
+    const el = es[i];
     if (anchor && el.nextSibling instanceof Element && el.nextSibling.matches('.cite, .quote')) {
       el.replaceWith(`\n>${el.nextSibling.matches('.quote.invalid') ? ' ' : ''}`);
-      return;
+      continue;
     }
     if (anchor && el.parentElement?.closest('.cite, .quote')) {
       el.replaceWith(`\n>${el.parentElement.closest('.quote.invalid') ? ' ' : ''}`);
-      return;
+      continue;
     }
     if (anchor) {
       el.replaceWith(`\n>>${anchor}\n> `);
       anchor = '';
-      return;
+      continue;
     }
     else {
       el.replaceWith(`\n> `);
-      return;
+      continue;
     }
-  });
+  }
   anchor && node.append(`\n>>${anchor}`);
   return node.textContent!;
 }