securemark 0.295.8 → 0.296.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securemark",
-  "version": "0.295.8",
+  "version": "0.296.0",
   "description": "Secure markdown renderer working on browsers for user input data.",
   "private": false,
   "homepage": "https://github.com/falsandtru/securemark",

package/src/combinator/control/constraint/contract.ts

@@ -1,5 +1,5 @@
-import { Parser, Input, List, Node, Context, failsafe } from '../../data/parser';
-import { matcher } from '../../../combinator';
+import { Parser, Input, List, Node, Context } from '../../data/parser';
+import { matcher, bind } from '../../../combinator';
 
 //export function contract<P extends Parser>(patterns: string | RegExp | (string | RegExp)[], parser: P, cond: (nodes: readonly Data<P>[], rest: string) => boolean): P;
 //export function contract<N>(patterns: string | RegExp | (string | RegExp)[], parser: Parser<N>, cond: (nodes: readonly N[], rest: string) => boolean): Parser<N> {
@@ -11,32 +11,16 @@ export function validate<P extends Parser>(cond: ((input: Input<Parser.Context<P
 export function validate<N>(pattern: string | RegExp | ((input: Input<Context>) => boolean), parser: Parser<N>): Parser<N> {
   if (typeof pattern === 'function') return guard(pattern, parser);
   const match = matcher(pattern, false);
-  return input => {
-    const { context } = input;
-    const { source, position } = context;
-    if (position === source.length) return;
-    if (!match(input)) return;
-    return parser(input);
-  };
+  return input => match(input) ? parser(input) : undefined;
 }
 
 function guard<P extends Parser>(f: (input: Input<Parser.Context<P>>) => boolean, parser: P): P;
 function guard<N>(f: (input: Input<Context>) => boolean, parser: Parser<N>): Parser<N> {
-  return input =>
-    f(input)
-      ? parser(input)
-      : undefined;
+  return input => f(input) ? parser(input) : undefined;
 }
 
 export function verify<P extends Parser>(parser: P, cond: (nodes: List<Node<Parser.Node<P>>>, context: Parser.Context<P>) => boolean): P;
 export function verify<N>(parser: Parser<N>, cond: (nodes: List<Node<N>>, context: Context) => boolean): Parser<N> {
   assert(parser);
-  return failsafe(input => {
-    const { context } = input;
-    const { source, position } = context;
-    if (position === source.length) return;
-    const result = parser(input);
-    if (result && !cond(result, context)) return;
-    return result;
-  });
+  return bind(parser, (nodes, context) => cond(nodes, context) ? nodes : undefined)
 }

package/src/combinator/data/parser/context.ts

@@ -159,7 +159,7 @@ export function constraint<N>(state: number, positive: boolean | Parser<N>, pars
   };
 }
 
-export function matcher(pattern: string | RegExp, advance: boolean): Parser<string> {
+export function matcher(pattern: string | RegExp, advance: boolean, verify?: (source: string, position: number, range: number) => boolean): Parser<string> {
   assert(pattern instanceof RegExp ? !pattern.flags.match(/[gm]/) && pattern.sticky && !pattern.source.startsWith('^') : true);
   const count = typeof pattern === 'object'
     ? /[^^\\*+][*+]/.test(pattern.source)
@@ -169,6 +169,7 @@ export function matcher(pattern: string | RegExp, advance: boolean): Parser<stri
       return ({ context }) => {
         const { source, position } = context;
         if (!source.startsWith(pattern, position)) return;
+        if (verify?.(source, position, pattern.length) === false) return;
         if (advance) {
           context.position += pattern.length;
         }
@@ -182,6 +183,7 @@ export function matcher(pattern: string | RegExp, advance: boolean): Parser<stri
         if (!pattern.test(source)) return;
         const src = source.slice(position, pattern.lastIndex);
         count && consume(src.length, context);
+        if (verify?.(source, position, src.length) === false) return;
         if (advance) {
           context.position += src.length;
         }

package/src/combinator/data/parser/sequence.ts

@@ -1,10 +1,10 @@
-import { Parser, List, Node, Context } from '../parser';
+import { Parser, List, Node, Context, failsafe } from '../parser';
 
 export function sequence<P extends Parser>(parsers: Parser.SubParsers<P>): Parser.SubNode<P> extends Parser.Node<P> ? P : Parser<Parser.SubNode<P>, Parser.Context<P>, Parser.SubParsers<P>>;
 export function sequence<N, D extends Parser<N>[]>(parsers: D): Parser<N, Context, D> {
   assert(parsers.every(f => f));
   if (parsers.length === 1) return parsers[0];
-  return input => {
+  return failsafe(input => {
     const { context } = input;
     const { source } = context;
     let nodes: List<Node<N>> | undefined;
@@ -16,5 +16,5 @@ export function sequence<N, D extends Parser<N>[]>(parsers: D): Parser<N, Contex
       nodes = nodes?.import(result) ?? result;
     }
     return nodes;
-  };
+  });
 }

package/src/combinator/data/parser.ts

@@ -1,4 +1,4 @@
-import { List } from './data';
+import { List } from './node';
 import { Delimiters } from './delimiter';
 
 export type Parser<N = unknown, C extends Context = Context, D extends Parser<unknown, C>[] = any>
@@ -20,7 +20,10 @@ export type Result<N, C extends Context = Context, D extends Parser<unknown, C>[
   | undefined;
 export { List };
 export class Node<N> implements List.Node {
-  constructor(public value: N) {
+  constructor(
+    public value: N,
+    public flags: number = 0,
+  ) {
   }
   public next?: this = undefined;
   public prev?: this = undefined;
@@ -66,6 +69,8 @@ export class Context {
   // Objectの内部実装を利用する。
   // 探索木を直接使用する場合は探索速度が重要で挿入は相対的に少なく削除は不要かつ不確実であるため
   // AVL木が適当と思われる。
+  // メモリの局所性を得るために木ごとに最初の数十から数百byte分のノードをプールしノードが不足した場合は
+  // 使い捨てノードを追加またはテーブルに移行するとよいだろう。
   // 最大セグメントサイズ10KB内で探索コストが平均実行性能を圧迫するほど大きくなるとは考えにくいが
   // 探索コストを減らすにはバックトラック位置数が規定数を超えた場合一定区間ごとに探索木を分割する方法が考えられる。
   // 10KBの入力すべてを保持する探索木を1024文字ごとに分割するために必要なテーブルサイズは64bit*98=784byteとなる。

package/src/parser/api/normalize.ts

@@ -1,6 +1,4 @@
-import { input } from '../../combinator/data/parser';
-import { Context } from '../context';
-import { unsafehtmlentity } from '../inline/htmlentity';
+import { html } from 'typed-dom/dom';
 
 const UNICODE_REPLACEMENT_CHARACTER = '\uFFFD';
 assert(UNICODE_REPLACEMENT_CHARACTER.trim());
@@ -15,7 +13,7 @@ function format(source: string): string {
 
 const invalid = new RegExp([
   /(?![\t\r\n])[\x00-\x1F\x7F]/g.source,
-  /(?!\u200D)[\u2006\u200B-\u200F\u202A-\u202F\u2060\uFEFF]/g.source,
+  /(?![\u200C\u200D])[\u2006\u200B-\u200F\u202A-\u202F\u2060\uFEFF]/g.source,
   // 後読みが重い
   ///(?<![\u1820\u1821])\u180E/g.source,
   ///[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g.source,
@@ -59,7 +57,12 @@ export const invisibleHTMLEntityNames = [
   'it',
   'InvisibleComma',
   'ic',
-] as const;
+] as readonly string[];
+const parser = (el => (entity: string): string => {
+  if (entity === '&NewLine;') return entity;
+  el.innerHTML = entity;
+  return el.textContent!;
+})(html('span'));
 const unreadableEscapeHTMLEntityNames = invisibleHTMLEntityNames.filter(name => ![
   'Tab',
   'NewLine',
@@ -69,7 +72,7 @@ const unreadableEscapeHTMLEntityNames = invisibleHTMLEntityNames.filter(name =>
   'zwnj',
 ].includes(name));
 const unreadableEscapeCharacters = unreadableEscapeHTMLEntityNames
-  .map(name => unsafehtmlentity(input(`&${name};`, new Context()))!.head!.value);
+  .map(name => parser(`&${name};`));
 assert(unreadableEscapeCharacters.length === unreadableEscapeHTMLEntityNames.length);
 assert(unreadableEscapeCharacters.every(c => c.length === 1));
 const unreadableEscapeCharacter = new RegExp(`[${unreadableEscapeCharacters.join('')}]`, 'g');
@@ -84,7 +87,7 @@ const unreadableSpecialCharacters = [
   // ZERO WIDTH SPACE
   '\u200B',
   // ZERO WIDTH NON-JOINER
-  '\u200C',
+  //'\u200C',
   // ZERO WIDTH JOINER
   //'\u200D',
   // LEFT-TO-RIGHT MARK

package/src/parser/block/extension/figbase.test.ts

@@ -13,10 +13,13 @@ describe('Unit: parser/block/extension/figbase', () => {
       assert.deepStrictEqual(inspect(parser, input('$-0.', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('$-0.1', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('$-1', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$-0 0', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('$-0\n 0', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('$-name', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('$-name-0', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('$group-0', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$-0]', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[$-0', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input(' [$-0]', new Context())), undefined);
     });
 

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

@@ -5,7 +5,7 @@ import { label } from '../../inline/extension/label';
 import { html } from 'typed-dom/dom';
 
 export const figbase: ExtensionParser.FigbaseParser = block(fmap(
-  validate(/\[?\$-(?:[0-9]+\.)*0\]?(?:$|[ \n])/y,
+  validate(/\[?\$-(?:[0-9]+\.)*0\]?[^\S\n]*(?:$|\n)/y,
   line(union([label]))),
   ([{ value: el }]) => {
     const label = el.getAttribute('data-label')!;

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

@@ -22,8 +22,8 @@ describe('Unit: parser/block/paragraph', () => {
       assert.deepStrictEqual(inspect(parser, input('a\\ \n', new Context())), [['<p>a</p>'], '']);
       assert.deepStrictEqual(inspect(parser, input('a\\\n', new Context())), [['<p>a</p>'], '']);
       assert.deepStrictEqual(inspect(parser, input('a\\\nb', new Context())), [['<p>a<br>b</p>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('a&NewLine;b', new Context())), [['<p>a b</p>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('&Tab;&NewLine;', new Context())), [['<p>&amp;Tab;</p>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a&NewLine;b', new Context())), [['<p>a<span class="invalid">&amp;NewLine;</span>b</p>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('&Tab;&nbsp;', new Context())), [['<p>&amp;Tab;</p>'], '']);
       assert.deepStrictEqual(inspect(parser, input('<wbr>', new Context())), [['<p>&lt;wbr&gt;</p>'], '']);
       assert.deepStrictEqual(inspect(parser, input('<wbr>\n', new Context())), [['<p>&lt;wbr&gt;</p>'], '']);
       assert.deepStrictEqual(inspect(parser, input('<wbr>\na', new Context())), [['<p>&lt;wbr&gt;<br>a</p>'], '']);

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

@@ -1,5 +1,6 @@
 import { ReplyParser } from '../../block';
 import { List, Node } from '../../../combinator/data/parser';
+import { Flag } from '../../node';
 import { union, line, focus, open, fmap } from '../../../combinator';
 import { anchor } from '../../inline/autolink/anchor';
 import { str } from '../../source';
@@ -33,6 +34,6 @@ export const cite: ReplyParser.CiteParser = line(fmap(
             ? define(node, { 'data-depth': `${quotes.length + 1}` }, node.innerText.slice(1))
             : node.slice(1),
         ]))),
-      new Node(html('br')),
+      new Node(html('br'), Flag.invisible),
     ]);
   }));

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

@@ -1,5 +1,6 @@
 import { ReplyParser } from '../../block';
 import { List, Node } from '../../../combinator/data/parser';
+import { Flag } from '../../node';
 import { union, some, block, validate, rewrite, convert, lazy, fmap } from '../../../combinator';
 import { math } from '../../inline/math';
 import { autolink } from '../../inline/autolink';
@@ -21,7 +22,7 @@ export const quote: ReplyParser.QuoteParser = lazy(() => block(fmap(
         unescsource,
       ])))),
   (ns, { source, position }) => new List([
-    new Node(source[position - 1] === '\n' ? ns.pop()!.value as HTMLBRElement : html('br')),
+    new Node(source[position - 1] === '\n' ? ns.pop()!.value as HTMLBRElement : html('br'), Flag.invisible),
     new Node(html('span', { class: 'quote' }, defrag(unwrap(ns)))),
   ].reverse())),
   false));

package/src/parser/block/reply.ts

@@ -1,5 +1,6 @@
 import { ReplyParser } from '../block';
 import { List, Node } from '../../combinator/data/parser';
+import { Flag } from '../node';
 import { union, some, block, validate, rewrite, fmap } from '../../combinator';
 import { cite, syntax as csyntax } from './reply/cite';
 import { quote, syntax as qsyntax } from './reply/quote';
@@ -20,6 +21,6 @@ export const reply: ReplyParser = block(validate(csyntax, fmap(
       visualize(fmap(some(inline), (ns, { source, position }) =>
         source[position - 1] === '\n'
           ? ns
-          : ns.push(new Node(html('br'))) && ns)))
+          : ns.push(new Node(html('br'), Flag.invisible)) && ns)))
   ])),
   ns => new List([new Node(html('p', defrag(unwrap(trimBlankNodeEnd(ns)))))]))));

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

@@ -19,7 +19,10 @@ describe('Unit: parser/inline/annotation', () => {
       assert.deepStrictEqual(inspect(parser, input('(([))', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('(([%))', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('(( ))', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('(( (a', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('(( a))', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('(( a ))', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('((\\ a))', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('((<wbr>a))', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('((\n))', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('((\na))', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('((\\\na))', new Context())), undefined);
@@ -35,10 +38,6 @@ describe('Unit: parser/inline/annotation', () => {
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser, input('(( a))', new Context())), [['<sup class="annotation"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('(( a ))', new Context())), [['<sup class="annotation"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('((\\ a))', new Context())), [['<sup class="annotation"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('((<wbr>a))', new Context())), [['<sup class="annotation"><span>a</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser, input('((a))', new Context())), [['<sup class="annotation"><span>a</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser, input('((a ))', new Context())), [['<sup class="annotation"><span>a</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser, input('((a  ))', new Context())), [['<sup class="annotation"><span>a</span></sup>'], '']);

package/src/parser/inline/annotation.ts

@@ -3,14 +3,14 @@ import { State, Backtrack } from '../context';
 import { List, Node } from '../../combinator/data/parser';
 import { union, some, precedence, state, constraint, surround, setBacktrack, lazy } from '../../combinator';
 import { inline } from '../inline';
-import { trimBlankStart, trimBlankNodeEnd } from '../visibility';
+import { beforeNonblank, trimBlankNodeEnd } from '../visibility';
 import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const annotation: AnnotationParser = lazy(() => constraint(State.annotation, surround(
   '((',
   precedence(1, state(State.annotation,
-  trimBlankStart(some(union([inline]), ')', [[')', 1]])))),
+  beforeNonblank(some(union([inline]), ')', [[')', 1]])))),
   '))',
   false,
   [2, 1 | Backtrack.common, 3 | Backtrack.doublebracket],

package/src/parser/inline/emphasis.ts

@@ -5,14 +5,14 @@ import { union, some, recursion, precedence, surround, lazy } from '../../combin
 import { inline } from '../inline';
 import { strong } from './strong';
 import { str } from '../source';
-import { tightStart, afterNonblank } from '../visibility';
+import { beforeNonblank, afterNonblank } from '../visibility';
 import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const emphasis: EmphasisParser = lazy(() => surround(
-  str(/\*(?!\*)/y),
+  str('*', (source, position, range) => !source.startsWith('*', position + range)),
   precedence(0, recursion(Recursion.inline,
-  tightStart(some(union([
+  beforeNonblank(some(union([
     some(inline, '*', afterNonblank),
     strong,
   ]))))),

package/src/parser/inline/emstrong.ts

@@ -5,8 +5,8 @@ import { union, some, recursion, precedence, surround, lazy, bind } from '../../
 import { inline } from '../inline';
 import { strong } from './strong';
 import { emphasis } from './emphasis';
-import { str } from '../source';
-import { tightStart, afterNonblank } from '../visibility';
+import { strs } from '../source';
+import { beforeNonblank, afterNonblank } from '../visibility';
 import { unwrap, repeat } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
@@ -25,8 +25,8 @@ const subemphasis: Parser.IntermediateParser<EmphasisParser> = lazy(() => some(u
 export const emstrong: EmStrongParser = lazy(() =>
   precedence(0, recursion(Recursion.inline, repeat('***', surround(
     '',
-    tightStart(some(union([some(inline, '*', afterNonblank)]))),
-    str(/\*{1,3}/y),
+    beforeNonblank(some(union([some(inline, '*', afterNonblank)]))),
+    strs('*', 3),
     false, [],
     ([, bs, cs], context): Result<Parser.Node<EmStrongParser>, Parser.Context<EmStrongParser>> => {
       assert(cs.length === 1);

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

@@ -6,7 +6,7 @@ import { inline } from '../../inline';
 import { indexee, identity } from './indexee';
 import { unsafehtmlentity } from '../htmlentity';
 import { txt, str } from '../../source';
-import { tightStart, trimBlankNodeEnd } from '../../visibility';
+import { beforeNonblank, trimBlankNodeEnd } from '../../visibility';
 import { unwrap } from '../../util';
 import { html, define, defrag } from 'typed-dom/dom';
 
@@ -15,7 +15,7 @@ import IndexParser = ExtensionParser.IndexParser;
 export const index: IndexParser = lazy(() => constraint(State.index, fmap(indexee(surround(
   str('[#'),
   precedence(1, state(State.linkers,
-  tightStart(
+  beforeNonblank(
   some(inits([
     inline,
     signature,

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

@@ -1,6 +1,6 @@
 import { ExtensionParser } from '../../inline';
 import { List, Node } from '../../../combinator/data/parser';
-import { union, focus, surround } from '../../../combinator';
+import { union, validate, focus, surround } from '../../../combinator';
 import { signature } from './index';
 import { html } from 'typed-dom/dom';
 
@@ -10,10 +10,10 @@ import { html } from 'typed-dom/dom';
 // テキストまたはインデクスを付けて同期が必要な機会を減らすのが
 // 継続的編集において最も簡便となる。
 
-export const indexer: ExtensionParser.IndexerParser = surround(
+export const indexer: ExtensionParser.IndexerParser = validate(' [|', surround(
   / \[(?=\|\S)/y,
   union([
     signature,
     focus(/\|(?=\])/y, () => new List([new Node(html('span', { class: 'indexer', 'data-index': '' }))])),
   ]),
-  /\][^\S\n]*(?:$|\n)/y);
+  /\][^\S\n]*(?:$|\n)/y));

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

@@ -4,7 +4,7 @@ import { List, Node } from '../../../combinator/data/parser';
 import { union, some, recursion, precedence, surround, lazy } from '../../../combinator';
 import { inline } from '../../inline';
 import { str } from '../../source';
-import { tightStart } from '../../visibility';
+import { beforeNonblank } from '../../visibility';
 import { invalid } from '../../util';
 import { html } from 'typed-dom/dom';
 
@@ -16,7 +16,7 @@ export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => surroun
   // ^はabbrで使用済みだが^:などのようにして分離使用可能
   str(/\[[:^|]/y),
   precedence(1, recursion(Recursion.inline,
-  tightStart(some(union([inline]), ']', [[']', 1]])))),
+  beforeNonblank(some(union([inline]), ']', [[']', 1]])))),
   str(']'),
   false,
   [3 | Backtrack.common],

package/src/parser/inline/html.ts

@@ -1,6 +1,7 @@
 import { HTMLParser } from '../inline';
 import { Recursion } from '../context';
 import { List, Node, Context } from '../../combinator/data/parser';
+import { Flag } from '../node';
 import { union, some, recursion, precedence, validate, surround, open, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
@@ -28,7 +29,7 @@ export const html: HTMLParser = lazy(() => validate(/<[a-z]+(?=[ >])/yi,
       open(str(/ ?/y), str('>'), true),
       true, [],
       ([as, bs = new List(), cs], context) =>
-        new List([new Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs).import(cs))], new List(), new List(), context))]),
+        new List([new Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs).import(cs))], new List(), new List(), context), as.head!.value === '<wbr' ? Flag.invisible : Flag.none)]),
       ([as, bs = new List()], context) =>
         new List([new Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs))], new List(), new List(), context))])),
     match(

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

@@ -33,11 +33,11 @@ describe('Unit: parser/inline/htmlentity', () => {
       assert.deepStrictEqual(inspect(parser, input('"', new Context())), [['&'], '#X22;']);
       assert.deepStrictEqual(inspect(parser, input('ആ', new Context())), [['&'], '#XD06;']);
       assert.deepStrictEqual(inspect(parser, input('ಫ', new Context())), [['&'], '#xcab;']);
+      assert.deepStrictEqual(inspect(parser, input('&NewLine;', new Context())), [['<span class="invalid">&amp;NewLine;</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input(' &amp;', new Context())), undefined);
     });
 
     it('entity', () => {
-      assert.deepStrictEqual(inspect(parser, input('&NewLine;', new Context())), [[' '], '']);
       assert.deepStrictEqual(inspect(parser, input('&nbsp;', new Context())), [['\u00A0'], '']);
       assert.deepStrictEqual(inspect(parser, input('&amp;', new Context())), [['&'], '']);
       assert.deepStrictEqual(inspect(parser, input('&copy;', new Context())), [['©'], '']);

package/src/parser/inline/htmlentity.ts

@@ -1,6 +1,7 @@
 import { HTMLEntityParser, UnsafeHTMLEntityParser } from '../inline';
 import { Backtrack } from '../context';
 import { List, Node } from '../../combinator/data/parser';
+import { Flag, isInvisibleHTMLEntityName } from '../node';
 import { union, surround, fmap } from '../../combinator';
 import { str } from '../source';
 import { invalid } from '../util';
@@ -11,15 +12,19 @@ export const unsafehtmlentity: UnsafeHTMLEntityParser = surround(
   false,
   [3 | Backtrack.unescapable],
   ([as, bs, cs]) =>
-    new List([new Node(parser(as.head!.value + bs.head!.value + cs.head!.value))]),
+    new List([
+      new Node(
+        parser(as.head!.value + bs.head!.value + cs.head!.value),
+        isInvisibleHTMLEntityName(bs.head!.value) ? Flag.invisible : Flag.none)
+    ]),
   ([as, bs]) =>
     new List([new Node(as.head!.value + (bs?.head?.value ?? ''))]));
 
 export const htmlentity: HTMLEntityParser = fmap(
   union([unsafehtmlentity]),
-  ([{ value }]) => new List([
-    length === 1 || value.at(-1) !== ';'
-      ? new Node(value)
+  ([{ value, flags }]) => new List([
+    value.length === 1 || value.at(-1) !== ';'
+      ? new Node(value, flags)
       : new Node(html('span', {
           class: 'invalid',
           ...invalid('htmlentity', 'syntax', 'Invalid HTML entity'),
@@ -27,7 +32,7 @@ export const htmlentity: HTMLEntityParser = fmap(
   ]));
 
 const parser = (el => (entity: string): string => {
-  if (entity === '
') return ' ';
+  if (entity === '
') return entity;
   el.innerHTML = entity;
   return el.textContent!;
 })(html('span'));

package/src/parser/inline/italic.ts

@@ -3,7 +3,7 @@ import { Recursion, Command } from '../context';
 import { List, Node } from '../../combinator/data/parser';
 import { union, some, recursion, precedence, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
-import { tightStart, afterNonblank } from '../visibility';
+import { beforeNonblank, afterNonblank } from '../visibility';
 import { unwrap, repeat } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
@@ -13,7 +13,7 @@ import { html, defrag } from 'typed-dom/dom';
 export const italic: ItalicParser = lazy(() =>
   precedence(0, recursion(Recursion.inline, repeat('///', surround(
     '',
-    tightStart(some(union([inline]), '///', afterNonblank)),
+    beforeNonblank(some(union([inline]), '///', afterNonblank)),
     '///',
     false, [],
     ([, bs], { buffer }) => buffer.import(bs),

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

@@ -76,10 +76,15 @@ describe('Unit: parser/inline/link', () => {
       assert.deepStrictEqual(inspect(parser, input('[ ]{ }', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('[ ]{b}', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('[  ]{b}', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[ a]{b}', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[ a ]{b}', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[\\ a]{b}', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[ \\ a]{b}', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('[\n]{b}', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('[\\ ]{b}', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('[\\\n]{b}', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('[	]{b}', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[‍]{b}', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('[[]{b}', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('[]]{b}', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('[a]{}', new Context())), undefined);
@@ -131,10 +136,6 @@ describe('Unit: parser/inline/link', () => {
       assert.deepStrictEqual(inspect(parser, input('[]{^/b}', new Context({ host: new URL('/0.a0', location.origin) }))), [[`<a class="url" href="/b">^/b</a>`], '']);
       assert.deepStrictEqual(inspect(parser, input('[]{^/b}', new Context({ host: new URL('/0.0', location.origin) }))), [[`<a class="url" href="/0.0/b">^/b</a>`], '']);
       assert.deepStrictEqual(inspect(parser, input('[]{^/b}', new Context({ host: new URL('/0.0,0.0,0z', location.origin) }))), [[`<a class="url" href="/0.0,0.0,0z/b">^/b</a>`], '']);
-      assert.deepStrictEqual(inspect(parser, input('[ a]{b}', new Context())), [['<a class="link" href="b">a</a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[ a ]{b}', new Context())), [['<a class="link" href="b">a</a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[\\ a]{b}', new Context())), [['<a class="link" href="b">a</a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[ \\ a]{b}', new Context())), [['<a class="link" href="b">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[a ]{b}', new Context())), [['<a class="link" href="b">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[a  ]{b}', new Context())), [['<a class="link" href="b">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[a]{b}', new Context())), [['<a class="link" href="b">a</a>'], '']);

package/src/parser/inline/link.ts

@@ -5,7 +5,7 @@ import { union, inits, sequence, subsequence, some, consume, precedence, state,
 import { inline, media, shortmedia } from '../inline';
 import { attributes } from './html';
 import { str } from '../source';
-import { trimBlankStart, trimBlankNodeEnd } from '../visibility';
+import { beforeNonblank, trimBlankNodeEnd } from '../visibility';
 import { unwrap, invalid, stringify } from '../util';
 import { ReadonlyURL } from 'spica/url';
 import { html, define, defrag } from 'typed-dom/dom';
@@ -20,7 +20,7 @@ export const textlink: LinkParser.TextLinkParser = lazy(() => bind(
     constraint(State.link, state(State.linkers, dup(surround(
       '[',
       precedence(1,
-      trimBlankStart(some(union([inline]), ']', [[']', 1]]))),
+      beforeNonblank(some(union([inline]), ']', [[']', 1]]))),
       ']',
       true,
       [3 | Backtrack.common | Backtrack.link, 2 | Backtrack.ruby],
@@ -43,7 +43,9 @@ export const textlink: LinkParser.TextLinkParser = lazy(() => bind(
         bs && as.import(bs).push(new Node(Command.Cancel)) && as)),
   ]),
   ([{ value: content }, { value: params = undefined } = {}], context) => {
-    if (context.state & State.link) return new List([new Node(context.source.slice(context.position - context.range, context.position))]);
+    if (context.state & State.link) return new List([
+      new Node(context.source.slice(context.position - context.range, context.position).replace(/\\($|.)/g, '$1'))
+    ]);
     if (content.last!.value === Command.Separator) {
       content.pop();
       if (params === undefined) {
@@ -88,7 +90,7 @@ export const medialink: LinkParser.MediaLinkParser = lazy(() => constraint(State
     new List([new Node(parse(content, params as List<Node<string>>, context))])))));
 
 export const uri: LinkParser.ParameterParser.UriParser = union([
-  open(/ /y, str(/\S+/y)),
+  open(' ', str(/\S+/y)),
   str(/[^\s{}]+/y),
 ]);
 

package/src/parser/inline/mark.ts

@@ -4,14 +4,14 @@ import { List, Node } from '../../combinator/data/parser';
 import { union, some, recursion, precedence, state, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { identity, signature } from './extension/indexee';
-import { tightStart, afterNonblank } from '../visibility';
+import { beforeNonblank, afterNonblank } from '../visibility';
 import { unwrap, repeat } from '../util';
 import { html, define, defrag } from 'typed-dom/dom';
 
 export const mark: MarkParser = lazy(() =>
   precedence(0, recursion(Recursion.inline, repeat('==', surround(
     '',
-    tightStart(state(State.mark, some(union([inline]), '==', afterNonblank))),
+    beforeNonblank(state(State.mark, some(union([inline]), '==', afterNonblank))),
     '==',
     false, [],
     ([, bs], { buffer }) => buffer.import(bs),

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

@@ -41,10 +41,15 @@ describe('Unit: parser/inline/media', () => {
       assert.deepStrictEqual(inspect(parser, input('![ ]{}', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('![ ]{b}', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('![  ]{b}', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('![ a]{b}', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('![ a ]{b}', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('![\\ a]{b}', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('![ \\ a]{b}', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('![\n]{b}', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('![\\ ]{b}', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('![\\\n]{b}', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('![	]{b}', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('![‍]{b}', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('![&a;]{b}', new Context())), [['<a href="b" target="_blank"><img class="media" data-src="b" alt="&amp;a;"></a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('![[]{b}', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('![]]{b}', new Context())), undefined);
@@ -79,8 +84,6 @@ describe('Unit: parser/inline/media', () => {
       assert.deepStrictEqual(inspect(parser, input('![]{?/../}', new Context())), [[`<a href="?/../" target="_blank"><img class="media" data-src="?/../" alt="?/../"></a>`], '']);
       assert.deepStrictEqual(inspect(parser, input('![]{#/../}', new Context())), [[`<a href="#/../" target="_blank"><img class="media" data-src="#/../" alt="#/../"></a>`], '']);
       assert.deepStrictEqual(inspect(parser, input('![]{^/b}', new Context())), [[`<a href="/b" target="_blank"><img class="media" data-src="/b" alt="^/b"></a>`], '']);
-      assert.deepStrictEqual(inspect(parser, input('![ a]{b}', new Context())), [['<a href="b" target="_blank"><img class="media" data-src="b" alt="a"></a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('![ a ]{b}', new Context())), [['<a href="b" target="_blank"><img class="media" data-src="b" alt="a"></a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('![a ]{b}', new Context())), [['<a href="b" target="_blank"><img class="media" data-src="b" alt="a"></a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('![a  ]{b}', new Context())), [['<a href="b" target="_blank"><img class="media" data-src="b" alt="a"></a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('![a b]{c}', new Context())), [['<a href="c" target="_blank"><img class="media" data-src="c" alt="a b"></a>'], '']);