securemark 0.257.1 → 0.258.0

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

@@ -10,7 +10,7 @@ describe('Unit: parser/inline/template', () => {
       assert.deepStrictEqual(inspect(parser('')), undefined);
       assert.deepStrictEqual(inspect(parser('{')), undefined);
       assert.deepStrictEqual(inspect(parser('{}')), undefined);
-      assert.deepStrictEqual(inspect(parser('{{')), undefined);
+      assert.deepStrictEqual(inspect(parser('{{')), [['', '{{'], '']);
       assert.deepStrictEqual(inspect(parser('{{\\}}')), undefined);
       assert.deepStrictEqual(inspect(parser('{{a}b}')), undefined);
       assert.deepStrictEqual(inspect(parser('{{{a}}')), undefined);

package/src/parser/inline/template.ts

@@ -1,17 +1,20 @@
 import { undefined } from 'spica/global';
 import { TemplateParser } from '../inline';
-import { union, some, rewrite, precedence, creator, surround, lazy } from '../../combinator';
+import { union, some, syntax, creator, precedence, surround, lazy } from '../../combinator';
+import { optimize } from './link';
 import { escsource, str } from '../source';
+import { Rule } from '../context';
 import { html } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
-export const template: TemplateParser = lazy(() => creator(precedence(3, rewrite(
-  surround('{{', some(union([bracket, escsource]), '}'), '}}', true),
-  source => [[html('span', { class: 'template' }, source.replace(/\x1B/g, ''))], '']))));
+export const template: TemplateParser = lazy(() => syntax(Rule.none, 2, surround(
+  '{{', some(union([bracket, escsource]), '}'), '}}', true,
+  ([, ns = []], rest) => [[html('span', { class: 'template' }, `{{${ns.join('').replace(/\x1B/g, '')}}}`)], rest],
+  ([, ns = [], rest], next) => next[0] === '}' ? undefined : optimize('{{', ns, rest))));
 
-const bracket: TemplateParser.BracketParser = lazy(() => union([
+const bracket: TemplateParser.BracketParser = lazy(() => creator(union([
   surround(str('('), some(union([bracket, escsource]), ')'), str(')'), true, undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),
   surround(str('['), some(union([bracket, escsource]), ']'), str(']'), true, undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),
   surround(str('{'), some(union([bracket, escsource]), '}'), str('}'), true, undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),
   surround(str('"'), precedence(8, some(escsource, /^"|^\\?\n/)), str('"'), true),
-]));
+])));

package/src/parser/inline.test.ts

@@ -146,6 +146,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('((((a))')), [['', '((', '<sup class="annotation"><span>a</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('((((a))))')), [['<sup class="annotation"><span><span class="paren">((a))</span></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('((<bdi>))')), [['<sup class="annotation"><span><span class="invalid">&lt;bdi&gt;</span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('((${))}$')), [['', '((', '<span class="math" translate="no" data-src="${))}$">${))}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('"((""))')), [['"', '<sup class="annotation"><span>""</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[[a]]')), [['', '[', '<sup class="reference"><span>a</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[[[a]]')), [['', '[[', '<sup class="reference"><span>a</span></sup>'], '']);
@@ -155,6 +156,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('[[[a]{b}]]')), [['<sup class="reference"><span><a href="b">a</a></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[(([a]{#}))]{#}')), [['<a href="#"><span class="paren">(<span class="paren">([a]{#})</span>)</span></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[[<bdi>]]')), [['<sup class="reference"><span><span class="invalid">&lt;bdi&gt;</span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[${]]}$')), [['', '[[', '<span class="math" translate="no" data-src="${]]}$">${]]}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('"[[""]]')), [['"', '<sup class="reference"><span>""</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[a](b)]{c}')), [['<a href="c"><ruby>a<rp>(</rp><rt>b</rt><rp>)</rp></ruby></a>'], '']);
       assert.deepStrictEqual(inspect(parser('<http://host>')), [['<', '<a href="http://host" target="_blank">http://host</a>', '>'], '']);

package/src/parser/locale.ts

@@ -2,6 +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';
 
 export function localize<P extends Parser<HTMLElement | string>>(parser: P): P;
 export function localize(parser: Parser<HTMLElement | string>): Parser<HTMLElement | string> {
@@ -10,13 +11,11 @@ export function localize(parser: Parser<HTMLElement | string>): Parser<HTMLEleme
     const el = ns.length === 1 && typeof ns[0] === 'object'
       ? ns[0]
       : html('div', ns);
-    const es = el.querySelectorAll('.linebreak:not(:empty)');
-    for (let i = 0, len = es.length; i < len; ++i) {
-      const sb = es[i];
-      assert(sb.firstChild!.textContent === ' ');
-      if (!check(sb)) continue;
-      sb.firstChild!.remove();
-    }
+    duffEach(el.querySelectorAll('.linebreak:not(:empty)'), el => {
+      assert(el.firstChild!.textContent === ' ');
+      if (!check(el)) return;
+      el.firstChild!.remove();
+    });
     return ns;
   });
 }

package/src/parser/processor/footnote.ts

@@ -2,6 +2,7 @@ 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';
 
 export function* footnote(
@@ -12,7 +13,7 @@ export function* footnote(
 ): Generator<HTMLAnchorElement | HTMLLIElement | undefined, undefined, undefined> {
   // Bug: Firefox
   //target.querySelectorAll(`:scope > .annotations`).forEach(el => el.remove());
-  target.querySelectorAll(`.annotations`).forEach(el => el.parentNode === target && el.remove());
+  duffEach(target.querySelectorAll(`.annotations`), el => el.parentNode === target && el.remove());
   yield* reference(target, footnotes?.references, opts, bottom);
   yield* annotation(target, footnotes?.annotations, opts, bottom);
   return;
@@ -40,8 +41,9 @@ function build(
     const titles = new Map<string, string>();
     // Bug: Firefox
     //const splitters = push([], target.querySelectorAll(`:scope > :is(${splitter ?? '_'})`));
-    const splitters = push([], target.querySelectorAll(splitter ?? '_'))
-      .filter(el => el.parentNode === target);
+    const splitters = duffReduce(target.querySelectorAll(splitter ?? '_'), (acc, el) =>
+      el.parentNode === target ? push(acc, [el]) : acc
+    , [] as Element[]);
     let count = 0;
     let total = 0;
     let style: 'count' | 'abbr';

package/src/parser/source/text.ts

@@ -1,6 +1,6 @@
 import { undefined } from 'spica/global';
 import { TextParser, TxtParser, LinebreakParser } from '../source';
-import { union, focus, creator } from '../../combinator';
+import { union, creator, focus } from '../../combinator';
 import { str } from './str';
 import { html } from 'typed-dom/dom';
 

package/src/parser/util.ts

@@ -1,223 +1,3 @@
-import { undefined } from 'spica/global';
-import { MarkdownParser } from '../../markdown';
-import { Parser, eval } from '../combinator/data/parser';
-import { union, some, verify, convert, fmap } from '../combinator';
-import { unsafehtmlentity } from './inline/htmlentity';
-import { linebreak, unescsource } from './source';
-import { invisibleHTMLEntityNames } from './api/normalize';
-import { memoize, reduce } from 'spica/memoize';
-import { push } from 'spica/array';
-
-export function clean<P extends Parser<unknown>>(parser: P): P;
-export function clean<T>(parser: Parser<T, MarkdownParser.Context>): Parser<T, MarkdownParser.Context> {
-  const clean = memoize<MarkdownParser.Context, MarkdownParser.Context>(context => ({
-    resources: context.resources,
-    precedence: context.precedence,
-    delimiters: context.delimiters,
-    host: context.host,
-    url: context.url,
-    id: context.id,
-    header: context.header,
-    cache: context.caches,
-  }), new WeakMap());
-  return (source, context) =>
-    parser(source, context.syntax ? clean(context) : context);
-}
-
-export const regBlankStart = new RegExp(
-  /^(?:\\?[^\S\n]|&IHN;|<wbr>)+/.source.replace('IHN', `(?:${invisibleHTMLEntityNames.join('|')})`));
-
-export function blankWith(delimiter: string | RegExp): RegExp;
-export function blankWith(starting: '' | '\n', delimiter: string | RegExp): RegExp;
-export function blankWith(starting: '' | '\n', delimiter?: string | RegExp): RegExp {
-  if (delimiter === undefined) return blankWith('', starting);
-  return new RegExp(String.raw
-    `^(?:(?=${
-      starting
-    })(?:\\?\s|&(?:${invisibleHTMLEntityNames.join('|')});|<wbr>)${starting && '+'})?${
-      typeof delimiter === 'string' ? delimiter.replace(/[*+()\[\]]/g, '\\$&') : delimiter.source
-    }`);
-}
-
-export function visualize<P extends Parser<HTMLElement | string>>(parser: P): P;
-export function visualize<T extends HTMLElement | string>(parser: Parser<T>): Parser<T> {
-  const blankline = new RegExp(
-    /^(?:\\$|\\?[^\S\n]|&IHN;|<wbr>)+$/.source.replace('IHN', `(?:${invisibleHTMLEntityNames.join('|')})`),
-    'gm');
-  return union([
-    convert(
-      source => source.replace(blankline, line => line.replace(/[\\&<]/g, '\x1B$&')),
-      verify(parser, (ns, rest, context) => !rest && hasVisible(ns, context))),
-    some(union([linebreak, unescsource])),
-  ]);
-}
-function hasVisible(
-  nodes: readonly (HTMLElement | string)[],
-  { syntax: { inline: { media = true } = {} } = {} }: MarkdownParser.Context = {},
-): boolean {
-  for (let i = 0; i < nodes.length; ++i) {
-    const node = nodes[i];
-    if (typeof node === 'string') {
-      if (node && node.trimStart()) return true;
-    }
-    else {
-      if (node.innerText.trimStart()) return true;
-      if (media && (node.classList.contains('media') || node.getElementsByClassName('media')[0])) return true;
-    }
-  }
-  return false;
-}
-
-export function startLoose<P extends Parser<HTMLElement | string>>(parser: P, except?: string): P;
-export function startLoose<T extends HTMLElement | string>(parser: Parser<T>, except?: string): Parser<T> {
-  return (source, context) =>
-    isStartLoose(source, context, except)
-      ? parser(source, context)
-      : undefined;
-}
-const isStartLoose = reduce((source: string, context: MarkdownParser.Context, except?: string): boolean => {
-  return isStartTight(source.replace(regBlankStart, ''), context, except);
-}, (source, _, except = '') => `${source}\x1E${except}`);
-
-export function startTight<P extends Parser<unknown>>(parser: P, except?: string): P;
-export function startTight<T>(parser: Parser<T>, except?: string): Parser<T> {
-  return (source, context) =>
-    isStartTight(source, context, except)
-      ? parser(source, context)
-      : undefined;
-}
-const isStartTight = reduce((source: string, context: MarkdownParser.Context, except?: string): boolean => {
-  if (source === '') return true;
-  if (except && source.slice(0, except.length) === except) return false;
-  switch (source[0]) {
-    case ' ':
-    case '　':
-    case '\t':
-    case '\n':
-      return false;
-    case '\\':
-      return source[1]?.trimStart() !== '';
-    case '&':
-      switch (true) {
-        case source.length > 2
-          && source[1] !== ' '
-          && eval(unsafehtmlentity(source, context))?.[0]?.trimStart() === '':
-          return false;
-      }
-      return true;
-    case '<':
-      switch (true) {
-        case source.length >= 5
-          && source[1] === 'w'
-          && source.slice(0, 5) === '<wbr>':
-          return false;
-      }
-      return true;
-    default:
-      return source[0].trimStart() !== '';
-  }
-}, (source, _, except = '') => `${source}\x1E${except}`);
-
-export function isStartLooseNodes(nodes: readonly (HTMLElement | string)[]): boolean {
-  if (nodes.length === 0) return true;
-  for (let i = 0; i < nodes.length; ++i) {
-    const node = nodes[i];
-    if (isVisible(node)) return true;
-    if (typeof node === 'object') {
-      if (node.tagName === 'BR') break;
-      if (node.className === 'linebreak') break;
-    }
-  }
-  return false;
-}
-export function isStartTightNodes(nodes: readonly (HTMLElement | string)[]): boolean {
-  if (nodes.length === 0) return true;
-  return isVisible(nodes[0], 0);
-}
-//export function isEndTightNodes(nodes: readonly (HTMLElement | string)[]): boolean {
-//  if (nodes.length === 0) return true;
-//  return isVisible(nodes[nodes.length - 1], -1);
-//}
-function isVisible(node: HTMLElement | string, strpos?: number): boolean {
-  switch (typeof node) {
-    case 'string':
-      const char = node && strpos !== undefined
-        ? node[strpos >= 0 ? strpos : node.length + strpos]
-        : node;
-      switch (char) {
-        case '':
-        case ' ':
-        case '\t':
-        case '\n':
-          return false;
-        default:
-          return char.trimStart() !== '';
-      }
-    default:
-      switch (node.tagName) {
-        case 'BR':
-        case 'WBR':
-          return false;
-        case 'SPAN':
-          return node.className !== 'linebreak';
-        default:
-          return true;
-      }
-  }
-}
-
-export function trimBlank<P extends Parser<HTMLElement | string>>(parser: P): P;
-export function trimBlank<T extends HTMLElement | string>(parser: Parser<T>): Parser<T> {
-  return trimBlankStart(trimBlankEnd(parser));
-}
-export function trimBlankStart<P extends Parser<unknown>>(parser: P): P;
-export function trimBlankStart<T>(parser: Parser<T>): Parser<T> {
-  return convert(
-    reduce(source => source.replace(regBlankStart, '')),
-    parser);
-}
-export function trimBlankEnd<P extends Parser<HTMLElement | string>>(parser: P): P;
-export function trimBlankEnd<T extends HTMLElement | string>(parser: Parser<T>): Parser<T> {
-  return fmap(
-    parser,
-    trimNodeEnd);
-}
-export function trimNode<T extends HTMLElement | string>(nodes: T[]): T[] {
-  return trimNodeStart(trimNodeEnd(nodes));
-}
-function trimNodeStart<T extends HTMLElement | string>(nodes: T[]): T[] {
-  for (let node = nodes[0]; nodes.length > 0 && !isVisible(node = nodes[0], 0);) {
-    if (nodes.length === 1 && typeof node === 'object' && node.className === 'indexer') break;
-    if (typeof node === 'string') {
-      const pos = node.trimStart().length;
-      if (pos > 0) {
-        nodes[0] = node.slice(pos) as T;
-        break;
-      }
-    }
-    nodes.shift();
-  }
-  return nodes;
-}
-function trimNodeEnd<T extends HTMLElement | string>(nodes: T[]): T[] {
-  const skip = nodes.length > 0 &&
-    typeof nodes[nodes.length - 1] === 'object' &&
-    nodes[nodes.length - 1]['className'] === 'indexer'
-    ? [nodes.pop()!]
-    : [];
-  for (let node = nodes[0]; nodes.length > 0 && !isVisible(node = nodes[nodes.length - 1], -1);) {
-    if (typeof node === 'string') {
-      const pos = node.trimEnd().length;
-      if (pos > 0) {
-        nodes[nodes.length - 1] = node.slice(0, pos) as T;
-        break;
-      }
-    }
-    nodes.pop();
-  }
-  return push(nodes, skip);
-}
-
 export function stringify(nodes: readonly (HTMLElement | string)[]): string {
   let acc = '';
   for (let i = 0; i < nodes.length; ++i) {

package/src/parser/visibility.ts

@@ -0,0 +1,205 @@
+import { undefined } from 'spica/global';
+import { MarkdownParser } from '../../markdown';
+import { Parser, eval } from '../combinator/data/parser';
+import { union, some, verify, convert, fmap } from '../combinator';
+import { unsafehtmlentity } from './inline/htmlentity';
+import { linebreak, unescsource } from './source';
+import { State } from './context';
+import { invisibleHTMLEntityNames } from './api/normalize';
+import { reduce } from 'spica/memoize';
+import { push } from 'spica/array';
+
+export function visualize<P extends Parser<HTMLElement | string>>(parser: P): P;
+export function visualize<T extends HTMLElement | string>(parser: Parser<T>): Parser<T> {
+  const blankline = new RegExp(
+    /^(?:\\$|\\?[^\S\n]|&IHN;|<wbr>)+$/.source.replace('IHN', `(?:${invisibleHTMLEntityNames.join('|')})`),
+    'gm');
+  return union([
+    convert(
+      source => source.replace(blankline, line => line.replace(/[\\&<]/g, '\x1B$&')),
+      verify(parser, (ns, rest, context) => !rest && hasVisible(ns, context))),
+    some(union([linebreak, unescsource])),
+  ]);
+}
+function hasVisible(
+  nodes: readonly (HTMLElement | string)[],
+  { state = 0 }: MarkdownParser.Context = {},
+): boolean {
+  for (let i = 0; i < nodes.length; ++i) {
+    const node = nodes[i];
+    if (typeof node === 'string') {
+      if (node && node.trimStart()) return true;
+    }
+    else {
+      if (node.innerText.trimStart()) return true;
+      if (state & State.media ^ State.media &&
+          (node.classList.contains('media') || node.getElementsByClassName('media')[0])) return true;
+    }
+  }
+  return false;
+}
+
+export const regBlankStart = new RegExp(
+  /^(?:\\?[^\S\n]|&IHN;|<wbr>)+/.source.replace('IHN', `(?:${invisibleHTMLEntityNames.join('|')})`));
+
+export function blankWith(delimiter: string | RegExp): RegExp;
+export function blankWith(starting: '' | '\n', delimiter: string | RegExp): RegExp;
+export function blankWith(starting: '' | '\n', delimiter?: string | RegExp): RegExp {
+  if (delimiter === undefined) return blankWith('', starting);
+  return new RegExp(String.raw
+    `^(?:(?=${
+      starting
+    })(?:\\?\s|&(?:${invisibleHTMLEntityNames.join('|')});|<wbr>)${starting && '+'})?${
+      typeof delimiter === 'string' ? delimiter.replace(/[*+()\[\]]/g, '\\$&') : delimiter.source
+    }`);
+}
+
+export function startLoose<P extends Parser<HTMLElement | string>>(parser: P, except?: string): P;
+export function startLoose<T extends HTMLElement | string>(parser: Parser<T>, except?: string): Parser<T> {
+  return (source, context) =>
+    isStartLoose(source, context, except)
+      ? parser(source, context)
+      : undefined;
+}
+const isStartLoose = reduce((source: string, context: MarkdownParser.Context, except?: string): boolean => {
+  return isStartTight(source.replace(regBlankStart, ''), context, except);
+}, (source, _, except = '') => `${source}\x1E${except}`);
+
+export function startTight<P extends Parser<unknown>>(parser: P, except?: string): P;
+export function startTight<T>(parser: Parser<T>, except?: string): Parser<T> {
+  return (source, context) =>
+    isStartTight(source, context, except)
+      ? parser(source, context)
+      : undefined;
+}
+const isStartTight = reduce((source: string, context: MarkdownParser.Context, except?: string): boolean => {
+  if (source === '') return true;
+  if (except && source.slice(0, except.length) === except) return false;
+  switch (source[0]) {
+    case ' ':
+    case '　':
+    case '\t':
+    case '\n':
+      return false;
+    case '\\':
+      return source[1]?.trimStart() !== '';
+    case '&':
+      switch (true) {
+        case source.length > 2
+          && source[1] !== ' '
+          && eval(unsafehtmlentity(source, context))?.[0]?.trimStart() === '':
+          return false;
+      }
+      return true;
+    case '<':
+      switch (true) {
+        case source.length >= 5
+          && source[1] === 'w'
+          && source.slice(0, 5) === '<wbr>':
+          return false;
+      }
+      return true;
+    default:
+      return source[0].trimStart() !== '';
+  }
+}, (source, _, except = '') => `${source}\x1E${except}`);
+
+export function isStartLooseNodes(nodes: readonly (HTMLElement | string)[]): boolean {
+  if (nodes.length === 0) return true;
+  for (let i = 0; i < nodes.length; ++i) {
+    const node = nodes[i];
+    if (isVisible(node)) return true;
+    if (typeof node === 'object') {
+      if (node.tagName === 'BR') break;
+      if (node.className === 'linebreak') break;
+    }
+  }
+  return false;
+}
+export function isStartTightNodes(nodes: readonly (HTMLElement | string)[]): boolean {
+  if (nodes.length === 0) return true;
+  return isVisible(nodes[0], 0);
+}
+//export function isEndTightNodes(nodes: readonly (HTMLElement | string)[]): boolean {
+//  if (nodes.length === 0) return true;
+//  return isVisible(nodes[nodes.length - 1], -1);
+//}
+function isVisible(node: HTMLElement | string, strpos?: number): boolean {
+  switch (typeof node) {
+    case 'string':
+      const char = node && strpos !== undefined
+        ? node[strpos >= 0 ? strpos : node.length + strpos]
+        : node;
+      switch (char) {
+        case '':
+        case ' ':
+        case '\t':
+        case '\n':
+          return false;
+        default:
+          return char.trimStart() !== '';
+      }
+    default:
+      switch (node.tagName) {
+        case 'BR':
+        case 'WBR':
+          return false;
+        case 'SPAN':
+          return node.className !== 'linebreak';
+        default:
+          return true;
+      }
+  }
+}
+
+export function trimBlank<P extends Parser<HTMLElement | string>>(parser: P): P;
+export function trimBlank<T extends HTMLElement | string>(parser: Parser<T>): Parser<T> {
+  return trimBlankStart(trimBlankEnd(parser));
+}
+export function trimBlankStart<P extends Parser<unknown>>(parser: P): P;
+export function trimBlankStart<T>(parser: Parser<T>): Parser<T> {
+  return convert(
+    reduce(source => source.replace(regBlankStart, '')),
+    parser);
+}
+export function trimBlankEnd<P extends Parser<HTMLElement | string>>(parser: P): P;
+export function trimBlankEnd<T extends HTMLElement | string>(parser: Parser<T>): Parser<T> {
+  return fmap(
+    parser,
+    trimNodeEnd);
+}
+export function trimNode<T extends HTMLElement | string>(nodes: T[]): T[] {
+  return trimNodeStart(trimNodeEnd(nodes));
+}
+function trimNodeStart<T extends HTMLElement | string>(nodes: T[]): T[] {
+  for (let node = nodes[0]; nodes.length > 0 && !isVisible(node = nodes[0], 0);) {
+    if (nodes.length === 1 && typeof node === 'object' && node.className === 'indexer') break;
+    if (typeof node === 'string') {
+      const pos = node.trimStart().length;
+      if (pos > 0) {
+        nodes[0] = node.slice(-pos) as T;
+        break;
+      }
+    }
+    nodes.shift();
+  }
+  return nodes;
+}
+function trimNodeEnd<T extends HTMLElement | string>(nodes: T[]): T[] {
+  const skip = nodes.length > 0 &&
+    typeof nodes[nodes.length - 1] === 'object' &&
+    nodes[nodes.length - 1]['className'] === 'indexer'
+    ? [nodes.pop()!]
+    : [];
+  for (let node = nodes[0]; nodes.length > 0 && !isVisible(node = nodes[nodes.length - 1], -1);) {
+    if (typeof node === 'string') {
+      const pos = node.trimEnd().length;
+      if (pos > 0) {
+        nodes[nodes.length - 1] = node.slice(0, pos) as T;
+        break;
+      }
+    }
+    nodes.pop();
+  }
+  return push(nodes, skip);
+}

package/src/util/info.ts

@@ -1,5 +1,6 @@
 import { Info } from '../..';
 import { scope } from './scope';
+import { duffReduce } from 'spica/duff';
 import { push } from 'spica/array';
 
 export function info(source: DocumentFragment | HTMLElement | ShadowRoot): Info {
@@ -20,7 +21,8 @@ export function info(source: DocumentFragment | HTMLElement | ShadowRoot): Info
   };
 
   function find<T extends HTMLElement>(selector: string): T[] {
-    return push([], source.querySelectorAll<T>(selector))
-      .filter(match);
+    return duffReduce(source.querySelectorAll<T>(selector), (acc, el) =>
+      match(el) ? push(acc, [el]) : acc
+    , [] as T[]);
   }
 }

package/src/util/quote.ts

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