securemark 0.257.2 → 0.258.1

package/src/parser/inline/autolink/url.ts

@@ -1,5 +1,5 @@
 import { AutolinkParser } from '../../inline';
-import { union, some, validate, focus, rewrite, precedence, creator, convert, surround, open, lazy } from '../../../combinator';
+import { union, some, creator, precedence, validate, focus, rewrite, convert, surround, open, lazy } from '../../../combinator';
 import { textlink } from '../link';
 import { unescsource } from '../../source';
 

package/src/parser/inline/autolink.ts

@@ -1,5 +1,5 @@
 import { AutolinkParser } from '../inline';
-import { union, some, validate, guard, fmap } from '../../combinator';
+import { union, some, syntax, guard, validate, fmap } from '../../combinator';
 import { url } from './autolink/url';
 import { email } from './autolink/email';
 import { channel } from './autolink/channel';
@@ -8,11 +8,13 @@ import { hashtag, emoji } from './autolink/hashtag';
 import { hashnum } from './autolink/hashnum';
 import { anchor } from './autolink/anchor';
 import { str } from '../source';
+import { Rule, State } from '../context';
 import { stringify } from '../util';
 
 export const autolink: AutolinkParser = fmap(
   validate(/^(?:[@#>0-9A-Za-z]|\S#)/,
-  guard(context => context.syntax?.inline?.autolink ?? true,
+  guard(context => ~context.state! & State.autolink,
+  syntax(Rule.autolink, 1,
   some(union([
     url,
     email,
@@ -29,5 +31,5 @@ export const autolink: AutolinkParser = fmap(
     // Escape unmatched hashtag-like strings.
     str(new RegExp(/^#+(?:[^\p{C}\p{S}\p{P}\s]|emoji|['_])*/u.source.replace('emoji', emoji), 'u')),
     anchor,
-  ])))),
+  ]))))),
   ns => ns.length === 1 ? ns : [stringify(ns)]);

package/src/parser/inline/bracket.ts

@@ -1,30 +1,31 @@
 import { undefined } from 'spica/global';
 import { BracketParser } from '../inline';
-import { union, some, precedence, creator, surround, lazy } from '../../combinator';
+import { union, some, syntax, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
+import { Rule } from '../context';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift, push } from 'spica/array';
 
 const index = /^[0-9A-Za-z]+(?:(?:[.-]|, )[0-9A-Za-z]+)*/;
 
-export const bracket: BracketParser = lazy(() => creator(0, union([
-  surround(str('('), precedence(2, str(index)), str(')')),
-  surround(str('('), precedence(2, some(inline, ')', [[')', 2]])), str(')'), true,
+export const bracket: BracketParser = lazy(() => union([
+  syntax(Rule.none, 2, surround(str('('), str(index), str(')'))),
+  syntax(Rule.bracket, 2, surround(str('('), some(inline, ')', [[')', 2]]), str(')'), true,
     ([as, bs = [], cs], rest) => [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))], rest],
-    ([as, bs = []], rest) => [unshift([''], unshift(as, bs)), rest]),
-  surround(str('（'), precedence(2, str(new RegExp(index.source.replace(', ', '[，、]').replace(/[09AZaz.]|\-(?!\w)/g, c => c.trimStart() && String.fromCharCode(c.charCodeAt(0) + 0xFEE0))))), str('）')),
-  surround(str('（'), precedence(2, some(inline, '）', [['）', 2]])), str('）'), true,
+    ([as, bs = []], rest) => [unshift([''], unshift(as, bs)), rest])),
+  syntax(Rule.none, 2, surround(str('（'), str(new RegExp(index.source.replace(', ', '[，、]').replace(/[09AZaz.]|\-(?!\w)/g, c => c.trimStart() && String.fromCharCode(c.charCodeAt(0) + 0xFEE0)))), str('）'))),
+  syntax(Rule.bracket, 2, surround(str('（'), some(inline, '）', [['）', 2]]), str('）'), true,
     ([as, bs = [], cs], rest) => [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))], rest],
-    ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  surround(str('['), precedence(2, some(inline, ']', [[']', 2]])), str(']'), true,
+    ([as, bs = []], rest) => [unshift(as, bs), rest])),
+  syntax(Rule.bracket, 2, surround(str('['), some(inline, ']', [[']', 2]]), str(']'), true,
     undefined,
-    ([as, bs = []], rest) => [unshift([''], unshift(as, bs)), rest]),
-  surround(str('{'), precedence(2, some(inline, '}', [['}', 2]])), str('}'), true,
+    ([as, bs = []], rest) => [unshift([''], unshift(as, bs)), rest])),
+  syntax(Rule.bracket, 2, surround(str('{'), some(inline, '}', [['}', 2]]), str('}'), true,
     undefined,
-    ([as, bs = []], rest) => [unshift(as, bs), rest]),
+    ([as, bs = []], rest) => [unshift(as, bs), rest])),
   // Control media blinking in editing rather than control confusion of pairs of quote marks.
-  surround(str('"'), precedence(8, some(inline, '"', [['"', 8]])), str('"'), true,
+  syntax(Rule.quote, 8, surround(str('"'), some(inline, '"', [['"', 8]]), str('"'), true,
     undefined,
-    ([as, bs = []], rest) => [unshift(as, bs), rest]),
-])));
+    ([as, bs = []], rest) => [unshift(as, bs), rest])),
+]));

