securemark 0.249.0 → 0.251.0

package/karma.conf.js

@@ -12,7 +12,7 @@ module.exports = function (config) {
       { pattern: 'https://cdnjs.cloudflare.com/ajax/libs/dompurify/2.3.8/purify.js', watched: false, served: false, included: true, integrity: 'sha512-QaF+0tDlqVmwZaQSc0kImgYmw+Cd66TxA5D9X70I5V9BNSqk6yBTbyqw2VEUsVYV5OTbxw8HD9d45on1wvYv7g==' },
       { pattern: 'dist/**/*.{js,map}', watched: true, served: true, included: true },
     ],
-    reporters: ['dots', 'coverage'],
+    reporters: ['dots'],
     preprocessors: {
       'dist/**/*.js': ['coverage'],
     },

package/markdown.d.ts

@@ -736,7 +736,7 @@ export namespace MarkdownParser {
       }
     }
     export interface CommentParser extends
-      // [# comment #]
+      // [% comment %]
       Inline<'comment'>,
       Parser<HTMLElement | string, Context, [
         InlineParser,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securemark",
-  "version": "0.249.0",
+  "version": "0.251.0",
   "description": "Secure markdown renderer working on browsers for user input data.",
   "private": false,
   "homepage": "https://github.com/falsandtru/securemark",
@@ -34,11 +34,11 @@
     "@types/mocha": "9.1.1",
     "@types/power-assert": "1.5.8",
     "@types/prismjs": "1.26.0",
-    "@typescript-eslint/parser": "^5.26.0",
+    "@typescript-eslint/parser": "^5.27.1",
     "babel-loader": "^8.2.5",
     "babel-plugin-unassert": "^3.2.0",
     "concurrently": "^7.2.1",
-    "eslint": "^8.16.0",
+    "eslint": "^8.17.0",
     "eslint-plugin-redos": "^4.4.0",
     "eslint-webpack-plugin": "^3.1.1",
     "glob": "^8.0.3",
@@ -49,22 +49,22 @@
     "karma-mocha": "^2.0.1",
     "karma-power-assert": "^1.0.0",
     "mocha": "^10.0.0",
-    "npm-check-updates": "^13.0.3",
+    "npm-check-updates": "^13.1.2",
     "semver": "^7.3.7",
-    "spica": "0.0.554",
+    "spica": "0.0.567",
     "ts-loader": "^9.3.0",
-    "typed-dom": "^0.0.297",
-    "typescript": "4.7.2",
-    "webpack": "^5.72.1",
+    "typed-dom": "^0.0.298",
+    "typescript": "4.7.3",
+    "webpack": "^5.73.0",
     "webpack-cli": "^4.9.2",
     "webpack-merge": "^5.8.0"
   },
   "scripts": {
     "update": "ncu -u && npm i --no-shrinkwrap && bundle update",
-    "dev": "concurrently \"webpack --env mode=test -w\" \"karma start --auto-watch --reporters dots\" \"webpack --env mode=dist -w --output-path ./gh-pages/assets/dist\" \"bundle exec jekyll serve -s ./gh-pages -d ./gh-pages/_site --incremental\"",
-    "test": "webpack --env mode=test && karma start --single-run --concurrency 1",
+    "dev": "concurrently \"webpack --env mode=test -w\" \"karma start --auto-watch\" \"webpack --env mode=dist -w --output-path ./gh-pages/assets/dist\" \"bundle exec jekyll serve -s ./gh-pages -d ./gh-pages/_site --incremental\"",
+    "test": "webpack --env mode=test && karma start --single-run --concurrency 1 --reporters dots,coverage",
     "lint": "webpack --env mode=lint",
-    "bench": "webpack --env mode=bench && karma start --single-run --concurrency 1 --reporters dots",
+    "bench": "webpack --env mode=bench && karma start --single-run --concurrency 1",
     "dist": "webpack --env mode=dist"
   },
   "author": "falsandtru",

package/src/combinator/control/manipulation/indent.ts

@@ -9,15 +9,18 @@ import { open } from './surround';
 import { memoize } from 'spica/memoize';
 
 export function indent<P extends Parser<unknown>>(parser: P, separation?: boolean): P;
