securemark 0.294.3 → 0.294.5

package/src/parser/inline/code.ts

@@ -1,26 +1,20 @@
 import { CodeParser } from '../inline';
 import { List, Data } from '../../combinator/data/parser';
-import { open, match } from '../../combinator';
-import { Backtrack } from '../context';
+import { match } from '../../combinator';
 import { invalid } from '../util';
 import { html } from 'typed-dom/dom';
 
-export const code: CodeParser = open(
-  /(?=`)/y,
-  match(
-    /(`+)(?!`)([^\n]*?)(?:((?<!`)\1(?!`))|(?=$|\n))/y,
-    ([whole, opener, body, closer]) => () =>
-      closer
-        ? new List([new Data(html('code', { 'data-src': whole }, format(body)))])
-        : body
-          ? new List([new Data(html('code', {
-              class: 'invalid',
-              ...invalid('code', 'syntax', `Missing the closing symbol "${opener}"`)
-            }, whole))])
-          : new List([new Data(opener)]),
-    true),
-  false,
-  [3 | Backtrack.bracket]);
+export const code: CodeParser = match(
+  /(`+)(?!`)([^\n]*?)(?:((?<!`)\1(?!`))|(?=$|\n))/y,
+  ([whole, opener, body, closer]) => () =>
+    closer
+      ? new List([new Data(html('code', { 'data-src': whole }, format(body)))])
+      : body
+        ? new List([new Data(html('code', {
+            class: 'invalid',
+            ...invalid('code', 'syntax', `Missing the closing symbol "${opener}"`)
+          }, whole))])
+        : new List([new Data(opener)]));
 
 function format(text: string): string {
   return text.length > 2

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

@@ -13,7 +13,7 @@ describe('Unit: parser/inline/deletion', () => {
       assert.deepStrictEqual(inspect(parser('~'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('~~'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('~~a'), ctx), [['~~', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('~~a~'), ctx), [['~~', 'a', '~'], '']);
+      assert.deepStrictEqual(inspect(parser('~~a~'), ctx), [['~~', 'a~'], '']);
       assert.deepStrictEqual(inspect(parser(' ~~a~~'), ctx), undefined);
     });
 

package/src/parser/inline/deletion.ts

@@ -1,13 +1,13 @@
 import { DeletionParser } from '../inline';
 import { Recursion, Command } from '../context';
 import { List, Data } from '../../combinator/data/parser';
-import { union, some, recursion, precedence, validate, surround, open, lazy } from '../../combinator';
+import { union, some, recursion, precedence, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { blankWith } from '../visibility';
 import { unwrap, repeat } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
-export const deletion: DeletionParser = lazy(() => validate('~~',
+export const deletion: DeletionParser = lazy(() =>
   precedence(0, repeat('~~', surround(
     '',
     recursion(Recursion.inline,
@@ -18,4 +18,4 @@ export const deletion: DeletionParser = lazy(() => validate('~~',
     '~~', false,
     ([, bs], { buffer }) => buffer!.import(bs),
     ([, bs], { buffer }) => bs && buffer!.import(bs).push(new Data(Command.Cancel)) && buffer!),
-    nodes => new List([new Data(html('del', defrag(unwrap(nodes))))])))));
+    nodes => new List([new Data(html('del', defrag(unwrap(nodes))))]))));

package/src/parser/inline/emstrong.ts

@@ -1,7 +1,7 @@
 import { EmStrongParser, EmphasisParser, StrongParser } from '../inline';
 import { Recursion, Command } from '../context';
 import { Result, List, Data, Node, Context, IntermediateParser } from '../../combinator/data/parser';
-import { union, some, recursion, precedence, validate, surround, open, lazy, bind } from '../../combinator';
+import { union, some, recursion, precedence, surround, open, lazy, bind } from '../../combinator';
 import { inline } from '../inline';
 import { strong } from './strong';
 import { emphasis } from './emphasis';
@@ -24,7 +24,7 @@ const subemphasis: IntermediateParser<EmphasisParser> = lazy(() => some(union([
 // 開閉が明示的でない構文は開閉の不明確な記号による再帰的適用を行わず
 // 可能な限り早く閉じるよう解析しなければならない。
 // このため終端記号の後ろを見て終端を中止し同じ構文を再帰的に適用してはならない。
-export const emstrong: EmStrongParser = lazy(() => validate('***',
+export const emstrong: EmStrongParser = lazy(() =>
   precedence(0, repeat('***', surround(
     '',
     recursion(Recursion.inline,
@@ -142,7 +142,7 @@ export const emstrong: EmStrongParser = lazy(() => validate('***',
         nodes = prepend('*'.repeat(prefix - postfix), nodes);
       }
       return nodes;
-    }))));
+    })));
 
 function prepend<N>(prefix: string, nodes: List<Data<N>>): List<Data<N>> {
   if (typeof nodes.head?.value === 'string') {

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

@@ -11,7 +11,7 @@ import { html } from 'typed-dom/dom';
 // 継続的編集において最も簡便となる。
 
 export const indexer: ExtensionParser.IndexerParser = surround(
-  /\s\[(?=\|\S)/y,
+  / \[(?=\|\S)/y,
   union([
     signature,
     focus(/\|(?=\])/y, () => new List([new Data(html('span', { class: 'indexer', 'data-index': '' }))])),

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

@@ -65,6 +65,7 @@ describe('Unit: parser/inline/html', () => {
     it('basic', () => {
       assert.deepStrictEqual(inspect(parser('<wbr>'), ctx), [['<wbr>'], '']);
       assert.deepStrictEqual(inspect(parser('<wbr >'), ctx), [['<wbr>'], '']);
+      assert.deepStrictEqual(inspect(parser('<wbr  >'), ctx), [['<span class="invalid">&lt;wbr </span>'], ' >']);
       assert.deepStrictEqual(inspect(parser('<wbr>a'), ctx), [['<wbr>'], 'a']);
       assert.deepStrictEqual(inspect(parser('<bdi >a</bdi>'), ctx), [['<bdi>a</bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi  >a</bdi>'), ctx), [['<span class="invalid">&lt;bdi  &gt;a&lt;/bdi&gt;</span>'], '']);

package/src/parser/inline/html.ts

@@ -32,7 +32,7 @@ export const html: HTMLParser = lazy(() => validate(/<[a-z]+(?=[ >])/yi,
       ([as, bs = new List()], context) =>
         new List([new Data(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs))], new List(), new List(), context))])),
     match(
-      new RegExp(String.raw`<(${TAGS.join('|')})(?=[^\S\n]|>)`, 'y'),
+      new RegExp(String.raw`<(${TAGS.join('|')})(?=[ >])`, 'y'),
       memoize(
       ([, tag]) =>
         surround<HTMLParser.TagParser, string>(

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

@@ -13,7 +13,7 @@ describe('Unit: parser/inline/insertion', () => {
       assert.deepStrictEqual(inspect(parser('+'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('++'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('++a'), ctx), [['++', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('++a+'), ctx), [['++', 'a', '+'], '']);
+      assert.deepStrictEqual(inspect(parser('++a+'), ctx), [['++', 'a+'], '']);
       assert.deepStrictEqual(inspect(parser(' ++a++'), ctx), undefined);
     });
 

package/src/parser/inline/insertion.ts

@@ -1,13 +1,13 @@
 import { InsertionParser } from '../inline';
 import { Recursion, Command } from '../context';
 import { List, Data } from '../../combinator/data/parser';
-import { union, some, recursion, precedence, validate, surround, open, lazy } from '../../combinator';
+import { union, some, recursion, precedence, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { blankWith } from '../visibility';
 import { unwrap, repeat } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
-export const insertion: InsertionParser = lazy(() => validate('++',
+export const insertion: InsertionParser = lazy(() =>
   precedence(0, repeat('++', surround(
     '',
     recursion(Recursion.inline,
@@ -18,4 +18,4 @@ export const insertion: InsertionParser = lazy(() => validate('++',
     '++', false,
     ([, bs], { buffer }) => buffer!.import(bs),
     ([, bs], { buffer }) => bs && buffer!.import(bs).push(new Data(Command.Cancel)) && buffer!),
-    nodes => new List([new Data(html('ins', defrag(unwrap(nodes))))])))));
+    nodes => new List([new Data(html('ins', defrag(unwrap(nodes))))]))));

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

@@ -16,8 +16,8 @@ describe('Unit: parser/inline/italic', () => {
       assert.deepStrictEqual(inspect(parser('///a\n///'), ctx), [['///', 'a', '<br>', '///'], '']);
       assert.deepStrictEqual(inspect(parser('///a\\ ///'), ctx), [['///', 'a', ' ', '///'], '']);
       assert.deepStrictEqual(inspect(parser('///a\\\n///'), ctx), [['///', 'a', '<br>', '///'], '']);
-      assert.deepStrictEqual(inspect(parser('///a/b'), ctx), [['///', 'a', '/b'], '']);
-      assert.deepStrictEqual(inspect(parser('///a//b'), ctx), [['///', 'a', '//b'], '']);
+      assert.deepStrictEqual(inspect(parser('///a/b'), ctx), [['///', 'a/b'], '']);
+      assert.deepStrictEqual(inspect(parser('///a//b'), ctx), [['///', 'a//b'], '']);
       assert.deepStrictEqual(inspect(parser('///a*b///'), ctx), [['///', 'a', '*', 'b', '///'], '']);
       assert.deepStrictEqual(inspect(parser('/// ///'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('/// a///'), ctx), undefined);

package/src/parser/inline/italic.ts

@@ -1,7 +1,7 @@
 import { ItalicParser } from '../inline';
 import { Recursion, Command } from '../context';
 import { List, Data } from '../../combinator/data/parser';
-import { union, some, recursion, precedence, validate, surround, open, lazy } from '../../combinator';
+import { union, some, recursion, precedence, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { tightStart, blankWith } from '../visibility';
 import { unwrap, repeat } from '../util';
@@ -10,7 +10,7 @@ import { html, defrag } from 'typed-dom/dom';
 // 可読性のため実際にはオブリーク体を指定する。
 // 斜体は単語に使うとかえって見づらく読み飛ばしやすくなるため使わないべきであり
 // ある程度の長さのある文に使うのが望ましい。
-export const italic: ItalicParser = lazy(() => validate('///',
+export const italic: ItalicParser = lazy(() =>
   precedence(0, repeat('///', surround(
     '',
     recursion(Recursion.inline,
@@ -21,4 +21,4 @@ export const italic: ItalicParser = lazy(() => validate('///',
     '///', false,
     ([, bs], { buffer }) => buffer!.import(bs),
     ([, bs], { buffer }) => bs && buffer!.import(bs).push(new Data(Command.Cancel)) && buffer!),
-    nodes => new List([new Data(html('i', defrag(unwrap(nodes))))])))));
+    nodes => new List([new Data(html('i', defrag(unwrap(nodes))))]))));

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

@@ -180,7 +180,6 @@ describe('Unit: parser/inline/link', () => {
       assert.deepStrictEqual(inspect(parser('[[![]{a}]{b}]{b}'), ctx), [['<a class="link" href="b">[![]{a}]{b}</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[((a))]{b}'), ctx), [['<a class="link" href="b"><span class="paren">((a))</span></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[[[a]]]{b}'), ctx), [['<a class="link" href="b">[[a]]</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[!http://host]{/}'), ctx), [['<a class="link" href="/" target="_blank"><img class="media" data-src="http://host" alt="http://host"></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a]{b}'), ctx), [['<a class="link" href="b">#a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[@a]{b}'), ctx), [['<a class="link" href="b">@a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[@a@b]{c}'), ctx), [['<a class="link" href="c">@a@b</a>'], '']);

package/src/parser/inline/link.ts

@@ -2,7 +2,7 @@ import { MarkdownParser } from '../../../markdown';
 import { LinkParser } from '../inline';
 import { State, Backtrack, Command } from '../context';
 import { List, Data } from '../../combinator/data/parser';
-import { union, inits, tails, sequence, subsequence, some, creation, precedence, state, constraint, validate, surround, open, setBacktrack, dup, reverse, lazy, fmap, bind } from '../../combinator';
+import { union, inits, tails, sequence, subsequence, some, creation, precedence, state, constraint, surround, open, setBacktrack, dup, reverse, lazy, fmap, bind } from '../../combinator';
 import { inline, media, shortmedia } from '../inline';
 import { attributes } from './html';
 import { unescsource, str } from '../source';
@@ -75,7 +75,7 @@ export const textlink: LinkParser.TextLinkParser = lazy(() => constraint(State.l
     return new List([new Data(parse(content, params as List<Data<string>>, context))]);
   }))))));
 
-export const medialink: LinkParser.MediaLinkParser = lazy(() => constraint(State.link | State.media, validate(/[[{]/y, creation(10,
+export const medialink: LinkParser.MediaLinkParser = lazy(() => constraint(State.link | State.media, creation(10,
   state(State.linkers,
   bind(sequence([
     dup(surround(
@@ -85,7 +85,7 @@ export const medialink: LinkParser.MediaLinkParser = lazy(() => constraint(State
     dup(surround(/{(?![{}])/y, inits([uri, some(option)]), / ?}/y)),
   ]),
   ([{ value: content }, { value: params }], context) =>
-    new List([new Data(parse(content, params as List<Data<string>>, context))])))))));
+    new List([new Data(parse(content, params as List<Data<string>>, context))]))))));
 
 export const unsafelink: LinkParser.UnsafeLinkParser = lazy(() =>
   creation(10,

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

@@ -13,7 +13,7 @@ describe('Unit: parser/inline/mark', () => {
       assert.deepStrictEqual(inspect(parser('='), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('=='), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('==a'), ctx), [['==', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('==a='), ctx), [['==', 'a', '='], '']);
+      assert.deepStrictEqual(inspect(parser('==a='), ctx), [['==', 'a='], '']);
       assert.deepStrictEqual(inspect(parser('==a =='), ctx), [['==', 'a', ' ', '=='], '']);
       assert.deepStrictEqual(inspect(parser('==a  =='), ctx), [['==', 'a', ' ', '=='], '']);
       assert.deepStrictEqual(inspect(parser('==a\n=='), ctx), [['==', 'a', '<br>', '=='], '']);

package/src/parser/inline/mark.ts

@@ -1,14 +1,14 @@
 import { MarkParser } from '../inline';
 import { State, Recursion, Command } from '../context';
 import { List, Data } from '../../combinator/data/parser';
-import { union, some, recursion, precedence, state, constraint, validate, surround, open, lazy } from '../../combinator';
+import { union, some, recursion, precedence, state, constraint, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { identity, signature } from './extension/indexee';
 import { tightStart, blankWith } from '../visibility';
 import { unwrap, repeat } from '../util';
 import { html, define, defrag } from 'typed-dom/dom';
 
-export const mark: MarkParser = lazy(() => constraint(State.linkers & ~State.mark, validate('==',
+export const mark: MarkParser = lazy(() => constraint(State.linkers & ~State.mark,
   precedence(0, state(State.mark, repeat('==', surround(
     '',
     recursion(Recursion.inline,
@@ -25,4 +25,4 @@ export const mark: MarkParser = lazy(() => constraint(State.linkers & ~State.mar
       return el.id
         ? new List([new Data(el), new Data(html('a', { href: `#${el.id}` }))])
         : new List([new Data(el)]);
-    }))))));
+    })))));

