securemark 0.258.2 → 0.258.5

package/src/parser/inline/link.ts

@@ -1,12 +1,12 @@
 import { undefined, location, encodeURI, decodeURI, Location } from 'spica/global';
 import { LinkParser, TextLinkParser } from '../inline';
 import { Result, eval, exec } from '../../combinator/data/parser';
-import { union, inits, tails, subsequence, some, guard, syntax, state, validate, surround, open, dup, reverse, lazy, fmap, bind } from '../../combinator';
+import { union, inits, tails, subsequence, some, constraint, syntax, creation, precedence, 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 { Rule, State } from '../context';
+import { Syntax, State } from '../context';
 import { trimNode } from '../visibility';
 import { stringify } from '../util';
 import { html, define, defrag } from 'typed-dom/dom';
@@ -17,8 +17,9 @@ const optspec = {
 } as const;
 Object.setPrototypeOf(optspec, null);
 
-export const link: LinkParser = lazy(() => validate(['[', '{'], syntax(Rule.link, 2, 10, bind(
-  guard(context => ~context.state! & State.link,
+export const link: LinkParser = lazy(() => validate(['[', '{'], bind(
+  constraint(State.link, false,
+  syntax(Syntax.link, 2, 10,
   fmap(subsequence([
     state(State.link,
     dup(union([
@@ -35,7 +36,7 @@ export const link: LinkParser = lazy(() => validate(['[', '{'], syntax(Rule.link
     ]))),
     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, []])),
+  ([as, bs = []]) => bs[0] === '\r' && bs.shift() ? [as, bs] : as[0] === '\r' && as.shift() ? [[], as] : [as, []]))),
   ([content, params]: [(HTMLElement | string)[], string[]], rest, context) => {
     assert(content[0] !== '' || params.length === 0);
     if (content[0] === '') return [content, rest];
@@ -61,13 +62,14 @@ export const link: LinkParser = lazy(() => validate(['[', '{'], syntax(Rule.link
     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(['[', '{'], syntax(Rule.link, 2, 10, bind(
+export const textlink: TextLinkParser = lazy(() => validate(['[', '{'], bind(
+  creation(10, precedence(2,
   reverse(tails([
     dup(surround('[', some(union([unescsource]), ']'), ']')),
     dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]*}/)),
-  ])),
+  ])))),
   ([params, content = []], rest, context) => {
     assert(params[0] === '\r');
     params.shift();
@@ -86,7 +88,7 @@ export const textlink: TextLinkParser = lazy(() => validate(['[', '{'], syntax(R
     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

@@ -3,16 +3,17 @@ import { union, some, syntax, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
 import { startTight, blankWith } from '../visibility';
-import { Rule } from '../context';
+import { Syntax } from '../context';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
-export const mark: MarkParser = lazy(() => syntax(Rule.none, 1, surround(
+export const mark: MarkParser = lazy(() => surround(
   str('=='),
+  syntax(Syntax.none, 1, 1,
   startTight(some(union([
     some(inline, blankWith('==')),
     open(some(inline, '='), mark),
-  ]))),
+  ])))),
   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,11 +1,11 @@
 import { MathParser } from '../inline';
-import { union, some, creator, precedence, validate, focus, rewrite, surround, lazy } from '../../combinator';
+import { union, some, creation, precedence, validate, focus, rewrite, surround, lazy } from '../../combinator';
 import { escsource, unescsource } from '../source';
 import { html } from 'typed-dom/dom';
 
 const forbiddenCommand = /\\(?:begin|tiny|huge|large)(?![a-z])/i;
 
-export const math: MathParser = lazy(() => validate('$', creator(rewrite(
+export const math: MathParser = lazy(() => validate('$', creation(rewrite(
   union([
     surround('$', precedence(6, bracket), '$'),
     surround(
@@ -31,7 +31,7 @@ export const math: MathParser = lazy(() => validate('$', creator(rewrite(
       source)
   ], '']))));
 
-const bracket: MathParser.BracketParser = lazy(() => creator(surround(
+const bracket: MathParser.BracketParser = lazy(() => creation(surround(
   '{',
   some(union([
     bracket,

package/src/parser/inline/media.ts

@@ -1,11 +1,11 @@
 import { undefined, location } from 'spica/global';
 import { MediaParser } from '../inline';
-import { union, inits, tails, some, creator, precedence, guard, syntax, validate, verify, surround, open, dup, lazy, fmap, bind } from '../../combinator';
+import { union, inits, tails, some, syntax, creation, precedence, constraint, 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 { Syntax, State } from '../context';
 import { html, define } from 'typed-dom/dom';
 import { ReadonlyURL } from 'spica/url';
 import { unshift, shift, push } from 'spica/array';
@@ -18,9 +18,10 @@ const optspec = {
 } as const;
 Object.setPrototypeOf(optspec, null);
 
-export const media: MediaParser = lazy(() => validate(['![', '!{'], syntax(Rule.media, 2, 10, bind(verify(fmap(open(
+export const media: MediaParser = lazy(() => validate(['![', '!{'], bind(verify(fmap(open(
   '!',
-  guard(context => ~context.state! & State.media,
+  constraint(State.media, false,
+  syntax(Syntax.media, 2, 10,
   tails([
     dup(surround(
       '[',
@@ -28,7 +29,7 @@ export const media: MediaParser = lazy(() => validate(['![', '!{'], syntax(Rule.
       ']',
       true)),
     dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]*}/)),
-  ]))),
+  ])))),
   ([as, bs]) => bs ? [[as.join('').trim() || as.join('')], shift(bs)[1]] : [[''], shift(as)[1]]),
   ([[text]]) => text === '' || text.trim() !== ''),
   ([[text], params], rest, context) => {
@@ -58,9 +59,9 @@ export const media: MediaParser = lazy(() => validate(['![', '!{'], syntax(Rule.
       textlink as MediaParser,
       ([link]) => [define(link, { target: '_blank' }, [el])])
       (`{ ${INSECURE_URI}${params.join('')} }${rest}`, context);
-  }))));
+  })));
 
-const bracket: MediaParser.TextParser.BracketParser = lazy(() => creator(union([
+const bracket: MediaParser.TextParser.BracketParser = lazy(() => creation(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]),

package/src/parser/inline/reference.ts

@@ -1,17 +1,18 @@
 import { undefined } from 'spica/global';
 import { ReferenceParser } from '../inline';
-import { union, subsequence, some, context, creator, guard, syntax, state, validate, surround, open, lazy, bind } from '../../combinator';
+import { union, subsequence, some, context, syntax, creation, constraint, state, surround, open, lazy, bind } from '../../combinator';
 import { inline } from '../inline';
 import { optimize } from './link';
 import { str, stropt } from '../source';
-import { Rule, State } from '../context';
+import { Syntax, 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('[[', syntax(Rule.reference, 6, surround(
+export const reference: ReferenceParser = lazy(() => surround(
   '[[',
-  guard(context => ~context.state! & State.reference,
+  constraint(State.reference, false,
+  syntax(Syntax.reference, 6, 1,
   state(State.annotation | State.reference | State.media,
   startLoose(
   context({ delimiters: undefined },
@@ -19,13 +20,13 @@ export const reference: ReferenceParser = lazy(() => validate('[[', syntax(Rule.
     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, next)))));
+  ([, ns, rest], next) => next[0] === ']' ? undefined : optimize('[[', ns, rest, next)));
 
-const abbr: ReferenceParser.AbbrParser = creator(bind(surround(
+const abbr: ReferenceParser.AbbrParser = creation(bind(surround(
   '^',
   union([str(/^(?![0-9]+\s?[|\]])[0-9A-Za-z]+(?:(?:-|(?=\W)(?!'\d)'?(?!\.\d)\.?(?!,\S),? ?)[0-9A-Za-z]+)*(?:-|'?\.?,? ?)?/)]),
   /^\|?(?=]])|^\|[^\S\n]*/),

package/src/parser/inline/ruby.ts

@@ -1,15 +1,15 @@
 import { undefined } from 'spica/global';
 import { RubyParser } from '../inline';
 import { eval, exec } from '../../combinator/data/parser';
-import { sequence, syntax, creator, validate, verify, focus, surround, lazy, fmap } from '../../combinator';
+import { sequence, syntax, creation, validate, verify, focus, surround, lazy, fmap } from '../../combinator';
 import { unsafehtmlentity } from './htmlentity';
 import { text as txt } from '../source';
-import { Rule } from '../context';
+import { Syntax } 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('[', syntax(Rule.none, 2, fmap(verify(
+export const ruby: RubyParser = lazy(() => validate('[', syntax(Syntax.none, 2, 1, fmap(verify(
   sequence([
     surround('[', focus(/^(?:\\[^\n]|[^\\[\](){}"\n])+(?=]\()/, text), ']'),
     surround('(', focus(/^(?:\\[^\n]|[^\\[\](){}"\n])+(?=\))/, text), ')'),
@@ -48,7 +48,7 @@ export const ruby: RubyParser = lazy(() => validate('[', syntax(Rule.none, 2, fm
     }
   }))));
 
-const text: RubyParser.TextParser = creator((source, context) => {
+const text: RubyParser.TextParser = creation((source, context) => {
   const acc = [''];
   while (source !== '') {
     assert(source[0] !== '\n');

package/src/parser/inline/shortmedia.ts

@@ -1,11 +1,11 @@
 import { ShortmediaParser } from '../inline';
-import { union, guard, rewrite, open, convert } from '../../combinator';
+import { union, constraint, 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.state! & State.media,
+  constraint(State.media, false,
   open('!', url)),
   convert(
     source => `!{ ${source.slice(1)} }`,

package/src/parser/inline/strong.ts

@@ -3,20 +3,21 @@ import { union, some, syntax, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { emstrong } from './emstrong';
 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 strong: StrongParser = lazy(() => syntax(Rule.none, 1, surround(
+export const strong: StrongParser = lazy(() => surround(
   str('**'),
+  syntax(Syntax.none, 1, 1,
   startTight(some(union([
     some(inline, blankWith('**')),
     open(some(inline, '*'), union([
       emstrong,
       strong,
     ])),
-  ])), '*'),
+  ])), '*')),
   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.ts

@@ -1,18 +1,18 @@
 import { undefined } from 'spica/global';
 import { TemplateParser } from '../inline';
-import { union, some, syntax, creator, precedence, surround, lazy } from '../../combinator';
+import { union, some, syntax, creation, precedence, surround, lazy } from '../../combinator';
 import { optimize } from './link';
 import { escsource, str } from '../source';
-import { Rule } from '../context';
+import { Syntax } from '../context';
 import { html } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
-export const template: TemplateParser = lazy(() => syntax(Rule.none, 2, surround(
-  '{{', some(union([bracket, escsource]), '}'), '}}', true,
+export const template: TemplateParser = lazy(() => surround(
+  '{{', syntax(Syntax.none, 2, 1, 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, next))));
+  ([, ns = [], rest], next) => next[0] === '}' ? undefined : optimize('{{', ns, rest, next)));
 
-const bracket: TemplateParser.BracketParser = lazy(() => creator(union([
+const bracket: TemplateParser.BracketParser = lazy(() => creation(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]),

package/src/parser/inline.test.ts

@@ -110,7 +110,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('[@a]')), [['[', '<a href="/@a" class="account">@a</a>', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[#1][#2]')), [['<a class="index" href="#index:1">1</a>', '<a class="index" href="#index:2">2</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[$1]')), [['[', '$', '1', ']'], '']);
-      assert.deepStrictEqual(inspect(parser('[$1-2]')), [['[', '$', '1', '-', '2', ']'], '']);
+      assert.deepStrictEqual(inspect(parser('[$1-2]')), [['[', '$', '1-2', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[$-1][$-2]')), [['<a class="label" data-label="$-1">$-1</a>', '<a class="label" data-label="$-2">$-2</a>'], '']);
       assert.deepStrictEqual(inspect(parser('$-1, $-2')), [['<a class="label" data-label="$-1">$-1</a>', ',', ' ', '<a class="label" data-label="$-2">$-2</a>'], '']);
       assert.deepStrictEqual(inspect(parser('$-1 and $-2')), [['<a class="label" data-label="$-1">$-1</a>', ' ', 'and', ' ', '<a class="label" data-label="$-2">$-2</a>'], '']);
@@ -168,6 +168,8 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('[^a@b')), [['[^', '<a class="email" href="mailto:a@b">a@b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a*b\nc*]')), [['[', '<a href="/hashtags/a" class="hashtag">#a</a>', '<em>b<br>c</em>', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[*a\nb*]{/}')), [['[', '<em>a<br>b</em>', ']', '<a href="/">/</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[*a\nb]*')), [['[', '*', 'a', '<br>', 'b', ']', '*'], '']);
+      assert.deepStrictEqual(inspect(parser('[*[a\nb*]')), [['', '[', '*', '[', 'a', '<br>', 'b', '*', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[[*a\nb*]]')), [['[', '[', '<em>a<br>b</em>', ']', ']'], '']);
       assert.deepStrictEqual(inspect(parser('"[% *"*"*')), [['"', '[%', ' ', '*', '"', '*', '"', '*'], '']);
       assert.deepStrictEqual(inspect(parser('"[% "*"* %]')), [['"', '[%', ' ', '"', '*', '"', '*', ' ', '%', ']'], '']);
@@ -223,10 +225,10 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('#a\nb\n#c\n[#d]')), [['<a href="/hashtags/a" class="hashtag">#a</a>', '<br>', 'b', '<br>', '<a href="/hashtags/c" class="hashtag">#c</a>', '<br>', '<a class="index" href="#index:d">d</a>'], '']);
       assert.deepStrictEqual(inspect(parser('##a')), [['##a'], '']);
       assert.deepStrictEqual(inspect(parser('a#b')), [['a#b'], '']);
-      assert.deepStrictEqual(inspect(parser('0a#b')), [['0', 'a#b'], '']);
+      assert.deepStrictEqual(inspect(parser('0a#b')), [['0a#b'], '']);
       assert.deepStrictEqual(inspect(parser('あ#b')), [['あ#b'], '']);
       assert.deepStrictEqual(inspect(parser('あい#b')), [['あ', 'い#b'], '']);
-      assert.deepStrictEqual(inspect(parser('0aあ#b')), [['0a', 'あ#b'], '']);
+      assert.deepStrictEqual(inspect(parser('0aあ#b')), [['0aあ#b'], '']);
       assert.deepStrictEqual(inspect(parser('0aあい#b')), [['0a', 'あ', 'い#b'], '']);
       assert.deepStrictEqual(inspect(parser('「#あ」')), [['「', '<a href="/hashtags/あ" class="hashtag">#あ</a>', '」'], '']);
       assert.deepStrictEqual(inspect(parser('a\n#b')), [['a', '<br>', '<a href="/hashtags/b" class="hashtag">#b</a>'], '']);

package/src/parser/source/escapable.ts

@@ -1,10 +1,10 @@
 import { EscapableSourceParser } from '../source';
-import { creator } from '../../combinator';
+import { creation } from '../../combinator';
 import { nonWhitespace } from './text';
 
 const delimiter = /[\s\x00-\x2F\x3A-\x40\x5B-\x60\x7B-\x7F]/;
 
-export const escsource: EscapableSourceParser = creator(source => {
+export const escsource: EscapableSourceParser = creation(source => {
   if (source === '') return;
   const i = source.search(delimiter);
   switch (i) {

package/src/parser/source/str.ts

@@ -1,19 +1,19 @@
 import { undefined } from 'spica/global';
 import { StrParser } from '../source';
 import { Parser, Context } from '../../combinator/data/parser';
-import { creator } from '../../combinator';
+import { creation } from '../../combinator';
 
 export function str(pattern: string | RegExp): StrParser;
 export function str(pattern: string | RegExp): Parser<string, Context<StrParser>, []> {
   assert(pattern);
   return typeof pattern === 'string'
-    ? creator(source => {
+    ? creation(source => {
         if (source === '') return;
         return source.slice(0, pattern.length) === pattern
           ? [[pattern], source.slice(pattern.length)]
           : undefined;
       })
-    : creator(source => {
+    : creation(source => {
         if (source === '') return;
         const m = source.match(pattern);
         return m && m[0].length > 0
@@ -26,13 +26,13 @@ export function stropt(pattern: string | RegExp): StrParser;
 export function stropt(pattern: string | RegExp): Parser<string, Context<StrParser>, []> {
   assert(pattern);
   return typeof pattern === 'string'
-    ? creator(source => {
+    ? creation(source => {
         if (source === '') return;
         return source.slice(0, pattern.length) === pattern
           ? [[pattern], source.slice(pattern.length)]
           : undefined;
       })
-    : creator(source => {
+    : creation(source => {
         if (source === '') return;
         const m = source.match(pattern);
         return m

package/src/parser/source/text.test.ts

@@ -82,7 +82,7 @@ describe('Unit: parser/text/text', () => {
       assert.deepStrictEqual(inspect(parser('0@0')), [['0', '@', '0'], '']);
       assert.deepStrictEqual(inspect(parser('a@0')), [['a', '@', '0'], '']);
       assert.deepStrictEqual(inspect(parser('A@0')), [['A', '@', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('0aA@0')), [['0aA', '@', '0'], '']);
+      assert.deepStrictEqual(inspect(parser('aA@0')), [['aA', '@', '0'], '']);
       assert.deepStrictEqual(inspect(parser(' @0')), [[' ', '@', '0'], '']);
       assert.deepStrictEqual(inspect(parser('@@0')), [['@', '@', '0'], '']);
     });
@@ -96,10 +96,25 @@ describe('Unit: parser/text/text', () => {
       assert.deepStrictEqual(inspect(parser('0#0')), [['0', '#', '0'], '']);
       assert.deepStrictEqual(inspect(parser('a#0')), [['a', '#', '0'], '']);
       assert.deepStrictEqual(inspect(parser('A#0')), [['A', '#', '0'], '']);
+      assert.deepStrictEqual(inspect(parser('aA#0')), [['a', 'A', '#', '0'], '']);
       assert.deepStrictEqual(inspect(parser(' #0')), [[' ', '#', '0'], '']);
       assert.deepStrictEqual(inspect(parser('##0')), [['#', '#', '0'], '']);
     });
 
+    it('anchor', () => {
+      assert.deepStrictEqual(inspect(parser('>>0')), [['>', '>', '0'], '']);
+      assert.deepStrictEqual(inspect(parser('_>>0')), [['_', '>', '>', '0'], '']);
+      assert.deepStrictEqual(inspect(parser('$>>0')), [['$', '>', '>', '0'], '']);
+      assert.deepStrictEqual(inspect(parser('+>>0')), [['+', '>', '>', '0'], '']);
+      assert.deepStrictEqual(inspect(parser('->>0')), [['-', '>', '>', '0'], '']);
+      assert.deepStrictEqual(inspect(parser('0>>0')), [['0', '>', '>', '0'], '']);
+      assert.deepStrictEqual(inspect(parser('a>>0')), [['a', '>', '>', '0'], '']);
+      assert.deepStrictEqual(inspect(parser('A>>0')), [['A', '>', '>', '0'], '']);
+      assert.deepStrictEqual(inspect(parser('aA>>0')), [['a', 'A', '>', '>', '0'], '']);
+      assert.deepStrictEqual(inspect(parser(' >>0')), [[' ', '>', '>', '0'], '']);
+      assert.deepStrictEqual(inspect(parser('>>>>0')), [['>', '>', '>', '>', '0'], '']);
+    });
+
     it('localize', () => {
       assert.deepStrictEqual(inspect(parser('.\\\n0')), [['.', '<span class="linebreak"> </span>', '0'], '']);
       assert.deepStrictEqual(inspect(parser('。\\\n0')), [['。', '<span class="linebreak"></span>', '0'], '']);

package/src/parser/source/text.ts

@@ -1,15 +1,16 @@
 import { undefined } from 'spica/global';
 import { TextParser, TxtParser, LinebreakParser } from '../source';
-import { union, creator, focus } from '../../combinator';
+import { union, syntax, focus } from '../../combinator';
 import { str } from './str';
+import { Syntax } from '../context';
 import { html } from 'typed-dom/dom';
 
-export const delimiter = /[\s\x00-\x7F]|\S#|[（）、。！？][^\S\n]*(?=\\\n)/;
+export const delimiter = /[\s\x00-\x7F]|\S[#>]|[（）、。！？][^\S\n]*(?=\\\n)/;
 export const nonWhitespace = /[\S\n]|$/;
-export const nonAlphanumeric = /[^0-9A-Za-z]|\S#|$/;
+export const nonAlphanumeric = /[^0-9A-Za-z]|\S[#>]|$/;
 const repeat = str(/^(.)\1*/);
 
-export const text: TextParser = creator((source, context) => {
+export const text: TextParser = syntax(Syntax.none, 1, 1, (source, context) => {
   if (source === '') return;
   const i = source.search(delimiter);
   switch (i) {

package/src/parser/source/unescapable.ts

@@ -1,8 +1,8 @@
 import { UnescapableSourceParser } from '../source';
-import { creator } from '../../combinator';
+import { creation } from '../../combinator';
 import { delimiter, nonWhitespace, nonAlphanumeric, isAlphanumeric } from './text';
 
-export const unescsource: UnescapableSourceParser = creator(source => {
+export const unescsource: UnescapableSourceParser = creation(source => {
   assert(source[0] !== '\x1B');
   if (source === '') return;
   const i = source.search(delimiter);

package/src/parser/visibility.ts

@@ -12,7 +12,7 @@ import { push } from 'spica/array';
 export function visualize<P extends Parser<HTMLElement | string>>(parser: P): P;
 export function visualize<T extends HTMLElement | string>(parser: Parser<T>): Parser<T> {
   const blankline = new RegExp(
-    /^(?:\\$|\\?[^\S\n]|&IHN;|<wbr>)+$/.source.replace('IHN', `(?:${invisibleHTMLEntityNames.join('|')})`),
+    /^(?:\\$|\\?[^\S\n]|&IHN;|<wbr[^\S\n]*>)+$/.source.replace('IHN', `(?:${invisibleHTMLEntityNames.join('|')})`),
     'gm');
   return union([
     convert(
@@ -40,7 +40,7 @@ function hasVisible(
 }
 
 export const regBlankStart = new RegExp(
-  /^(?:\\?[^\S\n]|&IHN;|<wbr>)+/.source.replace('IHN', `(?:${invisibleHTMLEntityNames.join('|')})`));
+  /^(?:\\?[^\S\n]|&IHN;|<wbr[^\S\n]*>)+/.source.replace('IHN', `(?:${invisibleHTMLEntityNames.join('|')})`));
 
 export function blankWith(delimiter: string | RegExp): RegExp;
 export function blankWith(starting: '' | '\n', delimiter: string | RegExp): RegExp;
@@ -49,7 +49,7 @@ export function blankWith(starting: '' | '\n', delimiter?: string | RegExp): Reg
   return new RegExp(String.raw
     `^(?:(?=${
       starting
-    })(?:\\?\s|&(?:${invisibleHTMLEntityNames.join('|')});|<wbr>)${starting && '+'})?${
+    })(?:\\?\s|&(?:${invisibleHTMLEntityNames.join('|')});|<wbr[^\S\n]*>)${starting && '+'})?${
       typeof delimiter === 'string' ? delimiter.replace(/[*+()\[\]]/g, '\\$&') : delimiter.source
     }`);
 }
@@ -94,8 +94,8 @@ const isStartTight = reduce((source: string, context: MarkdownParser.Context, ex
     case '<':
       switch (true) {
         case source.length >= 5
-          && source[1] === 'w'
-          && source.slice(0, 5) === '<wbr>':
+          && source.slice(0, 4) === '<wbr'
+          && (source[5] === '>' || /^<wbr[^\S\n]*>/.test(source)):
           return false;
       }
       return true;