securemark 0.292.0 → 0.293.1

package/src/parser/block/heading.ts

@@ -8,7 +8,7 @@ import { invalid } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const segment: HeadingParser.SegmentParser = block(validate('#', focus(
-  /^#+[^\S\n]+\S[^\n]*(?:\n#+(?!\S)[^\n]*)*(?:$|\n)/,
+  /#+[^\S\n]+\S[^\n]*(?:\n#+(?!\S)[^\n]*)*(?:$|\n)/y,
   some(line(({ context: { source } }) => [[source]])))));
 
 export const heading: HeadingParser = block(rewrite(segment,
@@ -16,7 +16,7 @@ export const heading: HeadingParser = block(rewrite(segment,
   state(State.annotation | State.reference | State.index | State.label | State.link,
   line(indexee(fmap(union([
     open(
-      str(/^##+/),
+      str(/##+/y),
       visualize(trimBlank(some(union([indexer, inline])))), true),
     open(
       str('#'),

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

@@ -15,9 +15,9 @@ describe('Unit: parser/block/ilist', () => {
       assert(parser('- '));
       assert(parser('+ '));
       assert(parser('* '));
-      assert(parser('-\n-'));
-      assert(parser('+\n+'));
-      assert(parser('*\n*'));
+      assert(parser('- \n-'));
+      assert(parser('+ \n+'));
+      assert(parser('* \n*'));
     });
 
   });

package/src/parser/block/ilist.ts

@@ -1,25 +1,25 @@
 import { IListParser } from '../block';
 import { Parser } from '../../combinator/data/parser';
 import { Recursion } from '../context';
-import { union, inits, some, recursion, block, line, validate, indent, rewrite, open, trim, fallback, lazy, fmap } from '../../combinator';
+import { union, inits, some, recursion, block, line, validate, indent, rewrite, open, fallback, lazy, fmap } from '../../combinator';
 import { ulist_, fillFirstLine } from './ulist';
 import { olist_ } from './olist';
 import { inline } from '../inline';
 import { contentline } from '../source';
 import { visualize, trimBlank } from '../visibility';
-import { lineable, invalid } from '../util';
+import { invalid } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const ilist: IListParser = lazy(() => block(validate(
-  /^[-+*](?=[^\S\n]|\n[^\S\n]*\S)/,
+  /[-+*] /y,
   ilist_)));
 
 export const ilist_: IListParser = lazy(() => block(fmap(validate(
-  /^[-+*](?:$|\s)/,
+  /[-+*](?:$|[ \n])/y,
   some(recursion(Recursion.listitem, union([
     fmap(fallback(
       inits([
-        line(open(/^[-+*](?:$|\s)/, trim(visualize(trimBlank(lineable(some(inline))))), true)),
+        line(open(/[-+*](?:$|[ \n])/y, visualize(trimBlank(some(inline))), true)),
         indent(union([ulist_, olist_, ilist_])),
       ]),
       ilistitem),

package/src/parser/block/mathblock.ts

@@ -1,17 +1,17 @@
 import { MathBlockParser } from '../block';
-import { block, validate, fence, clear, fmap } from '../../combinator';
+import { block, fence, clear, fmap } from '../../combinator';
 import { invalid } from '../util';
 import { html } from 'typed-dom/dom';
 
-const opener = /^(\${2,})(?!\$)([^\n]*)(?:$|\n)/;
+const opener = /(\${2,})(?!\$)([^\n]*)(?:$|\n)/y;
 
-export const segment: MathBlockParser.SegmentParser = block(validate('$$',
-  clear(fence(opener, 300))));
+export const segment: MathBlockParser.SegmentParser = block(
+  clear(fence(opener, 300)));
 
-export const segment_: MathBlockParser.SegmentParser = block(validate('$$',
-  clear(fence(opener, 300, false))), false);
+export const segment_: MathBlockParser.SegmentParser = block(
+  clear(fence(opener, 300, false)), false);
 
-export const mathblock: MathBlockParser = block(validate('$$', fmap(
+export const mathblock: MathBlockParser = block(fmap(
   fence(opener, 300),
   // Bug: Type mismatch between outer and inner.
   ([body, overflow, closer, opener, delim, param]: string[], { caches: { math: cache = undefined } = {} }) => [
@@ -29,4 +29,4 @@ export const mathblock: MathBlockParser = block(validate('$$', fmap(
                 overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
                   'Invalid argument'),
         }, `${opener}${body}${overflow || closer}`),
-  ])));
+  ]));

package/src/parser/block/mediablock.ts

@@ -1,23 +1,23 @@
 import { MediaBlockParser } from '../block';
-import { union, inits, some, block, line, validate, fallback, fmap } from '../../combinator';
-import { medialink, media, shortmedia } from '../inline';
+import { union, inits, some, block, line, fallback, fmap } from '../../combinator';
+import { medialink, media, lineshortmedia } from '../inline';
 import { invalid } from '../util';
 import { html } from 'typed-dom/dom';
 
-export const mediablock: MediaBlockParser = block(validate(['[!', '!'], fmap(
+export const mediablock: MediaBlockParser = block(fmap(
   inits([
     line(union([
       medialink,
       media,
-      shortmedia,
+      lineshortmedia,
     ])),
     some(line(fallback(union([
       medialink,
       media,
-      shortmedia,
+      lineshortmedia,
     ]), ({ context: { source } }) => [[html('span', {
       class: 'invalid',
       ...invalid('mediablock', 'syntax', 'Not media syntax'),
     }, source.replace('\n', ''))]]))),
   ]),
-  ns => [html('div', ns)])));
+  ns => [html('div', ns)]));

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

@@ -28,8 +28,10 @@ describe('Unit: parser/block/olist', () => {
       assert.deepStrictEqual(inspect(parser('1.1.'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('1.a'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('1.\n'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('1.\n1. a'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('(1)'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('(1)\n'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('(1)\n(1) a'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('(I) '), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('(A) '), ctx), undefined);
       assert.deepStrictEqual(inspect(parser(' 1. '), ctx), undefined);
@@ -51,11 +53,11 @@ describe('Unit: parser/block/olist', () => {
 
     it('multiple', () => {
       // pending
-      assert.deepStrictEqual(inspect(parser('0.\n0'), ctx), [['<ol><li></li><li></li></ol>'], '']);
-      assert.deepStrictEqual(inspect(parser('0.\n0\n'), ctx), [['<ol><li></li><li></li></ol>'], '']);
-      assert.deepStrictEqual(inspect(parser('0.\n0.'), ctx), [['<ol><li></li><li></li></ol>'], '']);
-      assert.deepStrictEqual(inspect(parser('0.\n0. '), ctx), [['<ol><li></li><li></li></ol>'], '']);
-      assert.deepStrictEqual(inspect(parser('0.\n0.\n'), ctx), [['<ol><li></li><li></li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('0. \n0'), ctx), [['<ol><li></li><li></li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('0. \n0\n'), ctx), [['<ol><li></li><li></li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('0. \n0.'), ctx), [['<ol><li></li><li></li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('0. \n0. '), ctx), [['<ol><li></li><li></li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('0. \n0.\n'), ctx), [['<ol><li></li><li></li></ol>'], '']);
       // filled
       assert.deepStrictEqual(inspect(parser('0. 1\n0. 2'), ctx), [['<ol><li id="index::1">1</li><li id="index::2">2</li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('0. 1\n0. 2\n0. 3'), ctx), [['<ol><li id="index::1">1</li><li id="index::2">2</li><li id="index::3">3</li></ol>'], '']);
@@ -73,7 +75,7 @@ describe('Unit: parser/block/olist', () => {
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser('0.\n 0'), ctx), [['<ol><li><br><ol><li></li></ol></li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('0. \n 0'), ctx), [['<ol><li><br><ol><li></li></ol></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('0. 1\n 0'), ctx), [['<ol><li id="index::1">1<ol><li></li></ol></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('0. 1\n 0.'), ctx), [['<ol><li id="index::1">1<ol><li></li></ol></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('0. 1\n 0. '), ctx), [['<ol><li id="index::1">1<ol><li></li></ol></li></ol>'], '']);
@@ -93,16 +95,16 @@ describe('Unit: parser/block/olist', () => {
       assert.deepStrictEqual(inspect(parser('9. '), ctx), [['<ol><li data-marker="9."></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('00. '), ctx), [['<ol><li data-marker="00."></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('01. '), ctx), [['<ol><li data-marker="01."></li></ol>'], '']);
-      assert.deepStrictEqual(inspect(parser('0.\n1'), ctx), [['<ol><li></li><li data-marker="1."></li></ol>'], '']);
-      assert.deepStrictEqual(inspect(parser('8.\n9'), ctx), [['<ol><li data-marker="8."></li><li data-marker="9."></li></ol>'], '']);
-      assert.deepStrictEqual(inspect(parser('9.\n9'), ctx), [['<ol><li data-marker="9."></li><li data-marker="9." class="invalid"></li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('0. \n1'), ctx), [['<ol><li></li><li data-marker="1."></li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('8. \n9'), ctx), [['<ol><li data-marker="8."></li><li data-marker="9."></li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('9. \n9'), ctx), [['<ol><li data-marker="9."></li><li data-marker="9." class="invalid"></li></ol>'], '']);
     });
 
     it('branch', () => {
       assert.deepStrictEqual(inspect(parser('1-1. '), ctx), [['<ol><li data-marker="1-1."></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('1-1-1. '), ctx), [['<ol><li data-marker="1-1-1."></li></ol>'], '']);
-      assert.deepStrictEqual(inspect(parser('1.\n1-'), ctx), [['<ol><li></li><li data-marker="1-."></li></ol>'], '']);
-      assert.deepStrictEqual(inspect(parser('1.\n1-1'), ctx), [['<ol><li></li><li data-marker="1-1."></li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('1. \n1-'), ctx), [['<ol><li></li><li data-marker="1-."></li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('1. \n1-1'), ctx), [['<ol><li></li><li data-marker="1-1."></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('(1)-1 '), ctx), [['<ol data-format="paren"><li data-marker="(1)-1"></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('(1)-1-1 '), ctx), [['<ol data-format="paren"><li data-marker="(1)-1-1"></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('(1) \n(1)-'), ctx), [['<ol data-format="paren"><li></li><li data-marker="(1)-"></li></ol>'], '']);
@@ -119,7 +121,7 @@ describe('Unit: parser/block/olist', () => {
       assert.deepStrictEqual(inspect(parser('a. '), ctx), [['<ol type="a" data-type="lower-alpha"><li></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('I. '), ctx), [['<ol type="I" data-type="upper-roman"><li></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('A. '), ctx), [['<ol type="A" data-type="upper-alpha"><li></li></ol>'], '']);
-      assert.deepStrictEqual(inspect(parser('a.\n1.\nc'), ctx), [['<ol type="a" data-type="lower-alpha"><li></li><li data-marker="1."></li><li data-marker="c."></li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('a. \n1.\nc'), ctx), [['<ol type="a" data-type="lower-alpha"><li></li><li data-marker="1."></li><li data-marker="c."></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('i. 1'), ctx), [['<ol type="i" data-type="lower-roman"><li id="index::1">1</li></ol>'], '']);
     });
 
@@ -131,10 +133,10 @@ describe('Unit: parser/block/olist', () => {
     });
 
     it('indexer', () => {
-      assert.deepStrictEqual(inspect(parser('1. [|a]'), ctx), [['<ol><li id="index::[|a]">[|a]</li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('1. [|a]'), ctx), [['<ol><li id="index::[|a]"><span class="invalid">[|a]</span></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('1. a [|]'), ctx), [['<ol><li>a<span class="indexer" data-index=""></span></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('1. a [|b]'), ctx), [['<ol><li id="index::b">a<span class="indexer" data-index="b"></span></li></ol>'], '']);
-      assert.deepStrictEqual(inspect(parser('1. [ ] [|a]'), ctx), [['<ol class="checklist"><li id="index::[|a]"><span class="checkbox">☐</span>[|a]</li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('1. [ ] [|a]'), ctx), [['<ol class="checklist"><li id="index::[|a]"><span class="checkbox">☐</span><span class="invalid">[|a]</span></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('1. [ ] a [|b]'), ctx), [['<ol class="checklist"><li id="index::b"><span class="checkbox">☐</span>a<span class="indexer" data-index="b"></span></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('1. a [|]\n 1. c [|d]'), ctx), [['<ol><li>a<span class="indexer" data-index=""></span><ol><li id="index::d">c<span class="indexer" data-index="d"></span></li></ol></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('1. a [|b]\n 1. c [|d]'), ctx), [['<ol><li id="index::b">a<span class="indexer" data-index="b"></span><ol><li id="index::d">c<span class="indexer" data-index="d"></span></li></ol></li></ol>'], '']);

package/src/parser/block/olist.ts

@@ -1,24 +1,24 @@
 import { OListParser } from '../block';
 import { Recursion } from '../context';
-import { union, inits, subsequence, some, recursion, block, line, validate, indent, focus, open, match, trim, fallback, lazy, fmap } from '../../combinator';
+import { union, inits, subsequence, some, recursion, block, line, validate, indent, focus, open, match, fallback, lazy, fmap } from '../../combinator';
 import { ulist_, checkbox, fillFirstLine } from './ulist';
 import { ilist_, ilistitem } from './ilist';
 import { inline, indexee, indexer, dataindex } from '../inline';
-import { invalid, lineable } from '../util';
+import { invalid } from '../util';
 import { visualize, trimBlank } from '../visibility';
 import { memoize } from 'spica/memoize';
 import { html, define, defrag } from 'typed-dom/dom';
 
 const openers = {
-  '.': /^([0-9]+|[a-z]+|[A-Z]+)(?:-(?!-)[0-9]*)*(?![^\S\n])\.?(?:$|\s)/,
-  '(': /^\(([0-9]*|[a-z]*)(?![^)\n])\)?(?:-(?!-)[0-9]*)*(?:$|\s)/,
+  '.': /([0-9]+|[a-z]+|[A-Z]+)(?:-(?=$|[0-9\n])[0-9]*)*(?:\.?(?:$|[\n])|\. )/y,
+  '(': /\((?=$|[0-9a-z\n])([0-9]*|[a-z]*)(?=$|[)\n])\)?(?:-(?=$|[0-9\n])[0-9]*)*(?:$|[ \n])/y,
 } as const;
 
 export const olist: OListParser = lazy(() => block(validate(
   new RegExp([
-    /^([0-9]+|[a-z]+|[A-Z]+)(?:-[0-9]+)*\.(?=[^\S\n]|\n[^\S\n]*\S)/.source,
-    /^\(([0-9]+|[a-z]+)\)(?:-[0-9]+)*(?=[^\S\n]|\n[^\S\n]*\S)/.source,
-  ].join('|')),
+    /([0-9]+|[a-z]+|[A-Z]+)(?:-[0-9]+)*\. /y.source,
+    /\(([0-9]+|[a-z]+)\)(?:-[0-9]+)* /y.source,
+  ].join('|'), 'y'),
   olist_)));
 
 export const olist_: OListParser = lazy(() => block(union([
@@ -36,7 +36,7 @@ const list = (type: string, form: string): OListParser.ListParser => fmap(
       inits([
         line(open(heads[form], subsequence([
           checkbox,
-          trim(visualize(lineable(trimBlank(some(union([indexer, inline]))))))]), true)),
+          visualize(trimBlank(some(union([indexer, inline]))))]), true)),
         indent(union([ulist_, olist_, ilist_])),
       ]),
       ilistitem),
@@ -101,15 +101,15 @@ function style(type: string): string {
 function pattern(type: string): RegExp {
   switch (type) {
     case 'i':
-      return /^\(?i[).]?$/;
+      return /\(?i[).]?$/y;
     case 'a':
-      return /^\(?a[).]?$/;
+      return /\(?a[).]?$/y;
     case 'I':
-      return /^\(?I[).]?$/;
+      return /\(?I[).]?$/y;
     case 'A':
-      return /^\(?A[).]?$/;
+      return /\(?A[).]?$/y;
     default:
-      return /^\(?[01][).]?$/;
+      return /\(?[01][).]?$/y;
   }
 }
 

package/src/parser/block/pagebreak.ts

@@ -3,5 +3,5 @@ import { block, line, focus } from '../../combinator';
 import { html } from 'typed-dom/dom';
 
 export const pagebreak: PagebreakParser = block(line(focus(
-  /^={3,}[^\S\n]*(?:$|\n)/,
+  /={3,}[^\S\n]*(?:$|\n)/y,
   () => [[html('hr')]])));

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

@@ -23,7 +23,7 @@ describe('Unit: parser/block/paragraph', () => {
       assert.deepStrictEqual(inspect(parser('a\\\n'), ctx), [['<p>a</p>'], '']);
       assert.deepStrictEqual(inspect(parser('a\\\nb'), ctx), [['<p>a<br>b</p>'], '']);
       assert.deepStrictEqual(inspect(parser('a&NewLine;b'), ctx), [['<p>a b</p>'], '']);
-      assert.deepStrictEqual(inspect(parser('&Tab;&NewLine;'), ctx), [['<p>&amp;Tab;&amp;NewLine;</p>'], '']);
+      assert.deepStrictEqual(inspect(parser('&Tab;&NewLine;'), ctx), [['<p>&amp;NewLine;</p>'], '']);
       assert.deepStrictEqual(inspect(parser('<wbr>'), ctx), [['<p>&lt;wbr&gt;</p>'], '']);
       assert.deepStrictEqual(inspect(parser('<wbr>\n'), ctx), [['<p>&lt;wbr&gt;</p>'], '']);
       assert.deepStrictEqual(inspect(parser('<wbr>\na'), ctx), [['<p>&lt;wbr&gt;<br>a</p>'], '']);
@@ -36,9 +36,9 @@ describe('Unit: parser/block/paragraph', () => {
       assert.deepStrictEqual(inspect(parser('***a**b\n<wbr>*\nc'), ctx), [['<p>*<strong>a</strong>b<br><wbr>*<br>c</p>'], '']);
       assert.deepStrictEqual(inspect(parser('==a\n<wbr>==\nb'), ctx), [['<p>==a<br><wbr>==<br>b</p>'], '']);
       assert.deepStrictEqual(inspect(parser('http://host)'), ctx), [['<p><a class="url" href="http://host)" target="_blank">http://host)</a></p>'], '']);
-      assert.deepStrictEqual(inspect(parser('a\nhttp://host) \nb'), ctx), [['<p>a<br><a class="url" href="http://host)" target="_blank">http://host)</a> <br>b</p>'], '']);
+      assert.deepStrictEqual(inspect(parser('a\nhttp://host) \nb'), ctx), [['<p>a<br><a class="url" href="http://host)" target="_blank">http://host)</a><br>b</p>'], '']);
       assert.deepStrictEqual(inspect(parser('!http://host)'), ctx), [['<p>!<a class="url" href="http://host)" target="_blank">http://host)</a></p>'], '']);
-      assert.deepStrictEqual(inspect(parser('a\n!http://host) \nb'), ctx), [['<p>a<br>!<a class="url" href="http://host)" target="_blank">http://host)</a> <br>b</p>'], '']);
+      assert.deepStrictEqual(inspect(parser('a\n!http://host) \nb'), ctx), [['<p>a<br>!<a class="url" href="http://host)" target="_blank">http://host)</a><br>b</p>'], '']);
       assert.deepStrictEqual(inspect(parser('\ta'), ctx), [['<p>\ta</p>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^A]]'), ctx), [['<p><sup class="reference" data-abbr="A"><span></span></sup></p>'], '']);
     });
@@ -67,7 +67,6 @@ describe('Unit: parser/block/paragraph', () => {
       assert.deepStrictEqual(inspect(parser('[% a %]'), ctx), [['<p><span class="remark"><input type="checkbox"><span>[% a %]</span></span></p>'], '']);
       assert.deepStrictEqual(inspect(parser('[% a %]b'), ctx), [['<p><span class="remark"><input type="checkbox"><span>[% a %]</span></span>b</p>'], '']);
       assert.deepStrictEqual(inspect(parser('[% a %]\nb'), ctx), [['<p><span class="remark"><input type="checkbox"><span>[% a %]</span></span><br>b</p>'], '']);
-      assert.deepStrictEqual(inspect(parser('[%% a %%]'), ctx), [['<p><span class="remark"><input type="checkbox"><span>[%% a %%]</span></span></p>'], '']);
       assert.deepStrictEqual(inspect(parser('[%\n<wbr>\n%]'), ctx), [['<p><span class="remark"><input type="checkbox"><span>[%<br>&lt;wbr&gt;<br>%]</span></span></p>'], '']);
       assert.deepStrictEqual(inspect(parser('[%\n<wbr>\n%]a'), ctx), [['<p><span class="remark"><input type="checkbox"><span>[%<br>&lt;wbr&gt;<br>%]</span></span>a</p>'], '']);
       assert.deepStrictEqual(inspect(parser('[%\n<wbr>\n%]\na'), ctx), [['<p><span class="remark"><input type="checkbox"><span>[%<br>&lt;wbr&gt;<br>%]</span></span><br>a</p>'], '']);

package/src/parser/block/paragraph.ts

@@ -1,10 +1,9 @@
 import { ParagraphParser } from '../block';
 import { union, some, block, fmap } from '../../combinator';
 import { inline } from '../inline';
-import { lineable } from '../util';
 import { visualize, trimBlankEnd } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 
 export const paragraph: ParagraphParser = block(fmap(
-  visualize(trimBlankEnd(lineable(some(union([inline]))))),
+  visualize(trimBlankEnd(some(union([inline])))),
   ns => [html('p', defrag(ns))]));

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

@@ -1,25 +1,23 @@
 import { ReplyParser } from '../../block';
-import { union, line, validate, focus, open, fmap } from '../../../combinator';
+import { union, line, focus, open, fmap } from '../../../combinator';
 import { anchor } from '../../inline/autolink/anchor';
 import { str } from '../../source';
 import { invalid } from '../../util';
 import { html, define, defrag } from 'typed-dom/dom';
 
-export const syntax = /^>*(?=>>[^>\s]\S*[^\S\n]*(?:$|\n))/;
+export const syntax = />*(?=>>[^>\s]\S*[^\S\n]*(?:$|\n))/y;
 
-export const cite: ReplyParser.CiteParser = line(fmap(validate(
-  '>>',
+export const cite: ReplyParser.CiteParser = line(fmap(
   open(
     str(syntax),
     union([
       anchor,
       // Subject page representation.
       // リンクの実装は後で検討
-      focus(/^>>#\S*(?=\s*$)/, ({ context: { source } }) => [[html('a', { class: 'anchor' }, source)]]),
-      focus(/^>>https?:\/\/\S+(?=\s*$)/, ({ context: { source } }) => [[html('a', { class: 'anchor', href: source.slice(2).trimEnd(), target: '_blank' }, source)]]),
-      focus(/^>>.+(?=\s*$)/, ({ context: { source } }) => [[source]]),
-    ]),
-  )),
+      focus(/>>#\S*(?=\s*$)/y, ({ context: { source } }) => [[html('a', { class: 'anchor' }, source)]]),
+      focus(/>>https?:\/\/\S+(?=\s*$)/y, ({ context: { source } }) => [[html('a', { class: 'anchor', href: source.slice(2).trimEnd(), target: '_blank' }, source)]]),
+      focus(/>>.+(?=\s*$)/y, ({ context: { source } }) => [[source]]),
+    ])),
   ([quotes, node]: [string, HTMLElement | string]) => [
     html('span',
       typeof node === 'object'

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

@@ -3,16 +3,16 @@ import { union, some, block, validate, rewrite, convert, lazy, fmap } from '../.
 import { math } from '../../inline/math';
 import { autolink } from '../../inline/autolink';
 import { linebreak, unescsource, anyline } from '../../source';
+import { linearize } from '../../util';
 import { html, defrag } from 'typed-dom/dom';
 
-export const syntax = /^>+[^\S\n]/;
+export const syntax = />+[^\S\n]/y;
 
-export const quote: ReplyParser.QuoteParser = lazy(() => block(fmap(validate(
-  '>',
+export const quote: ReplyParser.QuoteParser = lazy(() => block(fmap(
   rewrite(
     some(validate(syntax, anyline)),
-    convert(
-      source => source.replace(/(?<=^>+[^\S\n])/mg, '\r').replace(/\n$/, ''),
+    linearize(convert(
+      source => source.replace(/(?<=^>+[^\S\n])/mg, '\r'),
       some(union([
         // quote補助関数が残した数式をパースする。
         math,
@@ -20,7 +20,7 @@ export const quote: ReplyParser.QuoteParser = lazy(() => block(fmap(validate(
         linebreak,
         unescsource,
       ])),
-      false))),
+      false), -1)),
   (ns: [string, ...(string | HTMLElement)[]]) => [
     html('span', { class: 'quote' }, defrag(ns)),
     html('br'),

package/src/parser/block/reply.ts

@@ -4,11 +4,11 @@ import { cite, syntax as csyntax } from './reply/cite';
 import { quote, syntax as qsyntax } from './reply/quote';
 import { inline } from '../inline';
 import { anyline } from '../source';
-import { lineable } from '../util';
+import { linearize } from '../util';
 import { visualize, trimBlankNodeEnd } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 
-const delimiter = new RegExp(`${csyntax.source}|${qsyntax.source}`);
+const delimiter = new RegExp(`${csyntax.source}|${qsyntax.source}`, 'y');
 
 export const reply: ReplyParser = block(validate(csyntax, fmap(
   some(union([
@@ -16,6 +16,6 @@ export const reply: ReplyParser = block(validate(csyntax, fmap(
     quote,
     rewrite(
       some(anyline, delimiter),
-      visualize(lineable(some(inline), 1))),
+      visualize(linearize(some(inline), 1))),
   ])),
   ns => [html('p', trimBlankNodeEnd(defrag(ns)))])));

package/src/parser/block/sidefence.ts

@@ -7,7 +7,7 @@ import { invalid } from '../util';
 import { html, define, defrag } from 'typed-dom/dom';
 
 export const sidefence: SidefenceParser = lazy(() => block(fmap(focus(
-  /^(?=\|+(?:[^\S\n]|\n\|))(?:\|+(?:[^\S\n][^\n]*)?(?:$|\n))+$/,
+  /(?=\|+(?:[^\S\n]|\n\|))(?:\|+(?:[^\S\n][^\n]*)?(?:$|\n))+$/y,
   union([source]), false),
   ([el]) => [
     define(el, {
@@ -16,13 +16,13 @@ export const sidefence: SidefenceParser = lazy(() => block(fmap(focus(
     }),
   ])));
 
-const opener = /^(?=\|\|+(?:$|\s))/;
+const opener = /(?=\|\|+(?:$|\s))/y;
 const unindent = (source: string) => source.replace(/(?<=^|\n)\|(?:[^\S\n]|(?=\|*(?:$|\s)))|\n$/g, '');
 
 const source: SidefenceParser.SourceParser = lazy(() => fmap(
   some(recursion(Recursion.block, union([
     focus(
-      /^(?:\|\|+(?:[^\S\n][^\n]*)?(?:$|\n))+/,
+      /(?:\|\|+(?:[^\S\n][^\n]*)?(?:$|\n))+/y,
       convert(unindent, source, false, true), false),
     rewrite(
       some(contentline, opener),

package/src/parser/block/table.ts

@@ -1,5 +1,5 @@
 import { TableParser } from '../block';
-import { union, sequence, some, block, line, validate, focus, rewrite, surround, open, close, trimStart, fallback, lazy, fmap } from '../../combinator';
+import { union, sequence, some, block, line, validate, focus, rewrite, surround, open, close, fallback, lazy, fmap } from '../../combinator';
 import { inline, media, medialink, shortmedia } from '../inline';
 import { contentline } from '../source';
 import { trimBlank } from '../visibility';
@@ -13,7 +13,7 @@ import AlignParser = TableParser.AlignParser;
 import CellParser = TableParser.CellParser;
 
 export const table: TableParser = lazy(() => block(fmap(validate(
-  /^\|[^\n]*(?:\n\|[^\n]*){2}/,
+  /\|[^\n]*(?:\n\|[^\n]*){2}/y,
   sequence([
     row(some(head), true),
     row(some(align), false),
@@ -27,7 +27,7 @@ export const table: TableParser = lazy(() => block(fmap(validate(
   ])));
 
 const row = <P extends CellParser | AlignParser>(parser: P, optional: boolean): RowParser<P> => fallback(fmap(
-  line(surround(/^(?=\|)/, some(union([parser])), /^[|\\]?\s*$/, optional)),
+  line(surround(/(?=\|)/y, some(union([parser])), /[|\\]?\s*$/y, optional)),
   es => [html('tr', es)]),
   rewrite(contentline, ({ context: { source } }) => [[
     html('tr', {
@@ -39,22 +39,22 @@ const row = <P extends CellParser | AlignParser>(parser: P, optional: boolean):
 const align: AlignParser = fmap(open(
   '|',
   union([
-    focus(/^:-+:?/, ({ context: { source } }) =>
+    focus(/:-+:?/y, ({ context: { source } }) =>
       [[source.at(-1) === ':' ? 'center' : 'start']], false),
-    focus(/^-+:?/, ({ context: { source } }) =>
+    focus(/-+:?/y, ({ context: { source } }) =>
       [[source.at(-1) === ':' ? 'end' : '']], false),
   ])),
   ns => [html('td', defrag(ns))]);
 
 const cell: CellParser = surround(
-  /^\|\s*(?=\S)/,
-  trimStart(union([
-    close(medialink, /^\s*(?=\||$)/),
-    close(media, /^\s*(?=\||$)/),
-    close(shortmedia, /^\s*(?=\||$)/),
-    trimBlank(some(inline, /^\|/, [[/^[|\\]?\s*$/, 9]])),
-  ])),
-  /^[^|]*/, true);
+  /\|\s*(?=\S)/y,
+  union([
+    close(medialink, /\s*(?=\||$)/y),
+    close(media, /\s*(?=\||$)/y),
+    close(shortmedia, /\s*(?=\||$)/y),
+    trimBlank(some(inline, /\|/y, [[/[|\\]?\s*$/y, 9]])),
+  ]),
+  /[^|]*/y, true);
 
 const head: CellParser.HeadParser = fmap(
   cell,

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

@@ -19,6 +19,7 @@ describe('Unit: parser/block/ulist', () => {
       assert.deepStrictEqual(inspect(parser('-[ ]'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('-[x]'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('-\n'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('-\n- a'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser(' - '), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('+'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('*'), ctx), undefined);
@@ -36,23 +37,23 @@ describe('Unit: parser/block/ulist', () => {
 
     it('multiple', () => {
       // pending
-      assert.deepStrictEqual(inspect(parser('-\n-'), ctx), [['<ul><li></li><li></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- \n-'), ctx), [['<ul><li></li><li></li></ul>'], '']);
       // filled
       assert.deepStrictEqual(inspect(parser('- 1\n- 2'), ctx), [['<ul><li id="index::1">1</li><li id="index::2">2</li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- 1\n- 2\n- 3'), ctx), [['<ul><li id="index::1">1</li><li id="index::2">2</li><li id="index::3">3</li></ul>'], '']);
       // invalid
-      assert.deepStrictEqual(inspect(parser('-\n+'), ctx), [['<ul><li></li><li id="index::+"><span class="invalid">+</span></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('-\n0'), ctx), [['<ul><li></li><li id="index::0"><span class="invalid">0</span></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- \n+'), ctx), [['<ul><li></li><li id="index::+"><span class="invalid">+</span></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- \n0'), ctx), [['<ul><li></li><li id="index::0"><span class="invalid">0</span></li></ul>'], '']);
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser('-\n -'), ctx), [['<ul><li><br><ul><li></li></ul></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- \n -'), ctx), [['<ul><li><br><ul><li></li></ul></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- 1\n - 2'), ctx), [['<ul><li id="index::1">1<ul><li id="index::2">2</li></ul></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- 1\n - 2\n- 3'), ctx), [['<ul><li id="index::1">1<ul><li id="index::2">2</li></ul></li><li id="index::3">3</li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- 1\n - 2\n - 3'), ctx), [['<ul><li id="index::1">1<ul><li id="index::2">2</li><li id="index::3">3</li></ul></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- 1\n - 2\n  - 3'), ctx), [['<ul><li id="index::1">1<ul><li id="index::2">2<ul><li id="index::3">3</li></ul></li></ul></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- 1\n  - 2\n - 3'), ctx), [['<ul><li id="index::1">1<ul><li id="index::2">2</li></ul></li><li id="index::-_3"><span class="invalid"> - 3</span></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('-\n -\n +\n -\n +\n+'), ctx), [['<ul><li><br><ul><li></li><li id="index::+"><span class="invalid">+</span></li><li></li><li id="index::+"><span class="invalid">+</span></li></ul></li><li id="index::+"><span class="invalid">+</span></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- \n -\n +\n -\n +\n+'), ctx), [['<ul><li><br><ul><li></li><li id="index::+"><span class="invalid">+</span></li><li></li><li id="index::+"><span class="invalid">+</span></li></ul></li><li id="index::+"><span class="invalid">+</span></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- 1\n + 2'), ctx), [['<ul><li id="index::1">1<ul class="invalid"><li>2</li></ul></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- 1\n 0'), ctx), [['<ul><li id="index::1">1<ol><li></li></ol></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- 1\n 0.'), ctx), [['<ul><li id="index::1">1<ol><li></li></ol></li></ul>'], '']);
@@ -71,10 +72,10 @@ describe('Unit: parser/block/ulist', () => {
     });
 
     it('indexer', () => {
-      assert.deepStrictEqual(inspect(parser('- [|a]'), ctx), [['<ul><li id="index::[|a]">[|a]</li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- [|a]'), ctx), [['<ul><li id="index::[|a]"><span class="invalid">[|a]</span></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- a [|]'), ctx), [['<ul><li>a<span class="indexer" data-index=""></span></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- a [|b]'), ctx), [['<ul><li id="index::b">a<span class="indexer" data-index="b"></span></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- [ ] [|a]'), ctx), [['<ul class="checklist"><li id="index::[|a]"><span class="checkbox">☐</span>[|a]</li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- [ ] [|a]'), ctx), [['<ul class="checklist"><li id="index::[|a]"><span class="checkbox">☐</span><span class="invalid">[|a]</span></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- [ ] a [|b]'), ctx), [['<ul class="checklist"><li id="index::b"><span class="checkbox">☐</span>a<span class="indexer" data-index="b"></span></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- a [|]\n - c [|d]'), ctx), [['<ul><li>a<span class="indexer" data-index=""></span><ul><li id="index::d">c<span class="indexer" data-index="d"></span></li></ul></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- a [|b]\n - c [|d]'), ctx), [['<ul><li id="index::b">a<span class="indexer" data-index="b"></span><ul><li id="index::d">c<span class="indexer" data-index="d"></span></li></ul></li></ul>'], '']);

package/src/parser/block/ulist.ts

@@ -1,26 +1,25 @@
 import { UListParser } from '../block';
 import { Recursion } from '../context';
-import { union, inits, subsequence, some, recursion, block, line, validate, indent, focus, open, trim, fallback, lazy, fmap } from '../../combinator';
+import { union, inits, subsequence, some, recursion, block, line, validate, indent, focus, open, fallback, lazy, fmap } from '../../combinator';
 import { olist_ } from './olist';
 import { ilist_, ilistitem } from './ilist';
 import { inline, indexer, indexee, dataindex } from '../inline';
-import { lineable } from '../util';
 import { visualize, trimBlank } from '../visibility';
 import { unshift } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
 export const ulist: UListParser = lazy(() => block(validate(
-  /^-(?=[^\S\n]|\n[^\S\n]*\S)/,
+  /- /y,
   ulist_)));
 
 export const ulist_: UListParser = lazy(() => block(fmap(validate(
-  /^-(?=$|\s)/,
+  /-(?=$|[ \n])/y,
   some(recursion(Recursion.listitem, union([
     indexee(fmap(fallback(
       inits([
-        line(open(/^-(?:$|\s)/, subsequence([
+        line(open(/-(?:$|[ \n])/y, subsequence([
           checkbox,
-          trim(visualize(lineable(trimBlank(some(union([indexer, inline])))))),
+          visualize(trimBlank(some(union([indexer, inline])))),
         ]), true)),
         indent(union([ulist_, olist_, ilist_])),
       ]),
@@ -30,7 +29,7 @@ export const ulist_: UListParser = lazy(() => block(fmap(validate(
   es => [format(html('ul', es))])));
 
 export const checkbox = focus(
-  /^\[[xX ]\](?=$|\s)/,
+  /\[[xX ]\](?=$|[ \n])/y,
   ({ context: { source } }) => [[
     html('span', { class: 'checkbox' }, source[1].trimStart() ? '☑' : '☐'),
   ]]);