securemark 0.219.4 → 0.223.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securemark",
-  "version": "0.219.4",
+  "version": "0.223.0",
   "description": "Secure markdown renderer working on browsers for user input data.",
   "private": false,
   "homepage": "https://github.com/falsandtru/securemark",
@@ -31,38 +31,38 @@
   },
   "devDependencies": {
     "@types/dompurify": "2.3.1",
-    "@types/jquery": "3.5.6",
+    "@types/jquery": "3.5.9",
     "@types/mathjax": "0.0.37",
     "@types/mocha": "9.0.0",
-    "@types/power-assert": "1.5.4",
+    "@types/power-assert": "1.5.8",
     "@types/prismjs": "1.16.6",
     "browserify": "^17.0.0",
     "browserify-shim": "^3.8.14",
-    "concurrently": "^6.3.0",
+    "concurrently": "^6.4.0",
     "del": "^6.0.0",
     "gulp": "^4.0.2",
     "gulp-derequire": "^3.0.0",
-    "gulp-footer": "^2.0.2",
+    "gulp-footer": "^2.1.0",
     "gulp-header": "^2.0.9",
     "gulp-load-plugins": "^2.0.7",
     "gulp-mocha": "^8.0.0",
     "gulp-rename": "^2.0.0",
     "gulp-unassert": "^2.0.0",
-    "karma": "^6.3.4",
+    "karma": "^6.3.9",
     "karma-chrome-launcher": "^3.1.0",
     "karma-coverage-istanbul-instrumenter": "^1.0.3",
     "karma-coverage-istanbul-reporter": "^3.0.3",
     "karma-espower-preprocessor": "^1.2.0",
-    "karma-firefox-launcher": "^2.1.1",
+    "karma-firefox-launcher": "^2.1.2",
     "karma-mocha": "^2.0.1",
-    "mocha": "^9.1.2",
-    "npm-check-updates": "^11.8.5",
+    "mocha": "^9.1.3",
+    "npm-check-updates": "^12.0.2",
     "power-assert": "^1.6.1",
     "semver": "^7.3.5",
-    "spica": "0.0.490",
+    "spica": "0.0.492",
     "tsify": "^5.0.4",
-    "typed-dom": "0.0.244",
-    "typescript": "4.4.3",
+    "typed-dom": "0.0.247",
+    "typescript": "4.5.2",
     "vinyl-buffer": "^1.0.1",
     "vinyl-source-stream": "^2.0.0"
   },

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

@@ -0,0 +1,8 @@
+import { Parser, Tree, Context } from '../../data/parser';
+import { union } from '../../data/parser/union';
+
+export function fallback<P extends Parser<unknown>>(parser: P, otherwise: Parser<Tree<P>, Context<P>>): P;
+export function fallback<T, P extends Parser<T>>(parser: P, otherwise: Parser<T, Context<P>>): P;
+export function fallback<T>(parser: Parser<T>, otherwise: Parser<T>): Parser<T> {
+  return union([parser, otherwise]);
+}

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

@@ -2,7 +2,7 @@ import { Parser, Ctx } from '../../data/parser';
 import { firstline, isEmpty } from '../constraint/line';
 import { unshift } from 'spica/array';
 
-export function fence<D extends Parser<unknown, C>[], C extends Ctx>(opener: RegExp, limit: number, separation: boolean = true): Parser<string, C, D> {
+export function fence<C extends Ctx, D extends Parser<unknown, C>[]>(opener: RegExp, limit: number, separation: boolean = true): Parser<string, C, D> {
   return source => {
     if (source === '') return;
     const matches = source.match(opener);

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

@@ -16,7 +16,6 @@ describe('Unit: combinator/indent', () => {
       assert.deepStrictEqual(inspect(parser('  a\n a')), [['a'], ' a']);
       assert.deepStrictEqual(inspect(parser(' \ta')), [['\ta'], '']);
       assert.deepStrictEqual(inspect(parser('\ta')), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser('　a')), [['a'], '']);
     });
 
   });

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

