securemark 0.295.7 → 0.295.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securemark",
-  "version": "0.295.7",
+  "version": "0.295.9",
   "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;

package/src/parser/api/normalize.ts

@@ -59,7 +59,7 @@ export const invisibleHTMLEntityNames = [
   'it',
   'InvisibleComma',
   'ic',
-] as const;
+] as readonly string[];
 const unreadableEscapeHTMLEntityNames = invisibleHTMLEntityNames.filter(name => ![
   'Tab',
   'NewLine',

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/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.ts

@@ -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/math.test.ts

@@ -14,6 +14,8 @@ describe('Unit: parser/inline/math', () => {
       assert.deepStrictEqual(inspect(parser, input('$$', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('$$$', 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\\\n$', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('$-0, $-1', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('$-0 and $-1', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('$-0と$-1', new Context())), undefined);
@@ -38,9 +40,13 @@ describe('Unit: parser/inline/math', () => {
       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('$ $', 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('$\n$', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$\\\n$', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$a\nb$', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$a\\\nb$', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('$a\\$\nb$', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('$a\\$\\\nb$', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('$`$', new Context())), undefined);
@@ -74,9 +80,12 @@ describe('Unit: parser/inline/math', () => {
       assert.deepStrictEqual(inspect(parser, input('${a}b$', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('${a}b{c}$', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('${a}{b}$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('${$}$', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('${\\}$', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('${\n}$', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('${\\\n}$', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('${a\nb}$', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('${a\\\nb}$', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('${$}$', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('${a\\$\nb}$', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('${a\\$\\\nb}$', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('$\\begin$', new Context())), [['<span class="invalid" translate="no">$\\begin$</span>'], '']);
@@ -109,7 +118,6 @@ describe('Unit: parser/inline/math', () => {
       assert.deepStrictEqual(inspect(parser, input('$a$[A](a)', new Context())), [['<span class="math" translate="no" data-src="$a$">$a$</span>'], '[A](a)']);
       assert.deepStrictEqual(inspect(parser, input('$A$', new Context())), [['<span class="math" translate="no" data-src="$A$">$A$</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('$-a$', new Context())), [['<span class="math" translate="no" data-src="$-a$">$-a$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$\\ $', new Context())), [['<span class="math" translate="no" data-src="$\\ $">$\\ $</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('$\\$$', new Context())), [['<span class="math" translate="no" data-src="$\\$$">$\\$$</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('$\\Pi$', new Context())), [['<span class="math" translate="no" data-src="$\\Pi$">$\\Pi$</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('$\\ 0$', new Context())), [['<span class="math" translate="no" data-src="$\\ 0$">$\\ 0$</span>'], '']);

package/src/parser/inline/math.ts

@@ -19,10 +19,10 @@ export const math: MathParser = lazy(() => rewrite(
     surround(
       /\$(?![\s{}])/y,
       precedence(2, some(union([
-        some(escsource, /\s?\$|[`"{}\n]/y),
+        some(escsource, /\$|[`"{}\n]/y),
         precedence(4, bracket),
       ]))),
-      /\$(?![-0-9A-Za-z])/y,
+      /(?<!\s)\$(?![-0-9A-Za-z])/y,
       false,
       [3 | Backtrack.escapable]),
   ]),

package/src/parser/inline/remark.ts

@@ -11,7 +11,7 @@ export const remark: RemarkParser = lazy(() => fallback(surround(
   str(/\[%(?=[ \n])/y),
   precedence(3, recursion(Recursion.inline,
   some(union([inline]), /[ \n]%\]/y, [[/[ \n]%\]/y, 3]]))),
-  close(text, str(`%]`)),
+  close(text, str('%]')),
   true, [],
   ([as, bs = new List(), cs]) => new List([
     new Node(html('span', { class: 'remark' }, [

package/src/parser/inline/strong.ts

@@ -5,14 +5,14 @@ import { union, some, recursion, precedence, surround, lazy } from '../../combin
 import { inline } from '../inline';
 import { emphasis } from './emphasis';
 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 strong: StrongParser = 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),
     emphasis,
   ]))))),

package/src/parser/node.ts

@@ -0,0 +1,10 @@
+import { invisibleHTMLEntityNames } from './api/normalize';
+
+export const enum Flag {
+  none,
+  invisible,
+}
+
+export function isinvisibleHTMLEntityName(name: string): boolean {
+  return invisibleHTMLEntityNames.includes(name);
+}

package/src/parser/source/str.ts

@@ -2,21 +2,23 @@ import { StrParser } from '../source';
 import { Parser, List, Node } from '../../combinator/data/parser';
 import { matcher } from '../../combinator';
 
-export function str(pattern: string | RegExp): StrParser;
-export function str(pattern: string | RegExp): Parser<string> {
-  return matcher(pattern, true);
+export function str(pattern: string | RegExp, verify?: (source: string, position: number, range: number) => boolean): StrParser;
+export function str(pattern: string | RegExp, verify?: (source: string, position: number, range: number) => boolean): Parser<string> {
+  return matcher(pattern, true, verify);
 }
 
-export function strs(pattern: string): StrParser;
-export function strs(pattern: string): Parser<string> {
+export function strs(pattern: string, limit?: number): StrParser;
+export function strs(pattern: string, limit: number = -1): Parser<string> {
   assert(pattern);
   return ({ context }) => {
     const { source } = context;
     let acc = '';
-    for (; context.position < source.length && source.startsWith(pattern, context.position);) {
+    for (let i = 0; i !== limit && context.position < source.length && source.startsWith(pattern, context.position); ++i) {
       acc += pattern;
       context.position += pattern.length;
     }
-    return new List([new Node(acc)]);
+    return acc
+      ? new List([new Node(acc)])
+      : undefined;
   };
 }