package/src/parser/inline/code.ts

@@ -1,5 +1,5 @@
 import { CodeParser } from '../inline';
-import { validate, creator, match } from '../../combinator';
+import { creator, validate, match } from '../../combinator';
 import { html } from 'typed-dom/dom';
 
 export const code: CodeParser = creator(validate('`', match(

package/src/parser/inline/comment.ts

@@ -1,12 +1,13 @@
 import { CommentParser } from '../inline';
-import { union, some, validate, precedence, creator, surround, open, close, match, lazy } from '../../combinator';
+import { union, some, syntax, validate, surround, open, close, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { text, str } from '../source';
+import { Rule } from '../context';
 import { html, defrag } from 'typed-dom/dom';
 import { memoize } from 'spica/memoize';
 import { unshift, push } from 'spica/array';
 
-export const comment: CommentParser = lazy(() => validate('[%', creator(precedence(4, match(
+export const comment: CommentParser = lazy(() => validate('[%', syntax(Rule.none, 4, match(
   /^\[(%+)\s/,
   memoize(
   ([, fence]) =>
@@ -21,4 +22,4 @@ export const comment: CommentParser = lazy(() => validate('[%', creator(preceden
         ]),
       ], rest],
       ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  ([, fence]) => fence.length, []))))));
+  ([, fence]) => fence.length, [])))));

package/src/parser/inline/deletion.ts

@@ -1,12 +1,13 @@
 import { DeletionParser } 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 deletion: DeletionParser = lazy(() => creator(precedence(1, surround(
+export const deletion: DeletionParser = lazy(() => syntax(Rule.none, 1, surround(
   str('~~'),
   some(union([
     some(inline, blankWith('\n', '~~')),
@@ -14,4 +15,4 @@ export const deletion: DeletionParser = lazy(() => creator(precedence(1, surroun
   ])),
   str('~~'), false,
   ([, bs], rest) => [[html('del', defrag(bs))], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest]))));
+  ([as, bs], rest) => [unshift(as, bs), rest])));

package/src/parser/inline/emphasis.ts

@@ -1,14 +1,15 @@
 import { EmphasisParser } 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 { strong } from './strong';
 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 emphasis: EmphasisParser = lazy(() => creator(precedence(1, surround(
+export const emphasis: EmphasisParser = lazy(() => syntax(Rule.none, 1, surround(
   str('*'),
   startTight(some(union([
     strong,
@@ -21,4 +22,4 @@ export const emphasis: EmphasisParser = lazy(() => creator(precedence(1, surroun
   ])), '*'),
   str('*'), false,
   ([, bs], rest) => [[html('em', defrag(bs))], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest]))));
+  ([as, bs], rest) => [unshift(as, bs), rest])));

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.test.ts

@@ -45,6 +45,7 @@ describe('Unit: parser/inline/link', () => {
     it('invalid', () => {
       assert.deepStrictEqual(inspect(parser('')), undefined);
       assert.deepStrictEqual(inspect(parser('{}')), undefined);
+      assert.deepStrictEqual(inspect(parser('[{b}')), [['', '[', '<a href="b">b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[]')), undefined);
       assert.deepStrictEqual(inspect(parser('[]{}')), undefined);
       assert.deepStrictEqual(inspect(parser('[]{ }')), undefined);
@@ -64,7 +65,7 @@ describe('Unit: parser/inline/link', () => {
       assert.deepStrictEqual(inspect(parser('[\\ ]{b}')), undefined);
       assert.deepStrictEqual(inspect(parser('[\\\n]{b}')), undefined);
       assert.deepStrictEqual(inspect(parser('[&Tab;]{b}')), undefined);
-      assert.deepStrictEqual(inspect(parser('[[]{b}')), undefined);
+      assert.deepStrictEqual(inspect(parser('[[]{b}')), [['', '[', '<a href="b">b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[]]{b}')), undefined);
       assert.deepStrictEqual(inspect(parser('[a]{}')), undefined);
       assert.deepStrictEqual(inspect(parser('[a\nb]{b}')), undefined);

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,41 +17,29 @@ 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,
         undefined,
-        ([, ns = [], rest], next) => next[0] === ']' ? undefined : optimize('[', ns, rest)),
+        ([, ns = [], rest], next) => next[0] === ']' ? undefined : optimize('[', ns, rest, next)),
     ]))),
-    // 全体の失敗が確定した時も解析し予算を浪費している
     dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]*}/)),
-  ]),
+  ], nodes => nodes[0][0] !== ''),
   ([as, bs = []]) => bs[0] === '\r' && bs.shift() ? [as, bs] : as[0] === '\r' && as.shift() ? [[], as] : [as, []])),
   ([content, params]: [(HTMLElement | string)[], string[]], rest, context) => {
-    if (params.length === 0) return;
     assert(content[0] !== '' || params.length === 0);
     if (content[0] === '') return [content, rest];
+    if (params.length === 0) return;
     assert(params.every(p => typeof p === 'string'));
     if (content.length !== 0 && trimNode(content).length === 0) return;
     if (eval(some(autolink)(stringify(content), context))?.some(node => typeof node === 'object')) return;
@@ -67,9 +57,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 +82,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+/)),
@@ -196,11 +186,15 @@ function decode(uri: string): string {
   }
 }
 
