securemark 0.296.0 → 0.296.2

package/package.json

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

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

@@ -1,5 +1,5 @@
 import { Parser, failsafe } from '../../data/parser';
-import { isBlankline } from './line';
+import { isEmptyline } from './line';
 
 export function block<P extends Parser>(parser: P, separation?: boolean): P;
 export function block<N>(parser: Parser<N>, separation = true): Parser<N> {
@@ -10,7 +10,7 @@ export function block<N>(parser: Parser<N>, separation = true): Parser<N> {
     if (position === source.length) return;
     const result = parser(input);
     if (result === undefined) return;
-    if (separation && !isBlankline(source, context.position)) return;
+    if (separation && !isEmptyline(source, context.position)) return;
     assert(context.position === source.length || source[context.position - 1] === '\n');
     return context.position === source.length || source[context.position - 1] === '\n'
       ? result

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

@@ -1,5 +1,6 @@
 import { Parser, Input, List, Node, Context } from '../../data/parser';
-import { matcher, bind } from '../../../combinator';
+import { tester } from '../../data/delimiter';
+import { bind } from '../monad/bind';
 
 //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> {
@@ -10,8 +11,8 @@ export function validate<P extends Parser>(pattern: string | RegExp, parser: P):
 export function validate<P extends Parser>(cond: ((input: Input<Parser.Context<P>>) => boolean), parser: P): 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 => match(input) ? parser(input) : undefined;
+  const test = tester(pattern, false);
+  return input => test(input) && parser(input);
 }
 
 function guard<P extends Parser>(f: (input: Input<Parser.Context<P>>) => boolean, parser: P): P;

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

@@ -14,7 +14,7 @@ export function line<N>(parser: Parser<N>): Parser<N> {
     context.source = source;
     context.offset -= position;
     if (result === undefined) return;
-    if (context.position < position + line.length && !isBlankline(source, context.position)) return;
+    if (context.position < position + line.length && !isEmptyline(source, context.position)) return;
     context.position = position + line.length;
     return result;
   });
@@ -27,10 +27,10 @@ export function firstline(source: string, position: number): string {
     : source.slice(position, i + 1);
 }
 
