securemark 0.258.2 → 0.258.5

package/src/parser/block/sidefence.ts

@@ -1,5 +1,5 @@
 import { SidefenceParser } from '../block';
-import { union, some, creator, block, focus, rewrite, convert, lazy, fmap } from '../../combinator';
+import { union, some, creation, block, focus, rewrite, convert, lazy, fmap } from '../../combinator';
 import { autolink } from '../autolink';
 import { contentline } from '../source';
 import { html, define, defrag } from 'typed-dom/dom';
@@ -20,7 +20,7 @@ const opener = /^(?=\|\|+(?:$|\s))/;
 const unindent = (source: string) => source.replace(/(^|\n)\|(?:[^\S\n]|(?=\|*(?:$|\s)))|\n$/g, '$1');
 
 const source: SidefenceParser.SourceParser = lazy(() => fmap(
-  some(creator(union([
+  some(creation(union([
     focus(
       /^(?:\|\|+(?:[^\S\n][^\n]*)?(?:$|\n))+/,
       convert(unindent, source)),

package/src/parser/block/table.ts

@@ -1,5 +1,5 @@
 import { TableParser } from '../block';
-import { union, sequence, some, creator, block, line, validate, focus, rewrite, surround, open, fallback, lazy, fmap } from '../../combinator';
+import { union, sequence, some, creation, block, line, validate, focus, rewrite, surround, open, fallback, lazy, fmap } from '../../combinator';
 import { inline } from '../inline';
 import { contentline } from '../source';
 import { trimNode } from '../visibility';
@@ -25,7 +25,7 @@ export const table: TableParser = lazy(() => block(fmap(validate(
     ]),
   ])));
 
-const row = <P extends CellParser | AlignParser>(parser: P, optional: boolean): RowParser<P> => creator(fallback(fmap(
+const row = <P extends CellParser | AlignParser>(parser: P, optional: boolean): RowParser<P> => creation(fallback(fmap(
   line(surround(/^(?=\|)/, some(union([parser])), /^[|\\]?\s*$/, optional)),
   es => [html('tr', es)]),
   rewrite(contentline, source => [[
@@ -37,7 +37,7 @@ const row = <P extends CellParser | AlignParser>(parser: P, optional: boolean):
     }, [html('td', source.replace('\n', ''))])
   ], ''])));
 
-const align: AlignParser = creator(fmap(open(
+const align: AlignParser = creation(fmap(open(
   '|',
   union([
     focus(/^:-+:/, () => [['center'], '']),
@@ -52,11 +52,11 @@ const cell: CellParser = surround(
   some(union([inline]), /^\|/, [[/^[|\\]?\s*$/, 9]]),
   /^[^|]*/, true);
 
-const head: CellParser.HeadParser = creator(fmap(
+const head: CellParser.HeadParser = creation(fmap(
   cell,
   ns => [html('th', trimNode(defrag(ns)))]));
 
-const data: CellParser.DataParser = creator(fmap(
+const data: CellParser.DataParser = creation(fmap(
   cell,
   ns => [html('td', trimNode(defrag(ns)))]));
 

package/src/parser/block/ulist.ts

@@ -1,5 +1,5 @@
 import { UListParser } from '../block';
-import { union, inits, subsequence, some, creator, state, block, line, validate, indent, focus, open, fallback, lazy, fmap } from '../../combinator';
+import { union, inits, subsequence, some, creation, 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';
@@ -15,7 +15,7 @@ export const ulist: UListParser = lazy(() => block(validate(
 
 export const ulist_: UListParser = lazy(() => block(fmap(validate(
   /^-(?=$|\s)/,
-  some(creator(union([
+  some(creation(union([
     indexee(fmap(fallback(
       inits([
         line(open(/^-(?:$|\s)/, subsequence([checkbox, trimBlank(some(union([indexer, inline])))]), true)),
@@ -26,11 +26,11 @@ export const ulist_: UListParser = lazy(() => block(fmap(validate(
   ])))),
   es => [format(html('ul', es))])));
 
-export const checkbox = focus(
+export const checkbox = creation(focus(
   /^\[[xX ]\](?=$|\s)/,
   source => [[
     html('span', { class: 'checkbox' }, source[1].trimStart() ? '☑' : '☐'),
-  ], '']);
+  ], '']));
 
 export function fillFirstLine(ns: (HTMLElement | string)[]): (HTMLElement | string)[] {
   return ns.length === 1

package/src/parser/block.ts

@@ -1,6 +1,6 @@
 import { undefined } from 'spica/global';
 import { MarkdownParser } from '../../markdown';
-import { union, reset, creator, open, fallback, recover } from '../combinator';
+import { union, reset, creation, open, fallback, recover } from '../combinator';
 import { emptyline } from './source';
 import { horizontalrule } from './block/horizontalrule';
 import { heading } from './block/heading';
@@ -35,8 +35,8 @@ export import BlockquoteParser = BlockParser.BlockquoteParser;
 export import ReplyParser = BlockParser.ReplyParser;
 export import ParagraphParser = BlockParser.ParagraphParser;
 
-export const block: BlockParser = creator(error(
-  reset({ resources: { budget: 50 * 1000, recursion: 20 } },
+export const block: BlockParser = creation(error(
+  reset({ resources: { clock: 50 * 1000, recursion: 20 } },
   union([
     emptyline,
     horizontalrule,

package/src/parser/context.ts

@@ -1,4 +1,4 @@
-export const enum Rule {
+export const enum Syntax {
   reference = 1 << 12,
   comment = 1 << 11,
   index = 1 << 10,

package/src/parser/inline/annotation.ts

@@ -1,20 +1,21 @@
 import { undefined } from 'spica/global';
 import { AnnotationParser } from '../inline';
-import { union, some, guard, context, syntax, state, validate, surround, lazy } from '../../combinator';
+import { union, some, context, syntax, constraint, state, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { optimize } from './link';
-import { Rule, State } from '../context';
+import { Syntax, State } from '../context';
 import { startLoose, trimNode } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 
-export const annotation: AnnotationParser = lazy(() => validate('((', syntax(Rule.annotation, 6, surround(
+export const annotation: AnnotationParser = lazy(() => surround(
   '((',
-  guard(context => ~context.state! & State.annotation,
+  constraint(State.annotation, false,
+  syntax(Syntax.annotation, 6, 1,
   state(State.annotation | State.media,
   startLoose(
   context({ delimiters: undefined },
-  some(union([inline]), ')', [[/^\\?\n/, 9], [')', 2], ['))', 6]])), ')'))),
+  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, next)))));
+  ([, ns, rest], next) => next[0] === ')' ? undefined : optimize('((', ns, rest, next)));

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

@@ -20,9 +20,9 @@ describe('Unit: parser/inline/autolink/email', () => {
       assert.deepStrictEqual(inspect(parser('a@b#1')), [['a@b#1'], '']);
       assert.deepStrictEqual(inspect(parser('a@@')), [['a@@'], '']);
       assert.deepStrictEqual(inspect(parser('a@@b')), [['a@@b'], '']);
-      assert.deepStrictEqual(inspect(parser('a+@b')), undefined);
-      assert.deepStrictEqual(inspect(parser('a..b@c')), undefined);
-      assert.deepStrictEqual(inspect(parser('a++b@c')), undefined);
+      assert.deepStrictEqual(inspect(parser('a+@b')), [['a'], '+@b']);
+      assert.deepStrictEqual(inspect(parser('a..b@c')), [['a'], '..b@c']);
+      assert.deepStrictEqual(inspect(parser('a++b@c')), [['a'], '++b@c']);
       assert.deepStrictEqual(inspect(parser(`a@${'b'.repeat(64)}`)), [[`a@${'b'.repeat(64)}`], '']);
       assert.deepStrictEqual(inspect(parser(' a@b')), undefined);
     });

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

@@ -1,11 +1,11 @@
 import { AutolinkParser } from '../../inline';
-import { creator, verify, rewrite } from '../../../combinator';
+import { creation, verify, rewrite } from '../../../combinator';
 import { str } from '../../source';
 import { html } from 'typed-dom/dom';
 
 // https://html.spec.whatwg.org/multipage/input.html
 
-export const email: AutolinkParser.EmailParser = creator(rewrite(verify(
+export const email: AutolinkParser.EmailParser = creation(rewrite(verify(
   str(/^[0-9A-Za-z]+(?:[.+_-][0-9A-Za-z]+)*@[0-9A-Za-z](?:(?:[0-9A-Za-z]|-(?=\w)){0,61}[0-9A-Za-z])?(?:\.[0-9A-Za-z](?:(?:[0-9A-Za-z]|-(?=\w)){0,61}[0-9A-Za-z])?)*(?![0-9A-Za-z])/),
   ([source]) => source.indexOf('@') <= 64 && source.length <= 255),
   source => [[html('a', { class: 'email', href: `mailto:${source}` }, source)], '']));

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

@@ -8,12 +8,12 @@ describe('Unit: parser/inline/autolink/url', () => {
 
     it('invalid', () => {
       assert.deepStrictEqual(inspect(parser('')), undefined);
-      assert.deepStrictEqual(inspect(parser('http')), undefined);
-      assert.deepStrictEqual(inspect(parser('ttp')), undefined);
-      assert.deepStrictEqual(inspect(parser('http://')), undefined);
-      assert.deepStrictEqual(inspect(parser('http://[')), undefined);
-      assert.deepStrictEqual(inspect(parser('http://]')), undefined);
-      assert.deepStrictEqual(inspect(parser('Http://host')), undefined);
+      assert.deepStrictEqual(inspect(parser('http')), [['http'], '']);
+      assert.deepStrictEqual(inspect(parser('ttp')), [['ttp'], '']);
+      assert.deepStrictEqual(inspect(parser('http://')), [['http'], '://']);
+      assert.deepStrictEqual(inspect(parser('http://[')), [['http'], '://[']);
+      assert.deepStrictEqual(inspect(parser('http://]')), [['http'], '://]']);
+      assert.deepStrictEqual(inspect(parser('Http://host')), [['Http'], '://host']);
       //assert.deepStrictEqual(inspect(parser('http://[::ffff:0:0%1]')), [['<a class="invalid">http://[::ffff:0:0%1]</a>'], '']);
       //assert.deepStrictEqual(inspect(parser('http://[::ffff:0:0/96]')), [['<a class="invalid">http://[::ffff:0:0/96]</a>'], '']);
       assert.deepStrictEqual(inspect(parser(' http://a')), undefined);

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

@@ -1,5 +1,5 @@
 import { AutolinkParser } from '../../inline';
-import { union, some, creator, precedence, validate, focus, rewrite, convert, surround, open, lazy } from '../../../combinator';
+import { union, some, creation, precedence, validate, focus, rewrite, convert, surround, open, lazy } from '../../../combinator';
 import { textlink } from '../link';
 import { unescsource } from '../../source';
 
@@ -13,7 +13,7 @@ export const url: AutolinkParser.UrlParser = lazy(() => validate(['http://', 'ht
     url => `{ ${url} }`,
     union([textlink])))));
 
-const bracket: AutolinkParser.UrlParser.BracketParser = lazy(() => creator(precedence(2, union([
+const bracket: AutolinkParser.UrlParser.BracketParser = lazy(() => creation(precedence(2, union([
   surround('(', some(union([bracket, unescsource]), ')'), ')', true),
   surround('[', some(union([bracket, unescsource]), ']'), ']', true),
   surround('{', some(union([bracket, unescsource]), '}'), '}', true),

package/src/parser/inline/autolink.ts

@@ -1,5 +1,5 @@
 import { AutolinkParser } from '../inline';
-import { union, some, syntax, guard, validate, fmap } from '../../combinator';
+import { union, some, syntax, constraint, validate, fmap } from '../../combinator';
 import { url } from './autolink/url';
 import { email } from './autolink/email';
 import { channel } from './autolink/channel';
@@ -8,18 +8,18 @@ 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 { Syntax, State } from '../context';
 import { stringify } from '../util';
 
 export const autolink: AutolinkParser = fmap(
-  validate(/^(?:[@#>0-9A-Za-z]|\S#)/,
-  guard(context => ~context.state! & State.autolink,
-  syntax(Rule.autolink, 1,
+  validate(/^(?:[@#>0-9A-Za-z]|\S[#>])/,
+  constraint(State.autolink, false,
+  syntax(Syntax.autolink, 1, 1,
   some(union([
     url,
     email,
     // Escape unmatched email-like strings.
-    str(/^[0-9A-Za-z]+(?:[.+_-][0-9A-Za-z]+)*(?:@(?:[0-9A-Za-z]+(?:[.-][0-9A-Za-z]+)*)?)+/),
+    str(/^[0-9A-Za-z]+(?:[.+_-][0-9A-Za-z]+)*(?:@(?:[0-9A-Za-z]+(?:[.-][0-9A-Za-z]+)*)?)*/),
     channel,
     account,
     // Escape unmatched account-like strings.

package/src/parser/inline/bracket.ts

@@ -3,29 +3,29 @@ import { BracketParser } from '../inline';
 import { union, some, syntax, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { Rule } from '../context';
+import { Syntax } 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(() => union([
-  surround(str('('), syntax(Rule.none, 2, str(index)), str(')')),
-  surround(str('('), syntax(Rule.bracket, 2, some(inline, ')', [[')', 2]])), str(')'), true,
+  surround(str('('), syntax(Syntax.none, 2, 1, str(index)), str(')')),
+  surround(str('('), syntax(Syntax.bracket, 2, 1, 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('（'), syntax(Rule.none, 2, str(new RegExp(index.source.replace(', ', '[，、]').replace(/[09AZaz.]|\-(?!\w)/g, c => c.trimStart() && String.fromCharCode(c.charCodeAt(0) + 0xFEE0))))), str('）')),
-  surround(str('（'), syntax(Rule.bracket, 2, some(inline, '）', [['）', 2]])), str('）'), true,
+  surround(str('（'), syntax(Syntax.none, 2, 1, str(new RegExp(index.source.replace(', ', '[，、]').replace(/[09AZaz.]|\-(?!\w)/g, c => c.trimStart() && String.fromCharCode(c.charCodeAt(0) + 0xFEE0))))), str('）')),
+  surround(str('（'), syntax(Syntax.bracket, 2, 1, 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('['), syntax(Rule.bracket, 2, some(inline, ']', [[']', 2]])), str(']'), true,
+  surround(str('['), syntax(Syntax.bracket, 2, 1, some(inline, ']', [[']', 2]])), str(']'), true,
     undefined,
     ([as, bs = []], rest) => [unshift([''], unshift(as, bs)), rest]),
-  surround(str('{'), syntax(Rule.bracket, 2, some(inline, '}', [['}', 2]])), str('}'), true,
+  surround(str('{'), syntax(Syntax.bracket, 2, 1, some(inline, '}', [['}', 2]])), str('}'), true,
     undefined,
     ([as, bs = []], rest) => [unshift(as, bs), rest]),
   // Control media blinking in editing rather than control confusion of pairs of quote marks.
-  surround(str('"'), syntax(Rule.quote, 8, some(inline, '"', [['"', 8]])), str('"'), true,
+  surround(str('"'), syntax(Syntax.quote, 8, 1, some(inline, '"', [['"', 8]])), str('"'), true,
     undefined,
     ([as, bs = []], rest) => [unshift(as, bs), rest]),
 ]));

package/src/parser/inline/code.ts

@@ -1,8 +1,8 @@
 import { CodeParser } from '../inline';
-import { creator, validate, match } from '../../combinator';
+import { creation, validate, match } from '../../combinator';
 import { html } from 'typed-dom/dom';
 
-export const code: CodeParser = creator(validate('`', match(
+export const code: CodeParser = creation(validate('`', match(
   /^(`+)(?!`)([^\n]*?[^`\n])\1(?!`)/,
   ([whole, , body]) => rest =>
     [[html('code', { 'data-src': whole }, format(body))], rest.slice(whole.length)])));

package/src/parser/inline/comment.ts

@@ -2,12 +2,12 @@ import { CommentParser } from '../inline';
 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 { Syntax } 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('[%', syntax(Rule.none, 4, match(
+export const comment: CommentParser = lazy(() => validate('[%', syntax(Syntax.none, 4, 1, match(
   /^\[(%+)\s/,
   memoize(
   ([, fence]) =>

package/src/parser/inline/deletion.ts

@@ -2,17 +2,18 @@ import { DeletionParser } from '../inline';
 import { union, some, syntax, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { Rule } from '../context';
+import { Syntax } from '../context';
 import { blankWith } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
-export const deletion: DeletionParser = lazy(() => syntax(Rule.none, 1, surround(
+export const deletion: DeletionParser = lazy(() => surround(
   str('~~'),
+  syntax(Syntax.none, 1, 1,
   some(union([
     some(inline, blankWith('\n', '~~')),
     open('\n', some(inline, '~'), true),
-  ])),
+  ]))),
   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

@@ -4,13 +4,14 @@ import { inline } from '../inline';
 import { emstrong } from './emstrong';
 import { strong } from './strong';
 import { str } from '../source';
-import { Rule } from '../context';
+import { Syntax } from '../context';
 import { startTight, blankWith } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
-export const emphasis: EmphasisParser = lazy(() => syntax(Rule.none, 1, surround(
+export const emphasis: EmphasisParser = lazy(() => surround(
   str('*'),
+  syntax(Syntax.none, 1, 1,
   startTight(some(union([
     strong,
     some(inline, blankWith('*')),
@@ -19,7 +20,7 @@ export const emphasis: EmphasisParser = lazy(() => syntax(Rule.none, 1, surround
       strong,
       emphasis,
     ])),
-  ])), '*'),
+  ])), '*')),
   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

@@ -5,7 +5,7 @@ import { inline } from '../inline';
 import { strong } from './strong';
 import { emphasis } from './emphasis';
 import { str } from '../source';
-import { Rule } from '../context';
+import { Syntax } from '../context';
 import { startTight, blankWith } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
@@ -27,12 +27,13 @@ const subemphasis: IntermediateParser<EmphasisParser> = lazy(() => some(union([
   ])),
 ])));
 
-export const emstrong: EmStrongParser = lazy(() => syntax(Rule.none, 1, surround(
+export const emstrong: EmStrongParser = lazy(() => surround(
   str('***'),
+  syntax(Syntax.none, 1, 1,
   startTight(some(union([
     some(inline, blankWith('*')),
     open(some(inline, '*'), inline),
-  ]))),
+  ])))),
   str(/^\*{1,3}/), false,
   ([, bs, cs], rest, context): Result<HTMLElement | string, typeof context> => {
     assert(cs.length === 1);
@@ -58,4 +59,4 @@ export const emstrong: EmStrongParser = lazy(() => syntax(Rule.none, 1, surround
     }
     assert(false);
   },
-  ([as, bs], rest) => [unshift(as, bs), rest])));
+  ([as, bs], rest) => [unshift(as, bs), rest]));

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

@@ -1,24 +1,25 @@
 import { undefined } from 'spica/global';
 import { ExtensionParser } from '../../inline';
-import { union, some, syntax, creator, precedence, guard, state, validate, surround, open, lazy, fmap } from '../../../combinator';
+import { union, some, syntax, creation, precedence, constraint, state, validate, surround, open, lazy, fmap } from '../../../combinator';
 import { inline } from '../../inline';
 import { indexee, identity } from './indexee';
 import { txt, str, stropt } from '../../source';
-import { Rule, State } from '../../context';
+import { Syntax, 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('[#', syntax(Rule.index, 2, fmap(indexee(surround(
+export const index: IndexParser = lazy(() => validate('[#', fmap(indexee(surround(
   '[#',
-  guard(context => ~context.state! & State.index,
+  constraint(State.index, false,
+  syntax(Syntax.index, 2, 1,
   state(State.annotation | State.reference | State.index | State.label | State.link | State.media | State.autolink,
   startTight(
   open(stropt(/^\|?/), trimBlankEnd(some(union([
     signature,
     inline,
-  ]), ']', [[/^\\?\n/, 9], [']', 2]])), true)))),
+  ]), ']', [[/^\\?\n/, 9], [']', 2]])), true))))),
   ']',
   false,
   ([, ns], rest) => [[html('a', defrag(ns))], rest])),
@@ -30,16 +31,16 @@ export const index: IndexParser = lazy(() => validate('[#', syntax(Rule.index, 2
         href: el.id ? `#${el.id}` : undefined,
       },
       el.childNodes),
-  ]))));
+  ])));
 
-const signature: IndexParser.SignatureParser = lazy(() => creator(fmap(open(
+const signature: IndexParser.SignatureParser = lazy(() => creation(fmap(open(
   '|#',
   startTight(some(union([bracket, txt]), ']'))),
   ns => [
     html('span', { class: 'indexer', 'data-index': identity(ns.join('')).slice(6) }),
   ])));
 
-const bracket: IndexParser.SignatureParser.BracketParser = lazy(() => creator(union([
+const bracket: IndexParser.SignatureParser.BracketParser = lazy(() => creation(union([
   surround(str('('), some(union([bracket, txt]), ')'), str(')'), true),
   surround(str('['), some(union([bracket, txt]), ']'), str(']'), true),
   surround(str('{'), some(union([bracket, txt]), '}'), str('}'), true),

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

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

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

@@ -1,6 +1,6 @@
 import { Array } from 'spica/global';
 import { ExtensionParser } from '../../inline';
-import { union, guard, creator, validate, surround, clear, fmap } from '../../../combinator';
+import { union, constraint, creation, validate, surround, clear, fmap } from '../../../combinator';
 import { str } from '../../source';
 import { State } from '../../context';
 import { html } from 'typed-dom/dom';
@@ -12,8 +12,8 @@ export const segment: ExtensionParser.LabelParser.SegmentParser = clear(validate
   body,
 ])));
 
-export const label: ExtensionParser.LabelParser = validate(['[$', '$'], creator(fmap(
-  guard(context => ~context.state! & State.label,
+export const label: ExtensionParser.LabelParser = validate(['[$', '$'], creation(fmap(
+  constraint(State.label, false,
   union([
     surround('[', body, ']'),
     body,

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

@@ -2,7 +2,7 @@ import { ExtensionParser } from '../../inline';
 import { union, some, syntax, validate, surround, lazy } from '../../../combinator';
 import { inline } from '../../inline';
 import { str } from '../../source';
-import { Rule } from '../../context';
+import { Syntax } from '../../context';
 import { startTight } from '../../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
@@ -11,9 +11,10 @@ import { unshift } from 'spica/array';
 
 // All syntax surrounded by square brackets shouldn't contain line breaks.
 
-export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => validate(['[:', '[^'], syntax(Rule.none, 2, surround(
+export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => validate(['[:', '[^'], surround(
   str(/^\[[:^]/),
-  startTight(some(union([inline]), ']', [[/^\\?\n/, 9], [']', 2]])),
+  syntax(Syntax.none, 2, 1,
+  startTight(some(union([inline]), ']', [[/^\\?\n/, 9], [']', 2]]))),
   str(']'), false,
   ([as, bs], rest) => [[
     html('span', {
@@ -23,4 +24,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.test.ts

@@ -122,7 +122,7 @@ describe('Unit: parser/inline/html', () => {
       assert.deepStrictEqual(inspect(parser('<bdo dir="rtl"  >a</bdo>')), [['<bdo dir="rtl">a</bdo>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo  dir="rtl">a</bdo>')), [['<bdo dir="rtl">a</bdo>'], '']);
       assert.deepStrictEqual(inspect(parser('<wbr\n>')), undefined);
-      assert.deepStrictEqual(inspect(parser('<wbr >')), [['<wbr'], ' >']);
+      assert.deepStrictEqual(inspect(parser('<wbr >')), [['<wbr>'], '']);
       assert.deepStrictEqual(inspect(parser('<wbr constructor>')), [['<wbr'], ' constructor>']);
       assert.deepStrictEqual(inspect(parser('<wbr X>')), [['<wbr'], ' X>']);
       assert.deepStrictEqual(inspect(parser('<wbr x>')), [['<wbr'], ' x>']);

package/src/parser/inline/html.ts

@@ -3,7 +3,7 @@ import { HTMLParser } from '../inline';
 import { union, subsequence, some, syntax, validate, focus, surround, open, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { Rule } from '../context';
+import { Syntax } from '../context';
 import { isStartLooseNodes, blankWith } from '../visibility';
 import { html as h, defrag } from 'typed-dom/dom';
 import { memoize } from 'spica/memoize';
@@ -19,9 +19,9 @@ 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]|>)/, syntax(Rule.none, 5, union([
+export const html: HTMLParser = lazy(() => validate('<', validate(/^<[a-z]+(?=[^\S\n]|>)/, syntax(Syntax.none, 5, 1, union([
   focus(
-    '<wbr>',
+    /^<wbr[^\S\n]*>/,
     () => [[h('wbr')], '']),
   focus(
     // https://html.spec.whatwg.org/multipage/syntax.html#void-elements
@@ -62,7 +62,7 @@ export const html: HTMLParser = lazy(() => validate('<', validate(/^<[a-z]+(?=[^
     new Cache(10000))),
 ])))));
 
-export const attribute: HTMLParser.TagParser.AttributeParser = union([
+export const attribute: HTMLParser.AttributeParser = union([
   str(/^[^\S\n]+[a-z]+(?:-[a-z]+)*(?:="(?:\\[^\n]|[^\\\n"])*")?(?=[^\S\n]|>)/),
 ]);
 

package/src/parser/inline/htmlentity.ts

@@ -1,10 +1,10 @@
 import { undefined } from 'spica/global';
 import { HTMLEntityParser, UnsafeHTMLEntityParser } from '../inline';
-import { union, creator, validate, focus, fmap } from '../../combinator';
+import { union, creation, validate, focus, fmap } from '../../combinator';
 import { html } from 'typed-dom/dom';
 import { reduce } from 'spica/memoize';
 
-export const unsafehtmlentity: UnsafeHTMLEntityParser = creator(validate('&', focus(
+export const unsafehtmlentity: UnsafeHTMLEntityParser = creation(validate('&', focus(
   /^&[0-9A-Za-z]+;/,
   entity => [[parse(entity) ?? `\x1B${entity}`], ''])));
 

package/src/parser/inline/insertion.ts

@@ -2,17 +2,18 @@ import { InsertionParser } from '../inline';
 import { union, some, syntax, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { Rule } from '../context';
+import { Syntax } from '../context';
 import { blankWith } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
-export const insertion: InsertionParser = lazy(() => syntax(Rule.none, 1, surround(
+export const insertion: InsertionParser = lazy(() => surround(
   str('++'),
+  syntax(Syntax.none, 1, 1,
   some(union([
     some(inline, blankWith('\n', '++')),
     open('\n', some(inline, '+'), true),
-  ])),
+  ]))),
   str('++'), false,
   ([, bs], rest) => [[html('ins', defrag(bs))], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest])));
+  ([as, bs], rest) => [unshift(as, bs), rest]));