securemark 0.297.4 → 0.297.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (24) hide show
  1. package/CHANGELOG.md +4 -0
  2. package/dist/index.js +158 -63
  3. package/package.json +1 -1
  4. package/src/combinator/data/parser/context.ts +26 -4
  5. package/src/parser/api/parse.test.ts +37 -1
  6. package/src/parser/block/blockquote.ts +1 -1
  7. package/src/parser/block/heading.test.ts +2 -2
  8. package/src/parser/block/sidefence.ts +4 -3
  9. package/src/parser/block/table.test.ts +2 -2
  10. package/src/parser/block/table.ts +1 -1
  11. package/src/parser/block.ts +2 -1
  12. package/src/parser/context.ts +17 -2
  13. package/src/parser/inline/annotation.test.ts +20 -16
  14. package/src/parser/inline/annotation.ts +68 -26
  15. package/src/parser/inline/bracket.test.ts +48 -48
  16. package/src/parser/inline/bracket.ts +8 -8
  17. package/src/parser/inline/emphasis.test.ts +2 -2
  18. package/src/parser/inline/emstrong.test.ts +3 -3
  19. package/src/parser/inline/extension/index.test.ts +1 -1
  20. package/src/parser/inline/italic.test.ts +1 -1
  21. package/src/parser/inline/link.test.ts +1 -1
  22. package/src/parser/inline/reference.test.ts +1 -1
  23. package/src/parser/inline/strong.test.ts +2 -2
  24. package/src/parser/inline.test.ts +23 -23
package/src/parser/block/sidefence.ts CHANGED
@@ -1,7 +1,7 @@
1
1
  import { SidefenceParser } from '../block';
2
2
  import { Recursion } from '../context';
3
3
  import { List, Node } from '../../combinator/data/parser';
4
- import { union, some, recursion, block, focus, rewrite, convert, lazy, fmap } from '../../combinator';
4
+ import { union, some, recursion, block, focus, rewrite, open, convert, lazy, fmap } from '../../combinator';
5
5
  import { autolink } from '../autolink';
6
6
  import { contentline } from '../source';
7
7
  import { unwrap, invalid } from '../util';
@@ -18,12 +18,13 @@ export const sidefence: SidefenceParser = lazy(() => block(fmap(focus(
18
18
  ]))));
19
19
 
20
20
  const opener = /(?=\|\|+(?:$|[ \n]))/y;
21
+ const indent = open(opener, some(contentline, /\|(?:$|[ \n])/y));
21
22
  const unindent = (source: string) => source.replace(/(?<=^|\n)\|(?: |(?=\|*(?:$|[ \n])))|\n$/g, '');
22
23
 
