securemark 0.257.2 → 0.258.1

package/src/combinator/data/parser.ts

@@ -1,3 +1,6 @@
+import { Delimiters } from './parser/context/delimiter';
+import { Memo } from './parser/context/memo';
+
 export type Parser<T, C extends Ctx = Ctx, D extends Parser<unknown, C>[] = any>
   = (source: string, context: C) => Result<T, C, D>;
 export type Result<T, C extends Ctx = Ctx, D extends Parser<unknown, C>[] = any>
@@ -11,6 +14,9 @@ export interface Ctx {
   };
   precedence?: number;
   delimiters?: Delimiters;
+  state?: number;
+  backtrackable?: number;
+  memo?: Memo;
 }
 export type Tree<P extends Parser<unknown>> = P extends Parser<infer T> ? T : never;
 export type SubParsers<P extends Parser<unknown>> = P extends Parser<unknown, Ctx, infer D> ? D : never;
@@ -20,53 +26,6 @@ export type IntermediateParser<P extends Parser<unknown>> = Parser<SubTree<P>, C
 type ExtractSubTree<D extends Parser<unknown>[]> = ExtractSubParser<D> extends infer T ? T extends Parser<infer U> ? U : never : never;
 type ExtractSubParser<D extends Parser<unknown>[]> = D extends (infer P)[] ? P extends Parser<unknown> ? P : never : never;
 
-export class Delimiters {
-  private readonly matchers: [number, string, number, (source: string) => boolean | undefined][] = [];
-  private readonly registry: Record<string, boolean> = {};
-  private length = 0;
-  public push(
-    ...delimiters: readonly {
-      readonly signature: string;
-      readonly matcher: (source: string) => boolean | undefined;
-      readonly precedence?: number;
-    }[]
-  ): void {
-    for (let i = 0; i < delimiters.length; ++i) {
-      const delimiter = delimiters[i];
-      assert(this.length >= this.matchers.length);
-      const { signature, matcher, precedence = 1 } = delimiter;
-      if (!this.registry[signature]) {
-        this.matchers.unshift([this.length, signature, precedence, matcher]);
-        this.registry[signature] = true;
-      }
-      ++this.length;
-    }
-  }
-  public pop(count = 1): void {
-    assert(count > 0);
-    for (let i = 0; i < count; ++i) {
-      assert(this.matchers.length > 0);
-      assert(this.length >= this.matchers.length);
-      if (--this.length === this.matchers[0][0]) {
-        this.registry[this.matchers.shift()![1]] = false;
-      }
-    }
-  }
-  public match(source: string, precedence = 1): boolean {
-    const { matchers } = this;
-    for (let i = 0; i < matchers.length; ++i) {
-      switch (matchers[i][3](source)) {
-        case true:
-          if (precedence < matchers[i][2]) return true;
-          continue;
-        case false:
-          return false;
-      }
-    }
-    return false;
-  }
-}
-
 export { eval_ as eval };
 function eval_<T>(result: NonNullable<Result<T>>, default_?: T[]): T[];
 function eval_<T>(result: Result<T>, default_: T[]): T[];

package/src/combinator.ts

@@ -4,14 +4,13 @@ export * from './combinator/data/parser/tails';
 export * from './combinator/data/parser/sequence';
 export * from './combinator/data/parser/subsequence';
 export * from './combinator/data/parser/some';
+export * from './combinator/data/parser/context';
 export * from './combinator/control/constraint/block';
 export * from './combinator/control/constraint/line';
 export * from './combinator/control/constraint/contract';
 export * from './combinator/control/manipulation/fence';
 export * from './combinator/control/manipulation/indent';
 export * from './combinator/control/manipulation/scope';
-export * from './combinator/control/manipulation/context';
-export * from './combinator/control/manipulation/resource';
 export * from './combinator/control/manipulation/surround';
 export * from './combinator/control/manipulation/match';
 export * from './combinator/control/manipulation/convert';

package/src/parser/api/bind.ts