-export function optimize(opener: string, ns: readonly (string | HTMLElement)[], rest: string): Result<string> {
+export function optimize(opener: string, ns: readonly (string | HTMLElement)[], rest: string, next: string): Result<string> {
+  if (next[+(next[0] === '\\')] === '\n') return;
   let count = 0;
   for (let i = 0; i < ns.length - 1; i += 2) {
-    if (ns[i] !== '' || ns[i + 1] !== opener[0]) break;
-    ++count;
+    const fst = ns[i];
+    const snd = ns[i + 1] as string;
+    assert(typeof snd === 'string');
+    if (fst !== '' || snd[0] !== opener[0]) break;
+    count += snd.length;
   }
   return [['', opener[0].repeat(opener.length + count)], rest.slice(count)];
 }

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.test.ts

@@ -22,6 +22,7 @@ describe('Unit: parser/inline/media', () => {
       assert.deepStrictEqual(inspect(parser('{}')), undefined);
       assert.deepStrictEqual(inspect(parser('[]')), undefined);
       assert.deepStrictEqual(inspect(parser('!{}')), undefined);
+      assert.deepStrictEqual(inspect(parser('![{b}')), undefined);
       assert.deepStrictEqual(inspect(parser('![]')), undefined);
       assert.deepStrictEqual(inspect(parser('![]{}')), undefined);
       assert.deepStrictEqual(inspect(parser('![]{ }')), undefined);

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]}"`]),