securemark 0.292.0 → 0.293.0

package/src/parser/inline/emphasis.ts

@@ -2,7 +2,6 @@ import { EmphasisParser } from '../inline';
 import { Recursion } from '../context';
 import { union, some, recursion, precedence, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
-import { emstrong } from './emstrong';
 import { strong } from './strong';
 import { str } from '../source';
 import { tightStart, blankWith } from '../visibility';
@@ -10,16 +9,12 @@ import { unshift } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
 export const emphasis: EmphasisParser = lazy(() => surround(
-  str('*', '*'),
+  str(/\*(?!\*)/y),
   precedence(0, recursion(Recursion.inline,
   tightStart(some(union([
     strong,
     some(inline, blankWith('*')),
-    open(some(inline, '*'), union([
-      emstrong,
-      strong,
-      emphasis,
-    ])),
+    open(some(inline, '*'), inline),
   ]))))),
   str('*'), false,
   ([, bs]) => [[html('em', defrag(bs))]],

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

@@ -11,11 +11,11 @@ describe('Unit: parser/inline/emstrong', () => {
     it('invalid', () => {
       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\n***'), ctx), [['***', 'a'], '\n***']);
-      assert.deepStrictEqual(inspect(parser('***a\\ ***'), ctx), [['***', 'a'], '\\ ***']);
-      assert.deepStrictEqual(inspect(parser('***a\\\n***'), ctx), [['***', 'a'], '\\\n***']);
+      assert.deepStrictEqual(inspect(parser('***a ***'), ctx), [['***', 'a', ' ', '***'], '']);
+      assert.deepStrictEqual(inspect(parser('***a  ***'), ctx), [['***', 'a', ' ', '***'], '']);
+      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('*** ***'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('*** a***'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('*** a ***'), ctx), undefined);
@@ -66,8 +66,8 @@ describe('Unit: parser/inline/emstrong', () => {
       assert.deepStrictEqual(inspect(parser('***a*\\ **b****'), ctx), [['<strong><em>a</em> <strong>b</strong></strong>'], '']);
       assert.deepStrictEqual(inspect(parser('***a*&Tab;**b****'), ctx), [['<strong><em>a</em>\t<strong>b</strong></strong>'], '']);
       assert.deepStrictEqual(inspect(parser('***a*<wbr>**b****'), ctx), [['<strong><em>a</em><wbr><strong>b</strong></strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('***a*b **'), ctx), [['**', '<em>a</em>', 'b'], ' **']);
-      assert.deepStrictEqual(inspect(parser('***a*b\\ **'), ctx), [['**', '<em>a</em>', 'b'], '\\ **']);
+      assert.deepStrictEqual(inspect(parser('***a*b **'), ctx), [['**', '<em>a</em>', 'b **'], '']);
+      assert.deepStrictEqual(inspect(parser('***a*b\\ **'), ctx), [['**', '<em>a</em>', 'b **'], '']);
       assert.deepStrictEqual(inspect(parser('***a**b*'), ctx), [['<em><strong>a</strong>b</em>'], '']);
       assert.deepStrictEqual(inspect(parser('***a**b*c'), ctx), [['<em><strong>a</strong>b</em>'], 'c']);
       assert.deepStrictEqual(inspect(parser('***a**b*c**'), ctx), [['<em><strong>a</strong>b</em>'], 'c**']);
@@ -77,8 +77,8 @@ describe('Unit: parser/inline/emstrong', () => {
       assert.deepStrictEqual(inspect(parser('***a**\\ *b**'), ctx), [['<em><strong>a</strong> <em>b</em></em>'], '']);
       assert.deepStrictEqual(inspect(parser('***a**&Tab;*b**'), ctx), [['<em><strong>a</strong>\t<em>b</em></em>'], '']);
       assert.deepStrictEqual(inspect(parser('***a**<wbr>*b**'), ctx), [['<em><strong>a</strong><wbr><em>b</em></em>'], '']);
-      assert.deepStrictEqual(inspect(parser('***a**b *'), ctx), [['*', '<strong>a</strong>', 'b'], ' *']);
-      assert.deepStrictEqual(inspect(parser('***a**b\\ *'), ctx), [['*', '<strong>a</strong>', 'b'], '\\ *']);
+      assert.deepStrictEqual(inspect(parser('***a**b *'), ctx), [['*', '<strong>a</strong>', 'b *'], '']);
+      assert.deepStrictEqual(inspect(parser('***a**b\\ *'), ctx), [['*', '<strong>a</strong>', 'b *'], '']);
       assert.deepStrictEqual(inspect(parser('***a*'), ctx), [['**', '<em>a</em>'], '']);
       assert.deepStrictEqual(inspect(parser('***a**'), ctx), [['*', '<strong>a</strong>'], '']);
       assert.deepStrictEqual(inspect(parser('***a***'), ctx), [['<em><strong>a</strong></em>'], '']);
@@ -109,11 +109,11 @@ describe('Unit: parser/inline/emstrong', () => {
       assert.deepStrictEqual(inspect(parser('******a******'), ctx), [['<em><strong><em><strong>a</strong></em></strong></em>'], '']);
       assert.deepStrictEqual(inspect(parser('******a******b'), ctx), [['<em><strong><em><strong>a</strong></em></strong></em>'], 'b']);
       assert.deepStrictEqual(inspect(parser('******a*b'), ctx), [['***', '**', '<em>a</em>', 'b'], '']);
-      assert.deepStrictEqual(inspect(parser('******a*b *'), ctx), [['***', '**', '<em>a</em>', 'b'], ' *']);
-      assert.deepStrictEqual(inspect(parser('******a*b **'), ctx), [['***', '**', '<em>a</em>', 'b'], ' **']);
-      assert.deepStrictEqual(inspect(parser('******a*b ***'), ctx), [['***', '**', '<em>a</em>', 'b'], ' ***']);
-      assert.deepStrictEqual(inspect(parser('******a*b ****'), ctx), [['***', '**', '<em>a</em>', 'b'], ' ****']);
-      assert.deepStrictEqual(inspect(parser('******a*b *****'), ctx), [['***', '**', '<em>a</em>', 'b'], ' *****']);
+      assert.deepStrictEqual(inspect(parser('******a*b *'), ctx), [['***', '**', '<em>a</em>', 'b *'], '']);
+      assert.deepStrictEqual(inspect(parser('******a*b **'), ctx), [['***', '**', '<em>a</em>', 'b **'], '']);
+      assert.deepStrictEqual(inspect(parser('******a*b ***'), ctx), [['***', '**', '<em>a</em>', 'b ***'], '']);
+      assert.deepStrictEqual(inspect(parser('******a*b ****'), ctx), [['***', '**', '<em>a</em>', 'b ****'], '']);
+      assert.deepStrictEqual(inspect(parser('******a*b *****'), ctx), [['***', '**', '<em>a</em>', 'b *****'], '']);
     });
 
   });

package/src/parser/inline/emstrong.ts

@@ -14,20 +14,12 @@ import { html, defrag } from 'typed-dom/dom';
 const substrong: IntermediateParser<StrongParser> = lazy(() => some(union([
   emphasis,
   some(inline, blankWith('*')),
-  open(some(inline, '*'), union([
-    emstrong,
-    strong,
-    emphasis,
-  ])),
+  open(some(inline, '*'), inline),
 ])));
 const subemphasis: IntermediateParser<EmphasisParser> = lazy(() => some(union([
   strong,
   some(inline, blankWith('*')),
-  open(some(inline, '*'), union([
-    emstrong,
-    strong,
-    emphasis,
-  ])),
+  open(some(inline, '*'), inline),
 ])));
 
 // 開閉が明示的でない構文は開閉の不明確な記号による再帰的適用を行わず
@@ -39,13 +31,9 @@ export const emstrong: EmStrongParser = lazy(() => validate('***',
     recursion(Recursion.inline,
     tightStart(some(union([
       some(inline, blankWith('*')),
-      open(some(inline, '*'), union([
-        emstrong,
-        strong,
-        emphasis,
-      ])),
+      open(some(inline, '*'), inline),
     ])))),
-    str(/^\*{1,3}/), false,
+    str(/\*{1,3}/y), false,
     ([, bs, cs], context): Result<Node<EmStrongParser>, Context<EmStrongParser>> => {
       assert(cs.length === 1);
       const { buffer } = context;

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

@@ -52,7 +52,7 @@ describe('Unit: parser/inline/extension/index', () => {
       assert.deepStrictEqual(inspect(parser('[#a [% b %]]'), ctx), [['<a class="index" href="#index::a">a <span class="remark"><input type="checkbox"><span>[% b %]</span></span></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a\\ ]'), ctx), [['<a class="index" href="#index::a">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a b]'), ctx), [['<a class="index" href="#index::a_b">a b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a  b]'), ctx), [['<a class="index" href="#index::a__b">a  b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a  b]'), ctx), [['<a class="index" href="#index::a_b">a b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a\tb]'), ctx), [['<a class="index" href="#index::a_b=33Mw2l">a\tb</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a_b]'), ctx), [['<a class="index" href="#index::a_b=2H8oCG">a_b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a\\ b]'), ctx), [['<a class="index" href="#index::a_b">a b</a>'], '']);
@@ -70,7 +70,7 @@ describe('Unit: parser/inline/extension/index', () => {
       assert.deepStrictEqual(inspect(parser('[#@a]'), ctx), [['<a class="index" href="#index::@a">@a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#http://host]'), ctx), [['<a class="index" href="#index::http://host">http://host</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#!http://host]'), ctx), [['<a class="index" href="#index::!http://host">!http://host</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#[%  %]]'), ctx), [['<a class="index"><span class="remark"><input type="checkbox"><span>[%  %]</span></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#[%  %]]'), ctx), [['<a class="index"><span class="remark"><input type="checkbox"><span>[% %]</span></span></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#[% a %]]'), ctx), [['<a class="index"><span class="remark"><input type="checkbox"><span>[% a %]</span></span></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a((b))]'), ctx), [['<a class="index" href="#index::a((b))">a<span class="paren">((b))</span></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a[[b]]]'), ctx), [['<a class="index" href="#index::a[[b]]">a[[b]]</a>'], '']);
@@ -89,10 +89,12 @@ describe('Unit: parser/inline/extension/index', () => {
       assert.deepStrictEqual(inspect(parser('[#a|*b*]'), ctx), [['<a class="index" href="#index::*b*">a<span class="indexer" data-index="*b*"></span></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a|*]*]'), ctx), [['<a class="index" href="#index::*">a<span class="indexer" data-index="*"></span></a>'], '*]']);
       assert.deepStrictEqual(inspect(parser('[#a|b c]'), ctx), [['<a class="index" href="#index::b_c">a<span class="indexer" data-index="b_c"></span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a|b  c]'), ctx), [['<a class="index" href="#index::b__c">a<span class="indexer" data-index="b__c"></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a|b  c]'), ctx), [['<a class="index" href="#index::b_c">a<span class="indexer" data-index="b_c"></span></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a|b\tc]'), ctx), [['<a class="index" href="#index::b_c=xeqYk">a<span class="indexer" data-index="b_c=xeqYk"></span></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a|b_c]'), ctx), [['<a class="index" href="#index::b_c=KUxv5">a<span class="indexer" data-index="b_c=KUxv5"></span></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a|\\[\\]]'), ctx), [['<a class="index" href="#index::[]">a<span class="indexer" data-index="[]"></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a|&]'), ctx), [['<a class="index" href="#index::&amp;">a<span class="indexer" data-index="&amp;"></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a|&copy]'), ctx), [['<a class="index" href="#index::&amp;copy">a<span class="indexer" data-index="&amp;copy"></span></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a|&copy;]'), ctx), [['<a class="index" href="#index::©">a<span class="indexer" data-index="©"></span></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a|&nbsp;]'), ctx), [['<a class="index" href="#index::a|">a|</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a|<wbr>]'), ctx), [['<a class="index" href="#index::a|">a|</a>'], '']);

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

@@ -1,6 +1,6 @@
 import { ExtensionParser } from '../../inline';
 import { State, Backtrack } from '../../context';
-import { union, inits, some, precedence, state, constraint, validate, focus, surround, lazy, fmap } from '../../../combinator';
+import { union, inits, some, precedence, state, constraint, validate, surround, lazy, fmap } from '../../../combinator';
 import { inline } from '../../inline';
 import { indexee, identity } from './indexee';
 import { unsafehtmlentity } from '../htmlentity';
@@ -46,15 +46,12 @@ export const index: IndexParser = lazy(() => constraint(State.index, fmap(indexe
   })));
 
 export const signature: IndexParser.SignatureParser = lazy(() => validate('|', surround(
-  str(/^\|(?!\\?\s)/),
+  str(/\|(?!\\?\s)/y),
   some(union([
     unsafehtmlentity,
-    focus(
-      /^(?:[^\\[\](){}<>"$`\n]|\\[^\n]?)/,
-      txt,
-      false),
+    some(txt, /(?:[&$[\](){}<>"`]|\\?\n)/y),
   ]), ']'),
-  /^(?=])/,
+  /(?=])/y,
   false,
   ([, ns]) => {
     const index = identity('index', undefined, ns.join(''))?.slice(7);

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

@@ -26,7 +26,7 @@ describe('Unit: parser/inline/extension/indexer', () => {
       assert.deepStrictEqual(inspect(parser(' [|a ]'), ctx), [['<span class="indexer" data-index="a"></span>'], '']);
       assert.deepStrictEqual(inspect(parser(' [|a  ]'), ctx), [['<span class="indexer" data-index="a"></span>'], '']);
       assert.deepStrictEqual(inspect(parser(' [|a b]'), ctx), [['<span class="indexer" data-index="a_b"></span>'], '']);
-      assert.deepStrictEqual(inspect(parser(' [|a  b]'), ctx), [['<span class="indexer" data-index="a__b"></span>'], '']);
+      assert.deepStrictEqual(inspect(parser(' [|a  b]'), ctx), [['<span class="indexer" data-index="a_b"></span>'], '']);
       assert.deepStrictEqual(inspect(parser(' [|a\tb]'), ctx), [['<span class="indexer" data-index="a_b=33Mw2l"></span>'], '']);
       assert.deepStrictEqual(inspect(parser(' [|a_b]'), ctx), [['<span class="indexer" data-index="a_b=2H8oCG"></span>'], '']);
       assert.deepStrictEqual(inspect(parser(' [|A]'), ctx), [['<span class="indexer" data-index="A"></span>'], '']);

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

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

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

@@ -4,7 +4,7 @@ import { union, constraint, clear, surround, fmap } from '../../../combinator';
 import { str } from '../../source';
 import { html } from 'typed-dom/dom';
 
-const body = str(/^\$[A-Za-z]*(?:(?:-[A-Za-z][0-9A-Za-z]*)+|-(?:(?:0|[1-9][0-9]*)\.)*(?:0|[1-9][0-9]*)(?![0-9A-Za-z]))/);
+const body = str(/\$[A-Za-z]*(?:(?:-[A-Za-z][0-9A-Za-z]*)+|-(?:(?:0|[1-9][0-9]*)\.)*(?:0|[1-9][0-9]*)(?![0-9A-Za-z]))/y);
 
 export const segment: ExtensionParser.LabelParser.SegmentParser = clear(union([
   surround('[', body, ']'),

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

@@ -14,7 +14,7 @@ import { html } from 'typed-dom/dom';
 
 export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => surround(
   // ^はabbrで使用済みだが^:などのようにして分離使用可能
-  str(/^\[[:^|]/),
+  str(/\[[:^|]/y),
   precedence(1, recursion(Recursion.inline,
   tightStart(some(union([inline]), ']', [[']', 1]])))),
   str(']'), false,

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

@@ -70,13 +70,13 @@ describe('Unit: parser/inline/html', () => {
       assert.deepStrictEqual(inspect(parser('<bdi  >a</bdi>'), ctx), [['<bdi>a</bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi> a</bdi>'), ctx), [['<bdi> a</bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi> a </bdi>'), ctx), [['<bdi> a </bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>  a  </bdi>'), ctx), [['<bdi>  a  </bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser('<bdi>  a  </bdi>'), ctx), [['<bdi> a </bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>\\ a</bdi>'), ctx), [['<bdi> a</bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi><wbr>a</bdi>'), ctx), [['<bdi><wbr>a</bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>a</bdi>'), ctx), [['<bdi>a</bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>a</bdi>a'), ctx), [['<bdi>a</bdi>'], 'a']);
       assert.deepStrictEqual(inspect(parser('<bdi>a </bdi>'), ctx), [['<bdi>a </bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>a \n </bdi>'), ctx), [['<bdi>a  </bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser('<bdi>a \n </bdi>'), ctx), [['<bdi>a </bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>a\n</bdi>'), ctx), [['<bdi>a</bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>a\n </bdi>'), ctx), [['<bdi>a </bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>a\n<wbr></bdi>'), ctx), [['<bdi>a<wbr></bdi>'], '']);

package/src/parser/inline/html.ts

@@ -1,7 +1,7 @@
 import { HTMLParser } from '../inline';
 import { Recursion } from '../context';
 import { Ctx } from '../../combinator/data/parser';
-import { union, subsequence, some, recursion, precedence, validate, focus, surround, open, match, lazy } from '../../combinator';
+import { union, some, recursion, precedence, validate, surround, open, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
 import { isLooseNodeStart, blankWith } from '../visibility';
@@ -20,33 +20,33 @@ const attrspecs = {
 Object.setPrototypeOf(attrspecs, null);
 Object.values(attrspecs).forEach(o => Object.setPrototypeOf(o, null));
 
-export const html: HTMLParser = lazy(() => validate(/^<[a-z]+(?=[^\S\n]|>)/i,
+export const html: HTMLParser = lazy(() => validate(/<[a-z]+(?=[^\S\n]|>)/yi,
   union([
     surround(
       // https://html.spec.whatwg.org/multipage/syntax.html#void-elements
-      str(/^<(?:area|base|br|col|embed|hr|img|input|link|meta|source|track|wbr)(?=[^\S\n]|>)/i),
+      str(/<(?:area|base|br|col|embed|hr|img|input|link|meta|source|track|wbr)(?=[^\S\n]|>)/yi),
       some(union([attribute])),
-      open(str(/^[^\S\n]*/), str('>'), true),
+      open(str(/[^\S\n]*/y), str('>'), true),
       true,
       ([as, bs = [], cs], context) =>
         [[elem(as[0].slice(1), false, push(unshift(as, bs), cs), [], [], context)]],
       ([as, bs = []], context) =>
         [[elem(as[0].slice(1), false, unshift(as, bs), [], [], context)]]),
     match(
-      new RegExp(String.raw`^<(${TAGS.join('|')})(?=[^\S\n]|>)`),
+      new RegExp(String.raw`<(${TAGS.join('|')})(?=[^\S\n]|>)`, 'y'),
       memoize(
       ([, tag]) =>
         surround<HTMLParser.TagParser, string>(
           surround(
-            str(`<${tag}`), some(attribute), open(str(/^[^\S\n]*/), str('>'), true),
+            str(`<${tag}`), some(attribute), open(str(/[^\S\n]*/y), str('>'), true),
             true,
             ([as, bs = [], cs]) => [push(unshift(as, bs), cs)],
             ([as, bs = []]) => [unshift(as, bs)]),
           precedence(3, recursion(Recursion.inline,
-          subsequence([
-            focus(/^[^\S\n]*\n/, some(inline)),
-            some(open(/^\n?/, some(inline, blankWith('\n', `</${tag}>`), [[blankWith('\n', `</${tag}>`), 3]]), true)),
-          ]))),
+          some(union([
+            some(inline, blankWith('\n', `</${tag}>`), [[blankWith('\n', `</${tag}>`), 3]]),
+            open('\n', some(inline, `</${tag}>`, [[`</${tag}>`, 3]]), true),
+          ])))),
           str(`</${tag}>`),
           true,
           ([as, bs = [], cs], context) =>
@@ -57,9 +57,9 @@ export const html: HTMLParser = lazy(() => validate(/^<[a-z]+(?=[^\S\n]|>)/i,
       new Map())),
     surround(
       // https://html.spec.whatwg.org/multipage/syntax.html#void-elements
-      str(/^<[a-z]{1,16}(?=[^\S\n]|>)/i),
+      str(/<[a-z]+(?=[^\S\n]|>)/yi),
       some(union([attribute])),
-      open(str(/^[^\S\n]*/), str('>'), true),
+      open(str(/[^\S\n]*/y), str('>'), true),
       true,
       ([as, bs = [], cs], context) =>
         [[elem(as[0].slice(1), false, push(unshift(as, bs), cs), [], [], context)]],
@@ -68,8 +68,8 @@ export const html: HTMLParser = lazy(() => validate(/^<[a-z]+(?=[^\S\n]|>)/i,
   ])));
 
 export const attribute: HTMLParser.AttributeParser = union([
-  str(/^[^\S\n]+[a-z]+(?:-[a-z]+)*(?:="(?:\\[^\n]|[^\\\n"])*")?(?=[^\S\n]|>)/i),
-  str(/^[^\S\n]+[^\s<>]+/),
+  str(/[^\S\n]+[a-z]+(?:-[a-z]+)*(?:="(?:\\[^\n]|[^\\\n"])*")?(?=[^\S\n]|>)/yi),
+  str(/[^\S\n]+[^\s<>]+/y),
 ]);
 
 function elem(tag: string, content: boolean, as: string[], bs: (HTMLElement | string)[], cs: string[], context: Ctx): HTMLElement {

package/src/parser/inline/htmlentity.ts

@@ -4,7 +4,7 @@ import { invalid } from '../util';
 import { html } from 'typed-dom/dom';
 
 export const unsafehtmlentity: UnsafeHTMLEntityParser = validate('&', focus(
-  /^&(?:[0-9A-Za-z]+;?)?/,
+  /&(?:[0-9A-Za-z]+;?)?/y,
   //({ source }) => [[parser(source) ?? `${Command.Error}${source}`], '']));
   ({ context }) => {
     const { source } = context;

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

@@ -23,12 +23,12 @@ describe('Unit: parser/inline/insertion', () => {
       assert.deepStrictEqual(inspect(parser('++ ++'), ctx), [['<ins> </ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++ a++'), ctx), [['<ins> a</ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++ a ++'), ctx), [['<ins> a </ins>'], '']);
-      assert.deepStrictEqual(inspect(parser('++  a  ++'), ctx), [['<ins>  a  </ins>'], '']);
+      assert.deepStrictEqual(inspect(parser('++  a  ++'), ctx), [['<ins> a </ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++\na++'), ctx), [['<ins><br>a</ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++\\\na++'), ctx), [['<ins><br>a</ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++<wbr>a++'), ctx), [['<ins><wbr>a</ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++a ++'), ctx), [['<ins>a </ins>'], '']);
-      assert.deepStrictEqual(inspect(parser('++a \n ++'), ctx), [['<ins>a  </ins>'], '']);
+      assert.deepStrictEqual(inspect(parser('++a \n ++'), ctx), [['<ins>a </ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++a\n++'), ctx), [['<ins>a</ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++a\n ++'), ctx), [['<ins>a </ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++a\n<wbr>++'), ctx), [['<ins>a<wbr></ins>'], '']);

package/src/parser/inline/insertion.ts

@@ -13,7 +13,7 @@ export const insertion: InsertionParser = lazy(() => validate('++',
     recursion(Recursion.inline,
     some(union([
       some(inline, blankWith('\n', '++')),
-      open('\n', some(insertion, '+'), true),
+      open('\n', some(inline, '+'), true),
     ]))),
     '++', false,
     ([, bs], { buffer }) => [push(buffer!, bs)],

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

@@ -11,11 +11,11 @@ describe('Unit: parser/inline/italic', () => {
     it('invalid', () => {
       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\n///'), ctx), [['///', 'a'], '\n///']);
-      assert.deepStrictEqual(inspect(parser('///a\\ ///'), ctx), [['///', 'a'], '\\ ///']);
-      assert.deepStrictEqual(inspect(parser('///a\\\n///'), ctx), [['///', 'a'], '\\\n///']);
+      assert.deepStrictEqual(inspect(parser('///a ///'), ctx), [['///', 'a', ' ', '/', '/', '/'], '']);
+      assert.deepStrictEqual(inspect(parser('///a  ///'), ctx), [['///', 'a', ' ', '/', '/', '/'], '']);
+      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', '/', '/', '/'], '']);

package/src/parser/inline/italic.ts

@@ -16,7 +16,7 @@ export const italic: ItalicParser = lazy(() => validate('///',
     recursion(Recursion.inline,
     tightStart(some(union([
       some(inline, blankWith('///')),
-      open(some(inline, '/'), italic),
+      open(some(inline, '/'), inline),
     ])))),
     '///', false,
     ([, bs], { buffer }) => [push(buffer!, bs)],

package/src/parser/inline/link.ts

@@ -4,7 +4,7 @@ import { State, Backtrack, Command } from '../context';
 import { union, inits, tails, sequence, subsequence, some, creation, precedence, state, constraint, validate, surround, open, setBacktrack, dup, reverse, lazy, fmap, bind } from '../../combinator';
 import { inline, media, shortmedia } from '../inline';
 import { attributes } from './html';
-import { linebreak, unescsource, str } from '../source';
+import { unescsource, str } from '../source';
 import { trimBlankStart, trimBlankNodeEnd } from '../visibility';
 import { invalid, stringify } from '../util';
 import { ReadonlyURL } from 'spica/url';
@@ -33,9 +33,9 @@ export const textlink: LinkParser.TextLinkParser = lazy(() => constraint(State.l
     // `{ `と`{`で個別にバックトラックが発生し+1nされる。
     // 自己再帰的にパースしてもオプションの不要なパースによる計算量の増加により相殺される。
     dup(surround(
-      /^{(?![{}])/,
+      /{(?![{}])/y,
       inits([uri, some(option)]),
-      /^[^\S\n]*}/,
+      /[^\S\n]*}/y,
       false,
       undefined,
       ([as, bs], context) => {
@@ -75,22 +75,22 @@ export const textlink: LinkParser.TextLinkParser = lazy(() => constraint(State.l
     return [[parse(defrag(content), params, context)]];
   }))))));
 
-export const medialink: LinkParser.MediaLinkParser = lazy(() => constraint(State.link | State.media, validate(['[', '{'], creation(10,
+export const medialink: LinkParser.MediaLinkParser = lazy(() => constraint(State.link | State.media, validate(/[[{]/y, creation(10,
   state(State.linkers,
   bind(reverse(sequence([
     dup(surround(
       '[',
       union([media, shortmedia]),
       ']')),
-    dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]*}/)),
+    dup(surround(/{(?![{}])/y, inits([uri, some(option)]), /[^\S\n]*}/y)),
   ])),
   ([params, content = []]: [string[], (HTMLElement | string)[]], context) =>
     [[parse(defrag(content), params, context)]]))))));
 
 export const linemedialink: LinkParser.LineMediaLinkParser = surround(
-  linebreak,
+  /(?<=^|[\r\n])/y,
   union([medialink]),
-  /^(?=[^\S\n]*(?:$|\n))/);
+  /(?=[^\S\n]*(?:$|\n))/y);
 
 export const unsafelink: LinkParser.UnsafeLinkParser = lazy(() =>
   creation(10,
@@ -99,20 +99,20 @@ export const unsafelink: LinkParser.UnsafeLinkParser = lazy(() =>
       '[',
       some(union([unescsource]), ']'),
       ']')),
-    dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]*}/)),
+    dup(surround(/{(?![{}])/y, inits([uri, some(option)]), /[^\S\n]*}/y)),
   ])),
   ([params, content = []], context) =>
     [[parse(defrag(content), params, context)]])));
 
 export const uri: LinkParser.ParameterParser.UriParser = union([
-  open(/^[^\S\n]+/, str(/^\S+/)),
-  str(/^[^\s{}]+/),
+  open(/[^\S\n]+/y, str(/\S+/y)),
+  str(/[^\s{}]+/y),
 ]);
 
 export const option: LinkParser.ParameterParser.OptionParser = union([
-  fmap(str(/^[^\S\n]+nofollow(?=[^\S\n]|})/), () => [` rel="nofollow"`]),
-  str(/^[^\S\n]+[a-z]+(?:-[a-z]+)*(?:="(?:\\[^\n]|[^\\\n"])*")?(?=[^\S\n]|})/i),
-  str(/^[^\S\n]+[^\s{}]+/),
+  fmap(str(/[^\S\n]+nofollow(?=[^\S\n]|})/y), () => [` rel="nofollow"`]),
+  str(/[^\S\n]+[a-z]+(?:-[a-z]+)*(?:="(?:\\[^\n]|[^\\\n"])*")?(?=[^\S\n]|})/yi),
+  str(/[^\S\n]+[^\s{}]+/y),
 ]);
 
 function parse(
@@ -248,10 +248,10 @@ export function resolve(uri: string, host: URL | Location, source: URL | Locatio
 }
 
 export function decode(uri: string): string {
-  const origin = uri.match(/^[a-z](?:[-.](?=[0-9a-z])|[0-9a-z])*:(?:\/{0,2}[^/?#\s]+|\/\/(?=[/]))/i)?.[0] ?? '';
+  const origin = uri.match(/[a-z](?:[-.](?=[0-9a-z])|[0-9a-z])*:(?:\/{0,2}[^/?#\s]+|\/\/(?=[/]))/yi)?.[0] ?? '';
   try {
     let path = decodeURI(uri.slice(origin.length));
-    if (!origin && /^[a-z](?:[-.](?=[0-9a-z])|[0-9a-z])*:\/{0,2}\S/i.test(path)) {
+    if (!origin && /[a-z](?:[-.](?=[0-9a-z])|[0-9a-z])*:\/{0,2}\S/yi.test(path)) {
       path = uri.slice(origin.length);
     }
     uri = origin + path;

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

@@ -14,11 +14,11 @@ describe('Unit: parser/inline/mark', () => {
       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\n=='), ctx), [['==', 'a'], '\n==']);
-      assert.deepStrictEqual(inspect(parser('==a\\ =='), ctx), [['==', 'a'], '\\ ==']);
-      assert.deepStrictEqual(inspect(parser('==a\\\n=='), ctx), [['==', 'a'], '\\\n==']);
+      assert.deepStrictEqual(inspect(parser('==a =='), ctx), [['==', 'a', ' ', '=', '='], '']);
+      assert.deepStrictEqual(inspect(parser('==a  =='), ctx), [['==', 'a', ' ', '=', '='], '']);
+      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('== =='), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('== a=='), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('== a =='), ctx), undefined);

package/src/parser/inline/mark.ts

@@ -14,7 +14,7 @@ export const mark: MarkParser = lazy(() => constraint(State.linkers & ~State.mar
     recursion(Recursion.inline,
     tightStart(some(union([
       some(inline, blankWith('==')),
-      open(some(inline, '='), mark),
+      open(some(inline, '='), inline),
     ])))),
     '==', false,
     ([, bs], { buffer }) => [push(buffer!, bs)],

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

@@ -31,10 +31,8 @@ describe('Unit: parser/inline/math', () => {
       assert.deepStrictEqual(inspect(parser('$a"$'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('$-a($-b)'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('$-a\\($-b\\)'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('$a($'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('$-a[$-b]'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('$-a\\[$-b\\]'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('$a[$'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('$-a{$-b}'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('$a{$'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('$a$b'), ctx), undefined);
@@ -81,11 +79,13 @@ describe('Unit: parser/inline/math', () => {
       assert.deepStrictEqual(inspect(parser('${\n}$'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('${a\\$\nb}$'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('${a\\$\\\nb}$'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('$\\begin{}$'), ctx), [['<span class="invalid" translate="no">$\\begin{}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('$\\begin$'), ctx), [['<span class="invalid" translate="no">$\\begin$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('$\\huge0$'), ctx), [['<span class="invalid" translate="no">$\\huge0$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('$\\Begin{}$'), ctx), [['<span class="invalid" translate="no">$\\Begin{}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('$\\Begin$'), ctx), [['<span class="invalid" translate="no">$\\Begin$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('$\\begin{}$'), ctx), [['<span class="invalid" translate="no">$\\begin{}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('${\\begin}$'), ctx), [['<span class="invalid" translate="no">${\\begin}$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('$http://host$'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('$http://host$'), ctx), [['<span class="invalid" translate="no">$http://host$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('${http://host}$'), ctx), [['<span class="invalid" translate="no">${http://host}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser(' ${a}$'), ctx), undefined);
     });
 
@@ -123,7 +123,7 @@ describe('Unit: parser/inline/math', () => {
       assert.deepStrictEqual(inspect(parser('$E = mc^2$'), ctx), [['<span class="math" translate="no" data-src="$E = mc^2$">$E = mc^2$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('$f(x)$'), ctx), [['<span class="math" translate="no" data-src="$f(x)$">$f(x)$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('$f: x \\to y$'), ctx), [['<span class="math" translate="no" data-src="$f: x \\to y$">$f: x \\to y$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('$k$-space'), ctx), [['<span class="math" translate="no" data-src="$k$">$k$</span>'], '-space']);
+      assert.deepStrictEqual(inspect(parser('$k$\\-space'), ctx), [['<span class="math" translate="no" data-src="$k$">$k$</span>'], '\\-space']);
       assert.deepStrictEqual(inspect(parser('$a{b}$'), ctx), [['<span class="math" translate="no" data-src="$a{b}$">$a{b}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('$a\\{$\\}'), ctx), [['<span class="math" translate="no" data-src="$a\\{$">$a\\{$</span>'], '\\}']);
       assert.deepStrictEqual(inspect(parser('${}$'), ctx), [['<span class="math" translate="no" data-src="${}$">${}$</span>'], '']);

package/src/parser/inline/math.ts

@@ -1,30 +1,26 @@
 import { MathParser } from '../inline';
 import { Backtrack, Recursion } from '../context';
-import { union, some, recursion, precedence, validate, focus, rewrite, surround, lazy } from '../../combinator';
+import { union, some, recursion, precedence, validate, rewrite, surround, lazy } from '../../combinator';
 import { escsource, str } from '../source';
 import { invalid } from '../util';
 import { html } from 'typed-dom/dom';
 
-const forbiddenCommand = /\\(?:begin|tiny|huge|large)(?![a-z])/i;
+const forbiddenCommand = /\\(?:begin|tiny|huge|large)(?![a-z])|:\/\//i;
 
 export const math: MathParser = lazy(() => validate('$', rewrite(
   union([
     surround(
-      /^\$(?={)/,
+      /\$(?={)/y,
       precedence(5, bracket),
       '$',
       false, undefined, undefined, [3 | Backtrack.bracket]),
     surround(
-      /^\$(?![\s{}])/,
+      /\$(?![\s{}])/y,
       precedence(2, some(union([
+        some(escsource, /\s?\$|[`"{}\n]/y),
         precedence(5, bracket),
-        some(focus(
-          /^(?:[ ([](?!\$)|\\[\\{}$#]?|[!%&')\x2A-\x5A\]^_\x61-\x7A|~])/,
-          escsource,
-          false),
-          '://'),
       ]))),
-      /^\$(?![0-9A-Za-z])/,
+      /\$(?![-0-9A-Za-z])/y,
       false, undefined, undefined, [3 | Backtrack.bracket]),
   ]),
   ({ context: { source, caches: { math: cache } = {} } }) => [[
@@ -46,7 +42,7 @@ const bracket: MathParser.BracketParser = lazy(() => surround(
   recursion(Recursion.terminal,
   some(union([
     bracket,
-    some(escsource, /^[{}$#\n]/),
+    some(escsource, /[{}$\n]/y),
   ]))),
   str('}'),
   true));