@@ -2,9 +2,10 @@ import { undefined, location } from 'spica/global';
 import { ParserSettings, Progress } from '../../..';
 import { MarkdownParser } from '../../../markdown';
 import { eval } from '../../combinator/data/parser';
+import { segment, validate, MAX_INPUT_SIZE } from '../segment';
 import { header } from '../header';
 import { block } from '../block';
-import { segment, validate, MAX_INPUT_SIZE } from '../segment';
+import { backtrackable } from '../context';
 import { normalize } from './normalize';
 import { headers } from './header';
 import { figure } from '../processor/figure';
@@ -23,6 +24,7 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
   let context: MarkdownParser.Context = {
     ...settings,
     host: settings.host ?? new ReadonlyURL(location.pathname, location.origin),
+    backtrackable,
   };
   if (context.host?.origin === 'null') throw new Error(`Invalid host: ${context.host.href}`);
   assert(!settings.id);
@@ -141,8 +143,7 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
 
   function nearest(index: number): HTMLElement | undefined {
     let el: HTMLElement | undefined;
-    let len = 0;
-    for (let i = 0; i < blocks.length; ++i) {
+    for (let i = 0, len = 0; i < blocks.length; ++i) {
       const block = blocks[i];
       len += block[0].length;
       el = block[1][0] ?? el;
@@ -152,8 +153,7 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
   }
 
   function index(source: HTMLElement): number {
-    let len = 0;
-    for (let i = 0; i < blocks.length; ++i) {
+    for (let i = 0, len = 0; i < blocks.length; ++i) {
       const block = blocks[i];
       if (block[1].includes(source)) return len;
       len += block[0].length;

package/src/parser/api/parse.test.ts

@@ -234,6 +234,15 @@ describe('Unit: parser/api/parse', () => {
     });
 
     it('recursion', () => {
+      assert.deepStrictEqual(
+        [...parse('{'.repeat(20)).children].map(el => el.outerHTML),
+        [`<p>${'{'.repeat(20)}</p>`]);
+      assert.deepStrictEqual(
+        [...parse('{'.repeat(21)).children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
+        [
+          '<h1 id="error:rnd" class="error">Error: Too much recursion</h1>',
+          `<pre class="error" translate="no">${'{'.repeat(21)}</pre>`,
+        ]);
       assert.deepStrictEqual(
         [...parse('('.repeat(20)).children].map(el => el.outerHTML),
         [`<p>${'('.repeat(20)}</p>`]);
@@ -253,14 +262,8 @@ describe('Unit: parser/api/parse', () => {
           `<pre class="error" translate="no">${'['.repeat(21)}</pre>`,
         ]);
       assert.deepStrictEqual(
-        [...parse('{'.repeat(20)).children].map(el => el.outerHTML),
-        [`<p>${'{'.repeat(20)}</p>`]);
-      assert.deepStrictEqual(
-        [...parse('{'.repeat(21)).children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
-        [
-          '<h1 id="error:rnd" class="error">Error: Too much recursion</h1>',
-          `<pre class="error" translate="no">${'{'.repeat(21)}</pre>`,
-        ]);
+        [...parse('['.repeat(17) + '\na').children].map(el => el.outerHTML),
+        [`<p>${'['.repeat(17)}<br>a</p>`]);
     });
 
     if (!navigator.userAgent.includes('Chrome')) return;

package/src/parser/api/parse.ts

@@ -2,9 +2,10 @@ import { location } from 'spica/global';
 import { ParserOptions } from '../../..';
 import { MarkdownParser } from '../../../markdown';
 import { eval } from '../../combinator/data/parser';
+import { segment, validate, MAX_SEGMENT_SIZE } from '../segment';
 import { header } from '../header';
 import { block } from '../block';
-import { segment, validate, MAX_SEGMENT_SIZE } from '../segment';
+import { backtrackable } from '../context';
 import { normalize } from './normalize';
 import { headers } from './header';
 import { figure } from '../processor/figure';
@@ -29,6 +30,7 @@ export function parse(source: string, opts: Options = {}, context?: MarkdownPars
     ...context?.resources && {
       resources: context.resources,
     },
+    backtrackable,
   };
   if (context.host?.origin === 'null') throw new Error(`Invalid host: ${context.host.href}`);
   const node = frag();

package/src/parser/block/blockquote.ts

@@ -1,5 +1,5 @@
 import { BlockquoteParser } from '../block';
-import { union, some, block, validate, rewrite, creator, open, convert, lazy, fmap } from '../../combinator';
+import { union, some, creator, block, validate, rewrite, open, convert, lazy, fmap } from '../../combinator';
 import { autolink } from '../autolink';
 import { contentline } from '../source';
 import { parse } from '../api/parse';

package/src/parser/block/dlist.ts

@@ -1,23 +1,17 @@
 import { DListParser } from '../block';
-import { union, inits, some, block, line, validate, rewrite, context, creator, open, trimEnd, lazy, fmap } from '../../combinator';
+import { union, inits, some, creator, state, block, line, validate, rewrite, open, trimEnd, lazy, fmap } from '../../combinator';
 import { inline, indexee, indexer } from '../inline';
 import { anyline } from '../source';
+import { State } from '../context';
 import { localize } from '../locale';
-import { visualize, trimBlank } from '../util';
+import { visualize, trimBlank } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { push } from 'spica/array';
 
 export const dlist: DListParser = lazy(() => block(localize(fmap(validate(
   /^~[^\S\n]+(?=\S)/,
   some(inits([
-    context({ syntax: { inline: {
-      annotation: false,
-      reference: false,
-      index: false,
-      label: false,
-      link: false,
-      media: false,
-    }}},
+    state(State.annotation | State.reference | State.index | State.label | State.link | State.media,
     some(term)),
     some(desc),
   ]))),

package/src/parser/block/extension/figure.ts

@@ -1,6 +1,6 @@
 import { undefined } from 'spica/global';
 import { ExtensionParser } from '../../block';
-import { union, inits, sequence, some, block, line, fence, rewrite, context, close, match, convert, trimEnd, fallback, fmap } from '../../../combinator';
+import { union, inits, sequence, some, state, block, line, fence, rewrite, close, match, convert, trimEnd, fallback, fmap } from '../../../combinator';
 import { str, contentline, emptyline } from '../../source';
 import { label, segment as seg_label } from '../../inline/extension/label';
 import { ulist } from '../ulist';
@@ -13,8 +13,9 @@ import { table, segment_ as seg_table } from './table';
 import { blockquote, segment as seg_blockquote } from '../blockquote';
 import { placeholder, segment_ as seg_placeholder } from './placeholder';
 import { inline, media, shortmedia } from '../../inline';
+import { State } from '../../context';
 import { localize } from '../../locale';
-import { visualize, trimBlank } from '../../util';
+import { visualize, trimBlank } from '../../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { memoize } from 'spica/memoize';
 
@@ -66,7 +67,7 @@ export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
       ])),
       emptyline,
       block(localize(
-        context({ syntax: { inline: { media: false } } },
+        state(State.media,
         visualize(trimBlank(trimEnd(some(inline))))))),
     ]),
   ])),

package/src/parser/block/extension/table.ts

@@ -2,11 +2,11 @@ import { undefined, BigInt, Array } from 'spica/global';
 import { max, min, isArray } from 'spica/alias';
 import { ExtensionParser } from '../../block';
 import { Tree, eval } from '../../../combinator/data/parser';
-import { union, subsequence, inits, some, block, line, validate, fence, rewrite, creator, open, clear, convert, trim, dup, lazy, fmap } from '../../../combinator';
+import { union, subsequence, inits, some, creator, block, line, validate, fence, rewrite, open, clear, convert, trim, dup, lazy, fmap } from '../../../combinator';
 import { inline } from '../../inline';
 import { str, anyline, emptyline, contentline } from '../../source';
 import { localize } from '../../locale';
-import { visualize } from '../../util';
+import { visualize } from '../../visibility';
 import { html, define, defrag } from 'typed-dom/dom';
 import { unshift, splice } from 'spica/array';
 

package/src/parser/block/heading.ts

@@ -1,8 +1,9 @@
 import { HeadingParser } from '../block';
-import { union, some, block, line, validate, focus, rewrite, context, open, fmap } from '../../combinator';
+import { union, some, state, block, line, validate, focus, rewrite, open, fmap } from '../../combinator';
 import { inline, indexee, indexer } from '../inline';
 import { str } from '../source';
-import { visualize, trimBlank } from '../util';
+import { State } from '../context';
+import { visualize, trimBlank } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 
 export const segment: HeadingParser.SegmentParser = block(validate('#', focus(
@@ -10,23 +11,14 @@ export const segment: HeadingParser.SegmentParser = block(validate('#', focus(
   some(line(source => [[source], ''])))));
 
 export const heading: HeadingParser = block(rewrite(segment,
-  context({ syntax: { inline: {
-    annotation: false,
-    reference: false,
-    index: false,
-    label: false,
-    link: false,
-    media: false,
-  }}},
+  state(State.annotation | State.reference | State.index | State.label | State.link | State.media,
   line(indexee(fmap(union([
     open(
       str(/^##+/),
       visualize(trimBlank(some(union([indexer, inline])))), true),
     open(
       str('#'),
-      context({ syntax: { inline: {
-        autolink: false,
-      }}},
+      state(State.autolink,
       visualize(trimBlank(some(union([indexer, inline]))))), true),
   ]),
   ([h, ...ns]: [string, ...(HTMLElement | string)[]]) => [

package/src/parser/block/ilist.ts

@@ -1,13 +1,14 @@
 import { IListParser } from '../block';
-import { union, inits, some, block, line, validate, indent, context, creator, open, fallback, lazy, fmap } from '../../combinator';
+import { union, inits, some, creator, state, block, line, validate, indent, open, fallback, lazy, fmap } from '../../combinator';
 import { ulist_, fillFirstLine } from './ulist';
 import { olist_, invalid } from './olist';
 import { inline } from '../inline';
+import { State } from '../context';
 import { html, defrag } from 'typed-dom/dom';
 
 export const ilist: IListParser = lazy(() => block(validate(
   /^[-+*](?=[^\S\n]|\n[^\S\n]*\S)/,
-  context({ syntax: { inline: { media: false } } },
+  state(State.media,
   ilist_))));
 
 export const ilist_: IListParser = lazy(() => block(fmap(validate(

package/src/parser/block/olist.ts

@@ -1,13 +1,15 @@
 import { undefined } from 'spica/global';
 import { OListParser } from '../block';
-import { union, inits, subsequence, some, block, line, validate, indent, focus, rewrite, context, creator, open, match, fallback, lazy, fmap } from '../../combinator';
+import { union, inits, subsequence, some, creator, state, block, line, validate, indent, focus, rewrite, open, match, fallback, lazy, fmap } from '../../combinator';
 import { checkbox, ulist_, fillFirstLine } from './ulist';
 import { ilist_ } from './ilist';
 import { inline, indexee, indexer } from '../inline';
 import { contentline } from '../source';
-import { trimBlank } from '../util';
+import { State } from '../context';
+import { trimBlank } from '../visibility';
 import { html, define, defrag } from 'typed-dom/dom';
 import { memoize } from 'spica/memoize';
+import { duffbk } from 'spica/duff';
 import { shift } from 'spica/array';
 import { tuple } from 'spica/tuple';
 
@@ -21,7 +23,7 @@ export const olist: OListParser = lazy(() => block(validate(
     /^([0-9]+|[a-z]+|[A-Z]+)(?:-[0-9]+)*\.(?=[^\S\n]|\n[^\S\n]*\S)/.source,
     /^\(([0-9]+|[a-z]+)\)(?:-[0-9]+)*(?=[^\S\n]|\n[^\S\n]*\S)/.source,
   ].join('|')),
-  context({ syntax: { inline: { media: false } } },
+  state(State.media,
   olist_))));
 
 export const olist_: OListParser = lazy(() => block(union([
@@ -122,15 +124,16 @@ function format(el: HTMLOListElement, type: string, form: string): HTMLOListElem
     'data-type': style(type) || undefined,
   });
   const marker = el.firstElementChild?.getAttribute('data-marker')!.match(initial(type))?.[0] ?? '';
-  for (let es = el.children, len = es.length, i = 0; i < len; ++i) {
+  const es = el.children;
+  duffbk(es.length, i => {
     const el = es[i];
     switch (el.getAttribute('data-marker')) {
       case '':
       case marker:
         el.removeAttribute('data-marker');
-        continue;
+        return;
     }
-    break;
-  }
+    return false;
+  });
   return el;
 }

package/src/parser/block/paragraph.ts

@@ -2,7 +2,7 @@ import { ParagraphParser } from '../block';
 import { union, some, block, trimEnd, fmap } from '../../combinator';
 import { inline } from '../inline';
 import { localize } from '../locale';
-import { visualize } from '../util';
+import { visualize } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 
 export const paragraph: ParagraphParser = block(localize(fmap(

package/src/parser/block/reply/cite.ts

@@ -1,5 +1,5 @@
 import { ReplyParser } from '../../block';
-import { union, tails, line, validate, focus, creator, reverse, fmap } from '../../../combinator';
+import { union, tails, creator, line, validate, focus, reverse, fmap } from '../../../combinator';
 import { anchor } from '../../inline/autolink/anchor';
 import { str } from '../../source';
 import { html, define, defrag } from 'typed-dom/dom';

package/src/parser/block/reply/quote.ts

@@ -1,6 +1,6 @@
 import { ReplyParser } from '../../block';
 import { eval } from '../../../combinator/data/parser';
-import { union, some, block, line, validate, rewrite, creator, lazy, fmap } from '../../../combinator';
+import { union, some, creator, block, line, validate, rewrite, lazy, fmap } from '../../../combinator';
 import { math } from '../../inline/math';
 import { str, anyline } from '../../source';
 import { autolink } from '../../autolink';

package/src/parser/block/reply.ts

@@ -5,7 +5,7 @@ import { quote, syntax as delimiter } from './reply/quote';
 import { inline } from '../inline';
 import { anyline } from '../source';
 import { localize } from '../locale';
-import { visualize } from '../util';
+import { visualize } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { push, pop } from 'spica/array';
 

package/src/parser/block/sidefence.ts

@@ -1,5 +1,5 @@
 import { SidefenceParser } from '../block';
-import { union, some, block, focus, rewrite, creator, convert, lazy, fmap } from '../../combinator';
+import { union, some, creator, block, focus, rewrite, convert, lazy, fmap } from '../../combinator';
 import { autolink } from '../autolink';
 import { contentline } from '../source';
 import { html, define, defrag } from 'typed-dom/dom';

package/src/parser/block/table.test.ts

@@ -29,6 +29,11 @@ describe('Unit: parser/block/table', () => {
       assert.deepStrictEqual(inspect(parser('|\n|-\n|')), [['<table><thead><tr></tr></thead><tbody><tr></tr></tbody></table>'], '']);
       assert.deepStrictEqual(inspect(parser('||\n|-|\n||')), [['<table><thead><tr><th></th></tr></thead><tbody><tr><td></td></tr></tbody></table>'], '']);
       assert.deepStrictEqual(inspect(parser('|||\n|-|-|\n|||')), [['<table><thead><tr><th></th><th></th></tr></thead><tbody><tr><td></td><td></td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|"|\n|-\n|')), [['<table><thead><tr><th>"</th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|`|\n|-\n|')), [['<table><thead><tr><th>`</th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|`|`|\n|-\n|')), [['<table><thead><tr><th><code data-src="`|`">|</code></th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|((|\n|-\n|')), [['<table><thead><tr><th>((</th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|${|\n|-\n|')), [['<table><thead><tr><th>${</th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
       assert.deepStrictEqual(inspect(parser('|a|b|\n|-|-|\n|1|2|')), [['<table><thead><tr><th>a</th><th>b</th></tr></thead><tbody><tr><td>1</td><td>2</td></tr></tbody></table>'], '']);
       assert.deepStrictEqual(inspect(parser('|a|b\n|-|-\n|1|2')), [['<table><thead><tr><th>a</th><th>b</th></tr></thead><tbody><tr><td>1</td><td>2</td></tr></tbody></table>'], '']);
       assert.deepStrictEqual(inspect(parser('|a|\n|-|\n|1|')), [['<table><thead><tr><th>a</th></tr></thead><tbody><tr><td>1</td></tr></tbody></table>'], '']);

package/src/parser/block/table.ts

@@ -1,8 +1,10 @@
 import { TableParser } from '../block';
-import { union, sequence, some, block, line, validate, focus, rewrite, creator, surround, open, fallback, lazy, fmap } from '../../combinator';
+import { union, sequence, some, creator, block, line, validate, focus, rewrite, surround, open, fallback, lazy, fmap } from '../../combinator';
 import { inline } from '../inline';
 import { contentline } from '../source';
+import { trimNode } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
+import { duffEach, duffReduce } from 'spica/duff';
 import { push } from 'spica/array';
 
 import RowParser = TableParser.RowParser;
@@ -24,7 +26,7 @@ export const table: TableParser = lazy(() => block(fmap(validate(
   ])));
 
 const row = <P extends CellParser | AlignParser>(parser: P, optional: boolean): RowParser<P> => creator(fallback(fmap(
-  line(surround(/^(?=\|)/, some(union([parser])), /^\|?\s*$/, optional)),
+  line(surround(/^(?=\|)/, some(union([parser])), /^[|\\]?\s*$/, optional)),
   es => [html('tr', es)]),
   rewrite(contentline, source => [[
     html('tr', {
@@ -46,31 +48,30 @@ const align: AlignParser = creator(fmap(open(
   ns => [html('td', defrag(ns))]));
 
 const cell: CellParser = surround(
-  /^\|(?:\\?\s)*(?=\S)/,
-  some(union([inline]), /^(?:\\?\s)*(?=\||\\?$)/),
+  /^\|\s*(?=\S)/,
+  some(union([inline]), /^\|/, [[/^[|\\]?\s*$/, 9]]),
   /^[^|]*/, true);
 
 const head: CellParser.HeadParser = creator(fmap(
   cell,
-  ns => [html('th', defrag(ns))]));
+  ns => [html('th', trimNode(defrag(ns)))]));
 
 const data: CellParser.DataParser = creator(fmap(
   cell,
-  ns => [html('td', defrag(ns))]));
+  ns => [html('td', trimNode(defrag(ns)))]));
 
 function format(rows: HTMLTableRowElement[]): HTMLTableRowElement[] {
   const aligns = rows[0].classList.contains('invalid')
     ? []
-    : push([], rows.shift()!.children).map(el => el.textContent!);
-  for (let i = 0, len = rows.length; i < len; ++i) {
-    const cols = rows[i].children;
-    for (let i = 0, len = cols.length; i < len; ++i) {
+    : duffReduce(rows.shift()!.children, (acc, el) => push(acc, [el.textContent!]), [] as string[]);
+  for (let i = 0; i < rows.length; ++i) {
+    duffEach(rows[i].children, (col, i) => {
       if (i > 0 && !aligns[i]) {
         aligns[i] = aligns[i - 1];
       }
-      if (!aligns[i]) continue;
-      cols[i].setAttribute('align', aligns[i]);
-    }
+      if (!aligns[i]) return;
+      col.setAttribute('align', aligns[i]);
+    });
   }
   return rows;
 }

package/src/parser/block/ulist.ts

@@ -1,15 +1,16 @@
 import { UListParser } from '../block';
-import { union, inits, subsequence, some, block, line, validate, indent, focus, context, creator, open, fallback, lazy, fmap } from '../../combinator';
+import { union, inits, subsequence, some, creator, state, block, line, validate, indent, focus, open, fallback, lazy, fmap } from '../../combinator';
 import { olist_, invalid } from './olist';
 import { ilist_ } from './ilist';
 import { inline, indexer, indexee } from '../inline';
-import { trimBlank } from '../util';
+import { State } from '../context';
+import { trimBlank } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
 export const ulist: UListParser = lazy(() => block(validate(
   /^-(?=[^\S\n]|\n[^\S\n]*\S)/,
-  context({ syntax: { inline: { media: false } } },
+  state(State.media,
   ulist_))));
 
 export const ulist_: UListParser = lazy(() => block(fmap(validate(

package/src/parser/block.ts

@@ -36,7 +36,7 @@ export import ReplyParser = BlockParser.ReplyParser;
 export import ParagraphParser = BlockParser.ParagraphParser;
 
 export const block: BlockParser = creator(error(
-  reset({ resources: { budget: 50 * 1000, recursion: 20 + 1 } },
+  reset({ resources: { budget: 50 * 1000, recursion: 20 } },
   union([
     emptyline,
     horizontalrule,

package/src/parser/context.ts

@@ -0,0 +1,32 @@
+export const enum Rule {
+  reference = 1 << 12,
+  comment = 1 << 11,
+  index = 1 << 10,
+  placeholder = 1 << 9,
+  link = 1 << 8,
+  bracket = 1 << 7,
+  media = 1 << 6,
+  annotation = 1 << 5,
+  mathbracket = 1 << 4,
+  html = 1 << 3,
+  math = 1 << 2,
+  autolink = 1 << 1,
+  quote = 1 << 0,
+  none = 0,
+}
+
+export const enum State {
+  annotation = 1 << 6,
+  reference = 1 << 5,
+  index = 1 << 4,
+  label = 1 << 3,
+  link = 1 << 2,
+  media = 1 << 1,
+  autolink = 1 << 0,
+}
+export const backtrackable = 0
+  | State.annotation
+  | State.reference
+  | State.index
+  | State.link
+  | State.media;

package/src/parser/header.ts

@@ -1,5 +1,5 @@
 import { MarkdownParser } from '../../markdown';
-import { union, inits, some, block, line, validate, focus, rewrite, guard, clear, convert, lazy, fmap } from '../combinator';
+import { union, inits, some, guard, block, line, validate, focus, rewrite, clear, convert, lazy, fmap } from '../combinator';
 import { segment } from './segment';
 import { str } from './source';
 import { normalize } from './api/normalize';

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

@@ -18,11 +18,11 @@ describe('Unit: parser/inline/annotation', () => {
       assert.deepStrictEqual(inspect(parser('((\n))')), undefined);
       assert.deepStrictEqual(inspect(parser('((\na))')), undefined);
       assert.deepStrictEqual(inspect(parser('((\\\na))')), undefined);
-      assert.deepStrictEqual(inspect(parser('((a\n))')), [['', '(('], 'a\n))']);
-      assert.deepStrictEqual(inspect(parser('((a\\\n))')), [['', '(('], 'a\\\n))']);
-      assert.deepStrictEqual(inspect(parser('((a\nb))')), [['', '(('], 'a\nb))']);
-      assert.deepStrictEqual(inspect(parser('((a\\\nb))')), [['', '(('], 'a\\\nb))']);
-      assert.deepStrictEqual(inspect(parser('((*a\nb*))')), [['', '(('], '*a\nb*))']);
+      assert.deepStrictEqual(inspect(parser('((a\n))')), undefined);
+      assert.deepStrictEqual(inspect(parser('((a\\\n))')), undefined);
+      assert.deepStrictEqual(inspect(parser('((a\nb))')), undefined);
+      assert.deepStrictEqual(inspect(parser('((a\\\nb))')), undefined);
+      assert.deepStrictEqual(inspect(parser('((*a\nb*))')), undefined);
       assert.deepStrictEqual(inspect(parser('((\\))')), undefined);
       assert.deepStrictEqual(inspect(parser('((a)b))')), undefined);
       assert.deepStrictEqual(inspect(parser('(((a))')), undefined);

package/src/parser/inline/annotation.ts

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

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

@@ -1,5 +1,5 @@
 import { AutolinkParser } from '../../inline';
-import { verify, rewrite, creator } from '../../../combinator';
+import { creator, verify, rewrite } from '../../../combinator';
 import { str } from '../../source';
 import { html } from 'typed-dom/dom';