-const blankline = /[^\S\n]*(?:$|\n)/y;
-export function isBlankline(source: string, position: number): boolean {
-  blankline.lastIndex = position;
+const emptyline = /[^\S\n]*(?:$|\n)/y;
+export function isEmptyline(source: string, position: number): boolean {
+  emptyline.lastIndex = position;
   return source.length === position
       || source[position] === '\n'
-      || blankline.test(source);
+      || emptyline.test(source);
 }

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

@@ -1,6 +1,6 @@
 import { Parser, List, Node, Context, failsafe } from '../../data/parser';
 import { consume } from '../../../combinator';
-import { firstline, isBlankline } from '../constraint/line';
+import { firstline, isEmptyline } from '../constraint/line';
 import { push } from 'spica/array';
 
 export function fence<C extends Context, D extends Parser<unknown, C>[]>(opener: RegExp, limit: number, separation = true): Parser<string, C, D> {
@@ -20,20 +20,20 @@ export function fence<C extends Context, D extends Parser<unknown, C>[]>(opener:
     context.position += matches[0].length;
     // Prevent annoying parsing in editing.
     const secondline = firstline(source, context.position);
-    if (isBlankline(secondline, 0) && firstline(source, context.position + secondline.length).trimEnd() !== delim) return;
+    if (isEmptyline(secondline, 0) && firstline(source, context.position + secondline.length).trimEnd() !== delim) return;
     let block = '';
     let closer = '';
     let overflow = '';
     for (let count = 1; ; ++count) {
       if (context.position === source.length) break;
       const line = firstline(source, context.position);
-      if ((closer || count > limit + 1) && isBlankline(line, 0)) break;
+      if ((closer || count > limit + 1) && isEmptyline(line, 0)) break;
       if(closer) {
         overflow += line;
       }
       if (!closer && count <= limit + 1 && line.slice(0, delim.length) === delim && line.trimEnd() === delim) {
         closer = line;
-        if (isBlankline(source, context.position + line.length)) {
+        if (isEmptyline(source, context.position + line.length)) {
           context.position += line.length;
           break;
         }

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

@@ -1,5 +1,5 @@
 import { Parser, input, failsafe } from '../../data/parser';
-import { matcher } from '../../../combinator';
+import { matcher } from '../../data/delimiter';
 
 export function focus<P extends Parser>(scope: string | RegExp, parser: P, slice?: boolean): P;
 export function focus<N>(scope: string | RegExp, parser: Parser<N>, slice = true): Parser<N> {

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

@@ -1,50 +1,64 @@
 import { Parser, Result, List, Node, Context, failsafe } from '../../data/parser';
-import { matcher, clear } from '../../../combinator';
+import { tester } from '../../data/delimiter';
 
 export function surround<P extends Parser, S = string>(
-  opener: string | RegExp | Parser<S, Parser.Context<P>>, parser: Parser.IntermediateParser<P>, closer: string | RegExp | Parser<S, Parser.Context<P>>,
+  opener: string | RegExp | Parser<S, Parser.Context<P>>,
+  parser: Parser.IntermediateParser<P>,
+  closer: string | RegExp | Parser<S, Parser.Context<P>>,
   optional?: false,
   backtracks?: readonly number[],
   f?: (rss: [List<Node<S>>, List<Node<Parser.SubNode<P>>>, List<Node<S>>], context: Parser.Context<P>) => Result<Parser.Node<P>, Parser.Context<P>, Parser.SubParsers<P>>,
   g?: (rss: [List<Node<S>>, List<Node<Parser.SubNode<P>>> | undefined], context: Parser.Context<P>) => Result<Parser.Node<P>, Parser.Context<P>, Parser.SubParsers<P>>,
 ): P;
 export function surround<P extends Parser, S = string>(
-  opener: string | RegExp | Parser<S, Parser.Context<P>>, parser: Parser.IntermediateParser<P>, closer: string | RegExp | Parser<S, Parser.Context<P>>,
+  opener: string | RegExp | Parser<S, Parser.Context<P>>,
+  parser: Parser.IntermediateParser<P>,
+  closer: string | RegExp | Parser<S, Parser.Context<P>>,
   optional?: boolean,
   backtracks?: readonly number[],
   f?: (rss: [List<Node<S>>, List<Node<Parser.SubNode<P>>> | undefined, List<Node<S>>], context: Parser.Context<P>) => Result<Parser.Node<P>, Parser.Context<P>, Parser.SubParsers<P>>,
   g?: (rss: [List<Node<S>>, List<Node<Parser.SubNode<P>>> | undefined], context: Parser.Context<P>) => Result<Parser.Node<P>, Parser.Context<P>, Parser.SubParsers<P>>,
 ): P;
 export function surround<P extends Parser, S = string>(
-  opener: string | RegExp | Parser<S, Parser.Context<P>>, parser: P, closer: string | RegExp | Parser<S, Parser.Context<P>>,
+  opener: string | RegExp | Parser<S, Parser.Context<P>>,
+  parser: P,
+  closer: string | RegExp | Parser<S, Parser.Context<P>>,
   optional?: false,
   backtracks?: readonly number[],
   f?: (rss: [List<Node<S>>, List<Node<Parser.Node<P>>>, List<Node<S>>], context: Parser.Context<P>) => Result<Parser.Node<P>, Parser.Context<P>, Parser.SubParsers<P>>,
   g?: (rss: [List<Node<S>>, List<Node<Parser.Node<P>>> | undefined], context: Parser.Context<P>) => Result<Parser.Node<P>, Parser.Context<P>, Parser.SubParsers<P>>,
 ): P;
 export function surround<P extends Parser, S = string>(
-  opener: string | RegExp | Parser<S, Parser.Context<P>>, parser: P, closer: string | RegExp | Parser<S, Parser.Context<P>>,
+  opener: string | RegExp | Parser<S, Parser.Context<P>>,
+  parser: P,
+  closer: string | RegExp | Parser<S, Parser.Context<P>>,
   optional?: boolean,
   backtracks?: readonly number[],
   f?: (rss: [List<Node<S>>, List<Node<Parser.Node<P>>> | undefined, List<Node<S>>], context: Parser.Context<P>) => Result<Parser.Node<P>, Parser.Context<P>, Parser.SubParsers<P>>,
   g?: (rss: [List<Node<S>>, List<Node<Parser.Node<P>>> | undefined], context: Parser.Context<P>) => Result<Parser.Node<P>, Parser.Context<P>, Parser.SubParsers<P>>,
 ): P;
 export function surround<P extends Parser<string>, S = string>(
-  opener: string | RegExp | Parser<S, Parser.Context<P>>, parser: string | RegExp | P, closer: string | RegExp | Parser<S, Parser.Context<P>>,
+  opener: string | RegExp | Parser<S, Parser.Context<P>>,
+  parser: string | RegExp | P,
+  closer: string | RegExp | Parser<S, Parser.Context<P>>,
   optional?: false,
   backtracks?: readonly number[],
   f?: (rss: [List<Node<S>>, List<Node<Parser.Node<P>>>, List<Node<S>>], context: Parser.Context<P>) => Result<Parser.Node<P>, Parser.Context<P>, Parser.SubParsers<P>>,
   g?: (rss: [List<Node<S>>, List<Node<Parser.Node<P>>> | undefined], context: Parser.Context<P>) => Result<Parser.Node<P>, Parser.Context<P>, Parser.SubParsers<P>>,
 ): P;
 export function surround<P extends Parser<string>, S = string>(
-  opener: string | RegExp | Parser<S, Parser.Context<P>>, parser: string | RegExp | P, closer: string | RegExp | Parser<S, Parser.Context<P>>,
+  opener: string | RegExp | Parser<S, Parser.Context<P>>,
+  parser: string | RegExp | P,
+  closer: string | RegExp | Parser<S, Parser.Context<P>>,
   optional?: boolean,
   backtracks?: readonly number[],
   f?: (rss: [List<Node<S>>, List<Node<Parser.Node<P>>> | undefined, List<Node<S>>], context: Parser.Context<P>) => Result<Parser.Node<P>, Parser.Context<P>, Parser.SubParsers<P>>,
   g?: (rss: [List<Node<S>>, List<Node<Parser.Node<P>>> | undefined], context: Parser.Context<P>) => Result<Parser.Node<P>, Parser.Context<P>, Parser.SubParsers<P>>,
 ): P;
 export function surround<N>(
-  opener: string | RegExp | Parser<N>, parser: string | RegExp | Parser<N>, closer: string | RegExp | Parser<N>,
+  opener: string | RegExp | Parser<N>,
+  parser: string | RegExp | Parser<N>,
+  closer: string | RegExp | Parser<N>,
   optional: boolean = false,
   backtracks: readonly number[] = [],
   f?: (rss: [List<Node<N>>, List<Node<N>>, List<Node<N>>], context: Context) => Result<N>,
@@ -53,19 +67,19 @@ export function surround<N>(
   switch (typeof opener) {
     case 'string':
     case 'object':
-      opener = clear(matcher(opener, true));
+      opener = tester(opener, true);
   }
   assert(opener);
   switch (typeof parser) {
     case 'string':
     case 'object':
-      parser = clear(matcher(parser, true));
+      parser = tester(parser, true);
   }
   assert(parser);
   switch (typeof closer) {
     case 'string':
     case 'object':
-      closer = clear(matcher(closer, true));
+      closer = tester(closer, true);
   }
   assert(closer);
   const [blen, rbs, wbs] = reduce(backtracks);
@@ -76,7 +90,7 @@ export function surround<N>(
     const { linebreak } = context;
     context.linebreak = 0;
     const nodesO = opener(input);
-    if (!nodesO) {
+    if (nodesO === undefined) {
       return void revert(context, linebreak);
     }
     if (rbs && isBacktrack(context, rbs, position, blen)) {
@@ -84,14 +98,14 @@ export function surround<N>(
     }
     const nodesM = context.position < source.length ? parser(input) : undefined;
     context.range = context.position - position;
-    if (!nodesM && !optional) {
+    if (nodesM === undefined && !optional) {
       wbs && setBacktrack(context, wbs, position);
       const result = g?.([nodesO, nodesM], context);
       return result || void revert(context, linebreak);
     }
     const nodesC = nodesM || optional ? closer(input) : undefined;
     context.range = context.position - position;
-    if (!nodesC) {
+    if (nodesC === undefined) {
       wbs && setBacktrack(context, wbs, position);
       const result = g?.([nodesO, nodesM], context);
       return result || void revert(context, linebreak);
@@ -102,7 +116,9 @@ export function surround<N>(
     context.range = context.position - position;
     const result = f
       ? f([nodesO, nodesM!, nodesC], context)
-      : nodesO.import(nodesM ?? new List()).import(nodesC);
+      : nodesM
+        ? nodesO.import(nodesM).import(nodesC)
+        : nodesO.import(nodesC);
     if (result) {
       context.linebreak ||= linebreak;
     }

package/src/combinator/data/delimiter.ts

@@ -1,5 +1,5 @@
-import { Input, Context } from './parser';
-import { matcher } from '../../combinator';
+import { Parser, Input, List, Node, Context } from './parser';
+import { consume } from './parser/context';
 
 interface Delimiter {
   readonly memory: Delimiter[];
@@ -33,11 +33,11 @@ export class Delimiters {
         return () => undefined;
       case 'string':
       case 'object':
-        const match = matcher(pattern, false);
-        const verify = after ? matcher(after, false) : undefined;
+        const test = tester(pattern, false);
+        const verify = after ? tester(after, false) : undefined;
         return verify
-          ? input => match(input) !== undefined && verify(input) !== undefined || undefined
-          : input => match(input) !== undefined || undefined;
+          ? input => test(input) !== undefined && verify(input) !== undefined || undefined
+          : input => test(input) !== undefined || undefined;
     }
   }
   private readonly tree: Record<number, Delimiter[]> = {};
@@ -150,3 +150,79 @@ export class Delimiters {
     return false;
   }
 }
+
+export function matcher(pattern: string | RegExp, advance: boolean, after?: Parser<string>): Parser<string> {
+  assert(pattern instanceof RegExp ? !pattern.flags.match(/[gm]/) && pattern.sticky && !pattern.source.startsWith('^') : true);
+  const count = typeof pattern === 'object'
+    ? /[^^\\*+][*+]/.test(pattern.source)
+    : false;
+  switch (typeof pattern) {
+    case 'string':
+      if (pattern === '') return () => new List([new Node(pattern)]);
+      return input => {
+        const { context } = input;
+        const { source, position } = context;
+        if (!source.startsWith(pattern, position)) return;
+        if (advance) {
+          context.position += pattern.length;
+        }
+        const next = after?.(input);
+        return after
+          ? next && new List([new Node(pattern)]).import(next)
+          : new List([new Node(pattern)]);
+      };
+    case 'object':
+      assert(pattern.sticky);
+      return input => {
+        const { context } = input;
+        const { source, position } = context;
+        pattern.lastIndex = position;
+        if (!pattern.test(source)) return;
+        const src = source.slice(position, pattern.lastIndex);
+        count && consume(src.length, context);
+        if (advance) {
+          context.position += src.length;
+        }
+        const next = after?.(input);
+        return after
+          ? next && new List([new Node(src)]).import(next)
+          : new List([new Node(src)]);
+      };
+  }
+}
+
+export function tester(pattern: string | RegExp, advance: boolean, after?: Parser<unknown>): Parser<never> {
+  assert(pattern instanceof RegExp ? !pattern.flags.match(/[gm]/) && pattern.sticky && !pattern.source.startsWith('^') : true);
+  const count = typeof pattern === 'object'
+    ? /[^^\\*+][*+]/.test(pattern.source)
+    : false;
+  switch (typeof pattern) {
+    case 'string':
+      if (pattern === '') return () => new List();
+      return input => {
+        const { context } = input;
+        const { source, position } = context;
+        if (!source.startsWith(pattern, position)) return;
+        if (advance) {
+          context.position += pattern.length;
+        }
+        if (after && after(input) === undefined) return;
+        return new List();
+      };
+    case 'object':
+      assert(pattern.sticky);
+      return input => {
+        const { context } = input;
+        const { source, position } = context;
+        pattern.lastIndex = position;
+        if (!pattern.test(source)) return;
+        const len = pattern.lastIndex - position;
+        count && consume(len, context);
+        if (advance) {
+          context.position += len;
+        }
+        if (after && after(input) === undefined) return;
+        return new List();
+      };
+  }
+}

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

@@ -1,4 +1,4 @@
-import { Parser, Result, List, Node, Context, Options } from '../../data/parser';
+import { Parser, Result, Context, Options } from '../../data/parser';
 import { min } from 'spica/alias';
 import { clone } from 'spica/assign';
 
@@ -158,36 +158,3 @@ export function constraint<N>(state: number, positive: boolean | Parser<N>, pars
       : undefined;
   };
 }
-
-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)
-    : false;
-  switch (typeof pattern) {
-    case 'string':
-      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;
-        }
-        return new List([new Node(pattern)]);
-      };
-    case 'object':
-      assert(pattern.sticky);
-      return ({ context }) => {
-        const { source, position } = context;
-        pattern.lastIndex = position;
-        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;
-        }
-        return new List([new Node(src)]);
-      };
-  }
-}

package/src/parser/api/normalize.ts

@@ -24,7 +24,7 @@ function sanitize(source: string): string {
 
 // https://dev.w3.org/html5/html-author/charref
 // https://en.wikipedia.org/wiki/Whitespace_character
-export const invisibleHTMLEntityNames = [
+const invisibleHTMLEntityNames = [
   'Tab',
   'NewLine',
   'NonBreakingSpace',
@@ -63,6 +63,10 @@ const parser = (el => (entity: string): string => {
   el.innerHTML = entity;
   return el.textContent!;
 })(html('span'));
+export const invisibleBlankHTMLEntityNames: readonly string[] = invisibleHTMLEntityNames
+  .filter(name => parser(`&${name};`).trimStart() === '');
+export const invisibleGraphHTMLEntityNames: readonly string[] = invisibleHTMLEntityNames
+  .filter(name => parser(`&${name};`).trimStart() !== '');
 const unreadableEscapeHTMLEntityNames = invisibleHTMLEntityNames.filter(name => ![
   'Tab',
   'NewLine',

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

@@ -34,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'), Flag.invisible),
+      new Node(html('br'), Flag.blank),
     ]);
   }));

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

@@ -22,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'), Flag.invisible),
+    new Node(source[position - 1] === '\n' ? ns.pop()!.value as HTMLBRElement : html('br'), Flag.blank),
     new Node(html('span', { class: 'quote' }, defrag(unwrap(ns)))),
   ].reverse())),
   false));

package/src/parser/block/reply.ts

@@ -21,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'), Flag.invisible)) && ns)))
+          : ns.push(new Node(html('br'), Flag.blank)) && ns)))
   ])),
   ns => new List([new Node(html('p', defrag(unwrap(trimBlankNodeEnd(ns)))))]))));

