securemark 0.295.4 → 0.295.6

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

@@ -4,12 +4,25 @@ import { Delimiters } from '../delimiter';
 type DelimiterOption = readonly [delimiter: string | RegExp, precedence: number];
 
 export function some<P extends Parser>(parser: P, limit?: number): P;
-export function some<P extends Parser>(parser: P, end?: string | RegExp, delimiters?: readonly DelimiterOption[], limit?: number): P;
-export function some<N>(parser: Parser<N>, end?: string | RegExp | number, delimiters: readonly DelimiterOption[] = [], limit = -1): Parser<N> {
-  if (typeof end === 'number') return some(parser, undefined, delimiters, end);
+export function some<P extends Parser>(parser: P, delimiters?: readonly DelimiterOption[]): P;
+export function some<P extends Parser>(parser: P, delimiter: string | RegExp, delimiters?: readonly DelimiterOption[]): P;
+export function some<P extends Parser>(parser: P, delimiter: string | RegExp, after: string | RegExp, delimiters?: readonly DelimiterOption[]): P;
+export function some<N>(parser: Parser<N>, delimiter?: number | string | RegExp | readonly DelimiterOption[], after?: string | RegExp | readonly DelimiterOption[], delimiters?: readonly DelimiterOption[], limit = -1): Parser<N> {
+  if (typeof delimiter === 'number') {
+    limit = delimiter;
+    delimiter = undefined;
+  }
+  else if (Array.isArray(delimiter)) {
+    delimiters = delimiter;
+    delimiter = undefined;
+  }
+  else if (after === undefined || Array.isArray(after)) {
+    delimiters = after;
+    after = undefined;
+  }
   assert(parser);
-  const match = Delimiters.matcher(end);
-  const delims = delimiters.map(([delimiter, precedence]) => ({
+  const match = Delimiters.matcher(delimiter as string, after as string);
+  const delims = delimiters?.map(([delimiter, precedence]) => ({
     signature: Delimiters.signature(delimiter),
     matcher: Delimiters.matcher(delimiter),
     precedence,
@@ -19,9 +32,7 @@ export function some<N>(parser: Parser<N>, end?: string | RegExp | number, delim
     const { source, position } = context;
     //assert(context.backtracks ??= {});
     let nodes: List<Node<N>> | undefined;
-    if (delims.length > 0) {
-      context.delimiters.push(delims);
-    }
+    delims && context.delimiters.push(delims);
     // whileは数倍遅い
     for (const len = source.length; context.position < len;) {
       if (match(input)) break;
@@ -31,9 +42,7 @@ export function some<N>(parser: Parser<N>, end?: string | RegExp | number, delim
       nodes = nodes?.import(result) ?? result;
       if (limit >= 0 && context.position - position > limit) break;
     }
-    if (delims.length > 0) {
-      context.delimiters.pop(delims.length);
-    }
+    delims && context.delimiters.pop(delims.length);
     assert(context.position >= position);
     return context.position > position
       ? nodes

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

@@ -30,7 +30,7 @@ describe('Unit: parser/api/bind', () => {
     const cfgs = { notes: { references: html('ol') } };
 
     it('huge input', () => {
-      const iter = bind(html('div'), { ...cfgs, id: '' }).parse(`${'\n'.repeat(10 * 1000 ** 2)}`);
+      const iter = bind(html('div'), { ...cfgs, id: '' }).parse(`${'\n'.repeat(1e6 + 1)}`);
       assert.deepStrictEqual(
         inspect(iter),
         [
@@ -42,7 +42,7 @@ describe('Unit: parser/api/bind', () => {
     it('huge segment', function () {
       this.timeout(10 * 1000);
 
-      const iter = bind(html('div'), { ...cfgs, id: '' }).parse(`${'\n'.repeat(1000 ** 2 - 1)}`);
+      const iter = bind(html('div'), { ...cfgs, id: '' }).parse(`${'\n'.repeat(1e5 + 1)}`);
       assert.deepStrictEqual(
         inspect(iter, 3),
         [

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

@@ -6,7 +6,7 @@ describe('Unit: parser/api/parse', () => {
   describe('parse', () => {
     it('huge input', () => {
       assert.deepStrictEqual(
-        [...parse(`${'\n'.repeat(10 * 1000 ** 2)}`, { id: '' }).children].map(el => el.outerHTML),
+        [...parse(`${'\n'.repeat(1e6 + 1)}`, { id: '' }).children].map(el => el.outerHTML),
         [
           '<h1 class="error">Error: Too large input over 1,000,000 bytes.</h1>',
           `<pre class="error" translate="no">${'\n'.repeat(997)}...</pre>`,
@@ -15,7 +15,7 @@ describe('Unit: parser/api/parse', () => {
 
     it('huge segment', () => {
       assert.deepStrictEqual(
-        [...parse(`${'\n'.repeat(100 * 1000 + 1)}`, { id: '' }).children].map(el => el.outerHTML),
+        [...parse(`${'\n'.repeat(1e5 + 1)}`, { id: '' }).children].map(el => el.outerHTML),
         [
           '<h1 class="error">Error: Too large segment over 100,000 bytes.</h1>',
           `<pre class="error" translate="no">${'\n'.repeat(997)}...</pre>`,
@@ -360,22 +360,32 @@ describe('Unit: parser/api/parse', () => {
         ]);
     });
 
-    it('backtrack', function () {
-      this.timeout(5000);
+    it('backtrack 1', () => {
       // 最悪計算量での実行速度はCommonMarkの公式JS実装の32nに対して50-400%程度。
       // 6n = annotation + reference + link + url/math + ruby + text
-      const source = `((([[[[#$[${'.'.repeat(16664)}]]]`;
       assert.deepStrictEqual(
-        [...parse(source, {}, new Context({ resources: { clock: 100000, recursions: [100] } })).children]
+        [...parse(`((([[[[#$[${'.'.repeat(16665)}`, {}, new Context({ resources: { clock: 100000, recursions: [100] } })).children]
+          .map(el => el.tagName),
+        ['P']);
+    });
+
+    it('backtrack 1 error', () => {
+      assert.deepStrictEqual(
+        [...parse(`((([[[[#$[${'.'.repeat(16665 + 1)}`, {}, new Context({ resources: { clock: 100000, recursions: [100] } })).children]
+          .map(el => el.tagName),
+        ['H1', 'PRE']);
+    });
+
+    it('backtrack 2', () => {
+      assert.deepStrictEqual(
+        [...parse(`((([[[[#$[${'.'.repeat(16664)}]]]`, {}, new Context({ resources: { clock: 100000, recursions: [100] } })).children]
           .map(el => el.tagName),
         ['P', 'OL']);
     });
 
-    it('backtrack error', function () {
-      this.timeout(5000);
-      const source = `((([[[[#$[${'.'.repeat(16664 + 1)}]]]`;
+    it('backtrack 2 error', () => {
       assert.deepStrictEqual(
-        [...parse(source, {}, new Context({ resources: { clock: 100000, recursions: [100] } })).children]
+        [...parse(`((([[[[#$[${'.'.repeat(16664 + 1)}]]]`, {}, new Context({ resources: { clock: 100000, recursions: [100] } })).children]
           .map(el => el.tagName),
         ['H1', 'PRE']);
     });

package/src/parser/block/blockquote.ts

@@ -22,7 +22,7 @@ const indent = block(open(opener, some(contentline, />(?:$|[ \n])/y)), false);
 const unindent = (source: string) => source.replace(/(?<=^|\n)>(?: |(?=>*(?:$|[ \n])))|\n$/g, '');
 
 const source: BlockquoteParser.SourceParser = lazy(() => fmap(
-  some(recursion(Recursion.blockquote, union([
+  recursion(Recursion.blockquote, some(union([
     rewrite(
       indent,
       convert(unindent, source, true)),
@@ -33,7 +33,7 @@ const source: BlockquoteParser.SourceParser = lazy(() => fmap(
   ns => new List([new Node(html('blockquote', unwrap(ns)))])));
 
 const markdown: BlockquoteParser.MarkdownParser = lazy(() => fmap(
-  some(recursion(Recursion.blockquote, union([
+  recursion(Recursion.blockquote, some(union([
     rewrite(
       indent,
       convert(unindent, markdown, true)),

package/src/parser/block/ilist.ts

@@ -17,7 +17,7 @@ export const ilist: IListParser = lazy(() => block(validate(
 
 export const ilist_: IListParser = lazy(() => block(fmap(validate(
   /[-+*](?:$|[ \n])/y,
-  some(recursion(Recursion.listitem, union([
+  recursion(Recursion.listitem, some(union([
     fmap(fallback(
       inits([
         line(open(/[-+*](?:$|[ \n])/y, visualize(trimBlank(some(inline))), true)),

package/src/parser/block/olist.ts

@@ -32,7 +32,7 @@ export const olist_: OListParser = lazy(() => block(union([
 ])));
 
 const list = (type: string, form: string): OListParser.ListParser => fmap(
-  some(recursion(Recursion.listitem, union([
+  recursion(Recursion.listitem, some(union([
     indexee(fmap(fallback(
       inits([
         line(open(heads[form], subsequence([

package/src/parser/block/sidefence.ts

@@ -21,7 +21,7 @@ const opener = /(?=\|\|+(?:$|[ \n]))/y;
 const unindent = (source: string) => source.replace(/(?<=^|\n)\|(?: |(?=\|*(?:$|[ \n])))|\n$/g, '');
 
 const source: SidefenceParser.SourceParser = lazy(() => fmap(
-  some(recursion(Recursion.block, union([
+  recursion(Recursion.block, some(union([
     focus(
       /(?:\|\|+(?=$|[ \n])[^\n]*(?:$|\n))+/y,
       convert(unindent, source, true)),

package/src/parser/block/ulist.ts

@@ -15,7 +15,7 @@ export const ulist: UListParser = lazy(() => block(validate(
 
 export const ulist_: UListParser = lazy(() => block(fmap(validate(
   /-(?=$|[ \n])/y,
-  some(recursion(Recursion.listitem, union([
+  recursion(Recursion.listitem, some(union([
     indexee(fmap(fallback(
       inits([
         line(open(/-(?:$|[ \n])/y, subsequence([

package/src/parser/inline/autolink/url.ts

@@ -12,7 +12,7 @@ export const url: AutolinkParser.UrlParser = lazy(() => rewrite(
     precedence(0, some(union([
       some(unescsource, /(?<![-+*=~^_,.;:!?]|\/{3})(?:[-+*=~^_,.;:!?]|\/{3,}(?!\/))*(?=[\\$"`\[\](){}<>（）［］｛｝|]|[^\x21-\x7E]|$)/y),
       precedence(1, verify(bracket, ns => ns.length > 0)),
-    ]), undefined, [[/[^\x21-\x7E]|\$/y, 9]])),
+    ]), [[/[^\x21-\x7E]|\$/y, 9]])),
     false,
     [3 | Backtrack.unescapable]),
   union([

package/src/parser/inline/bracket.ts

@@ -100,13 +100,11 @@ const s1 = lazy(() => surround(
         setBacktrack(context, 2 | Backtrack.link, head);
       }
       else {
-        context.state ^= State.link;
         if (!isBacktrack(context, 1 | Backtrack.link) && !textlink({ context })) {
           setBacktrack(context, 2 | Backtrack.link, head);
         }
         context.position = position;
         context.range = range;
-        context.state ^= State.link;
       }
     }
     return as.import(bs as List<Node<string>>).import(cs);

package/src/parser/inline/deletion.ts

@@ -8,15 +8,14 @@ import { unwrap, repeat } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const deletion: DeletionParser = lazy(() =>
-  precedence(0, repeat('~~', surround(
+  precedence(0, recursion(Recursion.inline, repeat('~~', surround(
     '',
-    recursion(Recursion.inline,
     some(union([
       some(inline, blankWith('\n', '~~')),
       open('\n', some(inline, '~'), true),
-    ]))),
+    ])),
     '~~',
     false, [],
     ([, bs], { buffer }) => buffer.import(bs),
     ([, bs], { buffer }) => bs && buffer.import(bs).push(new Node(Command.Cancel)) && buffer),
-    nodes => new List([new Node(html('del', defrag(unwrap(nodes))))]))));
+    nodes => new List([new Node(html('del', defrag(unwrap(nodes))))])))));

package/src/parser/inline/emphasis.ts

@@ -1,11 +1,11 @@
 import { EmphasisParser } from '../inline';
 import { Recursion } from '../context';
 import { List, Node } from '../../combinator/data/parser';
-import { union, some, recursion, precedence, surround, open, lazy } from '../../combinator';
+import { union, some, recursion, precedence, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { strong } from './strong';
 import { str } from '../source';
-import { tightStart, blankWith } from '../visibility';
+import { tightStart, afterNonblank } from '../visibility';
 import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
@@ -13,9 +13,8 @@ export const emphasis: EmphasisParser = lazy(() => surround(
   str(/\*(?!\*)/y),
   precedence(0, recursion(Recursion.inline,
   tightStart(some(union([
+    some(inline, '*', afterNonblank),
     strong,
-    some(inline, blankWith('*')),
-    open(some(inline, '*'), inline),
   ]))))),
   str('*'),
   false, [],

package/src/parser/inline/emstrong.ts

@@ -1,37 +1,31 @@
 import { EmStrongParser, EmphasisParser, StrongParser } from '../inline';
 import { Recursion, Command } from '../context';
 import { Parser, Result, List, Node } from '../../combinator/data/parser';
-import { union, some, recursion, precedence, surround, open, lazy, bind } from '../../combinator';
+import { union, some, recursion, precedence, surround, lazy, bind } from '../../combinator';
 import { inline } from '../inline';
 import { strong } from './strong';
 import { emphasis } from './emphasis';
 import { str } from '../source';
-import { tightStart, blankWith } from '../visibility';
+import { tightStart, afterNonblank } from '../visibility';
 import { unwrap, repeat } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 const substrong: Parser.IntermediateParser<StrongParser> = lazy(() => some(union([
+  some(inline, '*', afterNonblank),
   emphasis,
-  some(inline, blankWith('*')),
-  open(some(inline, '*'), inline),
 ])));
 const subemphasis: Parser.IntermediateParser<EmphasisParser> = lazy(() => some(union([
+  some(inline, '*', afterNonblank),
   strong,
-  some(inline, blankWith('*')),
-  open(some(inline, '*'), inline),
 ])));
 
 // 開閉が明示的でない構文は開閉の不明確な記号による再帰的適用を行わず
 // 可能な限り早く閉じるよう解析しなければならない。
 // このため終端記号の後ろを見て終端を中止し同じ構文を再帰的に適用してはならない。
 export const emstrong: EmStrongParser = lazy(() =>
-  precedence(0, repeat('***', surround(
+  precedence(0, recursion(Recursion.inline, repeat('***', surround(
     '',
-    recursion(Recursion.inline,
-    tightStart(some(union([
-      some(inline, blankWith('*')),
-      open(some(inline, '*'), inline),
-    ])))),
+    tightStart(some(union([some(inline, '*', afterNonblank)]))),
     str(/\*{1,3}/y),
     false, [],
     ([, bs, cs], context): Result<Parser.Node<EmStrongParser>, Parser.Context<EmStrongParser>> => {
@@ -143,7 +137,7 @@ export const emstrong: EmStrongParser = lazy(() =>
         nodes = prepend('*'.repeat(prefix - postfix), nodes);
       }
       return nodes;
-    })));
+    }))));
 
 function prepend<N>(prefix: string, nodes: List<Node<N>>): List<Node<N>> {
   if (typeof nodes.head?.value === 'string') {

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

@@ -29,29 +29,23 @@ export const index: IndexParser = lazy(() => constraint(State.index, fmap(indexe
       : undefined,
   undefined)),
   ns => {
-    if (ns.length === 1) {
-      const el = ns.head!.value as HTMLElement;
-      return new List([
-        new Node(define(el, {
-          id: el.id ? null : undefined,
-          class: 'index',
-          href: el.id ? `#${el.id}` : undefined,
-        }))
-      ]);
-    }
-    else {
-      assert(ns.last?.value === '');
-      ns.pop();
-      return ns;
-    }
+    assert(ns.length === 1);
+    const el = ns.head!.value as HTMLAnchorElement;
+    return new List([
+      new Node(define(el, {
+        id: el.id ? null : undefined,
+        class: 'index',
+        href: el.id ? `#${el.id}` : undefined,
+      }))
+    ]);
   })));
 
 export const signature: IndexParser.SignatureParser = lazy(() => validate('|', surround(
   str(/\|(?!\\?\s)/y),
-  some(union([
+  precedence(9, some(union([
     unsafehtmlentity,
     some(txt, /(?:[$"`\[\](){}<>（）［］｛｝|])/y),
-  ]), ']'),
+  ]), ']')),
   /(?=])/y,
   false,
   [3 | Backtrack.escapable],

package/src/parser/inline/insertion.ts

@@ -8,15 +8,14 @@ import { unwrap, repeat } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const insertion: InsertionParser = lazy(() =>
-  precedence(0, repeat('++', surround(
+  precedence(0, recursion(Recursion.inline, repeat('++', surround(
     '',
-    recursion(Recursion.inline,
     some(union([
       some(inline, blankWith('\n', '++')),
       open('\n', some(inline, '+'), true),
-    ]))),
+    ])),
     '++',
     false, [],
     ([, bs], { buffer }) => buffer.import(bs),
     ([, bs], { buffer }) => bs && buffer.import(bs).push(new Node(Command.Cancel)) && buffer),
-    nodes => new List([new Node(html('ins', defrag(unwrap(nodes))))]))));
+    nodes => new List([new Node(html('ins', defrag(unwrap(nodes))))])))));

package/src/parser/inline/italic.ts

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

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

@@ -183,7 +183,7 @@ describe('Unit: parser/inline/link', () => {
       assert.deepStrictEqual(inspect(parser, input('[@a]{b}', new Context())), [['<a class="link" href="b">@a</a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[@a@b]{c}', new Context())), [['<a class="link" href="c">@a@b</a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[a@b]{c}', new Context())), [['<a class="link" href="c">a@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"><mark>a</mark></a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[*a*]{b}', new Context())), [['<a class="link" href="b"><em>a</em></a>'], '']);
     });
 

package/src/parser/inline/link.ts

@@ -15,12 +15,12 @@ const optspec = {
 } as const;
 Object.setPrototypeOf(optspec, null);
 
-export const textlink: LinkParser.TextLinkParser = lazy(() => constraint(State.link,
-  precedence(1, state(State.linkers,
-  bind(subsequence([
-    dup(surround(
+export const textlink: LinkParser.TextLinkParser = lazy(() => bind(
+  subsequence([
+    constraint(State.link, state(State.linkers, dup(surround(
       '[',
-      trimBlankStart(some(union([inline]), ']', [[']', 1]])),
+      precedence(1,
+      trimBlankStart(some(union([inline]), ']', [[']', 1]]))),
       ']',
       true,
       [3 | Backtrack.common | Backtrack.link, 2 | Backtrack.ruby],
@@ -30,7 +30,7 @@ export const textlink: LinkParser.TextLinkParser = lazy(() => constraint(State.l
           return void setBacktrack(context, 2 | Backtrack.link | Backtrack.ruby, head);
         }
         return ns.push(new Node(Command.Separator)) && ns;
-      })),
+      })))),
     // `{ `と`{`で個別にバックトラックが発生し+1nされる。
     // 自己再帰的にパースしてもオプションの不要なパースによる計算量の増加により相殺される。
     dup(surround(
@@ -43,6 +43,7 @@ export const textlink: LinkParser.TextLinkParser = lazy(() => constraint(State.l
         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 (content.last!.value === Command.Separator) {
       content.pop();
       if (params === undefined) {
@@ -69,7 +70,7 @@ export const textlink: LinkParser.TextLinkParser = lazy(() => constraint(State.l
     assert(content.head?.value !== '');
     if (content.length !== 0 && trimBlankNodeEnd(content).length === 0) return;
     return new List([new Node(parse(content, params as List<Node<string>>, context))]);
-  })))));
+  }));
 
 export const medialink: LinkParser.MediaLinkParser = lazy(() => constraint(State.link | State.media,
   state(State.linkers,

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

@@ -38,12 +38,12 @@ describe('Unit: parser/inline/mark', () => {
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser, input('==a ==b====', new Context())), [['<mark id="mark::a_b">a <mark id="mark::b">b</mark><a href="#mark::b"></a></mark>', '<a href="#mark::a_b"></a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('==- ==b====', new Context())), [['<mark id="mark::-_b">- <mark id="mark::b">b</mark><a href="#mark::b"></a></mark>', '<a href="#mark::-_b"></a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('==a\\ ==b====', new Context())), [['<mark id="mark::a_b">a <mark id="mark::b">b</mark><a href="#mark::b"></a></mark>', '<a href="#mark::a_b"></a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('==a&Tab;==b====', new Context())), [['<mark id="mark::a_b=33Mw2l">a\t<mark id="mark::b">b</mark><a href="#mark::b"></a></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 id="mark::b">b</mark><a href="#mark::b"></a></mark>', '<a href="#mark::ab"></a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('==*==a==*==', new Context())), [['<mark id="mark::a"><em><mark id="mark::a">a</mark><a href="#mark::a"></a></em></mark>', '<a href="#mark::a"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('==a ==b====', new Context())), [['<mark id="mark::a_b">a <mark>b</mark></mark>', '<a href="#mark::a_b"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('==- ==b====', new Context())), [['<mark id="mark::-_b">- <mark>b</mark></mark>', '<a href="#mark::-_b"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('==a\\ ==b====', new Context())), [['<mark id="mark::a_b">a <mark>b</mark></mark>', '<a href="#mark::a_b"></a>'], '']);
+      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>'], '']);
     });
 
   });

package/src/parser/inline/mark.ts

@@ -1,29 +1,26 @@
 import { MarkParser } from '../inline';
 import { State, Recursion, Command } from '../context';
 import { List, Node } from '../../combinator/data/parser';
-import { union, some, recursion, precedence, state, constraint, surround, open, lazy } from '../../combinator';
+import { union, some, recursion, precedence, state, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { identity, signature } from './extension/indexee';
-import { tightStart, blankWith } from '../visibility';
+import { tightStart, afterNonblank } from '../visibility';
 import { unwrap, repeat } from '../util';
 import { html, define, defrag } from 'typed-dom/dom';
 
-export const mark: MarkParser = lazy(() => constraint(State.linkers & ~State.mark,
-  precedence(0, state(State.mark, repeat('==', surround(
+export const mark: MarkParser = lazy(() =>
+  precedence(0, recursion(Recursion.inline, repeat('==', surround(
     '',
-    recursion(Recursion.inline,
-    tightStart(some(union([
-      some(inline, blankWith('==')),
-      open(some(inline, '='), inline),
-    ])))),
+    tightStart(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 }) => {
+    (nodes, { id, state }) => {
       const el = html('mark', defrag(unwrap(nodes)));
+      if (state & State.linkers) 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}` }))])
         : new List([new Node(el)]);
-    })))));
+    }))));

package/src/parser/inline/ruby.ts

@@ -53,9 +53,9 @@ export const ruby: RubyParser = lazy(() => bind(
         assert(rubies.length > 0);
         return new List([
           new Node(html('ruby', defrag(unwrap(new List<Node<string | HTMLElement>>([
-            new Node(texts.foldr(({ value }, acc) => value + ' ' + acc, '').slice(0, -1)),
+            new Node(texts.foldl((acc, { value }) => acc ? acc + ' ' + value : value, '')),
             new Node(html('rp', '(')),
-            new Node(html('rt', rubies.foldr(({ value }, acc) => value + ' ' + acc, '').trim())),
+            new Node(html('rt', rubies.foldl((acc, { value }) => acc ? acc + ' ' + value : value, '').trim())),
             new Node(html('rp', ')')),
           ]))))),
         ]);

package/src/parser/inline/strong.ts

@@ -1,11 +1,11 @@
 import { StrongParser } from '../inline';
 import { Recursion } from '../context';
 import { List, Node } from '../../combinator/data/parser';
-import { union, some, recursion, precedence, surround, open, lazy } from '../../combinator';
+import { union, some, recursion, precedence, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { emphasis } from './emphasis';
 import { str } from '../source';
-import { tightStart, blankWith } from '../visibility';
+import { tightStart, afterNonblank } from '../visibility';
 import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
@@ -13,9 +13,8 @@ export const strong: StrongParser = lazy(() => surround(
   str(/\*\*(?!\*)/y),
   precedence(0, recursion(Recursion.inline,
   tightStart(some(union([
+    some(inline, '*', afterNonblank),
     emphasis,
-    some(inline, blankWith('*')),
-    open(some(inline, '*'), inline),
   ]))))),
   str('**'),
   false, [],

package/src/parser/inline.test.ts

@@ -154,7 +154,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser, input('[[a\nb]]', new Context())), [['[', '[', 'a', '<br>', 'b', ']', ']'], '']);
       assert.deepStrictEqual(inspect(parser, input('[[[a\nb]]]', new Context())), [['[', '[', '[', 'a', '<br>', 'b', ']', ']', ']'], '']);
       assert.deepStrictEqual(inspect(parser, input('"[[""]]', new Context())), [['"', '[', '[', '"', '"', ']', ']'], '']);
-      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"><mark>a</mark></a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[[a](b)]{c}', new Context())), [['<a class="link" href="c"><ruby>a<rp>(</rp><rt>b</rt><rp>)</rp></ruby></a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[[[[[[[{a}', new Context())), [['[', '[', '[', '[', '[', '[', '[', '<a class="url" href="a">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('<http://host>', new Context())), [['<', '<a class="url" href="http://host" target="_blank">http://host</a>', '>'], '']);
@@ -170,6 +170,9 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser, input('[#@a/http://host/(<bdi>)]</bdi>', new Context())), [['<a class="index" href="#index::@a/http://host/(&lt;bdi&gt;)">@a/http://host/<span class="paren">(<span class="invalid">&lt;bdi&gt;</span>)</span></a>', '</bdi', '>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[#a|<bdi>]</bdi>', new Context())), [['<a class="index" href="#index::a|&lt;bdi&gt;">a|<span class="invalid">&lt;bdi&gt;</span></a>', '</bdi', '>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[[#a|<bdi>]</bdi>', new Context())), [['[', '<a class="index" href="#index::a|&lt;bdi&gt;">a|<span class="invalid">&lt;bdi&gt;</span></a>', '</bdi', '>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[*==*]{a}', new Context())), [['<a class="link" href="a">*==*</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[]{"}[[""]]}]', new Context())), [['<a class="url" href="&quot;">"</a>', '<sup class="reference"><span>""</span></sup>', '}', ']'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[ []{"}[[""]]}]', new Context())), [['[', ' ', '<a class="url" href="&quot;">"</a>', '<sup class="reference"><span>""</span></sup>', '}', ']'], '']);
     });
 
     it('uri', () => {

package/src/parser/segment.test.ts

@@ -4,12 +4,12 @@ import { Command } from './context';
 describe('Unit: parser/segment', () => {
   describe('segment', () => {
     it('huge input', () => {
-      const result = segment(`${'\n'.repeat(10 * 1000 ** 2)}`).next().value?.split('\n', 1)[0];
+      const result = segment(`${'\n'.repeat(1e6 + 1)}`).next().value?.split('\n', 1)[0];
       assert(result?.startsWith(`${Command.Error}Too large input`));
     });
 
     it('huge segment', () => {
-      const result = segment(`${'\n'.repeat(1000 ** 2 - 1)}`).next().value?.split('\n', 1)[0];
+      const result = segment(`${'\n'.repeat(1e5 + 1)}`).next().value?.split('\n', 1)[0];
       assert(result?.startsWith(`${Command.Error}Too large segment`));
     });
 

package/src/parser/segment.ts

@@ -13,7 +13,7 @@ export const MAX_SEGMENT_SIZE = 100_000; // 100,000 bytes (Max value size of FDB
 export const MAX_INPUT_SIZE = MAX_SEGMENT_SIZE * 10;
 
 const parser: SegmentParser = union([
-  some(emptyline),
+  some(emptyline, MAX_SEGMENT_SIZE + 1),
   input => {
     const { context: { source, position } } = input;
     if (position === source.length) return;
@@ -36,7 +36,7 @@ const parser: SegmentParser = union([
         return extension(input);
     }
   },
-  some(contentline),
+  some(contentline, MAX_SEGMENT_SIZE + 1),
 ]) as any;
 
 export function* segment(source: string): Generator<string, undefined, undefined> {