securemark 0.296.1 → 0.296.3

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;
+    const nodesC = optional || nodesM ? 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.test.ts

@@ -21,9 +21,9 @@ describe('Unit: combinator/data/parser/context', () => {
       const ctx: Ctx = new Context();
       assert.deepStrictEqual([...unwrap(reset(base, parser)(input('123', ctx))!)], [3, 2, 1]);
       assert(base.resources?.clock === 3);
-      assert(ctx.resources?.clock === undefined);
+      assert(ctx.resources?.clock === 0);
       assert.throws(() => reset(base, parser)(input('1234', ctx)));
-      assert(ctx.resources?.clock === undefined);
+      assert(ctx.resources?.clock === 0);
     });
 
     it('node', () => {

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

@@ -1,16 +1,25 @@
-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';
 
 export function reset<P extends Parser>(base: Options, parser: P): P;
 export function reset<N>(base: Context, parser: Parser<N>): Parser<N> {
+  return input => {
+    const { context } = input;
+    // @ts-expect-error
+    context.resources ??= {
+      clock: base.resources?.clock,
+      recursions: base.resources?.recursions.slice(),
+    };
+    context.backtracks = {};
+    return parser(input);
+  };
   assert(Object.getPrototypeOf(base) === Object.prototype);
   assert(Object.freeze(base));
   const changes = Object.entries(base);
   const values = Array(changes.length);
   return ({ context }) =>
-    // 大域離脱時の汚染回避のため複製
-    apply(parser, { ...context }, changes, values, true);
+    apply(parser, context, changes, values, true);
 }
 
 export function context<P extends Parser>(base: Options, parser: P): P;
@@ -158,36 +167,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/bind.ts

@@ -8,7 +8,7 @@ import { headers } from './header';
 import { figure } from '../processor/figure';
 import { note } from '../processor/note';
 import { ReadonlyURL } from 'spica/url';
-import { push, splice } from 'spica/array';
+import { splice } from 'spica/array';
 
 interface Settings extends ParserSettings {
 }
@@ -29,8 +29,8 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
   if (context.host?.origin === 'null') throw new Error(`Invalid host: ${context.host.href}`);
   type Block = readonly [segment: string, blocks: readonly HTMLElement[], url: string];
   const blocks: Block[] = [];
-  const adds: [HTMLElement, Node | null][] = [];
-  const dels: [HTMLElement][] = [];
+  const adds: (readonly [HTMLElement, Node | null])[] = [];
+  const dels: (readonly [HTMLElement])[] = [];
   const bottom = target.firstChild;
   let revision: symbol | undefined;
   return {
@@ -75,7 +75,7 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
     for (; index < sourceSegments.length - last; ++index) {
       assert(rev === revision);
       const seg = sourceSegments[index];
-      const es = block(input(seg, context))
+      const es = block(input(seg, new Context(context)))
         ?.foldl<HTMLElement[]>((acc, { value }) => void acc.push(value) || acc, []) ?? [];
       // @ts-expect-error
       context.header = false;
@@ -83,7 +83,7 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
       if (es.length === 0) continue;
       // All deletion processes always run after all addition processes have done.
       // Therefore any `base` node will never be unavailable by deletions until all the dependent `el` nodes are added.
-      push(adds, es.map(el => [el, base] as const));
+      adds.push(...es.map(el => [el, base] as const));
       adds.reverse();
       for (; adds.length > 0;) {
         assert(rev === revision);
@@ -98,7 +98,7 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
       assert(rev === revision);
       const es = refuse[i][1];
       if (es.length === 0) continue;
-      push(dels, es.map(el => [el]));
+      dels.push(...es.map(el => [el] as const));
     }
     assert(blocks.length === sourceSegments.length);
     adds.reverse();

package/src/parser/api/parse.ts

@@ -34,7 +34,7 @@ export function parse(source: string, options: Options = {}, context?: Context):
   context.header = true;
   for (const seg of segment(source)) {
     node.append(
-      ...block(input(seg, context))
+      ...block(input(seg, new Context(context)))
         ?.foldl<HTMLElement[]>((acc, { value }) => void acc.push(value) || acc, []) ?? []);
     // @ts-expect-error
     context.header = false;

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/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),

package/src/parser/inline/link.ts

@@ -1,7 +1,7 @@
 import { LinkParser } from '../inline';
 import { Context, State, Backtrack, Command } from '../context';
 import { List, Node } from '../../combinator/data/parser';
-import { union, inits, sequence, subsequence, some, consume, precedence, state, constraint, surround, open, setBacktrack, dup, lazy, fmap, bind } from '../../combinator';
+import { union, inits, sequence, subsequence, some, consume, precedence, state, constraint, surround, open, close, setBacktrack, dup, lazy, fmap, bind } from '../../combinator';
 import { inline, media, shortmedia } from '../inline';
 import { attributes } from './html';
 import { str } from '../source';
@@ -18,9 +18,9 @@ Object.setPrototypeOf(optspec, null);
 export const textlink: LinkParser.TextLinkParser = lazy(() => bind(
   subsequence([
     constraint(State.link, state(State.linkers, dup(surround(
-      '[',
+      close('[', beforeNonblank),
       precedence(1,
-      beforeNonblank(some(union([inline]), ']', [[']', 1]]))),
+      some(union([inline]), ']', [[']', 1]])),
       ']',
       true,
       [3 | Backtrack.common | Backtrack.link, 2 | Backtrack.ruby],

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

@@ -44,6 +44,7 @@ describe('Unit: parser/inline/mark', () => {
       assert.deepStrictEqual(inspect(parser, input('==a&Tab;==b====', new Context())), [['<mark id="mark::a_b=33Mw2l">a\t<mark>b</mark></mark>', '<a href="#mark::a_b=33Mw2l"></a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('==a<wbr>==b====', new Context())), [['<mark id="mark::ab">a<wbr><mark>b</mark></mark>', '<a href="#mark::ab"></a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('==*==a==*==', new Context())), [['<mark id="mark::a"><em><mark>a</mark></em></mark>', '<a href="#mark::a"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('====a== b==', new Context())), [['<mark id="mark::a_b"><mark>a</mark> b</mark>', '<a href="#mark::a_b"></a>'], '']);
     });
 
   });

package/src/parser/inline/mark.ts

@@ -9,16 +9,16 @@ 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(
+  precedence(0, recursion(Recursion.inline, repeat('==', beforeNonblank, surround(
     '',
-    beforeNonblank(state(State.mark, some(union([inline]), '==', afterNonblank))),
+    state(State.mark, some(union([inline]), '==', afterNonblank)),
     '==',
     false, [],
     ([, bs], { buffer }) => buffer.import(bs),
     ([, bs], { buffer }) => bs && buffer.import(bs).push(new Node(Command.Cancel)) && buffer),
-    (nodes, { id, state }) => {
+    (nodes, { id, state }, nest) => {
       const el = html('mark', defrag(unwrap(nodes)));
-      if (state & State.linkers) return new List([new Node(el)]);
+      if (state & State.linkers || nest) return new List([new Node(el)]);
       define(el, { id: identity('mark', id, signature(el)) });
       return el.id
         ? new List([new Node(el), new Node(html('a', { href: `#${el.id}` }))])

package/src/parser/inline/reference.ts

@@ -1,7 +1,7 @@
 import { ReferenceParser } from '../inline';
 import { State, Backtrack, Command } from '../context';
 import { List, Node } from '../../combinator/data/parser';
-import { union, subsequence, some, precedence, state, constraint, surround, isBacktrack, setBacktrack, lazy } from '../../combinator';
+import { union, subsequence, some, precedence, state, constraint, surround, open, isBacktrack, setBacktrack, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { textlink } from './link';
 import { str } from '../source';
@@ -10,11 +10,11 @@ import { unwrap, invalid } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const reference: ReferenceParser = lazy(() => constraint(State.reference, surround(
-  str('[['),
+  '[[',
   precedence(1, state(State.annotation | State.reference,
   subsequence([
     abbr,
-    beforeNonblank(some(inline, ']', [[']', 1]])),
+    open(beforeNonblank, some(inline, ']', [[']', 1]])),
   ]))),
   ']]',
   false,

package/src/parser/inline/strong.ts

@@ -5,17 +5,17 @@ import { union, some, recursion, precedence, surround, lazy } from '../../combin
 import { inline } from '../inline';
 import { emphasis } from './emphasis';
 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 strong: StrongParser = 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),
     emphasis,
-  ]))))),
+  ])))),
   str('**'),
   false, [],
   ([, bs]) => new List([new Node(html('strong', defrag(unwrap(bs))))]),

package/src/parser/source/str.ts

@@ -1,10 +1,10 @@
 import { StrParser } from '../source';
 import { Parser, List, Node } from '../../combinator/data/parser';
-import { matcher } from '../../combinator';
+import { matcher, tester } from '../../combinator/data/delimiter';
 
-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 str(pattern: string | RegExp, after?: string | RegExp): StrParser;
+export function str(pattern: string | RegExp, after?: string | RegExp): Parser<string> {
+  return matcher(pattern, true, after ? tester(after, false) : undefined);
 }
 
 export function strs(pattern: string, limit?: number): StrParser;