package/src/parser/inline/annotation.ts

@@ -1,16 +1,16 @@
 import { AnnotationParser } from '../inline';
 import { State, Backtrack } from '../context';
 import { List, Node } from '../../combinator/data/parser';
-import { union, some, precedence, state, constraint, surround, setBacktrack, lazy } from '../../combinator';
+import { union, some, precedence, state, constraint, surround, close, setBacktrack, lazy } from '../../combinator';
 import { inline } from '../inline';
 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(
-  '((',
+  close('((', beforeNonblank),
   precedence(1, state(State.annotation,
-  beforeNonblank(some(union([inline]), ')', [[')', 1]])))),
+  some(union([inline]), ')', [[')', 1]]))),
   '))',
   false,
   [2, 1 | Backtrack.common, 3 | Backtrack.doublebracket],

package/src/parser/inline/deletion.ts

@@ -8,7 +8,7 @@ import { unwrap, repeat } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const deletion: DeletionParser = lazy(() =>
-  precedence(0, recursion(Recursion.inline, repeat('~~', surround(
+  precedence(0, recursion(Recursion.inline, repeat('~~', '', surround(
     '',
     some(union([
       some(inline, blankWith('\n', '~~')),

package/src/parser/inline/emphasis.ts

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

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

@@ -114,6 +114,7 @@ describe('Unit: parser/inline/emstrong', () => {
       assert.deepStrictEqual(inspect(parser, input('******a*b ***', new Context())), [['*****', '<em>a</em>', 'b ', '***'], '']);
       assert.deepStrictEqual(inspect(parser, input('******a*b ****', new Context())), [['*****', '<em>a</em>', 'b ', '****'], '']);
       assert.deepStrictEqual(inspect(parser, input('******a*b *****', new Context())), [['*****', '<em>a</em>', 'b ', '*****'], '']);
+      assert.deepStrictEqual(inspect(parser, input('******a*** b***', new Context())), [['<em><strong><em><strong>a</strong></em> b</strong></em>'], '']);
     });
 
   });

package/src/parser/inline/emstrong.ts

@@ -23,9 +23,9 @@ const subemphasis: Parser.IntermediateParser<EmphasisParser> = lazy(() => some(u
 // 可能な限り早く閉じるよう解析しなければならない。
 // このため終端記号の後ろを見て終端を中止し同じ構文を再帰的に適用してはならない。
 export const emstrong: EmStrongParser = lazy(() =>
-  precedence(0, recursion(Recursion.inline, repeat('***', surround(
+  precedence(0, recursion(Recursion.inline, repeat('***', beforeNonblank, surround(
     '',
-    beforeNonblank(some(union([some(inline, '*', afterNonblank)]))),
+    some(union([some(inline, '*', afterNonblank)])),
     strs('*', 3),
     false, [],
     ([, bs, cs], context): Result<Parser.Node<EmStrongParser>, Parser.Context<EmStrongParser>> => {
@@ -33,7 +33,7 @@ export const emstrong: EmStrongParser = lazy(() =>
       const { buffer } = context;
       switch (cs.head!.value) {
         case '***':
-          return bs;
+          return buffer.import(bs);
         case '**':
           return bind<EmphasisParser>(
             subemphasis,

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

@@ -13,13 +13,12 @@ import { html, define, defrag } from 'typed-dom/dom';
 import IndexParser = ExtensionParser.IndexParser;
 
 export const index: IndexParser = lazy(() => constraint(State.index, fmap(indexee(surround(
-  str('[#'),
+  str('[#', beforeNonblank),
   precedence(1, state(State.linkers,
-  beforeNonblank(
   some(inits([
     inline,
     signature,
-  ]), ']', [[']', 1]])))),
+  ]), ']', [[']', 1]]))),
   str(']'),
   false,
   [3 | Backtrack.common],

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

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

package/src/parser/inline/html.ts

@@ -5,7 +5,7 @@ import { Flag } from '../node';
 import { union, some, recursion, precedence, validate, surround, open, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { isLooseNodeStart, blankWith } from '../visibility';
+import { isNonblankFirstLine, blankWith } from '../visibility';
 import { invalid, unwrap } from '../util';
 import { memoize } from 'spica/memoize';
 import { html as h, defrag } from 'typed-dom/dom';
@@ -29,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), as.head!.value === '<wbr' ? Flag.invisible : Flag.none)]),
+        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.blank : 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(
@@ -85,7 +85,7 @@ function elem(tag: string, content: boolean, as: readonly string[], bs: List<Nod
   if (content) {
     if (cs.length === 0) return ielem('tag', `Missing the closing HTML tag "</${tag}>"`, context);
     if (bs.length === 0) return ielem('content', `Missing the content`, context);
-    if (!isLooseNodeStart(bs)) return ielem('content', `Missing the visible content in the same line`, context);
+    if (!isNonblankFirstLine(bs)) return ielem('content', `Missing the visible content in the same line`, context);
   }
   const [attrs] = attributes('html', attrspecs[tag], as.slice(1, as.at(-1) === '>' ? -1 : as.length));
   if (/(?<!\S)invalid(?!\S)/.test(attrs['class'] ?? '')) return ielem('attribute', 'Invalid HTML attribute', context)

package/src/parser/inline/htmlentity.ts

@@ -1,7 +1,7 @@
 import { HTMLEntityParser, UnsafeHTMLEntityParser } from '../inline';
 import { Backtrack } from '../context';
 import { List, Node } from '../../combinator/data/parser';
-import { Flag, isInvisibleHTMLEntityName } from '../node';
+import { Flag, isBlankHTMLEntityName } from '../node';
 import { union, surround, fmap } from '../../combinator';
 import { str } from '../source';
 import { invalid } from '../util';
@@ -15,7 +15,7 @@ export const unsafehtmlentity: UnsafeHTMLEntityParser = surround(
     new List([
       new Node(
         parser(as.head!.value + bs.head!.value + cs.head!.value),
-        isInvisibleHTMLEntityName(bs.head!.value) ? Flag.invisible : Flag.none)
+        isBlankHTMLEntityName(bs.head!.value) ? Flag.blank : Flag.none)
     ]),
   ([as, bs]) =>
     new List([new Node(as.head!.value + (bs?.head?.value ?? ''))]));

package/src/parser/inline/insertion.ts

@@ -8,7 +8,7 @@ import { unwrap, repeat } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const insertion: InsertionParser = lazy(() =>
-  precedence(0, recursion(Recursion.inline, repeat('++', surround(
+  precedence(0, recursion(Recursion.inline, repeat('++', '', surround(
     '',
     some(union([
       some(inline, blankWith('\n', '++')),

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

@@ -57,6 +57,7 @@ describe('Unit: parser/inline/italic', () => {
       assert.deepStrictEqual(inspect(parser, input('//////a/////b', new Context())), [['///', '<i>a</i>', '//b'], '']);
       assert.deepStrictEqual(inspect(parser, input('//////a//////', new Context())), [['<i><i>a</i></i>'], '']);
       assert.deepStrictEqual(inspect(parser, input('//////a///b///', new Context())), [['<i><i>a</i>b</i>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('//////a/// b///', new Context())), [['<i><i>a</i> b</i>'], '']);
       assert.deepStrictEqual(inspect(parser, input('///a ///b//////', new Context())), [['<i>a <i>b</i></i>'], '']);
       assert.deepStrictEqual(inspect(parser, input('///- ///b//////', new Context())), [['<i>- <i>b</i></i>'], '']);
       assert.deepStrictEqual(inspect(parser, input('///a\\ ///b//////', new Context())), [['<i>a <i>b</i></i>'], '']);

package/src/parser/inline/italic.ts

@@ -11,9 +11,9 @@ import { html, defrag } from 'typed-dom/dom';
 // 斜体は単語に使うとかえって見づらく読み飛ばしやすくなるため使わないべきであり
 // ある程度の長さのある文に使うのが望ましい。
 export const italic: ItalicParser = lazy(() =>
-  precedence(0, recursion(Recursion.inline, repeat('///', surround(
+  precedence(0, recursion(Recursion.inline, repeat('///', beforeNonblank, surround(
     '',
-    beforeNonblank(some(union([inline]), '///', afterNonblank)),
+    some(union([inline]), '///', afterNonblank),
     '///',
     false, [],
     ([, bs], { buffer }) => buffer.import(bs),