@@ -12,7 +12,7 @@ export function indent<P extends Parser<unknown>>(parser: P): P;
 export function indent<T>(parser: Parser<T>): Parser<T> {
   assert(parser);
   return bind(match(
-    /^(?=(([ \t　])\2*))/,
+    /^(?=(([ \t])\2*))/,
     reduce<string[], Parser<string>, string>(
     ([, indent]) =>
       some(line(open(indent, source => [[unline(source)], '']))),

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

@@ -1,6 +1,6 @@
-import { Parser, Result, Ctx } from '../../data/parser';
+import { Parser, Result, Ctx, Tree, Context } from '../../data/parser';
 
-export function recover<T, C extends Ctx, D extends Parser<unknown, C>[]>(parser: Parser<T, C, D> | Parser<T, C, [...Parser<never, C>[], Parser<T, C, D>]>, fallback: (source: string, context: C, reason: unknown) => Result<T, C, D>): Parser<T, C, D>;
+export function recover<P extends Parser<unknown>>(parser: P, fallback: (source: string, context: Context<P>, reason: unknown) => Result<Tree<P>>): P;
 export function recover<T>(parser: Parser<T>, fallback: (source: string, context: Ctx, reason: unknown) => Result<T>): Parser<T> {
   return (source, context) => {
     try {

package/src/combinator.ts

@@ -18,6 +18,7 @@ export * from './combinator/control/manipulation/convert';
 export * from './combinator/control/manipulation/trim';
 export * from './combinator/control/manipulation/duplicate';
 export * from './combinator/control/manipulation/reverse';
+export * from './combinator/control/manipulation/fallback';
 export * from './combinator/control/manipulation/recovery';
 export * from './combinator/control/manipulation/lazy';
 export * from './combinator/control/monad/fmap';

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

@@ -1,4 +1,4 @@
-import { normalize } from './normalize';
+import { normalize, escape } from './normalize';
 
 describe('Unit: parser/normalize', () => {
   describe('normalize', () => {
@@ -45,11 +45,6 @@ describe('Unit: parser/normalize', () => {
       assert(normalize('\x7F') === '\uFFFD');
     });
 
-    it('escape', () => {
-      assert(normalize('\u200B') === '​');
-      assert(normalize('\u200D') === '‍');
-    });
-
     it('sanitize', () => {
       assert(normalize('\u2006') === '\uFFFD');
       assert(normalize('\u202A') === '\uFFFD');
@@ -74,4 +69,12 @@ describe('Unit: parser/normalize', () => {
 
   });
 
+  describe('escape', () => {
+    it('', () => {
+      assert(escape('\u200B') === '​');
+      assert(escape('\u200D') === '‍');
+    });
+
+  });
+
 });

package/src/parser/api/normalize.ts

@@ -1,20 +1,41 @@
 import { htmlentity } from '../inline/htmlentity';
 import { eval } from '../../combinator/data/parser';
 
+const UNICODE_REPLACEMENT_CHARACTER = '\uFFFD';
+assert(UNICODE_REPLACEMENT_CHARACTER.trim());
+
+export function normalize(source: string): string {
+  return format(sanitize(source));
+}
+
+function format(source: string): string {
+  return source
+    .replace(/\r\n?/g, '\n');
+}
+
+function sanitize(source: string): string {
+  return source
+    .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]|[\u2006\u200B-\u200F\u202A-\u202F\u2060\uFEFF]|(^|[^\u1820\u1821])\u180E/g, `$1${UNICODE_REPLACEMENT_CHARACTER}`)
+    .replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]?|[\uDC00-\uDFFF]/g, char =>
+      char.length === 1
+        ? UNICODE_REPLACEMENT_CHARACTER
+        : char);
+}
+
 // https://dev.w3.org/html5/html-author/charref
 // https://en.wikipedia.org/wiki/Whitespace_character
 const unreadableHTMLEntityNames = [
   //'Tab',
   //'NewLine',
-  //'NonBreakingSpace',
-  //'nbsp',
+  'NonBreakingSpace',
+  'nbsp',
   'shy',
-  //'ensp',
-  //'emsp',
+  'ensp',
+  'emsp',
   'emsp13',
   'emsp14',
-  //'numsp',
-  //'puncsp',
+  'numsp',
+  'puncsp',
   'ThinSpace',
   'thinsp',
   'VeryThinSpace',
@@ -28,7 +49,7 @@ const unreadableHTMLEntityNames = [
   'zwnj',
   'lrm',
   'rlm',
-  //'MediumSpace',
+  'MediumSpace',
   'NoBreak',
   'ApplyFunction',
   'af',
@@ -78,30 +99,10 @@ const unreadableSpecialCharacters = [
   // ZERO WIDTH NON-BREAKING SPACE
   '\uFEFF',
 ];
-
-const UNICODE_REPLACEMENT_CHARACTER = '\uFFFD';
-assert(UNICODE_REPLACEMENT_CHARACTER.trim());
 assert(unreadableSpecialCharacters.every(c => sanitize(c) === UNICODE_REPLACEMENT_CHARACTER));
 
-export function normalize(source: string): string {
-  return format(sanitize(escape(source)));
-}
-
-function format(source: string): string {
-  return source
-    .replace(/\r\n?/g, '\n');
-}
-
-function sanitize(source: string): string {
-  return source
-    .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]|[\u2006\u200B-\u200F\u202A-\u202F\u2060\uFEFF]|(^|[^\u1820\u1821])\u180E/g, `$1${UNICODE_REPLACEMENT_CHARACTER}`)
-    .replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]?|[\uDC00-\uDFFF]/g, char =>
-      char.length === 1
-        ? UNICODE_REPLACEMENT_CHARACTER
-        : char);
-}
-
-function escape(source: string): string {
+// 特殊不可視文字はエディタおよびソースビューアの等幅および強調表示により可視化する
+export function escape(source: string): string {
   return source
     .replace(unreadableEscapableCharacter, char =>
       `&${unreadableHTMLEntityNames[unreadableEscapableCharacters.indexOf(char)]};`);

package/src/parser/block/ilist.ts

@@ -1,19 +1,21 @@
 import { IListParser } from '../block';
-import { union, inits, some, block, line, validate, indent, context, creator, open, convert, trim, lazy, fmap } from '../../combinator';
+import { union, inits, some, block, line, validate, indent, rewrite, context, creator, open, convert, trim, fallback, lazy, fmap } from '../../combinator';
 import { ulist_, fillFirstLine } from './ulist';
 import { olist_ } from './olist';
 import { inline } from '../inline';
+import { contentline } from '../source';
 import { html, defrag } from 'typed-dom';
 
 export const ilist: IListParser = lazy(() => block(fmap(validate(
   /^[-+*](?=[^\S\n]|\n[^\S\n]*\S)/,
   context({ syntax: { inline: { media: false } } },
   some(creator(union([
-    fmap(
+    fmap(fallback(
       inits([
         line(open(/^[-+*](?:$|\s)/, trim(some(inline)), true)),
         indent(union([ulist_, olist_, ilist_])),
       ]),
+      rewrite(contentline, source => [[html('span', source.replace('\n', ''))], ''])),
       ns => [html('li', defrag(fillFirstLine(ns)))]),
   ]))))),
   es => [

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

@@ -26,15 +26,8 @@ describe('Unit: parser/block/olist', () => {
       assert.deepStrictEqual(inspect(parser('1.1.')), undefined);
       assert.deepStrictEqual(inspect(parser('1.a')), undefined);
       assert.deepStrictEqual(inspect(parser('1.\n')), undefined);
-      assert.deepStrictEqual(inspect(parser('1. a\n  1. a\n 1. a')), undefined);
-      assert.deepStrictEqual(inspect(parser('1. \n1 ')), undefined);
-      assert.deepStrictEqual(inspect(parser('1. \n1--')), undefined);
-      assert.deepStrictEqual(inspect(parser('1. \n1--. ')), undefined);
-      assert.deepStrictEqual(inspect(parser('1. !http://host')), [['<ol><li>!<a href="http://host" target="_blank">http://host</a></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('(1)')), undefined);
       assert.deepStrictEqual(inspect(parser('(1)\n')), undefined);
-      assert.deepStrictEqual(inspect(parser('(1) \n(1)--')), undefined);
-      assert.deepStrictEqual(inspect(parser('(1) \n(1)-- ')), undefined);
       assert.deepStrictEqual(inspect(parser('(I) ')), undefined);
       assert.deepStrictEqual(inspect(parser('(A) ')), undefined);
       assert.deepStrictEqual(inspect(parser(' 1.')), undefined);
@@ -69,6 +62,8 @@ describe('Unit: parser/block/olist', () => {
       assert.deepStrictEqual(inspect(parser('(1) \n(1)')), [['<ol data-format="paren"><li></li><li></li></ol>'], '']);
       // filled
       assert.deepStrictEqual(inspect(parser('(1) \n(1) ')), [['<ol data-format="paren"><li></li><li></li></ol>'], '']);
+      // invalid
+      assert.deepStrictEqual(inspect(parser('0. \n0 ')), [['<ol><li></li><li><span class="invalid">0 </span></li></ol>'], '']);
     });
 
     it('nest', () => {
@@ -78,9 +73,11 @@ describe('Unit: parser/block/olist', () => {
       assert.deepStrictEqual(inspect(parser('0. 1\n 0. ')), [['<ol><li>1<ol><li></li></ol></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('0. 1\n 0.\n')), [['<ol><li>1<ol><li></li></ol></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('0. 1\n 0. 2')), [['<ol><li>1<ol><li>2</li></ol></li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('0. 1\n 0. 2\n0. 3')), [['<ol><li>1<ol><li>2</li></ol></li><li>3</li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('0. 1\n 0. 2\n 0. 3')), [['<ol><li>1<ol><li>2</li><li>3</li></ol></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('0. 1\n 0. 2\n  0. 3')), [['<ol><li>1<ol><li>2<ol><li>3</li></ol></li></ol></li></ol>'], '']);
-      assert.deepStrictEqual(inspect(parser('0. 1\n 0. 2\n0. 3')), [['<ol><li>1<ol><li>2</li></ol></li><li>3</li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('0. 1\n  0. 2\n 0. 3')), [['<ol><li>1<ol><li>2</li></ol></li><li><span class="invalid"> 0. 3</span></li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('0. !http://host')), [['<ol><li>!<a href="http://host" target="_blank">http://host</a></li></ol>'], '']);
     });
 
     it('index', () => {
@@ -102,6 +99,10 @@ describe('Unit: parser/block/olist', () => {
       assert.deepStrictEqual(inspect(parser('(1)-1-1 ')), [['<ol data-format="paren"><li data-marker="(1)-1-1"></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('(1) \n(1)-')), [['<ol data-format="paren"><li></li><li data-marker="(1)-"></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('(1) \n(1)-1')), [['<ol data-format="paren"><li></li><li data-marker="(1)-1"></li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('1. \n1--')), [['<ol><li></li><li><span class="invalid">1--</span></li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('1. \n1--. ')), [['<ol><li></li><li><span class="invalid">1--. </span></li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('(1) \n(1)--')), [['<ol data-format="paren"><li></li><li><span class="invalid">(1)--</span></li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('(1) \n(1)-- ')), [['<ol data-format="paren"><li></li><li><span class="invalid">(1)-- </span></li></ol>'], '']);
     });
 
     it('type', () => {

package/src/parser/block/olist.ts

@@ -1,9 +1,10 @@
 import { undefined } from 'spica/global';
 import { OListParser } from '../block';
-import { union, inits, subsequence, some, block, line, indent, focus, context, creator, open, match, convert, trim, trimStart, lazy, fmap } from '../../combinator';
+import { union, inits, subsequence, some, block, line, indent, focus, rewrite, context, creator, open, match, convert, trim, trimStart, fallback, lazy, fmap } from '../../combinator';
 import { checkbox, ulist_, fillFirstLine } from './ulist';
 import { ilist_ } from './ilist';
 import { inline } from '../inline';
+import { contentline } from '../source';
 import { html, define, defrag } from 'typed-dom';
 import { memoize } from 'spica/memoize';
 import { shift } from 'spica/array';
@@ -17,11 +18,12 @@ export const olist: OListParser = lazy(() => block(match(
 const list = (type: string, delim: string): OListParser => fmap(
   context({ syntax: { inline: { media: false } } },
   some(creator(union([
-    fmap(
+    fmap(fallback(
       inits([
         line(open(items[delim], trim(subsequence([checkbox, trimStart(some(inline))])), true)),
         indent(union([ulist_, olist_, ilist_])),
       ]),
+      iitem),
       (ns: [string, ...(HTMLElement | string)[]]) => [html('li', { 'data-marker': ns[0] }, defrag(fillFirstLine(shift(ns)[1])))]),
   ])))),
   es => [format(html('ol', es), type, delim)]);
@@ -45,6 +47,16 @@ export const olist_: OListParser = convert(
           .replace(/^\(((?:[0-9]+|[a-z]+))\)?((?:-(?!-)[0-9]*)*(?=$|\n))/, `($1)$2 `),
   olist);
 
+const iitem = rewrite(contentline, source => [[
+  '',
+  html('span', {
+    class: 'invalid',
+    'data-invalid-syntax': 'listitem',
+    'data-invalid-type': 'syntax',
+    'data-invalid-description': 'Fix the indent or the head of list items.',
+  }, source.replace('\n', ''))
+], '']);
+
 function type(index: string): string {
   switch (index) {
     case 'i':
@@ -102,8 +114,13 @@ function format(el: HTMLOListElement, type: string, delim: string): HTMLOListEle
   const marker = el.firstElementChild?.getAttribute('data-marker')!.match(initial(type))?.[0] ?? '';
   for (let es = el.children, len = es.length, i = 0; i < len; ++i) {
     const el = es[i];
-    if (el.getAttribute('data-marker') !== marker) break;
-    el.removeAttribute('data-marker');
+    switch (el.getAttribute('data-marker')) {
+      case '':
+      case marker:
+        el.removeAttribute('data-marker');
+        continue;
+    }
+    break;
   }
   return el;
 }

package/src/parser/block/paragraph/mention/cite.ts

@@ -10,10 +10,10 @@ export const cite: ParagraphParser.MentionParser.CiteParser = creator(line(fmap(
     str(/^>*(?=>>)/),
     anchor,
   ]))),
-  ([el, str = '']: [HTMLElement, string?]) => [
+  ([el, quotes = '']: [HTMLElement, string?]) => [
     html('span', { class: 'cite' }, defrag([
-      str + '>',
-      define(el, { 'data-depth': `${str.length + 1}` }, el.innerText.slice(1)),
+      quotes + '>',
+      define(el, { 'data-depth': `${quotes.length + 1}` }, el.innerText.slice(1)),
     ])),
     html('br'),
   ])));

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

@@ -13,7 +13,6 @@ describe('Unit: parser/block/table', () => {
       assert.deepStrictEqual(inspect(parser('||')), undefined);
       assert.deepStrictEqual(inspect(parser('|||')), undefined);
       assert.deepStrictEqual(inspect(parser('|\n|')), undefined);
-      assert.deepStrictEqual(inspect(parser('|\n|\n|')), undefined);
       assert.deepStrictEqual(inspect(parser('|h')), undefined);
       assert.deepStrictEqual(inspect(parser('|h')), undefined);
       assert.deepStrictEqual(inspect(parser('|h\n')), undefined);
@@ -26,6 +25,7 @@ describe('Unit: parser/block/table', () => {
     });
 
     it('valid', () => {
+      assert.deepStrictEqual(inspect(parser('|\n|\n|')), [['<table><thead><tr></tr></thead><tbody><tr class="invalid"><td>|</td></tr><tr></tr></tbody></table>'], '']);
       assert.deepStrictEqual(inspect(parser('|\n|-\n|')), [['<table><thead><tr></tr></thead><tbody><tr></tr></tbody></table>'], '']);
       assert.deepStrictEqual(inspect(parser('||\n|-|\n||')), [['<table><thead><tr><th></th></tr></thead><tbody><tr><td></td></tr></tbody></table>'], '']);
       assert.deepStrictEqual(inspect(parser('|||\n|-|-|\n|||')), [['<table><thead><tr><th></th><th></th></tr></thead><tbody><tr><td></td><td></td></tr></tbody></table>'], '']);

package/src/parser/block/table.ts

@@ -1,6 +1,7 @@
 import { TableParser } from '../block';
-import { union, sequence, some, block, line, validate, focus, creator, surround, open, lazy, fmap } from '../../combinator';
+import { union, sequence, some, block, line, validate, focus, rewrite, creator, surround, open, fallback, lazy, fmap } from '../../combinator';
 import { inline } from '../inline';
+import { contentline } from '../source';
 import { html, defrag } from 'typed-dom';
 import { push } from 'spica/array';
 
@@ -9,7 +10,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}/,
   sequence([
     row(some(head), true),
     row(some(align), false),
@@ -18,13 +19,21 @@ export const table: TableParser = lazy(() => block(fmap(validate(
   rows => [
     html('table', [
       html('thead', [rows.shift()!]),
-      html('tbody', format(rows, push([], rows.shift()!.children).map(el => el.textContent!))),
+      html('tbody', format(rows)),
     ]),
   ])));
 
-const row = <P extends CellParser | AlignParser>(parser: P, optional: boolean): RowParser<P> => creator(fmap(
+const row = <P extends CellParser | AlignParser>(parser: P, optional: boolean): RowParser<P> => creator(fallback(fmap(
   line(surround(/^(?=\|)/, some(union([parser])), /^\|?\s*$/, optional)),
-  es => [html('tr', es)]));
+  es => [html('tr', es)]),
+  rewrite(contentline, source => [[
+    html('tr', {
+      class: 'invalid',
+      'data-invalid-syntax': 'tablerow',
+      'data-invalid-type': 'syntax',
+      'data-invalid-description': 'Invalid table row.',
+    }, [html('td', source.replace('\n', ''))])
+  ], ''])));
 
 const align: AlignParser = creator(fmap(open(
   '|',
@@ -49,11 +58,12 @@ const data: CellParser.DataParser = creator(fmap(
   cell,
   ns => [html('td', defrag(ns))]));
 
-function format(rows: HTMLTableRowElement[], aligns: string[]): HTMLTableRowElement[] {
-  assert(aligns.length > 0);
+function format(rows: HTMLTableRowElement[]): HTMLTableRowElement[] {
+  const aligns = rows[0].classList.contains('invalid')
+    ? []
+    : push([], rows.shift()!.children).map(el => el.textContent!);
   for (let i = 0, len = rows.length; i < len; ++i) {
-    const row = rows[i];
-    const cols = row.children;
+    const cols = rows[i].children;
     for (let i = 0, len = cols.length; i < len; ++i) {
       if (i > 0 && !aligns[i]) {
         aligns[i] = aligns[i - 1];

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

@@ -17,11 +17,6 @@ describe('Unit: parser/block/ulist', () => {
       assert.deepStrictEqual(inspect(parser('-[ ]')), undefined);
       assert.deepStrictEqual(inspect(parser('-[x]')), undefined);
       assert.deepStrictEqual(inspect(parser('-\n')), undefined);
-      assert.deepStrictEqual(inspect(parser('-\n+')), undefined);
-      assert.deepStrictEqual(inspect(parser('-\n0')), undefined);
-      assert.deepStrictEqual(inspect(parser('-\n -\n 0')), undefined);
-      assert.deepStrictEqual(inspect(parser('- 0\n  - 0\n - 0')), undefined);
-      assert.deepStrictEqual(inspect(parser('- !http://host')), [['<ul><li>!<a href="http://host" target="_blank">http://host</a></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser(' -')), undefined);
       assert.deepStrictEqual(inspect(parser('+')), undefined);
       assert.deepStrictEqual(inspect(parser('*')), undefined);
@@ -43,6 +38,9 @@ describe('Unit: parser/block/ulist', () => {
       // filled
       assert.deepStrictEqual(inspect(parser('- 1\n- 2')), [['<ul><li>1</li><li>2</li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- 1\n- 2\n- 3')), [['<ul><li>1</li><li>2</li><li>3</li></ul>'], '']);
+      // invalid
+      assert.deepStrictEqual(inspect(parser('-\n+')), [['<ul><li></li><li><span class="invalid">+</span></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('-\n0')), [['<ul><li></li><li><span class="invalid">0</span></li></ul>'], '']);
     });
 
     it('nest', () => {
@@ -51,11 +49,14 @@ describe('Unit: parser/block/ulist', () => {
       assert.deepStrictEqual(inspect(parser('- 1\n - 2\n- 3')), [['<ul><li>1<ul><li>2</li></ul></li><li>3</li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- 1\n - 2\n - 3')), [['<ul><li>1<ul><li>2</li><li>3</li></ul></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- 1\n - 2\n  - 3')), [['<ul><li>1<ul><li>2<ul><li>3</li></ul></li></ul></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- 1\n  - 2\n - 3')), [['<ul><li>1<ul><li>2</li></ul></li><li><span class="invalid"> - 3</span></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('-\n -\n +\n -\n +\n+')), [['<ul><li><br><ul><li></li><li><span class="invalid">+</span></li><li></li><li><span class="invalid">+</span></li></ul></li><li><span class="invalid">+</span></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- 1\n + 2')), [['<ul><li>1<ul class="invalid"><li>2</li></ul></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- 1\n 0')), [['<ul><li>1<ol><li></li></ol></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- 1\n 0.')), [['<ul><li>1<ol><li></li></ol></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- 1\n 0. ')), [['<ul><li>1<ol><li></li></ol></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- 1\n 0. 2')), [['<ul><li>1<ol><li>2</li></ol></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- !http://host')), [['<ul><li>!<a href="http://host" target="_blank">http://host</a></li></ul>'], '']);
     });
 
     it('checkbox', () => {

package/src/parser/block/ulist.ts

@@ -1,20 +1,22 @@
 import { UListParser } from '../block';
-import { union, inits, subsequence, some, block, line, validate, indent, focus, context, creator, open, convert, trim, trimStart, lazy, fmap } from '../../combinator';
+import { union, inits, subsequence, some, block, line, validate, indent, focus, rewrite, context, creator, open, convert, trim, trimStart, fallback, lazy, fmap } from '../../combinator';
 import { olist_ } from './olist';
 import { ilist_ } from './ilist';
 import { inline } from '../inline';
 import { html, defrag } from 'typed-dom';
 import { unshift } from 'spica/array';
+import { contentline } from '../source';
 
 export const ulist: UListParser = lazy(() => block(fmap(validate(
   /^-(?=[^\S\n]|\n[^\S\n]*\S)/,
   context({ syntax: { inline: { media: false } } },
   some(creator(union([
-    fmap(
+    fmap(fallback(
       inits([
         line(open(/^-(?:$|\s)/, trim(subsequence([checkbox, trimStart(some(inline))])), true)),
         indent(union([ulist_, olist_, ilist_])),
       ]),
+      iitem),
       ns => [html('li', defrag(fillFirstLine(ns)))]),
   ]))))),
   es => [format(html('ul', es))])));
@@ -29,6 +31,15 @@ export const ulist_: UListParser = convert(
   source => source.replace(/^-(?=$|\n)/, `$& `),
   ulist);
 
+const iitem = rewrite(contentline, source => [[
+  html('span', {
+    class: 'invalid',
+    'data-invalid-syntax': 'listitem',
+    'data-invalid-type': 'syntax',
+    'data-invalid-description': 'Fix the indent or the head of list items.',
+  }, source.replace('\n', ''))
+], '']);
+
 export function fillFirstLine(ns: (HTMLElement | string)[]): (HTMLElement | string)[] {
   return ns.length === 1
       && typeof ns[0] === 'object'

package/src/parser/block.ts

@@ -1,6 +1,6 @@
 import { undefined } from 'spica/global';
 import { MarkdownParser } from '../../markdown';
-import { union, reset, creator, open, recover } from '../combinator';
+import { union, reset, creator, open, fallback, recover } from '../combinator';
 import { emptyline } from './source';
 import { horizontalrule } from './block/horizontalrule';
 import { heading } from './block/heading';
@@ -49,12 +49,10 @@ export const block: BlockParser = creator(error(
     paragraph
   ]))));
 
-function error(parser: MarkdownParser.BlockParser): MarkdownParser.BlockParser {
-  return recover(
-    union([
-      open('\0', source => { throw new Error(source.split('\n', 1)[0]); }),
-      parser,
-    ]),
+function error(parser: BlockParser): BlockParser {
+  return recover<BlockParser>(fallback(
+    open('\0', source => { throw new Error(source.split('\n', 1)[0]); }),
+    parser),
     (source, { id }, reason) => [[
       html('h1',
         {

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

@@ -14,8 +14,6 @@ describe('Unit: parser/inline/annotation', () => {
       assert.deepStrictEqual(inspect(parser('(())')), undefined);
       assert.deepStrictEqual(inspect(parser('(()))')), undefined);
       assert.deepStrictEqual(inspect(parser('(( ))')), undefined);
-      assert.deepStrictEqual(inspect(parser('(( a))')), undefined);
-      assert.deepStrictEqual(inspect(parser('(( a ))')), undefined);
       assert.deepStrictEqual(inspect(parser('((\n))')), undefined);
       assert.deepStrictEqual(inspect(parser('((\na))')), undefined);
       assert.deepStrictEqual(inspect(parser('((\\ a))')), undefined);
@@ -34,6 +32,8 @@ describe('Unit: parser/inline/annotation', () => {
     });
 
     it('basic', () => {
+      assert.deepStrictEqual(inspect(parser('(( a))')), [['<sup class="annotation">a</sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('(( a ))')), [['<sup class="annotation">a</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('((a))')), [['<sup class="annotation">a</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('((a ))')), [['<sup class="annotation">a</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('((a  ))')), [['<sup class="annotation">a</sup>'], '']);

package/src/parser/inline/annotation.ts

@@ -2,13 +2,13 @@ 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 { startTight, trimEnd } from '../util';
+import { startLoose, visible, trimNode } from '../util';
 import { html, defrag } from 'typed-dom';
 
 export const annotation: AnnotationParser = lazy(() => creator(validate('((', '))', '\n', fmap(surround(
   '((',
   guard(context => context.syntax?.inline?.annotation ?? true,
-  startTight(
+  startLoose(visible(
   context({ syntax: { inline: {
     annotation: false,
     // Redundant
@@ -20,6 +20,6 @@ export const annotation: AnnotationParser = lazy(() => creator(validate('((', ')
     //link: true,
     //autolink: true,
   }}, state: undefined },
-  union([some(inline, ')', /^\\?\n/)])))),
+  union([some(inline, ')', /^\\?\n/)]))))),
   '))'),
-  ns => [html('sup', { class: 'annotation' }, trimEnd(defrag(ns)))]))));
+  ns => [html('sup', { class: 'annotation' }, trimNode(defrag(ns)))]))));

package/src/parser/inline/emphasis.ts

@@ -3,7 +3,7 @@ import { union, some, creator, surround, close, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { strong } from './strong';
 import { str } from '../source';
-import { startTight, verifyEndTight, trimEndBR } from '../util';
+import { startTight, isEndTightNodes, trimEndBR } from '../util';
 import { html, defrag } from 'typed-dom';
 import { unshift } from 'spica/array';
 
@@ -12,7 +12,7 @@ export const emphasis: EmphasisParser = lazy(() => creator(surround(close(
   startTight(some(union([strong, some(inline, '*')]))),
   str('*'), false,
   ([as, bs, cs], rest) =>
-    verifyEndTight(bs)
+    isEndTightNodes(bs)
       ? [[html('em', defrag(trimEndBR(bs)))], rest]
       : [unshift(as, bs), cs[0] + rest],
   ([as, bs], rest) => [unshift(as, bs), rest])));