securemark 0.297.5 → 0.297.7

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.297.7
+
+- Fix annotation parser.
+
+## 0.297.6
+
+- Refactoring.
+
 ## 0.297.5
 
 - Fix annotation parser.

package/dist/index.js

@@ -1,4 +1,4 @@
-/*! securemark v0.297.5 https://github.com/falsandtru/securemark | (c) 2017, falsandtru | UNLICENSED License */
+/*! securemark v0.297.7 https://github.com/falsandtru/securemark | (c) 2017, falsandtru | UNLICENSED License */
 (function webpackUniversalModuleDefinition(root, factory) {
 	if(typeof exports === 'object' && typeof module === 'object')
 		module.exports = factory(require("Prism"), require("DOMPurify"));
@@ -6111,7 +6111,7 @@ const parser_1 = __webpack_require__(605);
 class Context extends parser_1.Context {
   constructor(options = {}) {
     super(options);
-    this.recursion = new RecursionCounter(5);
+    this.recursion = new RecursionCounter('annotation', 2);
     const {
       segment,
       buffer,
@@ -6134,7 +6134,8 @@ class Context extends parser_1.Context {
 }
 exports.Context = Context;
 class RecursionCounter {
-  constructor(limit) {
+  constructor(syntax, limit) {
+    this.syntax = syntax;
     this.limit = limit;
     this.stack = [];
     this.index = 0;
@@ -6144,7 +6145,8 @@ class RecursionCounter {
       stack
     } = this;
     for (; this.index > 0 && stack[this.index - 1] <= depth; --this.index);
-    if (this.index === this.limit) throw new Error('Too much recursion');
+    // 内側から数えるので無効化処理できずエラーを投げるしかない。
+    if (this.index === this.limit) throw new Error(`Too much ${this.syntax} recursion`);
     stack[this.index] = depth;
     ++this.index;
   }
@@ -6377,36 +6379,48 @@ const dom_1 = __webpack_require__(394);
 // 動的計画法を適用するか再帰数を制限する必要がある。
 // 動的計画法においては再帰的記録により指数空間計算量にならないよう下位の記録を消しながら記録しなければならない。
 // トリムも再帰的に行わないよう前後のトリムサイズの記録を要する。
-// しかし理論的には再帰数の制限はないがポップアップテキストの記録やハッシュの計算を行う言語仕様から指数計算量を
+// しかし理論的には無制限の再帰が可能だがホバーテキストの記録やハッシュの計算を行う言語仕様から指数計算量を
 // 避けられないためAnnotation構文に限り再帰数の制限が必要となる。
-// シグネチャやハッシュは分割計算可能にすれば解決するがポップアップテキストは記録せず動的に再計算して
+// シグネチャやハッシュは分割計算可能にすれば解決するがホバーテキストは記録せず動的に再計算して
 // 表示しなければ指数空間計算量を避けられない。
-// 注釈は本来再帰的に行うものではないため再帰数を制限して機能を優先するのが合理的となる。
+// 注釈を除外すると重複排除により参照元が消滅し欠番が生じるため少なくとも直接注釈は残す必要があるが間接注釈は
+// 除外できる。しかしこれを効率的に行うことは難しいため最大再帰数を1回に制限することで間接注釈を行えない
+// ようにするのが合理的だろう。
+// 原理的には逆順処理により圧縮後正順で再附番すればすべて解決するはずだがテキストとシグネチャとハッシュも
+// 修正する必要があるためほぼ完全な二重処理が必要になり三重以上の注釈という不適切な使用のために
+// 常に非常に非効率な処理を行い常時低速化するより三重以上の注釈を禁止して効率性を維持するのが妥当である。
+const MAX_DEPTH = 20;
 exports.annotation = (0, combinator_1.lazy)(() => (0, combinator_1.constraint)(128 /* State.annotation */, (0, combinator_1.surround)((0, combinator_1.open)('((', visibility_1.beforeNonblank), (0, combinator_1.precedence)(1, (0, combinator_1.recursions)([4 /* Recursion.annotation */, 3 /* Recursion.inline */, 5 /* Recursion.bracket */, 5 /* Recursion.bracket */], (0, combinator_1.some)((0, combinator_1.union)([inline_1.inline]), ')', [[')', 1]]))), '))', false, [], ([, ns], context) => {
   const {
-    linebreak
+    linebreak,
+    recursion,
+    resources
   } = context;
-  if (linebreak === 0) {
-    context.recursion.add(20 - (context.resources?.recursions[4 /* Recursion.annotation */] ?? context.resources?.recursions.at(-1) ?? 20));
-    return new parser_1.List([new parser_1.Node((0, dom_1.html)('sup', {
-      class: 'annotation'
-    }, [(0, dom_1.html)('span', (0, dom_1.defrag)((0, util_1.unwrap)((0, visibility_1.trimBlankNodeEnd)(ns))))]))]);
-  }
-  ns.unshift(new parser_1.Node('('));
-  ns.push(new parser_1.Node(')'));
-  return new parser_1.List([new parser_1.Node((0, dom_1.html)('span', {
-    class: 'bracket'
-  }, ['(', (0, dom_1.html)('span', {
-    class: 'bracket'
-  }, (0, dom_1.defrag)((0, util_1.unwrap)(ns))), ')']))]);
-}, ([, bs = new parser_1.List()], context) => {
+  if (linebreak !== 0) {
+    ns.unshift(new parser_1.Node('('));
+    ns.push(new parser_1.Node(')'));
+    return new parser_1.List([new parser_1.Node((0, dom_1.html)('span', {
+      class: 'bracket'
+    }, ['(', (0, dom_1.html)('span', {
+      class: 'bracket'
+    }, (0, dom_1.defrag)((0, util_1.unwrap)(ns))), ')']))]);
+  }
+  const depth = MAX_DEPTH - (resources?.recursions[4 /* Recursion.annotation */] ?? resources?.recursions.at(-1) ?? MAX_DEPTH);
+  recursion.add(depth);
+  return new parser_1.List([new parser_1.Node((0, dom_1.html)('sup', {
+    class: 'annotation'
+  }, [(0, dom_1.html)('span', (0, dom_1.defrag)((0, util_1.unwrap)((0, visibility_1.trimBlankNodeEnd)(ns))))]))]);
+}, ([, bs], context) => {
   const {
     source,
     position,
     range,
-    linebreak
+    linebreak,
+    recursion,
+    resources
   } = context;
-  if (linebreak === 0 && bs.length === 1 && source[position] === ')' && typeof bs.head?.value === 'object') {
+  const depth = MAX_DEPTH - (resources?.recursions[4 /* Recursion.annotation */] ?? resources?.recursions.at(-1) ?? MAX_DEPTH);
+  if (linebreak === 0 && bs && bs.length === 1 && source[position] === ')' && typeof bs.head?.value === 'object') {
     const {
       className
     } = bs.head.value;
@@ -6426,7 +6440,7 @@ exports.annotation = (0, combinator_1.lazy)(() => (0, combinator_1.constraint)(1
         lastChild.nodeValue = lastChild.nodeValue.slice(0, -1);
       }
       context.position += 1;
-      context.recursion.add(20 - (context.resources?.recursions[4 /* Recursion.annotation */] ?? context.resources?.recursions.at(-1) ?? 20));
+      recursion.add(depth);
       return new parser_1.List([new parser_1.Node((0, dom_1.html)('span', {
         class: 'bracket'
       }, ['(', (0, dom_1.html)('sup', {
@@ -6435,7 +6449,7 @@ exports.annotation = (0, combinator_1.lazy)(() => (0, combinator_1.constraint)(1
     }
     if (className === 'annotation' && deepunwrap(bs)) {
       context.position += 1;
-      context.recursion.add(20 - (context.resources?.recursions[4 /* Recursion.annotation */] ?? context.resources?.recursions.at(-1) ?? 20));
+      recursion.add(depth);
       return new parser_1.List([new parser_1.Node((0, dom_1.html)('span', {
         class: 'bracket'
       }, ['(', (0, dom_1.html)('sup', {
@@ -6443,19 +6457,32 @@ exports.annotation = (0, combinator_1.lazy)(() => (0, combinator_1.constraint)(1
       }, [(0, dom_1.html)('span', [bs.head.value])])]))]);
     }
   }
-  const str = linebreak === 0 ? source.slice(position - range + 2, position) : '';
-  if (linebreak === 0 && bracket_1.indexA.test(str)) {
-    return new parser_1.List([new parser_1.Node((0, dom_1.html)('span', {
-      class: 'bracket'
-    }, ['((' + str]))]);
+  bs ??= new parser_1.List();
+  bs.unshift(new parser_1.Node('('));
+  if (source[context.position] === ')') {
+    bs.push(new parser_1.Node(')'));
+    context.position += 1;
   }
+  const str = linebreak === 0 ? source.slice(position - range + 2, position) : '';
+  bs = linebreak === 0 && (str === '' || bracket_1.indexA.test(str)) ? new parser_1.List([new parser_1.Node((0, dom_1.html)('span', {
+    class: 'paren'
+  }, (0, dom_1.defrag)((0, util_1.unwrap)(bs))))]) : new parser_1.List([new parser_1.Node((0, dom_1.html)('span', {
+    class: 'bracket'
+  }, (0, dom_1.defrag)((0, util_1.unwrap)(bs))))]);
   bs.unshift(new parser_1.Node('('));
+  const cs = parser({
+    context
+  });
+  if (source[context.position] === ')') {
+    cs && bs.import(cs);
+    bs.push(new parser_1.Node(')'));
+    context.position += 1;
+  }
   return new parser_1.List([new parser_1.Node((0, dom_1.html)('span', {
     class: 'bracket'
-  }, ['(', (0, dom_1.html)('span', {
-    class: 'bracket'
-  }, (0, dom_1.defrag)((0, util_1.unwrap)(bs)))]))]);
+  }, (0, dom_1.defrag)((0, util_1.unwrap)(bs))))]);
 })));
+const parser = (0, combinator_1.lazy)(() => (0, combinator_1.precedence)(1, (0, combinator_1.some)(inline_1.inline, ')', [[')', 1]])));
 function deepunwrap(list) {
   let bottom = list.head.value;
   for (; bottom;) {
@@ -6786,7 +6813,7 @@ const p1 = (0, combinator_1.lazy)(() => (0, combinator_1.surround)((0, source_1.
   linebreak
 }) => {
   const str = linebreak === 0 ? source.slice(position - range + 1, position - 1) : '';
-  return linebreak === 0 && exports.indexA.test(str) ? new parser_1.List([new parser_1.Node((0, dom_1.html)('span', {
+  return linebreak === 0 && (str === '' || exports.indexA.test(str)) ? new parser_1.List([new parser_1.Node((0, dom_1.html)('span', {
     class: 'paren'
   }, `(${str})`))]) : new parser_1.List([new parser_1.Node((0, dom_1.html)('span', {
     class: 'bracket'
@@ -6799,7 +6826,7 @@ const p1 = (0, combinator_1.lazy)(() => (0, combinator_1.surround)((0, source_1.
     linebreak
   } = context;
   const str = linebreak === 0 ? source.slice(position - range + 1, position) : '';
-  return linebreak === 0 && exports.indexA.test(str) ? new parser_1.List([new parser_1.Node((0, dom_1.html)('span', {
+  return linebreak === 0 && (str === '' || exports.indexA.test(str)) ? new parser_1.List([new parser_1.Node((0, dom_1.html)('span', {
     class: 'paren'
   }, `(${str}`))]) : new parser_1.List([new parser_1.Node((0, dom_1.html)('span', {
     class: 'bracket'
@@ -6812,7 +6839,7 @@ const p2 = (0, combinator_1.lazy)(() => (0, combinator_1.surround)((0, source_1.
   linebreak
 }) => {
   const str = linebreak === 0 ? source.slice(position - range + 1, position - 1) : '';
-  return linebreak === 0 && indexF.test(str) ? new parser_1.List([new parser_1.Node((0, dom_1.html)('span', {
+  return linebreak === 0 && (str === '' || indexF.test(str)) ? new parser_1.List([new parser_1.Node((0, dom_1.html)('span', {
     class: 'paren'
   }, `（${str}）`))]) : new parser_1.List([new parser_1.Node((0, dom_1.html)('span', {
     class: 'bracket'
@@ -6825,7 +6852,7 @@ const p2 = (0, combinator_1.lazy)(() => (0, combinator_1.surround)((0, source_1.
     linebreak
   } = context;
   const str = linebreak === 0 ? source.slice(position - range + 1, position) : '';
-  return linebreak === 0 && indexF.test(str) ? new parser_1.List([new parser_1.Node((0, dom_1.html)('span', {
+  return linebreak === 0 && (str === '' || indexF.test(str)) ? new parser_1.List([new parser_1.Node((0, dom_1.html)('span', {
     class: 'paren'
   }, `（${str}`))]) : new parser_1.List([new parser_1.Node((0, dom_1.html)('span', {
     class: 'bracket'
@@ -7946,12 +7973,12 @@ exports.reference = (0, combinator_1.lazy)(() => (0, combinator_1.constraint)(64
     range,
     linebreak
   } = context;
-  if (linebreak === 0) {
-    return new parser_1.List([new parser_1.Node((0, dom_1.html)('sup', attributes(ns), [(0, dom_1.html)('span', (0, dom_1.defrag)((0, util_1.unwrap)((0, visibility_1.trimBlankNodeEnd)(ns))))]))]);
-  } else {
-    const head = position - range;
+  const head = position - range;
+  if (linebreak !== 0) {
     (0, combinator_1.setBacktrack)(context, 2 | 64 /* Backtrack.link */, head, 2);
+    return;
   }
+  return new parser_1.List([new parser_1.Node((0, dom_1.html)('sup', attributes(ns), [(0, dom_1.html)('span', (0, dom_1.defrag)((0, util_1.unwrap)((0, visibility_1.trimBlankNodeEnd)(ns))))]))]);
 }, (_, context) => {
   const {
     source,
@@ -8466,6 +8493,9 @@ function build(syntax, list, query, marker, splitter = '') {
         'data-marker': note ? undefined : marker(total + defs.size + 1, abbr)
       }, [content, (0, dom_1.html)('sup')]) : defs.get(identifier);
       initial && defs.set(identifier, def);
+      if (!initial && content.innerHTML.length > def.firstElementChild.innerHTML.length) {
+        def.firstElementChild.replaceWith(content);
+      }
       const defIndex = initial ? info.defIndex = total + defs.size : info.defIndex;
       const title = info.title ||= text;
       (0, dom_1.define)(ref, {
@@ -8498,13 +8528,14 @@ function build(syntax, list, query, marker, splitter = '') {
           info.queue.push(ref);
           break;
       }
-      yield ref.appendChild((0, dom_1.html)('a', {
+      ref.appendChild((0, dom_1.html)('a', {
         href: refId && defId && `#${defId}`
       }, marker(defIndex, abbr)));
       def.lastElementChild.appendChild((0, dom_1.html)('a', {
         href: refId && `#${refId}`,
         title: abbr && text || undefined
       }, `^${++refIndex}`));
+      yield;
     }
     if (note || defs.size > 0) {
       const splitter = splitters[iSplitters++];
@@ -9467,7 +9498,6 @@ function render(source, opts = {}) {
 }
 exports.render = render;
 function render_(base, source, opts) {
-  if (source.classList.contains('invalid')) return;
   try {
     switch (true) {
       case !!opts.code && !source.firstElementChild && source.matches('pre.code'):

package/package.json

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

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

@@ -307,7 +307,7 @@ describe('Unit: parser/api/parse', () => {
       //  ]);
       assert.deepStrictEqual(
         [...parse(`${'('.repeat(20)}0`).children].map(el => el.outerHTML),
-        [`<p>${'<span class="bracket">('.repeat(19)}(0${'</span>'.repeat(19)}</p>`]);
+        [`<p>${'<span class="bracket">('.repeat(19)}<span class="paren">(0</span>${'</span>'.repeat(19)}</p>`]);
       assert.deepStrictEqual(
         [...parse(`${'('.repeat(21)}0`).children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
         [
@@ -324,40 +324,40 @@ describe('Unit: parser/api/parse', () => {
           `<pre class="error" translate="no">${'['.repeat(21)}0</pre>`,
         ]);
       assert.deepStrictEqual(
-        [...parse(`${'(('.repeat(5)}0${'))'.repeat(5)}`).children].map(el => el.tagName),
+        [...parse(`${'(('.repeat(2)}0${'))'.repeat(2)}`).children].map(el => el.tagName),
         ['P', 'OL']);
       assert.deepStrictEqual(
-        [...parse(`${'(('.repeat(6)}0${'))'.repeat(6)}`).children].map(el => el.tagName),
+        [...parse(`${'(('.repeat(3)}0${'))'.repeat(3)}`).children].map(el => el.tagName),
         ['H1', 'PRE']);
       assert.deepStrictEqual(
-        [...parse(`${'(('.repeat(5)}!${'))'.repeat(5)}`).children].map(el => el.tagName),
+        [...parse(`${'(('.repeat(2)}!${'))'.repeat(2)}`).children].map(el => el.tagName),
         ['P', 'OL']);
       assert.deepStrictEqual(
-        [...parse(`${'(('.repeat(6)}!${'))'.repeat(6)}`).children].map(el => el.tagName),
+        [...parse(`${'(('.repeat(3)}!${'))'.repeat(3)}`).children].map(el => el.tagName),
         ['H1', 'PRE']);
       assert.deepStrictEqual(
-        [...parse(`(${'(('.repeat(5)}0${'))'.repeat(5)}`).children].map(el => el.tagName),
+        [...parse(`(${'(('.repeat(2)}0${'))'.repeat(2)}`).children].map(el => el.tagName),
         ['P', 'OL']);
       assert.deepStrictEqual(
-        [...parse(`(${'(('.repeat(6)}0${'))'.repeat(6)}`).children].map(el => el.tagName),
+        [...parse(`(${'(('.repeat(3)}0${'))'.repeat(3)}`).children].map(el => el.tagName),
         ['H1', 'PRE']);
       assert.deepStrictEqual(
-        [...parse(`(${'(('.repeat(5)}!${'))'.repeat(5)}`).children].map(el => el.tagName),
+        [...parse(`(${'(('.repeat(2)}!${'))'.repeat(2)}`).children].map(el => el.tagName),
         ['P', 'OL']);
       assert.deepStrictEqual(
-        [...parse(`(${'(('.repeat(6)}!${'))'.repeat(6)}`).children].map(el => el.tagName),
+        [...parse(`(${'(('.repeat(3)}!${'))'.repeat(3)}`).children].map(el => el.tagName),
         ['H1', 'PRE']);
       assert.deepStrictEqual(
-        [...parse(`${'(('.repeat(5)}0${'))'.repeat(5)}${'(('.repeat(5)}0${'))'.repeat(5)}`).children].map(el => el.tagName),
+        [...parse(`${'(('.repeat(2)}0${'))'.repeat(2)}${'(('.repeat(2)}0${'))'.repeat(2)}`).children].map(el => el.tagName),
         ['P', 'OL']);
       assert.deepStrictEqual(
-        [...parse(`${'(('.repeat(5)}0${'))'.repeat(5)}${'(('.repeat(6)}0${'))'.repeat(6)}`).children].map(el => el.tagName),
+        [...parse(`${'(('.repeat(2)}0${'))'.repeat(2)}${'(('.repeat(3)}0${'))'.repeat(3)}`).children].map(el => el.tagName),
         ['H1', 'PRE']);
       assert.deepStrictEqual(
-        [...parse(`${'(('.repeat(5)}0${'))'.repeat(5)}${'(('.repeat(9)}0${'))'.repeat(5)}`).children].map(el => el.tagName),
+        [...parse(`${'(('.repeat(2)}0${'))'.repeat(2)}${'(('.repeat(9)}0${'))'.repeat(2)}`).children].map(el => el.tagName),
         ['P', 'OL']);
       assert.deepStrictEqual(
-        [...parse(`${'(('.repeat(5)}0${'))'.repeat(5)}${'(('.repeat(9)}0${'))'.repeat(6)}`).children].map(el => el.tagName),
+        [...parse(`${'(('.repeat(2)}0${'))'.repeat(2)}${'(('.repeat(9)}0${'))'.repeat(3)}`).children].map(el => el.tagName),
         ['H1', 'PRE']);
     });
 

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

@@ -33,7 +33,7 @@ describe('Unit: parser/block/table', () => {
       assert.deepStrictEqual(inspect(parser, input('|||\n|-|-|\n|||', new Context())), [['<table><thead><tr><th></th><th></th></tr></thead><tbody><tr><td></td><td></td></tr></tbody></table>'], '']);
       assert.deepStrictEqual(inspect(parser, input('|"|\n|-\n|', new Context())), [['<table><thead><tr><th>"</th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
       assert.deepStrictEqual(inspect(parser, input('|`|`|\n|-\n|', new Context())), [['<table><thead><tr><th><code data-src="`|`">|</code></th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('|((|\n|-\n|', new Context())), [['<table><thead><tr><th><span class="bracket">(<span class="bracket">(</span></span></th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('|((|\n|-\n|', new Context())), [['<table><thead><tr><th><span class="bracket">(<span class="paren">(</span></span></th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
       assert.deepStrictEqual(inspect(parser, input('|a|b|\n|-|-|\n|1|2|', new Context())), [['<table><thead><tr><th>a</th><th>b</th></tr></thead><tbody><tr><td>1</td><td>2</td></tr></tbody></table>'], '']);
       assert.deepStrictEqual(inspect(parser, input('|a|b\n|-|-\n|1|2', new Context())), [['<table><thead><tr><th>a</th><th>b</th></tr></thead><tbody><tr><td>1</td><td>2</td></tr></tbody></table>'], '']);
       assert.deepStrictEqual(inspect(parser, input('|a|\n|-|\n|1|', new Context())), [['<table><thead><tr><th>a</th></tr></thead><tbody><tr><td>1</td></tr></tbody></table>'], '']);

package/src/parser/context.ts

@@ -28,7 +28,7 @@ export class Context extends Ctx {
   public override segment: Segment;
   public buffer: List<Node<(string | HTMLElement)>>;
   public sequential: boolean;
-  public recursion = new RecursionCounter(5);
+  public recursion = new RecursionCounter('annotation', 2);
   public readonly header: boolean;
   public readonly host?: URL;
   public readonly url?: URL;
@@ -42,14 +42,18 @@ export class Context extends Ctx {
 export type Options = Partial<Context>;
 
 class RecursionCounter {
-  constructor(private readonly limit: number) {
+  constructor(
+    private readonly syntax: string,
+    private readonly limit: number,
+  ) {
   }
   private readonly stack: number[] = [];
   private index = 0;
   public add(depth: number): void {
     const { stack } = this
     for (; this.index > 0 && stack[this.index - 1] <= depth; --this.index);
-    if (this.index === this.limit) throw new Error('Too much recursion');
+    // 内側から数えるので無効化処理できずエラーを投げるしかない。
+    if (this.index === this.limit) throw new Error(`Too much ${this.syntax} recursion`);
     stack[this.index] = depth;
     ++this.index;
   }

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

@@ -13,9 +13,15 @@ describe('Unit: parser/inline/annotation', () => {
       assert.deepStrictEqual(inspect(parser, input('(', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('()', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('((', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('(())', new Context())), [['<span class="bracket">(<span class="bracket">(</span></span>'], '))']);
-      assert.deepStrictEqual(inspect(parser, input('(()))', new Context())), [['<span class="bracket">(<span class="bracket">(</span></span>'], ')))']);
+      assert.deepStrictEqual(inspect(parser, input('(())', new Context())), [['<span class="bracket">(<span class="paren">()</span>)</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(()))', new Context())), [['<span class="bracket">(<span class="paren">()</span>)</span>'], ')']);
       assert.deepStrictEqual(inspect(parser, input('(("))', new Context())), [['<span class="bracket">(<span class="bracket">("))</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('((a', new Context())), [['<span class="bracket">(<span class="paren">(a</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('((!', new Context())), [['<span class="bracket">(<span class="bracket">(!</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('((a)', new Context())), [['<span class="bracket">(<span class="paren">(a)</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('((!)', new Context())), [['<span class="bracket">(<span class="bracket">(!)</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('((a)b)', new Context())), [['<span class="bracket">(<span class="paren">(a)</span>b)</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('((!)b)', new Context())), [['<span class="bracket">(<span class="bracket">(!)</span>b)</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('(([))', new Context())), [['<span class="bracket">(<span class="bracket">([))</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('(([%))', new Context())), [['<span class="bracket">(<span class="bracket">([%))</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('(( ))', new Context())), undefined);
@@ -31,9 +37,7 @@ describe('Unit: parser/inline/annotation', () => {
       assert.deepStrictEqual(inspect(parser, input('((a\nb))', new Context())), [['<span class="bracket">(<span class="bracket">(a<br>b)</span>)</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('((a\\\nb))', new Context())), [['<span class="bracket">(<span class="bracket">(a<br>b)</span>)</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('((*a\nb*))', new Context())), [['<span class="bracket">(<span class="bracket">(<em>a<br>b</em>)</span>)</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('((\\))', new Context())), [['<span class="bracket">(<span class="bracket">()</span></span>'], ')']);
-      assert.deepStrictEqual(inspect(parser, input('((a)b))', new Context())), [['<span class="bracket">((a</span>'], ')b))']);
-      assert.deepStrictEqual(inspect(parser, input('((!)b))', new Context())), [['<span class="bracket">(<span class="bracket">(!</span></span>'], ')b))']);
+      assert.deepStrictEqual(inspect(parser, input('((\\))', new Context())), [['<span class="bracket">(<span class="bracket">())</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('(((a))', new Context())), [['<span class="bracket">(<sup class="annotation"><span>a</span></sup></span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('(((!))', new Context())), [['<span class="bracket">(<sup class="annotation"><span>!</span></sup></span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('(((*a*))', new Context())), [['<span class="bracket">(<sup class="annotation"><span><em>a</em></span></sup></span>'], '']);
@@ -57,6 +61,8 @@ describe('Unit: parser/inline/annotation', () => {
       assert.deepStrictEqual(inspect(parser, input('((@a))', new Context())), [['<sup class="annotation"><span><a class="account" href="/@a">@a</a></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser, input('((http://host))', new Context())), [['<sup class="annotation"><span><a class="url" href="http://host" target="_blank">http://host</a></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser, input('((![]{a}))', new Context())), [['<sup class="annotation"><span>!<a class="url" href="a">a</a></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('((a(())))', new Context())), [['<sup class="annotation"><span>a<span class="bracket">(<span class="paren">()</span>)</span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('((a[[]]))', new Context())), [['<sup class="annotation"><span>a[[]]</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser, input('(([[a] ]))', new Context())), [['<sup class="annotation"><span>[[a] ]</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser, input('(((a)))', new Context())), [['<sup class="annotation"><span><span class="paren">(a)</span></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser, input('((((a))))', new Context())), [['<sup class="annotation"><span><sup class="annotation"><span>a</span></sup></span></sup>'], '']);

package/src/parser/inline/annotation.ts

@@ -12,11 +12,17 @@ import { html, defrag } from 'typed-dom/dom';
 // 動的計画法を適用するか再帰数を制限する必要がある。
 // 動的計画法においては再帰的記録により指数空間計算量にならないよう下位の記録を消しながら記録しなければならない。
 // トリムも再帰的に行わないよう前後のトリムサイズの記録を要する。
-// しかし理論的には再帰数の制限はないがポップアップテキストの記録やハッシュの計算を行う言語仕様から指数計算量を
+// しかし理論的には無制限の再帰が可能だがホバーテキストの記録やハッシュの計算を行う言語仕様から指数計算量を
 // 避けられないためAnnotation構文に限り再帰数の制限が必要となる。
-// シグネチャやハッシュは分割計算可能にすれば解決するがポップアップテキストは記録せず動的に再計算して
+// シグネチャやハッシュは分割計算可能にすれば解決するがホバーテキストは記録せず動的に再計算して
 // 表示しなければ指数空間計算量を避けられない。
-// 注釈は本来再帰的に行うものではないため再帰数を制限して機能を優先するのが合理的となる。
+// 注釈を除外すると重複排除により参照元が消滅し欠番が生じるため少なくとも直接注釈は残す必要があるが間接注釈は
+// 除外できる。しかしこれを効率的に行うことは難しいため最大再帰数を1回に制限することで間接注釈を行えない
+// ようにするのが合理的だろう。
+// 原理的には逆順処理により圧縮後正順で再附番すればすべて解決するはずだがテキストとシグネチャとハッシュも
+// 修正する必要があるためほぼ完全な二重処理が必要になり三重以上の注釈という不適切な使用のために
+// 常に非常に非効率な処理を行い常時低速化するより三重以上の注釈を禁止して効率性を維持するのが妥当である。
+const MAX_DEPTH = 20;
 export const annotation: AnnotationParser = lazy(() => constraint(State.annotation, surround(
   open('((', beforeNonblank),
   precedence(1, recursions([Recursion.annotation, Recursion.inline, Recursion.bracket, Recursion.bracket],
@@ -24,18 +30,20 @@ export const annotation: AnnotationParser = lazy(() => constraint(State.annotati
   '))',
   false, [],
   ([, ns], context) => {
-    const { linebreak } = context;
-    if (linebreak === 0) {
-      context.recursion.add(20 - (context.resources?.recursions[Recursion.annotation] ?? context.resources?.recursions.at(-1) ?? 20));
-      return new List([new Node(html('sup', { class: 'annotation' }, [html('span', defrag(unwrap(trimBlankNodeEnd(ns))))]))]);
+    const { linebreak, recursion, resources } = context;
+    if (linebreak !== 0) {
+      ns.unshift(new Node('('));
+      ns.push(new Node(')'));
+      return new List([new Node(html('span', { class: 'bracket' }, ['(', html('span', { class: 'bracket' }, defrag(unwrap(ns))), ')']))]);
     }
-    ns.unshift(new Node('('));
-    ns.push(new Node(')'));
-    return new List([new Node(html('span', { class: 'bracket' }, ['(', html('span', { class: 'bracket' }, defrag(unwrap(ns))), ')']))]);
+    const depth = MAX_DEPTH - (resources?.recursions[Recursion.annotation] ?? resources?.recursions.at(-1) ?? MAX_DEPTH);
+    recursion.add(depth);
+    return new List([new Node(html('sup', { class: 'annotation' }, [html('span', defrag(unwrap(trimBlankNodeEnd(ns))))]))]);
   },
-  ([, bs = new List()], context) => {
-    const { source, position, range, linebreak } = context;
-    if (linebreak === 0 && bs.length === 1 && source[position] === ')' && typeof bs.head?.value === 'object') {
+  ([, bs], context) => {
+    const { source, position, range, linebreak, recursion, resources } = context;
+    const depth = MAX_DEPTH - (resources?.recursions[Recursion.annotation] ?? resources?.recursions.at(-1) ?? MAX_DEPTH);
+    if (linebreak === 0 && bs && bs.length === 1 && source[position] === ')' && typeof bs.head?.value === 'object') {
       const { className } = bs.head.value;
       if (className === 'paren' || className === 'bracket') {
         const { firstChild, lastChild } = bs.head.value;
@@ -54,23 +62,37 @@ export const annotation: AnnotationParser = lazy(() => constraint(State.annotati
           lastChild!.nodeValue = lastChild!.nodeValue!.slice(0, -1);
         }
         context.position += 1;
-        context.recursion.add(20 - (context.resources?.recursions[Recursion.annotation] ?? context.resources?.recursions.at(-1) ?? 20));
+        recursion.add(depth);
         return new List([new Node(html('span', { class: 'bracket' }, ['(', html('sup', { class: 'annotation' }, [html('span', bs.head.value.childNodes)])]))]);
       }
       if (className === 'annotation' && deepunwrap(bs)) {
         context.position += 1;
-        context.recursion.add(20 - (context.resources?.recursions[Recursion.annotation] ?? context.resources?.recursions.at(-1) ?? 20));
+        recursion.add(depth);
         return new List([new Node(html('span', { class: 'bracket' }, ['(', html('sup', { class: 'annotation' }, [html('span', [bs.head.value])])]))]);
       }
     }
-    const str = linebreak === 0 ? source.slice(position - range + 2, position) : '';
-    if (linebreak === 0 && indexA.test(str)) {
-      return new List([new Node(html('span', { class: 'bracket' }, ['((' + str]))]);
+    bs ??= new List();
+    bs.unshift(new Node('('));
+    if (source[context.position] === ')') {
+      bs.push(new Node(')'));
+      context.position += 1;
     }
+    const str = linebreak === 0 ? source.slice(position - range + 2, position) : '';
+    bs = linebreak === 0 && (str === '' || indexA.test(str))
+      ? new List([new Node(html('span', { class: 'paren' }, defrag(unwrap(bs))))])
+      : new List([new Node(html('span', { class: 'bracket' }, defrag(unwrap(bs))))]);
     bs.unshift(new Node('('));
-    return new List([new Node(html('span', { class: 'bracket' }, ['(', html('span', { class: 'bracket' }, defrag(unwrap(bs)))]))]);
+    const cs = parser({ context });
+    if (source[context.position] === ')') {
+      cs && bs.import(cs);
+      bs.push(new Node(')'));
+      context.position += 1;
+    }
+    return new List([new Node(html('span', { class: 'bracket' }, defrag(unwrap(bs))))]);
   })));
 
+const parser = lazy(() => precedence(1, some(inline, ')', [[')', 1]])));
+
 function deepunwrap(list: List<Node<string | HTMLElement>>): boolean {
   let bottom = list.head!.value as HTMLElement;
   for (; bottom;) {

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

@@ -9,8 +9,8 @@ describe('Unit: parser/inline/bracket', () => {
     const parser = some(bracket);
 
     it('(', () => {
-      assert.deepStrictEqual(inspect(parser, input('(', new Context())), [['<span class="bracket">(</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('()', new Context())), [['<span class="bracket">()</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(', new Context())), [['<span class="paren">(</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('()', new Context())), [['<span class="paren">()</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('(a', new Context())), [['<span class="paren">(a</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('(0)', new Context())), [['<span class="paren">(0)</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('(1)', new Context())), [['<span class="paren">(1)</span>'], '']);
@@ -41,7 +41,8 @@ describe('Unit: parser/inline/bracket', () => {
       assert.deepStrictEqual(inspect(parser, input('(ABBR, ABBR)', new Context())), [['<span class="paren">(ABBR, ABBR)</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('(\\a)', new Context())), [['<span class="bracket">(a)</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('(==)', new Context())), [['<span class="bracket">(==)</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('("(\n))"(")', new Context())), [['<span class="bracket">("<span class="bracket">(</span><br>)</span>'], ')"(")']);
+      assert.deepStrictEqual(inspect(parser, input('(()', new Context())), [['<span class="bracket">(<span class="paren">()</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('("(\n))"(")', new Context())), [['<span class="bracket">("<span class="paren">(</span><br>)</span>'], ')"(")']);
       assert.deepStrictEqual(inspect(parser, input('($)$', new Context())), [['<span class="bracket">(<span class="math" translate="no" data-src="$)$">$)$</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser, input(')', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('（１，２）', new Context())), [['<span class="paren">（１，２）</span>'], '']);
@@ -80,10 +81,10 @@ describe('Unit: parser/inline/bracket', () => {
       assert.deepStrictEqual(inspect(parser, input('""', new Context())), [['"', '"'], '']);
       assert.deepStrictEqual(inspect(parser, input('"a', new Context())), [['"', 'a'], '']);
       assert.deepStrictEqual(inspect(parser, input('"a"', new Context())), [['"', 'a', '"'], '']);
-      assert.deepStrictEqual(inspect(parser, input('"(")"', new Context())), [['"', '<span class="bracket">(</span>', '"'], ')"']);
-      assert.deepStrictEqual(inspect(parser, input('"(("', new Context())), [['"', '<span class="bracket">(<span class="bracket">(</span></span>', '"'], '']);
+      assert.deepStrictEqual(inspect(parser, input('"(")"', new Context())), [['"', '<span class="paren">(</span>', '"'], ')"']);
+      assert.deepStrictEqual(inspect(parser, input('"(("', new Context())), [['"', '<span class="bracket">(<span class="paren">(</span></span>', '"'], '']);
       assert.deepStrictEqual(inspect(parser, input('"(\\")"', new Context())), [['"', '<span class="bracket">(")</span>', '"'], '']);
-      assert.deepStrictEqual(inspect(parser, input('"(\n)"(")', new Context())), [['"', '<span class="bracket">(</span>'], '\n)"(")']);
+      assert.deepStrictEqual(inspect(parser, input('"(\n)"(")', new Context())), [['"', '<span class="paren">(</span>'], '\n)"(")']);
       assert.deepStrictEqual(inspect(parser, input('"\n"', new Context())), [['"'], '\n"']);
       assert.deepStrictEqual(inspect(parser, input('"\n"(")', new Context())), [['"'], '\n"(")']);
     });

package/src/parser/inline/bracket.ts

@@ -41,14 +41,14 @@ const p1 = lazy(() => surround(
   true, [],
   ([as, bs = [], cs], { source, position, range, linebreak }) => {
     const str = linebreak === 0 ? source.slice(position - range + 1, position - 1) : '';
-    return linebreak === 0 && indexA.test(str)
+    return linebreak === 0 && (str === '' || indexA.test(str))
       ? new List([new Node(html('span', { class: 'paren' }, `(${str})`))])
       : new List([new Node(html('span', { class: 'bracket' }, defrag(unwrap(as.import(bs as List<Node<string>>).import(cs)))))]);
   },
   ([as, bs = new List()], context) => {
     const { source, position, range, linebreak } = context;
     const str = linebreak === 0 ? source.slice(position - range + 1, position) : '';
-    return linebreak === 0 && indexA.test(str)
+    return linebreak === 0 && (str === '' || indexA.test(str))
       ? new List([new Node(html('span', { class: 'paren' }, `(${str}`))])
       : new List([new Node(html('span', { class: 'bracket' }, defrag(unwrap(as.import(bs as List<Node<string>>)))))]);
   }));
@@ -60,14 +60,14 @@ const p2 = lazy(() => surround(
   true, [],
   ([as, bs = [], cs], { source, position, range, linebreak }) => {
     const str = linebreak === 0 ? source.slice(position - range + 1, position - 1) : '';
-    return linebreak === 0 && indexF.test(str)
+    return linebreak === 0 && (str === '' || indexF.test(str))
       ? new List([new Node(html('span', { class: 'paren' }, `（${str}）`))])
       : new List([new Node(html('span', { class: 'bracket' }, defrag(unwrap(as.import(bs as List<Node<string>>).import(cs)))))]);
   },
   ([as, bs = new List()], context) => {
     const { source, position, range, linebreak } = context;
     const str = linebreak === 0 ? source.slice(position - range + 1, position) : '';
-    return linebreak === 0 && indexF.test(str)
+    return linebreak === 0 && (str === '' || indexF.test(str))
       ? new List([new Node(html('span', { class: 'paren' }, `（${str}`))])
       : new List([new Node(html('span', { class: 'bracket' }, defrag(unwrap(as.import(bs as List<Node<string>>)))))]);
   }));

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

@@ -15,6 +15,7 @@ const MAX = 60;
 const ELLIPSIS = '...';
 const PART = (MAX - ELLIPSIS.length) / 2 | 0;
 const REM = MAX - PART * 2 - ELLIPSIS.length;
+assert(PART * 2 + REM + ELLIPSIS.length === MAX);
 const table = [
   ...[...Array(36)].map((_, i) => i.toString(36)),
   ...[...Array(36)].map((_, i) => i.toString(36).toUpperCase()).slice(-26),

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

@@ -15,6 +15,9 @@ describe('Unit: parser/inline/reference', () => {
       assert.deepStrictEqual(inspect(parser, input('[[', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('[[]]', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('[[]]]', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[[a', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[[a]', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[[a]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('[[[%]]', new Context())), undefined);
@@ -51,6 +54,7 @@ describe('Unit: parser/inline/reference', () => {
       assert.deepStrictEqual(inspect(parser, input('[[@a]]', new Context())), [['<sup class="reference"><span><a class="account" href="/@a">@a</a></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[[http://host]]', new Context())), [['<sup class="reference"><span><a class="url" href="http://host" target="_blank">http://host</a></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[[![]{a}]]', new Context())), [['<sup class="reference"><span>!<a class="url" href="a">a</a></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[a[[]]]]', new Context())), [['<sup class="reference"><span>a[[]]</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[[[a]]]', new Context())), [['<sup class="reference"><span>[a]</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[[[[a]]]]', new Context())), [['<sup class="reference"><span>[[a]]</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[[((a))]]', new Context())), [['<sup class="reference"><span><span class="bracket">(<span class="paren">(a)</span>)</span></span></sup>'], '']);

package/src/parser/inline/reference.ts

@@ -21,13 +21,12 @@ export const reference: ReferenceParser = lazy(() => constraint(State.reference,
   [2, 1 | Backtrack.common, 3 | Backtrack.doublebracket],
   ([, ns], context) => {
     const { position, range, linebreak } = context;
-    if (linebreak === 0) {
-      return new List([new Node(html('sup', attributes(ns), [html('span', defrag(unwrap(trimBlankNodeEnd(ns))))]))]);
-    }
-    else {
-      const head = position - range;
+    const head = position - range;
+    if (linebreak !== 0) {
       setBacktrack(context, 2 | Backtrack.link, head, 2);
+      return;
     }
+    return new List([new Node(html('sup', attributes(ns), [html('span', defrag(unwrap(trimBlankNodeEnd(ns))))]))]);
   },
   (_, context): undefined => {
     const { source, position, range, linebreak } = context;

package/src/parser/inline.test.ts

@@ -83,11 +83,11 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser, input('*++  a  ++*', new Context())), [['<em><ins> a </ins></em>'], '']);
       assert.deepStrictEqual(inspect(parser, input('*<bdi>`a`</bdi>*', new Context())), [['<em><bdi><code data-src="`a`">a</code></bdi></em>'], '']);
       assert.deepStrictEqual(inspect(parser, input('*a"\nb*', new Context())), [['<em>a"<br>b</em>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('*a"\n"("b*', new Context())), [['<em>a"<br>"<span class="bracket">(</span>"b</em>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('*a"\n"("b*', new Context())), [['<em>a"<br>"<span class="paren">(</span>"b</em>'], '']);
       assert.deepStrictEqual(inspect(parser, input('"*a\nb*', new Context())), [['"', '*', 'a', '<br>', 'b', '*'], '']);
       assert.deepStrictEqual(inspect(parser, input('"*a\n""b*', new Context())), [['"', '*', 'a', '<br>', '"', '"', 'b', '*'], '']);
       assert.deepStrictEqual(inspect(parser, input('"a\n"*b"c*', new Context())), [['"', 'a', '<br>', '"', '*', 'b', '"', 'c', '*'], '']);
-      assert.deepStrictEqual(inspect(parser, input('"*a**b\nc**"("*', new Context())), [['"', '*', 'a', '**', 'b', '<br>', 'c', '**', '"', '<span class="bracket">(</span>', '"', '*'], '']);
+      assert.deepStrictEqual(inspect(parser, input('"*a**b\nc**"("*', new Context())), [['"', '*', 'a', '**', 'b', '<br>', 'c', '**', '"', '<span class="paren">(</span>', '"', '*'], '']);
       assert.deepStrictEqual(inspect(parser, input('[% a"\nb %]', new Context())), [['<span class="remark"><input type="checkbox"><span>[% a"<br>b %]</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('"<bdi>"a\n""b</bdi>"', new Context())), [['"', '<span class="invalid">&lt;bdi&gt;</span>', '"', 'a', '<br>', '"', '"', 'b', '</bdi', '>', '"'], '']);
       assert.deepStrictEqual(inspect(parser, input('<bdi>*<bdi>a</bdi>*</bdi>', new Context())), [['<bdi><em><bdi>a</bdi></em></bdi>'], '']);
@@ -140,7 +140,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser, input('(([["*(*"] ]))', new Context())), [['<sup class="annotation"><span>[["*<span class="bracket">(*</span>"] ]</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser, input('(([:a\n]', new Context())), [['<span class="bracket">(<span class="bracket">(<span class="invalid">[:a\n]</span></span></span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('(({{\n}}', new Context())), [['<span class="bracket">(<span class="bracket">(<span class="template">{{<br>}}</span></span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('"((""))', new Context())), [['"', '<span class="bracket">(<span class="bracket">(</span></span>', '"', '"', ')', ')'], '']);
+      assert.deepStrictEqual(inspect(parser, input('"((""))', new Context())), [['"', '<span class="bracket">(<span class="paren">(</span></span>', '"', '"', ')', ')'], '']);
       assert.deepStrictEqual(inspect(parser, input('[[[a]]', new Context())), [['[', '<sup class="reference"><span>a</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[[[[a]]', new Context())), [['[', '[', '<sup class="reference"><span>a</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[[[[a]]]]', new Context())), [['<sup class="reference"><span>[[a]]</span></sup>'], '']);

package/src/parser/processor/note.test.ts

@@ -222,72 +222,50 @@ describe('Unit: parser/processor/note', () => {
     });
 
     it('nest', () => {
-      const target = parse('((a((b((c))))))((a))((b))((c))');
+      const target = parse('((a((b))))((a))((b))');
       for (let i = 0; i < 3; ++i) {
         [...note(target)];
         assert.deepStrictEqual(
           [...target.children].map(el => el.outerHTML),
           [
             html('p', [
-              html('sup', { class: 'annotation', id: 'annotation::ref:a((b((c)))):1', title: 'a((b((c))))' }, [
-                html('a', { href: '#annotation::def:a((b((c)))):1' }, '*1')
+              html('sup', { class: 'annotation', id: 'annotation::ref:a((b)):1', title: 'a((b))' }, [
+                html('a', { href: '#annotation::def:a((b)):1' }, '*1')
               ]),
               html('sup', { class: 'annotation', id: 'annotation::ref:a:1', title: 'a' }, [
-                html('a', { href: '#annotation::def:a:1' }, '*4')
+                html('a', { href: '#annotation::def:a:1' }, '*3')
               ]),
-              html('sup', { class: 'annotation', id: 'annotation::ref:b:1', title: 'b' }, [
-                html('a', { href: '#annotation::def:b:1' }, '*5')
-              ]),
-              html('sup', { class: 'annotation', id: 'annotation::ref:c:2', title: 'c' }, [
-                html('a', { href: '#annotation::def:c:1' }, '*3')
+              html('sup', { class: 'annotation', id: 'annotation::ref:b:2', title: 'b' }, [
+                html('a', { href: '#annotation::def:b:1' }, '*2')
               ]),
             ]).outerHTML,
             html('ol', { class: 'annotations' }, [
-              html('li', { id: 'annotation::def:a((b((c)))):1', 'data-marker': '*1' }, [
+              html('li', { id: 'annotation::def:a((b)):1', 'data-marker': '*1' }, [
                 html('span', [
                   'a',
-                  html('sup', { class: 'annotation', id: 'annotation::ref:b((c)):1', title: 'b((c))' }, [
-                    html('a', { href: '#annotation::def:b((c)):1' }, '*2')
+                  html('sup', { class: 'annotation', id: 'annotation::ref:b:1', title: 'b' }, [
+                    html('a', { href: '#annotation::def:b:1' }, '*2')
                   ]),
                 ]),
                 html('sup', [
-                  html('a', { href: '#annotation::ref:a((b((c)))):1' }, '^1'),
+                  html('a', { href: '#annotation::ref:a((b)):1' }, '^1'),
                 ])
               ]),
-              html('li', { id: 'annotation::def:b((c)):1', 'data-marker': '*2' }, [
+              html('li', { id: 'annotation::def:b:1', 'data-marker': '*2' }, [
                 html('span', [
                   'b',
-                  html('sup', { class: 'annotation', id: 'annotation::ref:c:1', title: 'c' }, [
-                    html('a', { href: '#annotation::def:c:1' }, '*3')
-                  ]),
-                ]),
-                html('sup', [
-                  html('a', { href: '#annotation::ref:b((c)):1' }, '^2'),
-                ])
-              ]),
-              html('li', { id: 'annotation::def:c:1', 'data-marker': '*3' }, [
-                html('span', [
-                  'c',
                 ]),
                 html('sup', [
-                  html('a', { href: '#annotation::ref:c:1' }, '^3'),
-                  html('a', { href: '#annotation::ref:c:2' }, '^6'),
+                  html('a', { href: '#annotation::ref:b:1' }, '^2'),
+                  html('a', { href: '#annotation::ref:b:2' }, '^4'),
                 ])
               ]),
-              html('li', { id: 'annotation::def:a:1', 'data-marker': '*4' }, [
+              html('li', { id: 'annotation::def:a:1', 'data-marker': '*3' }, [
                 html('span', [
                   'a',
                 ]),
                 html('sup', [
-                  html('a', { href: '#annotation::ref:a:1' }, '^4'),
-                ])
-              ]),
-              html('li', { id: 'annotation::def:b:1', 'data-marker': '*5' }, [
-                html('span', [
-                  'b',
-                ]),
-                html('sup', [
-                  html('a', { href: '#annotation::ref:b:1' }, '^5'),
+                  html('a', { href: '#annotation::ref:a:1' }, '^3'),
                 ])
               ]),
             ]).outerHTML,

package/src/parser/processor/note.ts

@@ -154,6 +154,9 @@ function build(
         : defs.get(identifier)!;
       initial && defs.set(identifier, def);
       assert(def.lastElementChild?.matches('sup'));
+      if (!initial && content.innerHTML.length > def.firstElementChild!.innerHTML.length) {
+        def.firstElementChild!.replaceWith(content);
+      }
       const defIndex = initial
         ? info.defIndex = total + defs.size
         : info.defIndex;
@@ -187,7 +190,7 @@ function build(
           info.queue.push(ref);
           break;
       }
-      yield ref.appendChild(html('a', { href: refId && defId && `#${defId}` }, marker(defIndex, abbr)));
+      ref.appendChild(html('a', { href: refId && defId && `#${defId}` }, marker(defIndex, abbr)));
       assert(ref.title || ref.matches('.invalid'));
       def.lastElementChild!.appendChild(
         html('a',
@@ -196,6 +199,7 @@ function build(
             title: abbr && text || undefined,
           },
           `^${++refIndex}`));
+      yield;
     }
     if (note || defs.size > 0) {
       const splitter = splitters[iSplitters++];

package/src/renderer/render.ts

@@ -19,7 +19,6 @@ export function render(source: HTMLElement, opts: RenderingOptions = {}): void {
 }
 
 function render_(base: string, source: HTMLElement, opts: RenderingOptions): void {
-  if (source.classList.contains('invalid')) return;
   try {
     switch (true) {
       case !!opts.code