package/src/parser/inline/remark.ts

@@ -8,9 +8,9 @@ import { unwrap, invalid } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const remark: RemarkParser = lazy(() => fallback(surround(
-  str(/\[%(?=\s)/y),
+  str(/\[%(?=[ \n])/y),
   precedence(3, recursion(Recursion.inline,
-  some(union([inline]), /\s%\]/y, [[/\s%\]/y, 3]]))),
+  some(union([inline]), /[ \n]%\]/y, [[/[ \n]%\]/y, 3]]))),
   close(text, str(`%]`)), true,
   ([as, bs = new List(), cs]) => new List([
     new Data(html('span', { class: 'remark' }, [
@@ -19,6 +19,6 @@ export const remark: RemarkParser = lazy(() => fallback(surround(
     ])),
   ]),
   ([as, bs]) => bs && as.import(bs as List<Data<string>>)),
-  focus(/\[%+(?=\s)/y, ({ context: { source } }) => new List([
+  focus(/\[%+(?=[ \n])/y, ({ context: { source } }) => new List([
     new Data(html('span', { class: 'invalid', ...invalid('remark', 'syntax', 'Invalid start symbol') }, source))
   ]))));

package/src/parser/inline.test.ts

@@ -165,19 +165,19 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('"[% *"*"*'), ctx), [['"', '[%', ' ', '*', '"', '*', '"', '*'], '']);
       assert.deepStrictEqual(inspect(parser('"[% "*"* %]'), ctx), [['"', '<span class="remark"><input type="checkbox"><span>[% "*"* %]</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser('"{{""}}'), ctx), [['"', '{', '{', '"', '"', '}', '}'], '']);
-      assert.deepStrictEqual(inspect(parser('[#http://host/(<bdi>)]</bdi>'), ctx), [['<a class="index" href="#index::http://host/(&lt;bdi&gt;)">http://host/(&lt;bdi&gt;)</a>', '</bdi', '>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#@a/http://host/(<bdi>)]</bdi>'), ctx), [['<a class="index" href="#index::@a/http://host/(&lt;bdi&gt;)">@a/http://host/(&lt;bdi&gt;)</a>', '</bdi', '>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#http://host/(<bdi>)]</bdi>'), ctx), [['<a class="index" href="#index::http://host/(&lt;bdi&gt;)">http://host/<span class="paren">(<span class="invalid">&lt;bdi&gt;</span>)</span></a>', '</bdi', '>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#@a/http://host/(<bdi>)]</bdi>'), ctx), [['<a class="index" href="#index::@a/http://host/(&lt;bdi&gt;)">@a/http://host/<span class="paren">(<span class="invalid">&lt;bdi&gt;</span>)</span></a>', '</bdi', '>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a|<bdi>]</bdi>'), ctx), [['<a class="index" href="#index::a|&lt;bdi&gt;">a|<span class="invalid">&lt;bdi&gt;</span></a>', '</bdi', '>'], '']);
       assert.deepStrictEqual(inspect(parser('[[#a|<bdi>]</bdi>'), ctx), [['[', '<a class="index" href="#index::a|&lt;bdi&gt;">a|<span class="invalid">&lt;bdi&gt;</span></a>', '</bdi', '>'], '']);
     });
 
     it('uri', () => {
       assert.deepStrictEqual(inspect(parser('\nhttp://host'), ctx), [['<br>', '<a class="url" href="http://host" target="_blank">http://host</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('0http://host'), ctx), [['0http:', '//host'], '']);
-      assert.deepStrictEqual(inspect(parser('0aAhttp://host'), ctx), [['0aAhttp:', '//host'], '']);
+      assert.deepStrictEqual(inspect(parser('0http://host'), ctx), [['0http', '://host'], '']);
+      assert.deepStrictEqual(inspect(parser('0aAhttp://host'), ctx), [['0aAhttp', '://host'], '']);
       assert.deepStrictEqual(inspect(parser('?http://host'), ctx), [['?', '<a class="url" href="http://host" target="_blank">http://host</a>'], '']);
       assert.deepStrictEqual(inspect(parser('0!http://host'), ctx), [['0', '!', '<a class="url" href="http://host" target="_blank">http://host</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('0?http://host'), ctx), [['0', '?', '<a class="url" href="http://host" target="_blank">http://host</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('0?http://host'), ctx), [['0?', '<a class="url" href="http://host" target="_blank">http://host</a>'], '']);
       assert.deepStrictEqual(inspect(parser('_http://host'), ctx), [['_', '<a class="url" href="http://host" target="_blank">http://host</a>'], '']);
       assert.deepStrictEqual(inspect(parser('_http://host_'), ctx), [['_', '<a class="url" href="http://host" target="_blank">http://host</a>', '_'], '']);
       assert.deepStrictEqual(inspect(parser('*http://host*'), ctx), [['<em><a class="url" href="http://host" target="_blank">http://host</a></em>'], '']);
@@ -210,7 +210,7 @@ describe('Unit: parser/inline', () => {
 
     it('account', () => {
       assert.deepStrictEqual(inspect(parser('@a'), ctx), [['<a class="account" href="/@a">@a</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('@http://host'), ctx), [['@http', '://host'], '']);
+      assert.deepStrictEqual(inspect(parser('@http://host'), ctx), [['@', 'http', '://host'], '']);
       assert.deepStrictEqual(inspect(parser('_@a'), ctx), [['_', '<a class="account" href="/@a">@a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('_@a_'), ctx), [['_', '<a class="account" href="/@a">@a</a>', '_'], '']);
       assert.deepStrictEqual(inspect(parser('*@a*'), ctx), [['<em><a class="account" href="/@a">@a</a></em>'], '']);
@@ -222,9 +222,9 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('#a#'), ctx), [['#a', '#'], '']);
       assert.deepStrictEqual(inspect(parser('#a#b'), ctx), [['#a', '#b'], '']);
       assert.deepStrictEqual(inspect(parser('#a'), ctx), [['<a class="hashtag" href="/hashtags/a">#a</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('#http://host'), ctx), [['#http', '://host'], '']);
+      assert.deepStrictEqual(inspect(parser('#http://host'), ctx), [['#', 'http', '://host'], '']);
       assert.deepStrictEqual(inspect(parser('#a\nb\n#c\n[#d]'), ctx), [['<a class="hashtag" href="/hashtags/a">#a</a>', '<br>', 'b', '<br>', '<a class="hashtag" href="/hashtags/c">#c</a>', '<br>', '<a class="index" href="#index::d">d</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('##a'), ctx), [['##a'], '']);
+      assert.deepStrictEqual(inspect(parser('##a'), ctx), [['#', '<a class="hashtag" href="/hashtags/a">#a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('_#a'), ctx), [['_', '<a class="hashtag" href="/hashtags/a">#a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('_#a_'), ctx), [['_', '<a class="hashtag" href="/hashtags/a">#a</a>', '_'], '']);
       assert.deepStrictEqual(inspect(parser('_#a_b'), ctx), [['_', '<a class="hashtag" href="/hashtags/a_b">#a_b</a>'], '']);
@@ -233,8 +233,8 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('0a#b'), ctx), [['0a', '#b'], '']);
       assert.deepStrictEqual(inspect(parser('あ#b'), ctx), [['あ', '#b'], '']);
       assert.deepStrictEqual(inspect(parser('あい#b'), ctx), [['あい', '#b'], '']);
-      assert.deepStrictEqual(inspect(parser('0aあ#b'), ctx), [['0a', 'あ', '#b'], '']);
-      assert.deepStrictEqual(inspect(parser('0aあい#b'), ctx), [['0a', 'あい', '#b'], '']);
+      assert.deepStrictEqual(inspect(parser('0aあ#b'), ctx), [['0aあ', '#b'], '']);
+      assert.deepStrictEqual(inspect(parser('0aあい#b'), ctx), [['0aあい', '#b'], '']);
       assert.deepStrictEqual(inspect(parser('「#あ」'), ctx), [['「', '<a class="hashtag" href="/hashtags/あ">#あ</a>', '」'], '']);
       assert.deepStrictEqual(inspect(parser('a\n#b'), ctx), [['a', '<br>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('a\\\n#b'), ctx), [['a', '<br>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
@@ -248,7 +248,7 @@ describe('Unit: parser/inline', () => {
     it('hashnum', () => {
       assert.deepStrictEqual(inspect(parser('#1'), ctx), [['<a class="hashnum">#1</a>'], '']);
       assert.deepStrictEqual(inspect(parser(`#1'`), ctx), [[`<a class="hashnum">#1</a>`, `'`], '']);
-      assert.deepStrictEqual(inspect(parser('#1234567890@a'), ctx), [['#1234567890', '@a'], '']);
+      assert.deepStrictEqual(inspect(parser('#1234567890@a'), ctx), [['#', '1234567890', '@a'], '']);
       assert.deepStrictEqual(inspect(parser('_#1'), ctx), [['_', '<a class="hashnum">#1</a>'], '']);
       assert.deepStrictEqual(inspect(parser('_#1_'), ctx), [['_', '<a class="hashnum">#1</a>', '_'], '']);
       assert.deepStrictEqual(inspect(parser('_#1_0'), ctx), [['_', '<a class="hashtag" href="/hashtags/1_0">#1_0</a>'], '']);

package/src/parser/inline.ts

@@ -66,6 +66,7 @@ export const inline: InlineParser = lazy(() => union([
           case '%':
             return remark(input)
                 || textlink(input)
+                || ruby(input)
                 || bracket(input);
           case '#':
           case '$':
@@ -74,6 +75,7 @@ export const inline: InlineParser = lazy(() => union([
           case '|':
             return extension(input)
                 || textlink(input)
+                || ruby(input)
                 || bracket(input);
         }
         return textlink(input)

package/src/parser/source/text.ts

@@ -103,7 +103,6 @@ export function next(source: string, position: number, delimiter?: RegExp): numb
   const char = source[index];
   switch (char) {
     case '$':
-    case '%':
     case '*':
     case '+':
     case '~':
@@ -111,10 +110,15 @@ export function next(source: string, position: number, delimiter?: RegExp): numb
     case '/':
       index = backToWhitespace(source, position, index);
       break;
+    case '%':
+      index += index - 1 > position && source.startsWith(' %]', index - 1)
+        ? -1
+        : 0;
+      break;
     case '[':
-      index = source[index + 1] === '|'
-        ? backToWhitespace(source, position, index)
-        : index;
+      index += index - 1 > position && source.startsWith(' [|', index - 1)
+        ? -1
+        : 0;
       break;
     case ':':
       index = source.startsWith('//', index + 1)

package/src/parser/util.ts

@@ -28,7 +28,7 @@ export function repeat<N extends HTMLElement | string>(symbol: string, parser: P
   return failsafe(input => {
     const { context } = input;
     const { source, position } = context;
-    assert(source.startsWith(symbol, context.position));
+    if (!source.startsWith(symbol, context.position)) return;
     let nodes = new List<Data<N>>();
     let i = symbol.length;
     for (; source[context.position + i] === source[context.position];) ++i;

package/src/parser/visibility.ts

@@ -8,11 +8,11 @@ import { invisibleHTMLEntityNames } from './api/normalize';
 export namespace blank {
   export const line = new RegExp(
     // TODO: 行全体をエスケープ
-    /^(?:[^\S\r\n])*(?!\s)(\\?[^\S\r\n]|&IHN;|<wbr[^\S\n]*>|\\$)+$/mg.source
+    /^(\\?[^\S\r\n]|&IHN;|<wbr ?>|\\$)+$/mg.source
       .replace('IHN', `(?:${invisibleHTMLEntityNames.join('|')})`),
     'gm');
   export const start = new RegExp(
-    /(?:\\?[^\S\r\n]|&IHN;|<wbr[^\S\n]*>)+/y.source
+    /(?:\\?[^\S\r\n]|&IHN;|<wbr ?>)+/y.source
       .replace('IHN', `(?:${invisibleHTMLEntityNames.join('|')})`), 'y');
 }
 
@@ -46,7 +46,7 @@ export function blankWith(starts: '' | '\n', delimiter: string | RegExp): RegExp
 export function blankWith(starts: '' | '\n', delimiter?: string | RegExp): RegExp {
   if (delimiter === undefined) return blankWith('', starts);
   return new RegExp(String.raw
-    `(?:(?=${starts})(?:\\?\s|&(?:${invisibleHTMLEntityNames.join('|')});|<wbr[^\S\n]*>)${
+    `(?:(?=${starts})(?:\\?\s|&(?:${invisibleHTMLEntityNames.join('|')});|<wbr ?>)${
       // 空行除去
       // 完全な空行はエスケープ済みなので再帰的バックトラックにはならない。
       starts && '+'
@@ -75,7 +75,6 @@ export function tightStart<N>(parser: Parser<N>, except?: string): Parser<N> {
       ? parser(input)
       : undefined;
 }
-const wbr = /<wbr[^\S\n]*>/y;
 function isTightStart(input: Input<MarkdownParser.Context>, except?: string): boolean {
   const { context } = input;
   const { source, position } = context;
@@ -100,11 +99,10 @@ function isTightStart(input: Input<MarkdownParser.Context>, except?: string): bo
       context.position = position;
       return true;
     case '<':
-      wbr.lastIndex = position;
       switch (true) {
         case source.length - position >= 5
           && source.startsWith('<wbr', position)
-          && (source[position + 5] === '>' || wbr.test(source)):
+          && (source[position + 4] === '>' || source.startsWith(' >', position + 4)):
           return false;
       }
       return true;