23
24
  const source: SidefenceParser.SourceParser = lazy(() => fmap(
24
25
  recursion(Recursion.block, some(union([
25
- focus(
26
- /(?:\|\|+(?=$|[ \n])[^\n]*(?:$|\n))+/y,
26
+ rewrite(
27
+ indent,
27
28
  convert(unindent, source, true)),
28
29
  rewrite(
29
30
  some(contentline, opener),
package/src/parser/block/table.test.ts CHANGED
@@ -15,6 +15,7 @@ describe('Unit: parser/block/table', () => {
15
15
  assert.deepStrictEqual(inspect(parser, input('||', new Context())), undefined);
16
16
  assert.deepStrictEqual(inspect(parser, input('|||', new Context())), undefined);
17
17
  assert.deepStrictEqual(inspect(parser, input('|\n|', new Context())), undefined);
18
+ assert.deepStrictEqual(inspect(parser, input('|\n|\n|', new Context())), undefined);
18
19
  assert.deepStrictEqual(inspect(parser, input('|h', new Context())), undefined);
19
20
  assert.deepStrictEqual(inspect(parser, input('|h', new Context())), undefined);
20
21
  assert.deepStrictEqual(inspect(parser, input('|h\n', new Context())), undefined);
@@ -27,13 +28,12 @@ describe('Unit: parser/block/table', () => {
27
28
  });
28
29
 
29
30
  it('valid', () => {
30
- assert.deepStrictEqual(inspect(parser, input('|\n|\n|', new Context())), [['<table><thead><tr></tr></thead><tbody><tr class="invalid"><td>|</td></tr><tr></tr></tbody></table>'], '']);
31
31
  assert.deepStrictEqual(inspect(parser, input('|\n|-\n|', new Context())), [['<table><thead><tr></tr></thead><tbody><tr></tr></tbody></table>'], '']);
32
32
  assert.deepStrictEqual(inspect(parser, input('||\n|-|\n||', new Context())), [['<table><thead><tr><th></th></tr></thead><tbody><tr><td></td></tr></tbody></table>'], '']);
33
33
  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>'], '']);
34
34
  assert.deepStrictEqual(inspect(parser, input('|"|\n|-\n|', new Context())), [['<table><thead><tr><th>"</th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
35
35
  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>'], '']);
36
- assert.deepStrictEqual(inspect(parser, input('|((|\n|-\n|', new Context())), [['<table><thead><tr><th><span class="paren">(<span class="paren">(</span></span></th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
36
+ 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>'], '']);
37
37
  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>'], '']);
38
38
  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>'], '']);
39
39
  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/block/table.ts CHANGED
@@ -14,7 +14,7 @@ import AlignParser = TableParser.AlignParser;
14
14
  import CellParser = TableParser.CellParser;
15
15
 
16
16
  export const table: TableParser = lazy(() => block(fmap(validate(
17
- /\|[^\n]*(?:\n\|[^\n]*){2}/y,
17
+ /\|[^\n]*\n\|[-:][^\n]*\n\|/y,
18
18
  sequence([
19
19
  row(some(head), true),
20
20
  row(some(align), false),
package/src/parser/block.ts CHANGED
@@ -49,10 +49,11 @@ export const block: BlockParser = reset(
49
49
  // バックトラックのせいで文字数制限を受けないようにする。
50
50
  clock: MAX_SEGMENT_SIZE * 6 + 1,
51
51
  recursions: [
52
- 10 || Recursion.block,
52
+ 5 || Recursion.block,
53
53
  20 || Recursion.blockquote,
54
54
  40 || Recursion.listitem,
55
55
  20 || Recursion.inline,
56
+ 20 || Recursion.annotation,
56
57
  20 || Recursion.bracket,
57
58
  20 || Recursion.terminal,
58
59
  ],
package/src/parser/context.ts CHANGED
@@ -28,6 +28,7 @@ export class Context extends Ctx {
28
28
  public override segment: Segment;
29
29
  public buffer: List<Node<(string | HTMLElement)>>;
30
30
  public sequential: boolean;
31
+ public recursion = new RecursionCounter(5);
31
32
  public readonly header: boolean;
32
33
  public readonly host?: URL;
33
34
  public readonly url?: URL;
@@ -40,6 +41,20 @@ export class Context extends Ctx {
40
41
  }
41
42
  export type Options = Partial<Context>;
42
43
 
44
+ class RecursionCounter {
45
+ constructor(private readonly limit: number) {
46
+ }
47
+ private readonly stack: number[] = [];
48
+ private index = 0;
49
+ public add(depth: number): void {
50
+ const { stack } = this
51
+ for (; this.index > 0 && stack[this.index - 1] <= depth; --this.index);
52
+ if (this.index === this.limit) throw new Error('Too much recursion');
53
+ stack[this.index] = depth;
54
+ ++this.index;
55
+ }
56
+ }
57
+
43
58
  export const enum Segment {
44
59
  unknown = 0,
45
60
  write = 1,
@@ -70,11 +85,11 @@ export const enum State {
70
85
  }
71
86
 
72
87
  export const enum Recursion {
73
- //ignore,
74
- block = 1,
88
+ block,
75
89
  blockquote,
76
90
  listitem,
77
91
  inline,
92
+ annotation,
78
93
  bracket,
79
94
  terminal,
80
95
  }
package/src/parser/inline/annotation.test.ts CHANGED
@@ -13,11 +13,11 @@ describe('Unit: parser/inline/annotation', () => {
13
13
  assert.deepStrictEqual(inspect(parser, input('(', new Context())), undefined);
14
14
  assert.deepStrictEqual(inspect(parser, input('()', new Context())), undefined);
15
15
  assert.deepStrictEqual(inspect(parser, input('((', new Context())), undefined);
16
- assert.deepStrictEqual(inspect(parser, input('(())', new Context())), [['<span class="paren">(<span class="paren">(</span></span>'], '))']);
17
- assert.deepStrictEqual(inspect(parser, input('(()))', new Context())), [['<span class="paren">(<span class="paren">(</span></span>'], ')))']);
18
- assert.deepStrictEqual(inspect(parser, input('(("))', new Context())), [['<span class="paren">(<span class="paren">("))</span></span>'], '']);
19
- assert.deepStrictEqual(inspect(parser, input('(([))', new Context())), [['<span class="paren">(<span class="paren">([))</span></span>'], '']);
20
- assert.deepStrictEqual(inspect(parser, input('(([%))', new Context())), [['<span class="paren">(<span class="paren">([%))</span></span>'], '']);
16
+ assert.deepStrictEqual(inspect(parser, input('(())', new Context())), [['<span class="bracket">(<span class="bracket">(</span></span>'], '))']);
17
+ assert.deepStrictEqual(inspect(parser, input('(()))', new Context())), [['<span class="bracket">(<span class="bracket">(</span></span>'], ')))']);
18
+ assert.deepStrictEqual(inspect(parser, input('(("))', new Context())), [['<span class="bracket">(<span class="bracket">("))</span></span>'], '']);
19
+ assert.deepStrictEqual(inspect(parser, input('(([))', new Context())), [['<span class="bracket">(<span class="bracket">([))</span></span>'], '']);
20
+ assert.deepStrictEqual(inspect(parser, input('(([%))', new Context())), [['<span class="bracket">(<span class="bracket">([%))</span></span>'], '']);
21
21
  assert.deepStrictEqual(inspect(parser, input('(( ))', new Context())), undefined);
22
22
  assert.deepStrictEqual(inspect(parser, input('(( a))', new Context())), undefined);
23
23
  assert.deepStrictEqual(inspect(parser, input('(( a ))', new Context())), undefined);
@@ -26,16 +26,20 @@ describe('Unit: parser/inline/annotation', () => {
26
26
  assert.deepStrictEqual(inspect(parser, input('((\n))', new Context())), undefined);
27
27
  assert.deepStrictEqual(inspect(parser, input('((\na))', new Context())), undefined);
28
28
  assert.deepStrictEqual(inspect(parser, input('((\\\na))', new Context())), undefined);
29
- assert.deepStrictEqual(inspect(parser, input('((a\n))', new Context())), [['<span class="paren">(<span class="paren">(a<br>)</span>)</span>'], '']);
30
- assert.deepStrictEqual(inspect(parser, input('((a\\\n))', new Context())), [['<span class="paren">(<span class="paren">(a<br>)</span>)</span>'], '']);
31
- assert.deepStrictEqual(inspect(parser, input('((a\nb))', new Context())), [['<span class="paren">(<span class="paren">(a<br>b)</span>)</span>'], '']);
32
- assert.deepStrictEqual(inspect(parser, input('((a\\\nb))', new Context())), [['<span class="paren">(<span class="paren">(a<br>b)</span>)</span>'], '']);
33
- assert.deepStrictEqual(inspect(parser, input('((*a\nb*))', new Context())), [['<span class="paren">(<span class="paren">(<em>a<br>b</em>)</span>)</span>'], '']);
34
- assert.deepStrictEqual(inspect(parser, input('((\\))', new Context())), [['<span class="paren">(<span class="paren">()</span></span>'], ')']);
35
- assert.deepStrictEqual(inspect(parser, input('((a)b))', new Context())), [['<span class="paren">((a</span>'], ')b))']);
36
- assert.deepStrictEqual(inspect(parser, input('((!)b))', new Context())), [['<span class="paren">(<span class="paren">(!</span></span>'], ')b))']);
37
- assert.deepStrictEqual(inspect(parser, input('(((a))', new Context())), [['<span class="paren">(<sup class="annotation"><span>a</span></sup></span>'], '']);
38
- assert.deepStrictEqual(inspect(parser, input('(((!))', new Context())), [['<span class="paren">(<sup class="annotation"><span>!</span></sup></span>'], '']);
29
+ assert.deepStrictEqual(inspect(parser, input('((a\n))', new Context())), [['<span class="bracket">(<span class="bracket">(a<br>)</span>)</span>'], '']);
30
+ assert.deepStrictEqual(inspect(parser, input('((a\\\n))', new Context())), [['<span class="bracket">(<span class="bracket">(a<br>)</span>)</span>'], '']);
31
+ assert.deepStrictEqual(inspect(parser, input('((a\nb))', new Context())), [['<span class="bracket">(<span class="bracket">(a<br>b)</span>)</span>'], '']);
32
+ assert.deepStrictEqual(inspect(parser, input('((a\\\nb))', new Context())), [['<span class="bracket">(<span class="bracket">(a<br>b)</span>)</span>'], '']);
33
+ assert.deepStrictEqual(inspect(parser, input('((*a\nb*))', new Context())), [['<span class="bracket">(<span class="bracket">(<em>a<br>b</em>)</span>)</span>'], '']);
34
+ assert.deepStrictEqual(inspect(parser, input('((\\))', new Context())), [['<span class="bracket">(<span class="bracket">()</span></span>'], ')']);
35
+ assert.deepStrictEqual(inspect(parser, input('((a)b))', new Context())), [['<span class="bracket">((a</span>'], ')b))']);
36
+ assert.deepStrictEqual(inspect(parser, input('((!)b))', new Context())), [['<span class="bracket">(<span class="bracket">(!</span></span>'], ')b))']);
37
+ assert.deepStrictEqual(inspect(parser, input('(((a))', new Context())), [['<span class="bracket">(<sup class="annotation"><span>a</span></sup></span>'], '']);
38
+ assert.deepStrictEqual(inspect(parser, input('(((!))', new Context())), [['<span class="bracket">(<sup class="annotation"><span>!</span></sup></span>'], '']);
39
+ assert.deepStrictEqual(inspect(parser, input('(((*a*))', new Context())), [['<span class="bracket">(<sup class="annotation"><span><em>a</em></span></sup></span>'], '']);
40
+ assert.deepStrictEqual(inspect(parser, input('(((((a))))', new Context())), [['<span class="bracket">(<sup class="annotation"><span><sup class="annotation"><span>a</span></sup></span></sup></span>'], '']);
41
+ assert.deepStrictEqual(inspect(parser, input('(((((!))))', new Context())), [['<span class="bracket">(<sup class="annotation"><span><sup class="annotation"><span>!</span></sup></span></sup></span>'], '']);
42
+ assert.deepStrictEqual(inspect(parser, input('(((((*a*))))', new Context())), [['<span class="bracket">(<sup class="annotation"><span><sup class="annotation"><span><em>a</em></span></sup></span></sup></span>'], '']);
39
43
  assert.deepStrictEqual(inspect(parser, input(' ((a))', new Context())), undefined);
40
44
  });
41
45
 
@@ -54,7 +58,7 @@ describe('Unit: parser/inline/annotation', () => {
54
58
  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>'], '']);
55
59
  assert.deepStrictEqual(inspect(parser, input('((![]{a}))', new Context())), [['<sup class="annotation"><span>!<a class="url" href="a">a</a></span></sup>'], '']);
56
60
  assert.deepStrictEqual(inspect(parser, input('(([[a] ]))', new Context())), [['<sup class="annotation"><span>[[a] ]</span></sup>'], '']);
57
- assert.deepStrictEqual(inspect(parser, input('(((a)))', new Context())), [['<sup class="annotation"><span>(a)</span></sup>'], '']);
61
+ assert.deepStrictEqual(inspect(parser, input('(((a)))', new Context())), [['<sup class="annotation"><span><span class="paren">(a)</span></span></sup>'], '']);
58
62
  assert.deepStrictEqual(inspect(parser, input('((((a))))', new Context())), [['<sup class="annotation"><span><sup class="annotation"><span>a</span></sup></span></sup>'], '']);
59
63
  assert.deepStrictEqual(inspect(parser, input('(([[a]]))', new Context())), [['<sup class="annotation"><span><sup class="reference"><span>a</span></sup></span></sup>'], '']);
60
64
  });
package/src/parser/inline/annotation.ts CHANGED
@@ -1,57 +1,99 @@
1
1
  import { AnnotationParser } from '../inline';
2
2
  import { State, Recursion } from '../context';
3
3
  import { List, Node } from '../../combinator/data/parser';
4
- import { union, some, recursion, precedence, constraint, surround, open, lazy } from '../../combinator';
4
+ import { union, some, recursions, precedence, constraint, surround, open, lazy } from '../../combinator';
5
5
  import { inline } from '../inline';
6
6
  import { indexA } from './bracket';
7
7
  import { beforeNonblank, trimBlankNodeEnd } from '../visibility';
8
8
  import { unwrap } from '../util';
9
9
  import { html, defrag } from 'typed-dom/dom';
10
10
 
11
+ // シグネチャ等生成のために構文木のツリーウォークを再帰的に行い指数計算量にならないよう
12
+ // 動的計画法を適用するか再帰数を制限する必要がある。
13
+ // 動的計画法においては再帰的記録により指数空間計算量にならないよう下位の記録を消しながら記録しなければならない。
14
+ // トリムも再帰的に行わないよう前後のトリムサイズの記録を要する。
15
+ // しかし理論的には再帰数の制限はないがポップアップテキストの記録やハッシュの計算を行う言語仕様から指数計算量を
16
+ // 避けられないためAnnotation構文に限り再帰数の制限が必要となる。
17
+ // シグネチャやハッシュは分割計算可能にすれば解決するがポップアップテキストは記録せず動的に再計算して
18
+ // 表示しなければ指数空間計算量を避けられない。
19
+ // 注釈は本来再帰的に行うものではないため再帰数を制限して機能を優先するのが合理的となる。
11
20
  export const annotation: AnnotationParser = lazy(() => constraint(State.annotation, surround(
12
21
  open('((', beforeNonblank),
13
- precedence(1, recursion(Recursion.inline, recursion(Recursion.bracket, recursion(Recursion.bracket,
14
- some(union([inline]), ')', [[')', 1]]))))),
22
+ precedence(1, recursions([Recursion.annotation, Recursion.inline, Recursion.bracket, Recursion.bracket],
23
+ some(union([inline]), ')', [[')', 1]]))),
15
24
  '))',
16
25
  false, [],
17
26
  ([, ns], context) => {
18
27
  const { linebreak } = context;
19
28
  if (linebreak === 0) {
29
+ context.recursion.add(20 - (context.resources?.recursions[Recursion.annotation] ?? context.resources?.recursions.at(-1) ?? 20));
20
30
  return new List([new Node(html('sup', { class: 'annotation' }, [html('span', defrag(unwrap(trimBlankNodeEnd(ns))))]))]);
21
31
  }
22
32
  ns.unshift(new Node('('));
23
33
  ns.push(new Node(')'));
24
- return new List([new Node(html('span', { class: 'paren' }, ['(', html('span', { class: 'paren' }, defrag(unwrap(ns))), ')']))]);
34
+ return new List([new Node(html('span', { class: 'bracket' }, ['(', html('span', { class: 'bracket' }, defrag(unwrap(ns))), ')']))]);
25
35
  },
26
36
  ([, bs = new List()], context) => {
27
37
  const { source, position, range, linebreak } = context;
28
- if (linebreak === 0 && bs.length === 1 && source[position] === ')' && typeof bs.head?.value === 'object' && bs.head.value.className === 'paren') {
29
- const { firstChild, lastChild } = bs.head.value;
30
- assert(firstChild instanceof Text);
31
- if (firstChild!.nodeValue!.length === 1) {
32
- firstChild!.remove();
38
+ if (linebreak === 0 && bs.length === 1 && source[position] === ')' && typeof bs.head?.value === 'object') {
39
+ const { className } = bs.head.value;
40
+ if (className === 'paren' || className === 'bracket') {
41
+ const { firstChild, lastChild } = bs.head.value;
42
+ assert(firstChild instanceof Text);
43
+ if (firstChild!.nodeValue!.length === 1) {
44
+ firstChild!.remove();
45
+ }
46
+ else {
47
+ firstChild!.nodeValue = firstChild!.nodeValue!.slice(1);
48
+ }
49
+ assert(lastChild instanceof Text);
50
+ if (lastChild!.nodeValue!.length === 1) {
51
+ lastChild!.remove();
52
+ }
53
+ else {
54
+ lastChild!.nodeValue = lastChild!.nodeValue!.slice(0, -1);
55
+ }
56
+ context.position += 1;
57
+ context.recursion.add(20 - (context.resources?.recursions[Recursion.annotation] ?? context.resources?.recursions.at(-1) ?? 20));
58
+ return new List([new Node(html('span', { class: 'bracket' }, ['(', html('sup', { class: 'annotation' }, [html('span', bs.head.value.childNodes)])]))]);
33
59
  }
34
- else {
35
- firstChild!.nodeValue = firstChild!.nodeValue!.slice(1);
60
+ if (className === 'annotation' && deepunwrap(bs)) {
61
+ context.position += 1;
62
+ context.recursion.add(20 - (context.resources?.recursions[Recursion.annotation] ?? context.resources?.recursions.at(-1) ?? 20));
63
+ return new List([new Node(html('span', { class: 'bracket' }, ['(', html('sup', { class: 'annotation' }, [html('span', [bs.head.value])])]))]);
36
64
  }
37
- assert(lastChild instanceof Text);
38
- if (lastChild!.nodeValue!.length === 1) {
39
- lastChild!.remove();
40
- }
41
- else {
42
- lastChild!.nodeValue = lastChild!.nodeValue!.slice(0, -1);
43
- }
44
- context.position += 1;
45
- return new List([new Node(html('span', { class: 'paren' }, ['(', html('sup', { class: 'annotation' }, [html('span', bs.head.value.childNodes)])]))]);
46
- }
47
- if (linebreak === 0 && bs.length === 3 && source[position - range + 2] === '(' && source[position] === ')' && source[position - 1] === ')' && source[position - 2] !== '\\') {
48
- context.position += 1;
49
- return new List([new Node(html('span', { class: 'paren' }, ['(', html('sup', { class: 'annotation' }, [html('span', [bs.head!.next!.value])])]))]);
50
65
  }
51
66
  const str = linebreak === 0 ? source.slice(position - range + 2, position) : '';
52
67
  if (linebreak === 0 && indexA.test(str)) {
53
- return new List([new Node(html('span', { class: 'paren' }, ['((' + str]))]);
68
+ return new List([new Node(html('span', { class: 'bracket' }, ['((' + str]))]);
54
69
  }
55
70
  bs.unshift(new Node('('));
56
- return new List([new Node(html('span', { class: 'paren' }, ['(', html('span', { class: 'paren' }, defrag(unwrap(bs)))]))]);
71
+ return new List([new Node(html('span', { class: 'bracket' }, ['(', html('span', { class: 'bracket' }, defrag(unwrap(bs)))]))]);
57
72
  })));
73
+
74
+ function deepunwrap(list: List<Node<string | HTMLElement>>): boolean {
75
+ let bottom = list.head!.value as HTMLElement;
76
+ for (; bottom;) {
77
+ const el = bottom.firstChild!.firstChild;
78
+ if (el !== el?.parentNode?.lastChild) break;
79
+ if (el instanceof HTMLElement === false) break;
80
+ if (el?.className !== 'annotation') break;
81
+ bottom = el;
82
+ }
83
+ const el = bottom.firstChild!.firstChild;
84
+ if (el instanceof Element === false) return false;
85
+ if (el === el?.parentNode?.lastChild) {
86
+ const { className, firstChild, lastChild } = el;
87
+ if (className === 'paren' || className === 'bracket') {
88
+ firstChild!.nodeValue!.length === 1
89
+ ? firstChild!.remove()
90
+ : firstChild!.nodeValue = firstChild!.nodeValue!.slice(1);
91
+ lastChild!.nodeValue!.length === 1
92
+ ? lastChild!.remove()
93
+ : lastChild!.nodeValue = lastChild!.nodeValue!.slice(0, -1);
94
+ el.replaceWith(...el.childNodes);
95
+ return true;
96
+ }
97
+ }
98
+ return false;
99
+ }
package/src/parser/inline/bracket.test.ts CHANGED
@@ -9,51 +9,51 @@ describe('Unit: parser/inline/bracket', () => {
9
9
  const parser = some(bracket);
10
10
 
11
11
  it('(', () => {
12
- assert.deepStrictEqual(inspect(parser, input('(', new Context())), [['<span class="paren">(</span>'], '']);
13
- assert.deepStrictEqual(inspect(parser, input('()', new Context())), [['<span class="paren">()</span>'], '']);
14
- assert.deepStrictEqual(inspect(parser, input('(a', new Context())), [['(', 'a'], '']);
15
- assert.deepStrictEqual(inspect(parser, input('(0)', new Context())), [['(', '0', ')'], '']);
16
- assert.deepStrictEqual(inspect(parser, input('(1)', new Context())), [['(', '1', ')'], '']);
17
- assert.deepStrictEqual(inspect(parser, input('(10)', new Context())), [['(', '10', ')'], '']);
18
- assert.deepStrictEqual(inspect(parser, input('(2000)', new Context())), [['(', '2000', ')'], '']);
19
- assert.deepStrictEqual(inspect(parser, input('(0-1)', new Context())), [['(', '0-1', ')'], '']);
20
- assert.deepStrictEqual(inspect(parser, input('(0)-1', new Context())), [['(', '0', ')'], '-1']);
21
- assert.deepStrictEqual(inspect(parser, input('(0.1)', new Context())), [['(', '0.1', ')'], '']);
22
- assert.deepStrictEqual(inspect(parser, input('(0.1.2)', new Context())), [['(', '0.1.2', ')'], '']);
23
- assert.deepStrictEqual(inspect(parser, input('(1.1, 1.2-1.3, 1.4)', new Context())), [['(', '1.1, 1.2-1.3, 1.4', ')'], '']);
24
- assert.deepStrictEqual(inspect(parser, input('(1 2)', new Context())), [['<span class="paren">(1 2)</span>'], '']);
25
- assert.deepStrictEqual(inspect(parser, input('(1, 2)', new Context())), [['(', '1, 2', ')'], '']);
26
- assert.deepStrictEqual(inspect(parser, input('(1a)', new Context())), [['(', '1a', ')'], '']);
27
- assert.deepStrictEqual(inspect(parser, input('(a)', new Context())), [['(', 'a', ')'], '']);
28
- assert.deepStrictEqual(inspect(parser, input('(a1)', new Context())), [['(', 'a1', ')'], '']);
29
- assert.deepStrictEqual(inspect(parser, input('(a-1)', new Context())), [['(', 'a-1', ')'], '']);
30
- assert.deepStrictEqual(inspect(parser, input('(a.1)', new Context())), [['(', 'a.1', ')'], '']);
31
- assert.deepStrictEqual(inspect(parser, input('(a b)', new Context())), [['<span class="paren">(a b)</span>'], '']);
32
- assert.deepStrictEqual(inspect(parser, input('(word)', new Context())), [['(', 'word', ')'], '']);
33
- assert.deepStrictEqual(inspect(parser, input('(word word)', new Context())), [['<span class="paren">(word word)</span>'], '']);
34
- assert.deepStrictEqual(inspect(parser, input('(word, word)', new Context())), [['(', 'word, word', ')'], '']);
35
- assert.deepStrictEqual(inspect(parser, input('(A)', new Context())), [['(', 'A', ')'], '']);
36
- assert.deepStrictEqual(inspect(parser, input('(Name)', new Context())), [['(', 'Name', ')'], '']);
37
- assert.deepStrictEqual(inspect(parser, input('(Word word)', new Context())), [['<span class="paren">(Word word)</span>'], '']);
38
- assert.deepStrictEqual(inspect(parser, input('(Word Word)', new Context())), [['<span class="paren">(Word Word)</span>'], '']);
39
- assert.deepStrictEqual(inspect(parser, input('(Name, Name)', new Context())), [['(', 'Name, Name', ')'], '']);
40
- assert.deepStrictEqual(inspect(parser, input('(ABBR)', new Context())), [['(', 'ABBR', ')'], '']);
41
- assert.deepStrictEqual(inspect(parser, input('(ABBR, ABBR)', new Context())), [['(', 'ABBR, ABBR', ')'], '']);
42
- assert.deepStrictEqual(inspect(parser, input('(\\a)', new Context())), [['<span class="paren">(a)</span>'], '']);
43
- assert.deepStrictEqual(inspect(parser, input('(==)', new Context())), [['<span class="paren">(==)</span>'], '']);
44
- assert.deepStrictEqual(inspect(parser, input('("(\n))"(")', new Context())), [['<span class="paren">("<span class="paren">(</span><br>)</span>'], ')"(")']);
45
- assert.deepStrictEqual(inspect(parser, input('($)$', new Context())), [['<span class="paren">(<span class="math" translate="no" data-src="$)$">$)$</span></span>'], '']);
12
+ assert.deepStrictEqual(inspect(parser, input('(', new Context())), [['<span class="bracket">(</span>'], '']);
13
+ assert.deepStrictEqual(inspect(parser, input('()', new Context())), [['<span class="bracket">()</span>'], '']);
14
+ assert.deepStrictEqual(inspect(parser, input('(a', new Context())), [['<span class="paren">(a</span>'], '']);
15
+ assert.deepStrictEqual(inspect(parser, input('(0)', new Context())), [['<span class="paren">(0)</span>'], '']);
16
+ assert.deepStrictEqual(inspect(parser, input('(1)', new Context())), [['<span class="paren">(1)</span>'], '']);
17
+ assert.deepStrictEqual(inspect(parser, input('(10)', new Context())), [['<span class="paren">(10)</span>'], '']);
18
+ assert.deepStrictEqual(inspect(parser, input('(2000)', new Context())), [['<span class="paren">(2000)</span>'], '']);
19
+ assert.deepStrictEqual(inspect(parser, input('(0-1)', new Context())), [['<span class="paren">(0-1)</span>'], '']);
20
+ assert.deepStrictEqual(inspect(parser, input('(0)-1', new Context())), [['<span class="paren">(0)</span>'], '-1']);
21
+ assert.deepStrictEqual(inspect(parser, input('(0.1)', new Context())), [['<span class="paren">(0.1)</span>'], '']);
22
+ assert.deepStrictEqual(inspect(parser, input('(0.1.2)', new Context())), [['<span class="paren">(0.1.2)</span>'], '']);
23
+ assert.deepStrictEqual(inspect(parser, input('(1.1, 1.2-1.3, 1.4)', new Context())), [['<span class="paren">(1.1, 1.2-1.3, 1.4)</span>'], '']);
24
+ assert.deepStrictEqual(inspect(parser, input('(1 2)', new Context())), [['<span class="bracket">(1 2)</span>'], '']);
25
+ assert.deepStrictEqual(inspect(parser, input('(1, 2)', new Context())), [['<span class="paren">(1, 2)</span>'], '']);
26
+ assert.deepStrictEqual(inspect(parser, input('(1a)', new Context())), [['<span class="paren">(1a)</span>'], '']);
27
+ assert.deepStrictEqual(inspect(parser, input('(a)', new Context())), [['<span class="paren">(a)</span>'], '']);
28
+ assert.deepStrictEqual(inspect(parser, input('(a1)', new Context())), [['<span class="paren">(a1)</span>'], '']);
29
+ assert.deepStrictEqual(inspect(parser, input('(a-1)', new Context())), [['<span class="paren">(a-1)</span>'], '']);
30
+ assert.deepStrictEqual(inspect(parser, input('(a.1)', new Context())), [['<span class="paren">(a.1)</span>'], '']);
31
+ assert.deepStrictEqual(inspect(parser, input('(a b)', new Context())), [['<span class="bracket">(a b)</span>'], '']);
32
+ assert.deepStrictEqual(inspect(parser, input('(word)', new Context())), [['<span class="paren">(word)</span>'], '']);
33
+ assert.deepStrictEqual(inspect(parser, input('(word word)', new Context())), [['<span class="bracket">(word word)</span>'], '']);
34
+ assert.deepStrictEqual(inspect(parser, input('(word, word)', new Context())), [['<span class="paren">(word, word)</span>'], '']);
35
+ assert.deepStrictEqual(inspect(parser, input('(A)', new Context())), [['<span class="paren">(A)</span>'], '']);
36
+ assert.deepStrictEqual(inspect(parser, input('(Name)', new Context())), [['<span class="paren">(Name)</span>'], '']);
37
+ assert.deepStrictEqual(inspect(parser, input('(Word word)', new Context())), [['<span class="bracket">(Word word)</span>'], '']);
38
+ assert.deepStrictEqual(inspect(parser, input('(Word Word)', new Context())), [['<span class="bracket">(Word Word)</span>'], '']);
39
+ assert.deepStrictEqual(inspect(parser, input('(Name, Name)', new Context())), [['<span class="paren">(Name, Name)</span>'], '']);
40
+ assert.deepStrictEqual(inspect(parser, input('(ABBR)', new Context())), [['<span class="paren">(ABBR)</span>'], '']);
41
+ assert.deepStrictEqual(inspect(parser, input('(ABBR, ABBR)', new Context())), [['<span class="paren">(ABBR, ABBR)</span>'], '']);
42
+ assert.deepStrictEqual(inspect(parser, input('(\\a)', new Context())), [['<span class="bracket">(a)</span>'], '']);
43
+ assert.deepStrictEqual(inspect(parser, input('(==)', new Context())), [['<span class="bracket">(==)</span>'], '']);
44
+ assert.deepStrictEqual(inspect(parser, input('("(\n))"(")', new Context())), [['<span class="bracket">("<span class="bracket">(</span><br>)</span>'], ')"(")']);
45
+ assert.deepStrictEqual(inspect(parser, input('($)$', new Context())), [['<span class="bracket">(<span class="math" translate="no" data-src="$)$">$)$</span></span>'], '']);
46
46
  assert.deepStrictEqual(inspect(parser, input(')', new Context())), undefined);
47
- assert.deepStrictEqual(inspect(parser, input('（１，２）', new Context())), [['（', '１，２', '）'], '']);
48
- assert.deepStrictEqual(inspect(parser, input('（０－１）', new Context())), [['（', '０－１', '）'], '']);
49
- assert.deepStrictEqual(inspect(parser, input('（０．１）', new Context())), [['（', '０．１', '）'], '']);
50
- assert.deepStrictEqual(inspect(parser, input('（ａ）', new Context())), [['（', 'ａ', '）'], '']);
51
- assert.deepStrictEqual(inspect(parser, input('（Ａ）', new Context())), [['（', 'Ａ', '）'], '']);
52
- assert.deepStrictEqual(inspect(parser, input('（Ａ，Ｂ）', new Context())), [['（', 'Ａ，Ｂ', '）'], '']);
53
- assert.deepStrictEqual(inspect(parser, input('（Ａ、Ｂ）', new Context())), [['（', 'Ａ、Ｂ', '）'], '']);
54
- assert.deepStrictEqual(inspect(parser, input('(<bdi>a\\\nb</bdi>)', new Context())), [['<span class="paren">(<bdi>a<br>b</bdi>)</span>'], '']);
55
- assert.deepStrictEqual(inspect(parser, input('([% a\\\nb %])', new Context())), [['<span class="paren">(<span class="remark"><input type="checkbox"><span>[% a<br>b %]</span></span>)</span>'], '']);
56
- assert.deepStrictEqual(inspect(parser, input('({{\\\n}})', new Context())), [['<span class="paren">(<span class="template">{{\\<br>}}</span>)</span>'], '']);
47
+ assert.deepStrictEqual(inspect(parser, input('（１，２）', new Context())), [['<span class="paren">（１，２）</span>'], '']);
48
+ assert.deepStrictEqual(inspect(parser, input('（０－１）', new Context())), [['<span class="paren">（０－１）</span>'], '']);
49
+ assert.deepStrictEqual(inspect(parser, input('（０．１）', new Context())), [['<span class="paren">（０．１）</span>'], '']);
50
+ assert.deepStrictEqual(inspect(parser, input('（ａ）', new Context())), [['<span class="paren">（ａ）</span>'], '']);
51
+ assert.deepStrictEqual(inspect(parser, input('（Ａ）', new Context())), [['<span class="paren">（Ａ）</span>'], '']);
52
+ assert.deepStrictEqual(inspect(parser, input('（Ａ，Ｂ）', new Context())), [['<span class="paren">（Ａ，Ｂ）</span>'], '']);
53
+ assert.deepStrictEqual(inspect(parser, input('（Ａ、Ｂ）', new Context())), [['<span class="paren">（Ａ、Ｂ）</span>'], '']);
54
+ assert.deepStrictEqual(inspect(parser, input('(<bdi>a\\\nb</bdi>)', new Context())), [['<span class="bracket">(<bdi>a<br>b</bdi>)</span>'], '']);
55
+ assert.deepStrictEqual(inspect(parser, input('([% a\\\nb %])', new Context())), [['<span class="bracket">(<span class="remark"><input type="checkbox"><span>[% a<br>b %]</span></span>)</span>'], '']);
56
+ assert.deepStrictEqual(inspect(parser, input('({{\\\n}})', new Context())), [['<span class="bracket">(<span class="template">{{\\<br>}}</span>)</span>'], '']);
57
57
  });
58
58
 
59
59
  it('[', () => {
@@ -80,10 +80,10 @@ describe('Unit: parser/inline/bracket', () => {
80
80
  assert.deepStrictEqual(inspect(parser, input('""', new Context())), [['"', '"'], '']);
81
81
  assert.deepStrictEqual(inspect(parser, input('"a', new Context())), [['"', 'a'], '']);
82
82
  assert.deepStrictEqual(inspect(parser, input('"a"', new Context())), [['"', 'a', '"'], '']);
83
- assert.deepStrictEqual(inspect(parser, input('"(")"', new Context())), [['"', '<span class="paren">(</span>', '"'], ')"']);
84
- assert.deepStrictEqual(inspect(parser, input('"(("', new Context())), [['"', '<span class="paren">(<span class="paren">(</span></span>', '"'], '']);
85
- assert.deepStrictEqual(inspect(parser, input('"(\\")"', new Context())), [['"', '<span class="paren">(")</span>', '"'], '']);
86
- assert.deepStrictEqual(inspect(parser, input('"(\n)"(")', new Context())), [['"', '<span class="paren">(</span>'], '\n)"(")']);
83
+ assert.deepStrictEqual(inspect(parser, input('"(")"', new Context())), [['"', '<span class="bracket">(</span>', '"'], ')"']);
84
+ assert.deepStrictEqual(inspect(parser, input('"(("', new Context())), [['"', '<span class="bracket">(<span class="bracket">(</span></span>', '"'], '']);
85
+ assert.deepStrictEqual(inspect(parser, input('"(\\")"', new Context())), [['"', '<span class="bracket">(")</span>', '"'], '']);
86
+ assert.deepStrictEqual(inspect(parser, input('"(\n)"(")', new Context())), [['"', '<span class="bracket">(</span>'], '\n)"(")']);
87
87
  assert.deepStrictEqual(inspect(parser, input('"\n"', new Context())), [['"'], '\n"']);
88
88
  assert.deepStrictEqual(inspect(parser, input('"\n"(")', new Context())), [['"'], '\n"(")']);
89
89
  });
package/src/parser/inline/bracket.ts CHANGED
@@ -42,15 +42,15 @@ const p1 = lazy(() => surround(
42
42
  ([as, bs = [], cs], { source, position, range, linebreak }) => {
43
43
  const str = linebreak === 0 ? source.slice(position - range + 1, position - 1) : '';
44
44
  return linebreak === 0 && indexA.test(str)
45
- ? new List([new Node(as.head!.value), new Node(str), new Node(cs.head!.value)])
46
- : new List([new Node(html('span', { class: 'paren' }, defrag(unwrap(as.import(bs as List<Node<string>>).import(cs)))))]);
45
+ ? new List([new Node(html('span', { class: 'paren' }, `(${str})`))])
46
+ : new List([new Node(html('span', { class: 'bracket' }, defrag(unwrap(as.import(bs as List<Node<string>>).import(cs)))))]);
47
47
  },
48
48
  ([as, bs = new List()], context) => {
49
49
  const { source, position, range, linebreak } = context;
50
50
  const str = linebreak === 0 ? source.slice(position - range + 1, position) : '';
51
51
  return linebreak === 0 && indexA.test(str)
52
- ? new List([new Node(as.head!.value), new Node(str)])
53
- : new List([new Node(html('span', { class: 'paren' }, defrag(unwrap(as.import(bs as List<Node<string>>)))))]);
52
+ ? new List([new Node(html('span', { class: 'paren' }, `(${str}`))])
53
+ : new List([new Node(html('span', { class: 'bracket' }, defrag(unwrap(as.import(bs as List<Node<string>>)))))]);
54
54
  }));
55
55
 
56
56
  const p2 = lazy(() => surround(
@@ -61,15 +61,15 @@ const p2 = lazy(() => surround(
61
61
  ([as, bs = [], cs], { source, position, range, linebreak }) => {
62
62
  const str = linebreak === 0 ? source.slice(position - range + 1, position - 1) : '';
63
63
  return linebreak === 0 && indexF.test(str)
64
- ? new List([new Node(as.head!.value), new Node(str), new Node(cs.head!.value)])
65
- : new List([new Node(html('span', { class: 'paren' }, defrag(unwrap(as.import(bs as List<Node<string>>).import(cs)))))]);
64
+ ? new List([new Node(html('span', { class: 'paren' }, `（${str}）`))])
65
+ : new List([new Node(html('span', { class: 'bracket' }, defrag(unwrap(as.import(bs as List<Node<string>>).import(cs)))))]);
66
66
  },
67
67
  ([as, bs = new List()], context) => {
68
68
  const { source, position, range, linebreak } = context;
69
69
  const str = linebreak === 0 ? source.slice(position - range + 1, position) : '';
70
70
  return linebreak === 0 && indexF.test(str)
71
- ? new List([new Node(as.head!.value), new Node(str)])
72
- : new List([new Node(html('span', { class: 'paren' }, defrag(unwrap(as.import(bs as List<Node<string>>)))))]);
71
+ ? new List([new Node(html('span', { class: 'paren' }, `（${str}`))])
72
+ : new List([new Node(html('span', { class: 'bracket' }, defrag(unwrap(as.import(bs as List<Node<string>>)))))]);
73
73
  }));
74
74
 
75
75
  const s1 = lazy(() => surround(
package/src/parser/inline/emphasis.test.ts CHANGED
@@ -51,8 +51,8 @@ describe('Unit: parser/inline/emphasis', () => {
51
51
  assert.deepStrictEqual(inspect(parser, input('*a**b**c*', new Context())), [['<em>a<strong>b</strong>c</em>'], '']);
52
52
  assert.deepStrictEqual(inspect(parser, input('*a**b**c*d', new Context())), [['<em>a<strong>b</strong>c</em>'], 'd']);
53
53
  assert.deepStrictEqual(inspect(parser, input('*`a`*', new Context())), [['<em><code data-src="`a`">a</code></em>'], '']);
54
- assert.deepStrictEqual(inspect(parser, input('*(*a*)*', new Context())), [['<em><span class="paren">(<em>a</em>)</span></em>'], '']);
55
- assert.deepStrictEqual(inspect(parser, input('*(**a**)*', new Context())), [['<em><span class="paren">(<strong>a</strong>)</span></em>'], '']);
54
+ assert.deepStrictEqual(inspect(parser, input('*(*a*)*', new Context())), [['<em><span class="bracket">(<em>a</em>)</span></em>'], '']);
55
+ assert.deepStrictEqual(inspect(parser, input('*(**a**)*', new Context())), [['<em><span class="bracket">(<strong>a</strong>)</span></em>'], '']);
56
56
  });
57
57
 
58
58
  });
package/src/parser/inline/emstrong.test.ts CHANGED
@@ -37,9 +37,9 @@ describe('Unit: parser/inline/emstrong', () => {
37
37
 
38
38
  it('nest', () => {
39
39
  assert.deepStrictEqual(inspect(parser, input('***`a`***', new Context())), [['<em><strong><code data-src="`a`">a</code></strong></em>'], '']);
40
- assert.deepStrictEqual(inspect(parser, input('***(*a*)***', new Context())), [['<em><strong><span class="paren">(<em>a</em>)</span></strong></em>'], '']);
41
- assert.deepStrictEqual(inspect(parser, input('***(**a**)***', new Context())), [['<em><strong><span class="paren">(<strong>a</strong>)</span></strong></em>'], '']);
42
- assert.deepStrictEqual(inspect(parser, input('***(***a***)***', new Context())), [['<em><strong><span class="paren">(<em><strong>a</strong></em>)</span></strong></em>'], '']);
40
+ assert.deepStrictEqual(inspect(parser, input('***(*a*)***', new Context())), [['<em><strong><span class="bracket">(<em>a</em>)</span></strong></em>'], '']);
41
+ assert.deepStrictEqual(inspect(parser, input('***(**a**)***', new Context())), [['<em><strong><span class="bracket">(<strong>a</strong>)</span></strong></em>'], '']);
42
+ assert.deepStrictEqual(inspect(parser, input('***(***a***)***', new Context())), [['<em><strong><span class="bracket">(<em><strong>a</strong></em>)</span></strong></em>'], '']);
43
43
  assert.deepStrictEqual(inspect(parser, input('***a*', new Context())), [['**', '<em>a</em>'], '']);
44
44
  assert.deepStrictEqual(inspect(parser, input('***a*b', new Context())), [['**', '<em>a</em>', 'b'], '']);
45
45
  assert.deepStrictEqual(inspect(parser, input('***a*b*', new Context())), [['**', '<em>a</em>', 'b'], '*']);
package/src/parser/inline/extension/index.test.ts CHANGED
@@ -72,7 +72,7 @@ describe('Unit: parser/inline/extension/index', () => {
72
72
  assert.deepStrictEqual(inspect(parser, input('[#!http://host]', new Context())), [['<a class="index" href="#index::!http://host">!http://host</a>'], '']);
73
73
  assert.deepStrictEqual(inspect(parser, input('[#[% %]]', new Context())), [['<a class="index"><span class="remark"><input type="checkbox"><span>[% %]</span></span></a>'], '']);
74
74
  assert.deepStrictEqual(inspect(parser, input('[#[% a %]]', new Context())), [['<a class="index"><span class="remark"><input type="checkbox"><span>[% a %]</span></span></a>'], '']);
75
- assert.deepStrictEqual(inspect(parser, input('[#a((b))]', new Context())), [['<a class="index" href="#index::a((b))">a<span class="paren">((b))</span></a>'], '']);
75
+ assert.deepStrictEqual(inspect(parser, input('[#a((b))]', new Context())), [['<a class="index" href="#index::a((b))">a<span class="bracket">(<span class="paren">(b)</span>)</span></a>'], '']);
76
76
  assert.deepStrictEqual(inspect(parser, input('[#a[[b]]]', new Context())), [['<a class="index" href="#index::a[[b]]">a[[b]]</a>'], '']);
77
77
  });
78
78
 
package/src/parser/inline/italic.test.ts CHANGED
@@ -67,7 +67,7 @@ describe('Unit: parser/inline/italic', () => {
67
67
  assert.deepStrictEqual(inspect(parser, input('///a&Tab;///b//////', new Context())), [['<i>a\t<i>b</i></i>'], '']);
68
68
  assert.deepStrictEqual(inspect(parser, input('///a<wbr>///b//////', new Context())), [['<i>a<wbr><i>b</i></i>'], '']);
69
69
  assert.deepStrictEqual(inspect(parser, input('///`a`///', new Context())), [['<i><code data-src="`a`">a</code></i>'], '']);
70
- assert.deepStrictEqual(inspect(parser, input('///(///a///)///', new Context())), [['<i><span class="paren">(<i>a</i>)</span></i>'], '']);
70
+ assert.deepStrictEqual(inspect(parser, input('///(///a///)///', new Context())), [['<i><span class="bracket">(<i>a</i>)</span></i>'], '']);
71
71
  assert.deepStrictEqual(inspect(parser, input('///{http://host/}///', new Context())), [['<i><a class="url" href="http://host/" target="_blank">http://host/</a></i>'], '']);
72
72
  });
73
73
 
package/src/parser/inline/link.test.ts CHANGED
@@ -177,7 +177,7 @@ describe('Unit: parser/inline/link', () => {
177
177
  assert.deepStrictEqual(inspect(parser, input('[[![]{a}]{a}]{a}', new Context())), [['<a class="link" href="a">[![]{a}]{a}</a>'], '']);
178
178
  assert.deepStrictEqual(inspect(parser, input('[[![]{a}]{a}]{b}', new Context())), [['<a class="link" href="b">[![]{a}]{a}</a>'], '']);
179
179
  assert.deepStrictEqual(inspect(parser, input('[[![]{a}]{b}]{b}', new Context())), [['<a class="link" href="b">[![]{a}]{b}</a>'], '']);
180
- assert.deepStrictEqual(inspect(parser, input('[((a))]{b}', new Context())), [['<a class="link" href="b"><span class="paren">((a))</span></a>'], '']);
180
+ assert.deepStrictEqual(inspect(parser, input('[((a))]{b}', new Context())), [['<a class="link" href="b"><span class="bracket">(<span class="paren">(a)</span>)</span></a>'], '']);
181
181
  assert.deepStrictEqual(inspect(parser, input('[[[a]]]{b}', new Context())), [['<a class="link" href="b">[[a]]</a>'], '']);
182
182
  assert.deepStrictEqual(inspect(parser, input('[#a]{b}', new Context())), [['<a class="link" href="b">#a</a>'], '']);
183
183
  assert.deepStrictEqual(inspect(parser, input('[@a]{b}', new Context())), [['<a class="link" href="b">@a</a>'], '']);
package/src/parser/inline/reference.test.ts CHANGED
@@ -53,7 +53,7 @@ describe('Unit: parser/inline/reference', () => {
53
53
  assert.deepStrictEqual(inspect(parser, input('[[![]{a}]]', new Context())), [['<sup class="reference"><span>!<a class="url" href="a">a</a></span></sup>'], '']);
54
54
  assert.deepStrictEqual(inspect(parser, input('[[[a]]]', new Context())), [['<sup class="reference"><span>[a]</span></sup>'], '']);
55
55
  assert.deepStrictEqual(inspect(parser, input('[[[[a]]]]', new Context())), [['<sup class="reference"><span>[[a]]</span></sup>'], '']);
56
- assert.deepStrictEqual(inspect(parser, input('[[((a))]]', new Context())), [['<sup class="reference"><span><span class="paren">((a))</span></span></sup>'], '']);
56
+ assert.deepStrictEqual(inspect(parser, input('[[((a))]]', new Context())), [['<sup class="reference"><span><span class="bracket">(<span class="paren">(a)</span>)</span></span></sup>'], '']);
57
57
  });
58
58
 
59
59
  it('abbr', () => {
package/src/parser/inline/strong.test.ts CHANGED
@@ -48,8 +48,8 @@ describe('Unit: parser/inline/strong', () => {
48
48
  assert.deepStrictEqual(inspect(parser, input('**a*b*c**', new Context())), [['<strong>a<em>b</em>c</strong>'], '']);
49
49
  assert.deepStrictEqual(inspect(parser, input('**a*b*c**d', new Context())), [['<strong>a<em>b</em>c</strong>'], 'd']);
50
50
  assert.deepStrictEqual(inspect(parser, input('**`a`**', new Context())), [['<strong><code data-src="`a`">a</code></strong>'], '']);
51
- assert.deepStrictEqual(inspect(parser, input('**(*a*)**', new Context())), [['<strong><span class="paren">(<em>a</em>)</span></strong>'], '']);
52
- assert.deepStrictEqual(inspect(parser, input('**(**a**)**', new Context())), [['<strong><span class="paren">(<strong>a</strong>)</span></strong>'], '']);
51
+ assert.deepStrictEqual(inspect(parser, input('**(*a*)**', new Context())), [['<strong><span class="bracket">(<em>a</em>)</span></strong>'], '']);
52
+ assert.deepStrictEqual(inspect(parser, input('**(**a**)**', new Context())), [['<strong><span class="bracket">(<strong>a</strong>)</span></strong>'], '']);
53
53
  });
54
54
 
55
55
  });