securemark 0.257.3 → 0.258.0

package/src/parser/inline/emstrong.ts

@@ -1,11 +1,12 @@
 import { EmStrongParser, EmphasisParser, StrongParser } from '../inline';
 import { Result, IntermediateParser } from '../../combinator/data/parser';
-import { union, some, precedence, creator, surround, open, lazy, bind } from '../../combinator';
+import { union, syntax, some, surround, open, lazy, bind } from '../../combinator';
 import { inline } from '../inline';
 import { strong } from './strong';
 import { emphasis } from './emphasis';
 import { str } from '../source';
-import { startTight, blankWith } from '../util';
+import { Rule } from '../context';
+import { startTight, blankWith } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
@@ -26,7 +27,7 @@ const subemphasis: IntermediateParser<EmphasisParser> = lazy(() => some(union([
   ])),
 ])));
 
-export const emstrong: EmStrongParser = lazy(() => creator(precedence(1, surround(
+export const emstrong: EmStrongParser = lazy(() => syntax(Rule.none, 1, surround(
   str('***'),
   startTight(some(union([
     some(inline, blankWith('*')),
@@ -57,4 +58,4 @@ export const emstrong: EmStrongParser = lazy(() => creator(precedence(1, surroun
     }
     assert(false);
   },
-  ([as, bs], rest) => [unshift(as, bs), rest]))));
+  ([as, bs], rest) => [unshift(as, bs), rest])));

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

@@ -1,27 +1,20 @@
 import { undefined } from 'spica/global';
 import { ExtensionParser } from '../../inline';
-import { union, some, validate, guard, context, precedence, creator, surround, open, lazy, fmap } from '../../../combinator';
+import { union, some, syntax, creator, precedence, guard, state, validate, surround, open, lazy, fmap } from '../../../combinator';
 import { inline } from '../../inline';
 import { indexee, identity } from './indexee';
 import { txt, str, stropt } from '../../source';
-import { startTight, trimBlankEnd } from '../../util';
+import { Rule, State } from '../../context';
+import { startTight, trimBlankEnd } from '../../visibility';
 import { html, define, defrag } from 'typed-dom/dom';
 
 import IndexParser = ExtensionParser.IndexParser;
 
-export const index: IndexParser = lazy(() => validate('[#', creator(precedence(2, fmap(indexee(surround(
+export const index: IndexParser = lazy(() => validate('[#', syntax(Rule.index, 2, fmap(indexee(surround(
   '[#',
-  guard(context => context.syntax?.inline?.index ?? true,
+  guard(context => ~context.state! & State.index,
+  state(State.annotation | State.reference | State.index | State.label | State.link | State.media | State.autolink,
   startTight(
-  context({ syntax: { inline: {
-    annotation: false,
-    reference: false,
-    index: false,
-    label: false,
-    link: false,
-    media: false,
-    autolink: false,
-  }}},
   open(stropt(/^\|?/), trimBlankEnd(some(union([
     signature,
     inline,
@@ -37,7 +30,7 @@ export const index: IndexParser = lazy(() => validate('[#', creator(precedence(2
         href: el.id ? `#${el.id}` : undefined,
       },
       el.childNodes),
-  ])))));
+  ]))));
 
 const signature: IndexParser.SignatureParser = lazy(() => creator(fmap(open(
   '|#',

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

@@ -3,6 +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';
 
 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> {
@@ -27,35 +28,32 @@ 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;
-  for (
-    let es = target.querySelectorAll('code[data-src], .math[data-src], .comment, rt, rp, .reference, .checkbox, ul, ol'),
-        i = 0, len = es.length; i < len; ++i) {
-    const el = es[i];
+  duffEach(target.querySelectorAll('code[data-src], .math[data-src], .comment, rt, rp, .reference, .checkbox, ul, ol'), el => {
     switch (el.tagName) {
       case 'CODE':
         define(el, el.getAttribute('data-src')!);
-        continue;
+        return;
       case 'RT':
       case 'RP':
       case 'UL':
       case 'OL':
         el.remove();
-        continue;
+        return;
     }
     switch (el.className) {
       case 'math':
         define(el, el.getAttribute('data-src')!);
-        continue;
+        return;
       case 'comment':
       case 'checkbox':
         el.remove();
-        continue;
+        return;
       case 'reference':
         assert(el.firstElementChild?.hasAttribute('hidden'));
         el.firstChild!.remove();
-        continue;
+        return;
     }
-  }
+  });
   // Better:
   //return target.innerText;
   return target.textContent!;

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

@@ -1,12 +1,13 @@
 import { ExtensionParser } from '../../inline';
-import { union, verify, focus, creator, surround, fmap } from '../../../combinator';
+import { union, creator, state, verify, focus, surround, fmap } from '../../../combinator';
 import { index } from './index';
-import { clean } from '../../util';
+import { State } from '../../context';
 import { html } from 'typed-dom/dom';
 
 export const indexer: ExtensionParser.IndexerParser = creator(fmap(verify(surround(
   /^\s+(?=\[#\S)/,
-  clean(union([
+  state(State.index, false,
+  union([
     focus('[#]', () => [[html('a', { href: '#' })], '']),
     index,
   ])),

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

@@ -1,7 +1,8 @@
 import { Array } from 'spica/global';
 import { ExtensionParser } from '../../inline';
-import { union, validate, guard, creator, surround, clear, fmap } from '../../../combinator';
+import { union, guard, creator, validate, surround, clear, fmap } from '../../../combinator';
 import { str } from '../../source';
+import { State } from '../../context';
 import { html } from 'typed-dom/dom';
 
 const body = str(/^\$[A-Za-z]*(?:(?:-[A-Za-z][0-9A-Za-z]*)+|-(?:(?:0|[1-9][0-9]*)\.)*(?:0|[1-9][0-9]*)(?![0-9A-Za-z]))/);
@@ -12,7 +13,7 @@ export const segment: ExtensionParser.LabelParser.SegmentParser = clear(validate
 ])));
 
 export const label: ExtensionParser.LabelParser = validate(['[$', '$'], creator(fmap(
-  guard(context => context.syntax?.inline?.label ?? true,
+  guard(context => ~context.state! & State.label,
   union([
     surround('[', body, ']'),
     body,

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

@@ -1,8 +1,9 @@
 import { ExtensionParser } from '../../inline';
-import { union, some, validate, precedence, creator, surround, lazy } from '../../../combinator';
+import { union, some, syntax, validate, surround, lazy } from '../../../combinator';
 import { inline } from '../../inline';
 import { str } from '../../source';
-import { startTight } from '../../util';
+import { Rule } from '../../context';
+import { startTight } from '../../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
@@ -10,7 +11,7 @@ import { unshift } from 'spica/array';
 
 // All syntax surrounded by square brackets shouldn't contain line breaks.
 
-export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => validate(['[:', '[^'], creator(precedence(2, surround(
+export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => validate(['[:', '[^'], syntax(Rule.none, 2, surround(
   str(/^\[[:^]/),
   startTight(some(union([inline]), ']', [[/^\\?\n/, 9], [']', 2]])),
   str(']'), false,
@@ -22,4 +23,4 @@ export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => validat
       'data-invalid-message': `Reserved start symbol "${as[0][1]}" cannot be used in "[]"`,
     }, defrag(bs)),
   ], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest])))));
+  ([as, bs], rest) => [unshift(as, bs), rest]))));

package/src/parser/inline/html.ts

@@ -1,9 +1,10 @@
 import { undefined, Object } from 'spica/global';
 import { HTMLParser } from '../inline';
-import { union, subsequence, some, validate, focus, precedence, creator, surround, open, match, lazy } from '../../combinator';
+import { union, subsequence, some, syntax, validate, focus, surround, open, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { isStartLooseNodes, blankWith } from '../util';
+import { Rule } 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';
@@ -18,7 +19,7 @@ const attrspecs = {
 Object.setPrototypeOf(attrspecs, null);
 Object.values(attrspecs).forEach(o => Object.setPrototypeOf(o, null));
 
-export const html: HTMLParser = lazy(() => validate('<', validate(/^<[a-z]+(?=[^\S\n]|>)/, creator(precedence(5, union([
+export const html: HTMLParser = lazy(() => validate('<', validate(/^<[a-z]+(?=[^\S\n]|>)/, syntax(Rule.none, 5, union([
   focus(
     '<wbr>',
     () => [[h('wbr')], '']),
@@ -59,7 +60,7 @@ export const html: HTMLParser = lazy(() => validate('<', validate(/^<[a-z]+(?=[^
           [[elem(tag, as, bs, [])], rest]),
     ([, tag]) => tag,
     new Cache(10000))),
-]))))));
+])))));
 
 export const attribute: HTMLParser.TagParser.AttributeParser = union([
   str(/^[^\S\n]+[a-z]+(?:-[a-z]+)*(?:="(?:\\[^\n]|[^\\\n"])*")?(?=[^\S\n]|>)/),

package/src/parser/inline/htmlentity.ts

@@ -1,6 +1,6 @@
 import { undefined } from 'spica/global';
 import { HTMLEntityParser, UnsafeHTMLEntityParser } from '../inline';
-import { union, validate, focus, creator, fmap } from '../../combinator';
+import { union, creator, validate, focus, fmap } from '../../combinator';
 import { html } from 'typed-dom/dom';
 import { reduce } from 'spica/memoize';
 

package/src/parser/inline/insertion.ts

@@ -1,12 +1,13 @@
 import { InsertionParser } from '../inline';
-import { union, some, precedence, creator, surround, open, lazy } from '../../combinator';
+import { union, some, syntax, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { blankWith } from '../util';
+import { Rule } from '../context';
+import { blankWith } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
-export const insertion: InsertionParser = lazy(() => creator(precedence(1, surround(
+export const insertion: InsertionParser = lazy(() => syntax(Rule.none, 1, surround(
   str('++'),
   some(union([
     some(inline, blankWith('\n', '++')),
@@ -14,4 +15,4 @@ export const insertion: InsertionParser = lazy(() => creator(precedence(1, surro
   ])),
   str('++'), false,
   ([, bs], rest) => [[html('ins', defrag(bs))], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest]))));
+  ([as, bs], rest) => [unshift(as, bs), rest])));

package/src/parser/inline/link.ts

@@ -1,12 +1,14 @@
 import { undefined, location, encodeURI, decodeURI, Location } from 'spica/global';
 import { LinkParser, TextLinkParser } from '../inline';
 import { Result, eval } from '../../combinator/data/parser';
-import { union, inits, tails, subsequence, some, validate, guard, context, precedence, creator, surround, open, dup, reverse, lazy, fmap, bind } from '../../combinator';
+import { union, inits, tails, subsequence, some, guard, syntax, state, validate, surround, open, dup, reverse, lazy, fmap, bind } from '../../combinator';
 import { inline, media, shortmedia } from '../inline';
 import { attributes } from './html';
 import { autolink } from '../autolink';
 import { unescsource, str } from '../source';
-import { trimNode, stringify } from '../util';
+import { Rule, State } from '../context';
+import { trimNode } from '../visibility';
+import { stringify } from '../util';
 import { html, define, defrag } from 'typed-dom/dom';
 import { ReadonlyURL } from 'spica/url';
 
@@ -15,27 +17,16 @@ const optspec = {
 } as const;
 Object.setPrototypeOf(optspec, null);
 
-export const link: LinkParser = lazy(() => validate(['[', '{'], creator(10, precedence(2, bind(
-  guard(context => context.syntax?.inline?.link ?? true,
+export const link: LinkParser = lazy(() => validate(['[', '{'], syntax(Rule.link, 2, 10, bind(
+  guard(context => ~context.state! & State.link,
   fmap(subsequence([
-    context({ syntax: { inline: {
-      link: false,
-    }}},
+    state(State.link,
     dup(union([
       surround('[', media, ']'),
       surround('[', shortmedia, ']'),
       surround(
         '[',
-        context({ syntax: { inline: {
-          annotation: false,
-          reference: false,
-          index: false,
-          label: false,
-          // Redundant
-          //link: false,
-          media: false,
-          autolink: false,
-        }}},
+        state(State.annotation | State.reference | State.index | State.label | State.media | State.autolink,
         some(inline, ']', [[/^\\?\n/, 9], [']', 2]])),
         ']',
         true,
@@ -67,9 +58,9 @@ export const link: LinkParser = lazy(() => validate(['[', '{'], creator(10, prec
     if (el.classList.contains('invalid')) return [[el], rest];
     assert(el.classList.length === 0);
     return [[define(el, attributes('link', [], optspec, params))], rest];
-  })))));
+  }))));
 
-export const textlink: TextLinkParser = lazy(() => validate(['[', '{'], creator(10, precedence(2, bind(
+export const textlink: TextLinkParser = lazy(() => validate(['[', '{'], syntax(Rule.link, 2, 10, bind(
   reverse(tails([
     dup(surround('[', some(union([unescsource]), ']'), ']')),
     dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]*}/)),
@@ -92,7 +83,7 @@ export const textlink: TextLinkParser = lazy(() => validate(['[', '{'], creator(
     assert(!el.classList.contains('invalid'));
     assert(el.classList.length === 0);
     return [[define(el, attributes('link', [], optspec, params))], rest];
-  })))));
+  }))));
 
 export const uri: LinkParser.ParameterParser.UriParser = fmap(union([
   open(/^[^\S\n]+/, str(/^\S+/)),

package/src/parser/inline/mark.ts

@@ -1,12 +1,13 @@
 import { MarkParser } from '../inline';
-import { union, some, precedence, creator, surround, open, lazy } from '../../combinator';
+import { union, some, syntax, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { startTight, blankWith } from '../util';
+import { startTight, blankWith } from '../visibility';
+import { Rule } from '../context';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
-export const mark: MarkParser = lazy(() => creator(precedence(1, surround(
+export const mark: MarkParser = lazy(() => syntax(Rule.none, 1, surround(
   str('=='),
   startTight(some(union([
     some(inline, blankWith('==')),
@@ -14,4 +15,4 @@ export const mark: MarkParser = lazy(() => creator(precedence(1, surround(
   ]))),
   str('=='), false,
   ([, bs], rest) => [[html('mark', defrag(bs))], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest]))));
+  ([as, bs], rest) => [unshift(as, bs), rest])));

package/src/parser/inline/math.ts

@@ -1,5 +1,5 @@
 import { MathParser } from '../inline';
-import { union, some, validate, focus, rewrite, precedence, creator, surround, lazy } from '../../combinator';
+import { union, some, creator, precedence, validate, focus, rewrite, surround, lazy } from '../../combinator';
 import { escsource, unescsource } from '../source';
 import { html } from 'typed-dom/dom';
 

package/src/parser/inline/media.ts

@@ -1,10 +1,11 @@
 import { undefined, location } from 'spica/global';
 import { MediaParser } from '../inline';
-import { union, inits, tails, some, validate, verify, guard, precedence, creator, surround, open, dup, lazy, fmap, bind } from '../../combinator';
+import { union, inits, tails, some, creator, precedence, guard, syntax, validate, verify, surround, open, dup, lazy, fmap, bind } from '../../combinator';
 import { textlink, uri, option as linkoption, resolve } from './link';
 import { attributes } from './html';
 import { unsafehtmlentity } from './htmlentity';
 import { txt, str } from '../source';
+import { Rule, State } from '../context';
 import { html, define } from 'typed-dom/dom';
 import { ReadonlyURL } from 'spica/url';
 import { unshift, shift, push } from 'spica/array';
@@ -17,9 +18,9 @@ const optspec = {
 } as const;
 Object.setPrototypeOf(optspec, null);
 
-export const media: MediaParser = lazy(() => validate(['![', '!{'], creator(10, precedence(2, bind(verify(fmap(open(
+export const media: MediaParser = lazy(() => validate(['![', '!{'], syntax(Rule.media, 2, 10, bind(verify(fmap(open(
   '!',
-  guard(context => context.syntax?.inline?.media ?? true,
+  guard(context => ~context.state! & State.media,
   tails([
     dup(surround(
       '[',
@@ -52,19 +53,19 @@ export const media: MediaParser = lazy(() => validate(['![', '!{'], creator(10,
     if (el.hasAttribute('aspect-ratio')) {
       el.style.aspectRatio = el.getAttribute('aspect-ratio')!;
     }
-    if (context.syntax?.inline?.link === false || cache && cache.tagName !== 'IMG') return [[el], rest];
+    if (context.state! & State.link || cache && cache.tagName !== 'IMG') return [[el], rest];
     return fmap(
       textlink as MediaParser,
       ([link]) => [define(link, { target: '_blank' }, [el])])
       (`{ ${INSECURE_URI}${params.join('')} }${rest}`, context);
-  })))));
+  }))));
 
-const bracket: MediaParser.TextParser.BracketParser = lazy(() => union([
+const bracket: MediaParser.TextParser.BracketParser = lazy(() => creator(union([
   surround(str('('), some(union([unsafehtmlentity, bracket, txt]), ')'), str(')'), true, undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),
   surround(str('['), some(union([unsafehtmlentity, bracket, txt]), ']'), str(']'), true, undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),
   surround(str('{'), some(union([unsafehtmlentity, bracket, txt]), '}'), str('}'), true, undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),
   surround(str('"'), precedence(8, some(union([unsafehtmlentity, txt]), '"')), str('"'), true),
-]));
+])));
 
 const option: MediaParser.ParameterParser.OptionParser = union([
   fmap(str(/^[^\S\n]+[1-9][0-9]*x[1-9][0-9]*(?=[^\S\n]|})/), ([opt]) => [` width="${opt.slice(1).split('x')[0]}"`, ` height="${opt.slice(1).split('x')[1]}"`]),

package/src/parser/inline/reference.ts

@@ -1,35 +1,29 @@
 import { undefined } from 'spica/global';
 import { ReferenceParser } from '../inline';
-import { union, subsequence, some, validate, guard, context, precedence, creator, recursion, surround, open, lazy, bind } from '../../combinator';
+import { union, subsequence, some, context, creator, guard, syntax, state, validate, surround, open, lazy, bind } from '../../combinator';
 import { inline } from '../inline';
 import { optimize } from './link';
 import { str, stropt } from '../source';
-import { regBlankStart, startLoose, trimNode, stringify } from '../util';
+import { Rule, State } from '../context';
+import { regBlankStart, startLoose, trimNode } from '../visibility';
+import { stringify } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
-export const reference: ReferenceParser = lazy(() => validate('[[', creator(recursion(precedence(6, surround(
+export const reference: ReferenceParser = lazy(() => validate('[[', syntax(Rule.reference, 6, surround(
   '[[',
-  guard(context => context.syntax?.inline?.reference ?? true,
+  guard(context => ~context.state! & State.reference,
+  state(State.annotation | State.reference | State.media,
   startLoose(
-  context({ syntax: { inline: {
-    annotation: false,
-    reference: false,
-    media: false,
-    // Redundant
-    //index: true,
-    //label: true,
-    //link: true,
-    //autolink: true,
-  }}, delimiters: undefined },
+  context({ delimiters: undefined },
   subsequence([
     abbr,
     open(stropt(/^(?=\^)/), some(inline, ']', [[/^\\?\n/, 9], [']', 2], [']]', 6]])),
     some(inline, ']', [[/^\\?\n/, 9], [']', 2], [']]', 6]]),
-  ])), ']')),
+  ])), ']'))),
   ']]',
   false,
   ([, ns], rest) => [[html('sup', attributes(ns), [html('span', trimNode(defrag(ns)))])], rest],
-  ([, ns, rest], next) => next[0] === ']' ? undefined : optimize('[[', ns, rest)))))));
+  ([, ns, rest], next) => next[0] === ']' ? undefined : optimize('[[', ns, rest)))));
 
 const abbr: ReferenceParser.AbbrParser = creator(bind(surround(
   '^',

package/src/parser/inline/ruby.ts

@@ -1,14 +1,15 @@
 import { undefined } from 'spica/global';
 import { RubyParser } from '../inline';
 import { eval, exec } from '../../combinator/data/parser';
-import { sequence, validate, verify, focus, creator, surround, lazy, fmap } from '../../combinator';
+import { sequence, syntax, creator, validate, verify, focus, surround, lazy, fmap } from '../../combinator';
 import { unsafehtmlentity } from './htmlentity';
 import { text as txt } from '../source';
-import { isStartTightNodes } from '../util';
+import { Rule } from '../context';
+import { isStartTightNodes } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift, push } from 'spica/array';
 
-export const ruby: RubyParser = lazy(() => validate('[', creator(fmap(verify(
+export const ruby: RubyParser = lazy(() => validate('[', syntax(Rule.none, 2, fmap(verify(
   sequence([
     surround('[', focus(/^(?:\\[^\n]|[^\\[\](){}"\n])+(?=]\()/, text), ']'),
     surround('(', focus(/^(?:\\[^\n]|[^\\[\](){}"\n])+(?=\))/, text), ')'),

package/src/parser/inline/shortmedia.ts

@@ -1,10 +1,11 @@
 import { ShortmediaParser } from '../inline';
-import { union, rewrite, guard, open, convert } from '../../combinator';
+import { union, guard, rewrite, open, convert } from '../../combinator';
 import { url } from './autolink/url';
 import { media } from './media';
+import { State } from '../context';
 
 export const shortmedia: ShortmediaParser = rewrite(
-  guard(context => context.syntax?.inline?.media ?? true,
+  guard(context => ~context.state! & State.media,
   open('!', url)),
   convert(
     source => `!{ ${source.slice(1)} }`,

package/src/parser/inline/strong.ts

@@ -1,13 +1,14 @@
 import { StrongParser } from '../inline';
-import { union, some, precedence, creator, surround, open, lazy } from '../../combinator';
+import { union, some, syntax, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { emstrong } from './emstrong';
 import { str } from '../source';
-import { startTight, blankWith } from '../util';
+import { Rule } from '../context';
+import { startTight, blankWith } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
-export const strong: StrongParser = lazy(() => creator(precedence(1, surround(
+export const strong: StrongParser = lazy(() => syntax(Rule.none, 1, surround(
   str('**'),
   startTight(some(union([
     some(inline, blankWith('**')),
@@ -18,4 +19,4 @@ export const strong: StrongParser = lazy(() => creator(precedence(1, surround(
   ])), '*'),
   str('**'), false,
   ([, bs], rest) => [[html('strong', defrag(bs))], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest]))));
+  ([as, bs], rest) => [unshift(as, bs), rest])));

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(2, 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/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';