-export function indent<T>(parser: Parser<T>, separation = false): Parser<T> {
+export function indent<P extends Parser<unknown>>(opener: RegExp, parser: P, separation?: boolean): P;
+export function indent<T>(opener: RegExp | Parser<T>, parser?: Parser<T> | boolean, separation = false): Parser<T> {
+  if (typeof opener === 'function') return indent(/^([ \t])\1*/, opener, parser as boolean);
   assert(parser);
   return bind(block(match(
-    /^(?=(([ \t])\2*))/,
+    opener,
     memoize(
-    ([, indent]) =>
+    ([indent]) =>
       some(line(open(indent, source => [[unline(source)], '']))),
-    ([, indent]) => indent.length * 2 + +(indent[0] === ' '), [])), separation),
+    ([indent]) => indent.length * 2 + +(indent[0] === ' '), [])), separation),
     (nodes, rest, context) => {
+      assert(parser = parser as Parser<T>);
       const result = parser(nodes.join('\n'), context);
       return result && exec(result) === ''
         ? [eval(result), rest]

package/src/combinator/control/manipulation/match.ts

@@ -9,11 +9,10 @@ export function match<T>(pattern: RegExp, f: (matched: RegExpMatchArray) => Pars
     const param = source.match(pattern);
     if (!param) return;
     assert(source.startsWith(param[0]));
-    const rest = source.slice(param[0].length);
-    const result = f(param)(rest, context);
+    const result = f(param)(source, context);
     assert(check(source, result, false));
     if (!result) return;
-    return exec(result).length < source.length && exec(result).length <= rest.length
+    return exec(result).length < source.length && exec(result).length <= source.length
       ? result
       : undefined;
   };

package/src/parser/api/parse.test.ts

@@ -52,11 +52,11 @@ describe('Unit: parser/api/parse', () => {
         [...parse('<wbr>\na').children].map(el => el.outerHTML),
         ['<p>&lt;wbr&gt;<br>a</p>']);
       assert.deepStrictEqual(
-        [...parse('[#\n<wbr>\n#]').children].map(el => el.outerHTML),
-        ['<p><span class="comment"><input type="checkbox"><span>[#<br>&lt;wbr&gt;<br>#]</span></span></p>']);
+        [...parse('[%\n<wbr>\n%]').children].map(el => el.outerHTML),
+        ['<p><span class="comment"><input type="checkbox"><span>[%<br>&lt;wbr&gt;<br>%]</span></span></p>']);
       assert.deepStrictEqual(
-        [...parse('[#\n<wbr>\n#]\na').children].map(el => el.outerHTML),
-        ['<p><span class="comment"><input type="checkbox"><span>[#<br>&lt;wbr&gt;<br>#]</span></span><br>a</p>']);
+        [...parse('[%\n<wbr>\n%]\na').children].map(el => el.outerHTML),
+        ['<p><span class="comment"><input type="checkbox"><span>[%<br>&lt;wbr&gt;<br>%]</span></span><br>a</p>']);
     });
 
     it('linebreak', () => {
@@ -80,6 +80,12 @@ describe('Unit: parser/api/parse', () => {
         ['<p>a<br>\\<br>b</p>']);
     });
 
+    it('indent', () => {
+      assert.deepStrictEqual(
+        [...parse('   a').children].map(el => el.outerHTML),
+        ['<p>   a</p>']);
+    });
+
     it('url', () => {
       assert.deepStrictEqual(
         [...parse([
@@ -220,8 +226,8 @@ describe('Unit: parser/api/parse', () => {
 
     it('creation', () => {
       assert.deepStrictEqual(
-        [...parse('"[# '.repeat(100)).children].map(el => el.outerHTML),
-        [`<p>${'"[# '.repeat(100).trim()}</p>`]);
+        [...parse('"[% '.repeat(100)).children].map(el => el.outerHTML),
+        [`<p>${'"[% '.repeat(100).trim()}</p>`]);
     });
 
     it('recursion', () => {

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

@@ -72,7 +72,7 @@ describe('Unit: parser/block/blockquote', () => {
       assert.deepStrictEqual(inspect(parser('!> a\\\nb')), [['<blockquote><section><p>a<span class="linebreak"> </span>b</p><ol class="annotations"></ol><ol class="references"></ol></section></blockquote>'], '']);
       assert.deepStrictEqual(inspect(parser('!> *a\nb*')), [['<blockquote><section><p><em>a<br>b</em></p><ol class="annotations"></ol><ol class="references"></ol></section></blockquote>'], '']);
       assert.deepStrictEqual(inspect(parser('!> *a\n> b*')), [['<blockquote><section><p><em>a<br>b</em></p><ol class="annotations"></ol><ol class="references"></ol></section></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser('!>  a \n b  c ')), [['<blockquote><section><p>a<br> b  c</p><ol class="annotations"></ol><ol class="references"></ol></section></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('!>  a \n b  c ')), [['<blockquote><section><p> a<br> b  c</p><ol class="annotations"></ol><ol class="references"></ol></section></blockquote>'], '']);
       assert.deepStrictEqual(inspect(parser('!>> a')), [['<blockquote><blockquote><section><p>a</p><ol class="annotations"></ol><ol class="references"></ol></section></blockquote></blockquote>'], '']);
       assert.deepStrictEqual(inspect(parser('!>> a\n> b')), [['<blockquote><blockquote><section><p>a</p><ol class="annotations"></ol><ol class="references"></ol></section></blockquote><section><p>b</p><ol class="annotations"></ol><ol class="references"></ol></section></blockquote>'], '']);
       assert.deepStrictEqual(inspect(parser('!> - a')), [['<blockquote><section><ul><li>a</li></ul><ol class="annotations"></ol><ol class="references"></ol></section></blockquote>'], '']);
@@ -90,7 +90,7 @@ describe('Unit: parser/block/blockquote', () => {
       assert.deepStrictEqual(inspect(parser('!> \na')), [['<blockquote><section><p>a</p><ol class="annotations"></ol><ol class="references"></ol></section></blockquote>'], '']);
       assert.deepStrictEqual(inspect(parser('!>\n')), undefined);
       assert.deepStrictEqual(inspect(parser('!>\na')), [['<blockquote><section><p>a</p><ol class="annotations"></ol><ol class="references"></ol></section></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser('!>\n a')), [['<blockquote><section><p>a</p><ol class="annotations"></ol><ol class="references"></ol></section></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('!>\n a')), [['<blockquote><section><p> a</p><ol class="annotations"></ol><ol class="references"></ol></section></blockquote>'], '']);
       assert.deepStrictEqual(inspect(parser('!>\n>')), [['<blockquote><section><ol class="annotations"></ol><ol class="references"></ol></section></blockquote>'], '']);
       assert.deepStrictEqual(inspect(parser('!>\n> a')), [['<blockquote><section><p>a</p><ol class="annotations"></ol><ol class="references"></ol></section></blockquote>'], '']);
       assert.deepStrictEqual(inspect(parser('!>> ## a\n> ## a')), [['<blockquote><blockquote><section><h2>a</h2><ol class="annotations"></ol><ol class="references"></ol></section></blockquote><section><h2>a</h2><ol class="annotations"></ol><ol class="references"></ol></section></blockquote>'], '']);

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

@@ -33,6 +33,7 @@ describe('Unit: parser/block/dlist', () => {
     it('single', () => {
       assert.deepStrictEqual(inspect(parser('~ a')), [['<dl><dt id="index:a">a</dt><dd></dd></dl>'], '']);
       assert.deepStrictEqual(inspect(parser('~ \\')), [['<dl><dt id="index:\\">\\</dt><dd></dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser('~ \\ a')), [['<dl><dt id="index:a">a</dt><dd></dd></dl>'], '']);
       assert.deepStrictEqual(inspect(parser('~ a\nb')), [['<dl><dt id="index:a">a</dt><dd>b</dd></dl>'], '']);
       assert.deepStrictEqual(inspect(parser('~ a\nb\n')), [['<dl><dt id="index:a">a</dt><dd>b</dd></dl>'], '']);
       assert.deepStrictEqual(inspect(parser('~ a\nb\nc')), [['<dl><dt id="index:a">a</dt><dd>b<br>c</dd></dl>'], '']);
@@ -57,7 +58,7 @@ describe('Unit: parser/block/dlist', () => {
 
     it('multiple', () => {
       assert.deepStrictEqual(inspect(parser('~ a\n: b\n~ c\n: d')), [['<dl><dt id="index:a">a</dt><dd>b</dd><dt id="index:c">c</dt><dd>d</dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser('~ a\n  b\nc\n  d')), [['<dl><dt id="index:a">a</dt><dd>b<br>c<br>  d</dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser('~ a\n  b\nc\n  d')), [['<dl><dt id="index:a">a</dt><dd>  b<br>c<br>  d</dd></dl>'], '']);
       assert.deepStrictEqual(inspect(parser('~ a\n: b\nc\n: d')), [['<dl><dt id="index:a">a</dt><dd>b<br>c</dd><dd>d</dd></dl>'], '']);
       assert.deepStrictEqual(inspect(parser('~ a\n: b\nc\n~ d\n: e')), [['<dl><dt id="index:a">a</dt><dd>b<br>c</dd><dt id="index:d">d</dt><dd>e</dd></dl>'], '']);
       assert.deepStrictEqual(inspect(parser('~ a\n: b\n~ c\n: d\n~ e\n: f')), [['<dl><dt id="index:a">a</dt><dd>b</dd><dt id="index:c">c</dt><dd>d</dd><dt id="index:e">e</dt><dd>f</dd></dl>'], '']);

package/src/parser/block/dlist.ts

@@ -1,9 +1,9 @@
 import { DListParser } from '../block';
-import { union, inits, some, block, line, validate, rewrite, context, creator, open, trim, lazy, fmap } from '../../combinator';
+import { union, inits, some, block, line, validate, rewrite, context, creator, open, trimEnd, lazy, fmap } from '../../combinator';
 import { inline, indexee, indexer } from '../inline';
 import { anyline } from '../source';
 import { localize } from '../locale';
-import { visualize } from '../util';
+import { visualize, trimBlank } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 import { push } from 'spica/array';
 
@@ -25,7 +25,7 @@ export const dlist: DListParser = lazy(() => block(localize(fmap(validate(
 
 const term: DListParser.TermParser = creator(line(indexee(fmap(open(
   /^~[^\S\n]+(?=\S)/,
-  trim(visualize(some(union([indexer, inline])))),
+  visualize(trimBlank(some(union([indexer, inline])))),
   true),
   ns => [html('dt', defrag(ns))]))));
 
@@ -33,7 +33,7 @@ const desc: DListParser.DescriptionParser = creator(block(fmap(open(
   /^:[^\S\n]+(?=\S)|/,
   rewrite(
     some(anyline, /^[~:][^\S\n]+\S/),
-    trim(visualize(some(union([inline]))))),
+    visualize(trimEnd(some(union([inline]))))),
   true),
   ns => [html('dd', defrag(ns))]),
   false));

package/src/parser/block/extension/figure.ts

@@ -1,6 +1,6 @@
 import { undefined } from 'spica/global';
 import { ExtensionParser } from '../../block';
-import { union, inits, sequence, some, block, line, fence, rewrite, context, close, match, convert, trim, fallback, fmap } from '../../../combinator';
+import { union, inits, sequence, some, block, line, fence, rewrite, context, close, match, convert, trimEnd, fallback, fmap } from '../../../combinator';
 import { str, contentline, emptyline } from '../../source';
 import { label, segment as seg_label } from '../../inline/extension/label';
 import { ulist } from '../ulist';
@@ -15,7 +15,7 @@ import { blockquote, segment as seg_blockquote } from '../blockquote';
 import { placeholder, segment_ as seg_placeholder } from './placeholder';
 import { inline, media, shortmedia } from '../../inline';
 import { localize } from '../../locale';
-import { visualize } from '../../util';
+import { visualize, trimBlank } from '../../util';
 import { html, defrag } from 'typed-dom/dom';
 import { memoize } from 'spica/memoize';
 import { unshift } from 'spica/array';
@@ -23,7 +23,7 @@ import { unshift } from 'spica/array';
 import FigureParser = ExtensionParser.FigureParser;
 
 export const segment: FigureParser.SegmentParser = block(match(
-  /^(~{3,})(?:figure[^\S\n]|(?=\[?\$))/,
+  /^(~{3,})(?:figure[^\S\n])?(?=\[?\$)/,
   memoize(
   ([, fence], closer = new RegExp(String.raw`^${fence}[^\S\n]*(?:$|\n)`)) => close(
     sequence([
@@ -49,7 +49,7 @@ export const segment: FigureParser.SegmentParser = block(match(
   ([, fence]) => fence.length, [])));
 
 export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
-  convert(source => source.slice(source.match(/^~+(?:figure[^\S\n]+)?/)![0].length, source.trimEnd().lastIndexOf('\n')),
+  convert(source => source.slice(source.match(/^~+(?:\w+\s+)?/)![0].length, source.trimEnd().lastIndexOf('\n')),
   sequence([
     line(sequence([label, str(/^(?=\s).*\n/)])),
     inits([
@@ -70,7 +70,7 @@ export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
       emptyline,
       block(localize(
         context({ syntax: { inline: { media: false } } },
-        trim(visualize(some(inline)))))),
+        visualize(trimBlank(trimEnd(some(inline))))))),
     ]),
   ])),
   ([label, param, content, ...caption]: [HTMLAnchorElement, string, ...HTMLElement[]]) => [

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

@@ -40,6 +40,7 @@ describe('Unit: parser/block/heading', () => {
       assert.deepStrictEqual(inspect(parser('# a\\')), [['<h1 id="index:a">a</h1>'], '']);
       assert.deepStrictEqual(inspect(parser('# a\\\n')), [['<h1 id="index:a">a</h1>'], '']);
       assert.deepStrictEqual(inspect(parser('# \\')), [['<h1 id="index:\\">\\</h1>'], '']);
+      assert.deepStrictEqual(inspect(parser('# \\ a')), [['<h1 id="index:a">a</h1>'], '']);
       assert.deepStrictEqual(inspect(parser('## \\')), [['<h2 id="index:\\">\\</h2>'], '']);
       assert.deepStrictEqual(inspect(parser('# @a')), [['<h1 id="index:@a">@a</h1>'], '']);
       assert.deepStrictEqual(inspect(parser('## @a')), [['<h2 id="index:@a"><a href="/@a" class="account">@a</a></h2>'], '']);

package/src/parser/block/heading.ts

@@ -1,8 +1,8 @@
 import { HeadingParser } from '../block';
-import { union, some, block, line, validate, focus, rewrite, context, open, trim, fmap } from '../../combinator';
+import { union, some, block, line, validate, focus, rewrite, context, open, fmap } from '../../combinator';
 import { inline, indexee, indexer } from '../inline';
 import { str } from '../source';
-import { visualize } from '../util';
+import { visualize, trimBlank } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const segment: HeadingParser.SegmentParser = block(validate('#', focus(
@@ -21,13 +21,13 @@ export const heading: HeadingParser = block(rewrite(segment,
   line(indexee(fmap(union([
     open(
       str(/^##+/),
-      trim(visualize(some(union([indexer, inline])))), true),
+      visualize(trimBlank(some(union([indexer, inline])))), true),
     open(
       str('#'),
       context({ syntax: { inline: {
         autolink: false,
       }}},
-      trim(visualize(some(union([indexer, inline]))))), true),
+      visualize(trimBlank(some(union([indexer, inline]))))), true),
   ]),
   ([h, ...ns]: [string, ...(HTMLElement | string)[]]) => [
     h.length <= 6

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

@@ -9,20 +9,27 @@ describe('Unit: parser/block/indentblock', () => {
     it('invalid', () => {
       assert.deepStrictEqual(inspect(parser('')), undefined);
       assert.deepStrictEqual(inspect(parser('\na')), undefined);
-      assert.deepStrictEqual(inspect(parser(' a')), undefined);
-      assert.deepStrictEqual(inspect(parser(' \ta')), undefined);
-      assert.deepStrictEqual(inspect(parser('  a\nb')), undefined);
-      assert.deepStrictEqual(inspect(parser('  a\n b')), undefined);
+      assert.deepStrictEqual(inspect(parser('a')), undefined);
+      assert.deepStrictEqual(inspect(parser('  a')), undefined);
+      assert.deepStrictEqual(inspect(parser('   a')), undefined);
+      assert.deepStrictEqual(inspect(parser('   \ta')), undefined);
+      assert.deepStrictEqual(inspect(parser('    a\nb')), undefined);
+      assert.deepStrictEqual(inspect(parser('    a\n b')), undefined);
+      assert.deepStrictEqual(inspect(parser('    a\n\tb')), undefined);
     });
 
     it('valid', () => {
-      assert.deepStrictEqual(inspect(parser('  a')), [['<pre class="text">a</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('  a ')), [['<pre class="text">a </pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('  a \n')), [['<pre class="text">a </pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('  a \n    b')), [['<pre class="text">a <br>  b</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('  a\\\n  b')), [['<pre class="text">a\\<br>b</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('    a')), [['<pre class="text">a</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('    a ')), [['<pre class="text">a </pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('    a \n')), [['<pre class="text">a </pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('    a \n       b')), [['<pre class="text">a <br>   b</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('    a \\\n       b')), [['<pre class="text">a \\<br>   b</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('       a')), [['<pre class="text">   a</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('        a')), [['<pre class="text">a</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('    \ta')), [['<pre class="text">\ta</pre>'], '']);
       assert.deepStrictEqual(inspect(parser('\ta')), [['<pre class="text">a</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('\t a')), [['<pre class="text"> a</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('\t\ta')), [['<pre class="text">a</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('\t    a')), [['<pre class="text">    a</pre>'], '']);
     });
 
   });

package/src/parser/block/indentblock.ts

@@ -1,13 +1,13 @@
 import { IndentBlockParser } from '../block';
-import { union, block, validate, indent, convert } from '../../combinator';
+import { union, block, indent, convert } from '../../combinator';
 import { codeblock } from './codeblock';
 
 // 空行を含むインデントブロックはインデントの違いによるセグメント分割の境界が視認不能となるため採用しない
 
-export const indentblock: IndentBlockParser = block(validate(/^(?:  |\t)/, indent(convert(
+export const indentblock: IndentBlockParser = block(indent(/^( {4}|\t)\1*/, convert(
   source => {
     const fence = (source.match(/^`{3,}(?=[^\S\n]*$)/mg) ?? [])
       .reduce((max, fence) => fence > max ? fence : max, '``') + '`';
     return `${fence}\n${source}\n${fence}`;
   },
-  union([codeblock])), true)));
+  union([codeblock])), true));

package/src/parser/block/olist.ts

@@ -1,17 +1,18 @@
 import { undefined } from 'spica/global';
 import { OListParser } from '../block';
-import { union, inits, subsequence, some, block, line, validate, indent, focus, rewrite, context, creator, open, match, trim, trimStart, fallback, lazy, fmap } from '../../combinator';
+import { union, inits, subsequence, some, block, line, validate, indent, focus, rewrite, context, creator, open, match, trim, fallback, lazy, fmap } from '../../combinator';
 import { checkbox, ulist_, fillFirstLine } from './ulist';
 import { ilist_ } from './ilist';
 import { inline, indexee, indexer } from '../inline';
 import { contentline } from '../source';
+import { trimBlank } from '../util';
 import { html, define, defrag } from 'typed-dom/dom';
 import { memoize } from 'spica/memoize';
 import { shift } from 'spica/array';
 
 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]*)*(?![^\S\n])\.?(?=$|\s)/,
+  '(': /^\(([0-9]*|[a-z]*)(?![^)\n])\)?(?:-(?!-)[0-9]*)*(?=$|\s)/,
 } as const;
 
 export const olist: OListParser = lazy(() => block(validate(
@@ -24,10 +25,10 @@ export const olist: OListParser = lazy(() => block(validate(
 
 export const olist_: OListParser = lazy(() => block(union([
   match(
-    new RegExp(`^(?=${openers['.'].source.replace('?:', '')})`),
+    openers['.'],
     memoize(ms => list(type(ms[1]), '.'), ms => type(ms[1]).charCodeAt(0) || 0, [])),
   match(
-    new RegExp(`^(?=${openers['('].source.replace('?:', '')})`),
+    openers['('],
     memoize(ms => list(type(ms[1]), '('), ms => type(ms[1]).charCodeAt(0) || 0, [])),
 ])));
 
@@ -35,7 +36,7 @@ const list = (type: string, form: string): OListParser.ListParser => fmap(
   some(creator(union([
     indexee(fmap(fallback(
       inits([
-        line(open(heads[form], trim(subsequence([checkbox, trimStart(some(union([indexer, inline])))])), true)),
+        line(open(heads[form], trim(subsequence([checkbox, trimBlank(some(union([indexer, inline])))])), true)),
         indent(union([ulist_, olist_, ilist_])),
       ]),
       invalid),

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

@@ -33,7 +33,7 @@ describe('Unit: parser/block/paragraph', () => {
       assert.deepStrictEqual(inspect(parser('***a*b\n<wbr>**\nc')), [['<p>**<em>a</em>b<br><wbr>**<br>c</p>'], '']);
       assert.deepStrictEqual(inspect(parser('***a**b\n<wbr>*\nc')), [['<p>*<strong>a</strong>b<br><wbr>*<br>c</p>'], '']);
       assert.deepStrictEqual(inspect(parser('==a\n<wbr>==\nb')), [['<p>==a<br><wbr>==<br>b</p>'], '']);
-      assert.deepStrictEqual(inspect(parser(' a')), [['<p>a</p>'], '']);
+      assert.deepStrictEqual(inspect(parser('   a')), [['<p>   a</p>'], '']);
     });
 
     it('anchor', () => {
@@ -50,18 +50,18 @@ describe('Unit: parser/block/paragraph', () => {
       assert.deepStrictEqual(inspect(parser('a\n>>1')), [['<p>a<br><a href="?at=1" class="anchor">&gt;&gt;1</a></p>'], '']);
       assert.deepStrictEqual(inspect(parser('a\n>>1\nb')), [['<p>a<br><a href="?at=1" class="anchor">&gt;&gt;1</a><br>b</p>'], '']);
       assert.deepStrictEqual(inspect(parser('a\n>> b\nc')), [['<p>a<br>&gt;&gt; b<br>c</p>'], '']);
-      assert.deepStrictEqual(inspect(parser(' >>1')), [['<p><a href="?at=1" class="anchor">&gt;&gt;1</a></p>'], '']);
-      assert.deepStrictEqual(inspect(parser(' >>>1')), [['<p>&gt;<a href="?at=1" class="anchor">&gt;&gt;1</a></p>'], '']);
+      assert.deepStrictEqual(inspect(parser('   >>1')), [['<p>   <a href="?at=1" class="anchor">&gt;&gt;1</a></p>'], '']);
+      assert.deepStrictEqual(inspect(parser('   >>>1')), [['<p>   &gt;<a href="?at=1" class="anchor">&gt;&gt;1</a></p>'], '']);
     });
 
     it('comment', () => {
-      assert.deepStrictEqual(inspect(parser('[# a #]')), [['<p><span class="comment"><input type="checkbox"><span>[# a #]</span></span></p>'], '']);
-      assert.deepStrictEqual(inspect(parser('[# a #]b')), [['<p><span class="comment"><input type="checkbox"><span>[# a #]</span></span>b</p>'], '']);
-      assert.deepStrictEqual(inspect(parser('[# a #]\nb')), [['<p><span class="comment"><input type="checkbox"><span>[# a #]</span></span><br>b</p>'], '']);
-      assert.deepStrictEqual(inspect(parser('[## a ##]')), [['<p><span class="comment"><input type="checkbox"><span>[## a ##]</span></span></p>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#\n<wbr>\n#]')), [['<p><span class="comment"><input type="checkbox"><span>[#<br>&lt;wbr&gt;<br>#]</span></span></p>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#\n<wbr>\n#]a')), [['<p><span class="comment"><input type="checkbox"><span>[#<br>&lt;wbr&gt;<br>#]</span></span>a</p>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#\n<wbr>\n#]\na')), [['<p><span class="comment"><input type="checkbox"><span>[#<br>&lt;wbr&gt;<br>#]</span></span><br>a</p>'], '']);
+      assert.deepStrictEqual(inspect(parser('[% a %]')), [['<p><span class="comment"><input type="checkbox"><span>[% a %]</span></span></p>'], '']);
+      assert.deepStrictEqual(inspect(parser('[% a %]b')), [['<p><span class="comment"><input type="checkbox"><span>[% a %]</span></span>b</p>'], '']);
+      assert.deepStrictEqual(inspect(parser('[% a %]\nb')), [['<p><span class="comment"><input type="checkbox"><span>[% a %]</span></span><br>b</p>'], '']);
+      assert.deepStrictEqual(inspect(parser('[%% a %%]')), [['<p><span class="comment"><input type="checkbox"><span>[%% a %%]</span></span></p>'], '']);
+      assert.deepStrictEqual(inspect(parser('[%\n<wbr>\n%]')), [['<p><span class="comment"><input type="checkbox"><span>[%<br>&lt;wbr&gt;<br>%]</span></span></p>'], '']);
+      assert.deepStrictEqual(inspect(parser('[%\n<wbr>\n%]a')), [['<p><span class="comment"><input type="checkbox"><span>[%<br>&lt;wbr&gt;<br>%]</span></span>a</p>'], '']);
+      assert.deepStrictEqual(inspect(parser('[%\n<wbr>\n%]\na')), [['<p><span class="comment"><input type="checkbox"><span>[%<br>&lt;wbr&gt;<br>%]</span></span><br>a</p>'], '']);
     });
 
     it('template', () => {

package/src/parser/block/paragraph.ts

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

package/src/parser/block/reply.ts

@@ -1,5 +1,5 @@
 import { ReplyParser } from '../block';
-import { inits, subsequence, some, block, validate, rewrite, trim, fmap } from '../../combinator';
+import { inits, subsequence, some, block, validate, rewrite, trimEnd, fmap } from '../../combinator';
 import { cite } from './reply/cite';
 import { quote, syntax as delimiter } from './reply/quote';
 import { inline } from '../inline';
@@ -26,7 +26,7 @@ export const reply: ReplyParser = block(validate('>', localize(fmap(
       some(quote),
       fmap(rewrite(
         some(anyline, delimiter),
-        trim(visualize(some(inline)))),
+        visualize(trimEnd(some(inline)))),
         ns => push(ns, [html('br')])),
     ])),
   ]),

package/src/parser/block/ulist.ts

@@ -1,11 +1,12 @@
 import { UListParser } from '../block';
-import { union, inits, subsequence, some, block, line, validate, indent, focus, rewrite, context, creator, open, trim, trimStart, fallback, lazy, fmap } from '../../combinator';
+import { union, inits, subsequence, some, block, line, validate, indent, focus, rewrite, context, creator, open, trim, fallback, lazy, fmap } from '../../combinator';
 import { olist_ } from './olist';
 import { ilist_ } from './ilist';
 import { inline, indexer, indexee } from '../inline';
+import { contentline } from '../source';
+import { trimBlank } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
-import { contentline } from '../source';
 
 export const ulist: UListParser = lazy(() => block(validate(
   /^-(?=[^\S\n]|\n[^\S\n]*\S)/,
@@ -17,7 +18,7 @@ export const ulist_: UListParser = lazy(() => block(fmap(validate(
   some(creator(union([
     indexee(fmap(fallback(
       inits([
-        line(open(/^-(?:$|\s)/, trim(subsequence([checkbox, trimStart(some(union([indexer, inline])))])), true)),
+        line(open(/^-(?:$|\s)/, trim(subsequence([checkbox, trimBlank(some(union([indexer, inline])))])), true)),
         indent(union([ulist_, olist_, ilist_])),
       ]),
       invalid),

package/src/parser/inline/annotation.ts

@@ -2,7 +2,7 @@ import { undefined } from 'spica/global';
 import { AnnotationParser } from '../inline';
 import { union, some, validate, guard, context, creator, surround, lazy, fmap } from '../../combinator';
 import { inline } from '../inline';
-import { trimBlankInline } from '../util';
+import { trimBlank } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const annotation: AnnotationParser = lazy(() => creator(validate('((', '))', '\n', fmap(surround(
@@ -19,6 +19,6 @@ export const annotation: AnnotationParser = lazy(() => creator(validate('((', ')
     //link: true,
     //autolink: true,
   }}, delimiters: undefined },
-  trimBlankInline(some(union([inline]), ')', /^\\?\n/)))),
+  trimBlank(some(union([inline]), ')', /^\\?\n/)))),
   '))'),
   ns => [html('sup', { class: 'annotation' }, defrag(ns))]))));

package/src/parser/inline/code.ts

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