securemark 0.298.3 → 0.298.4

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/design.md +1 -5
  3. package/dist/index.js +64 -71
  4. package/package.json +1 -1
  5. package/src/parser/api/bind.ts +13 -16
  6. package/src/parser/api/parse.test.ts +7 -10
  7. package/src/parser/api/parse.ts +24 -27
  8. package/src/parser/block/heading.test.ts +2 -2
  9. package/src/parser/block/table.test.ts +1 -1
  10. package/src/parser/block.ts +63 -80
  11. package/src/parser/context.ts +20 -0
  12. package/src/parser/inline/annotation.test.ts +19 -19
  13. package/src/parser/inline/annotation.ts +10 -7
  14. package/src/parser/inline/bracket.test.ts +11 -11
  15. package/src/parser/inline/bracket.ts +7 -16
  16. package/src/parser/inline/emphasis.test.ts +2 -2
  17. package/src/parser/inline/emstrong.test.ts +3 -3
  18. package/src/parser/inline/extension/index.test.ts +1 -1
  19. package/src/parser/inline/italic.test.ts +1 -1
  20. package/src/parser/inline/link.test.ts +1 -1
  21. package/src/parser/inline/reference.test.ts +1 -1
  22. package/src/parser/inline/strong.test.ts +2 -2
  23. package/src/parser/inline.test.ts +14 -14
  24. package/src/parser/segment.ts +6 -9
package/src/parser/block.ts CHANGED
@@ -1,8 +1,7 @@
1
1
  import { MarkdownParser } from '../../markdown';
2
- import { Segment, Recursion, Command } from './context';
2
+ import { Segment, Command } from './context';
3
3
  import { List, Node } from '../combinator/data/parser';
4
- import { union, reset, firstline, recover } from '../combinator';
5
- import { MAX_SEGMENT_SIZE } from './segment';
4
+ import { union, firstline, recover } from '../combinator';
6
5
  import { header } from './header';
7
6
  import { emptysegment } from './source';
8
7
  import { pagebreak } from './block/pagebreak';
@@ -43,84 +42,68 @@ export import MediaBlockParser = BlockParser.MediaBlockParser;
43
42
  export import ReplyParser = BlockParser.ReplyParser;
44
43
  export import ParagraphParser = BlockParser.ParagraphParser;
45
44
 
46
- export const block: BlockParser = reset(
47
- {
48
- resources: {
49
- // バックトラックのせいで文字数制限を受けないようにする。
50
- clock: MAX_SEGMENT_SIZE * 6 + 1,
51
- recursions: [
52
- 5 || Recursion.block,
53
- 20 || Recursion.blockquote,
54
- 40 || Recursion.listitem,
55
- 20 || Recursion.inline,
56
- 20 || Recursion.annotation,
57
- 20 || Recursion.bracket,
58
- 20 || Recursion.terminal,
59
- ],
60
- },
45
+ export const block: BlockParser = error(union([
46
+ emptysegment,
47
+ input => {
48
+ const { source, position, segment } = input;
49
+ if (position === source.length) return;
50
+ switch (segment ^ Segment.write) {
51
+ case Segment.heading:
52
+ return heading(input);
53
+ case Segment.fig:
54
+ return fig(input);
55
+ case Segment.figure:
56
+ return figure(input);
57
+ }
58
+ const char = source[position];
59
+ switch (char) {
60
+ case Command.Error:
61
+ throw new Error(firstline(source, position + 1).trimEnd());
62
+ case '=':
63
+ if (source.startsWith('===', position)) return pagebreak(input);
64
+ break;
65
+ case '`':
66
+ if (source.startsWith('```', position)) return codeblock(input);
67
+ break;
68
+ case '~':
69
+ if (source.startsWith('~~~', position)) return extension(input);
70
+ if (source[position + 1] === ' ') return dlist(input);
71
+ break;
72
+ case '-':
73
+ if (source.startsWith('---', position)) return header(input);
74
+ if (source[position + 1] === ' ') return ulist(input) || ilist(input);
75
+ break;
76
+ case '+':
77
+ case '*':
78
+ if (source[position + 1] === ' ') return ilist(input);
79
+ break;
80
+ case '[':
81
+ switch (source[position + 1]) {
82
+ case '$':
83
+ return figbase(input);
84
+ case '!':
85
+ return mediablock(input);
86
+ }
87
+ break;
88
+ case '!':
89
+ if (source[position + 1] === '>') return blockquote(input);
90
+ return mediablock(input);
91
+ case '>':
92
+ if (source[position + 1] === '>') return blockquote(input) || reply(input);
93
+ return blockquote(input);
94
+ case '$':
95
+ if (source[position + 1] === '$') return mathblock(input);
96
+ return figbase(input);
97
+ case '|':
98
+ return table(input) || sidefence(input);
99
+ case '(':
100
+ return olist(input);
101
+ default:
102
+ if ('0' <= char && char <= '9') return olist(input);
103
+ }
61
104
  },
62
- error(union([
63
- emptysegment,
64
- input => {
65
- const { source, position, segment } = input;
66
- if (position === source.length) return;
67
- switch (segment ^ Segment.write) {
68
- case Segment.heading:
69
- return heading(input);
70
- case Segment.fig:
71
- return fig(input);
72
- case Segment.figure:
73
- return figure(input);
74
- }
75
- const char = source[position];
76
- switch (char) {
77
- case Command.Error:
78
- throw new Error(firstline(source, position + 1).trimEnd());
79
- case '=':
80
- if (source.startsWith('===', position)) return pagebreak(input);
81
- break;
82
- case '`':
83
- if (source.startsWith('```', position)) return codeblock(input);
84
- break;
85
- case '~':
86
- if (source.startsWith('~~~', position)) return extension(input);
87
- if (source[position + 1] === ' ') return dlist(input);
88
- break;
89
- case '-':
90
- if (source.startsWith('---', position)) return header(input);
91
- if (source[position + 1] === ' ') return ulist(input) || ilist(input);
92
- break;
93
- case '+':
94
- case '*':
95
- if (source[position + 1] === ' ') return ilist(input);
96
- break;
97
- case '[':
98
- switch (source[position + 1]) {
99
- case '$':
100
- return figbase(input);
101
- case '!':
102
- return mediablock(input);
103
- }
104
- break;
105
- case '!':
106
- if (source[position + 1] === '>') return blockquote(input);
107
- return mediablock(input);
108
- case '>':
109
- if (source[position + 1] === '>') return blockquote(input) || reply(input);
110
- return blockquote(input);
111
- case '$':
112
- if (source[position + 1] === '$') return mathblock(input);
113
- return figbase(input);
114
- case '|':
115
- return table(input) || sidefence(input);
116
- case '(':
117
- return olist(input);
118
- default:
119
- if ('0' <= char && char <= '9') return olist(input);
120
- }
121
- },
122
- paragraph
123
- ])));
105
+ paragraph
106
+ ]));
124
107
 
125
108
  function error(parser: BlockParser): BlockParser {
126
109
  const reg = new RegExp(String.raw`^${Command.Error}[^\r\n]*\r?\n`)
package/src/parser/context.ts CHANGED
@@ -1,6 +1,9 @@
1
1
  import { List, Node, Context as Ctx } from '../../src/combinator/data/parser';
2
2
  import { Dict } from 'spica/dict';
3
3
 
4
+ export const MAX_SEGMENT_SIZE = 100_000; // 100,000 bytes (Max value size of FDB)
5
+ export const MAX_INPUT_SIZE = MAX_SEGMENT_SIZE * 10;
6
+
4
7
  export class Context extends Ctx {
5
8
  constructor(
6
9
  options: Partial<Context> = {},
@@ -17,6 +20,19 @@ export class Context extends Ctx {
17
20
  id,
18
21
  caches,
19
22
  } = options;
23
+ this.resources ??= {
24
+ // バックトラックのせいで文字数制限を受けないようにする。
25
+ clock: MAX_SEGMENT_SIZE * (6 + 1),
26
+ recursions: [
27
+ 5 || Recursion.block,
28
+ 20 || Recursion.blockquote,
29
+ 40 || Recursion.listitem,
30
+ 20 || Recursion.inline,
31
+ 20 || Recursion.annotation,
32
+ 20 || Recursion.bracket,
33
+ 20 || Recursion.terminal,
34
+ ],
35
+ };
20
36
  this.segment = segment ?? Segment.unknown;
21
37
  this.local = local ?? false;
22
38
  this.sequential = sequential ?? false;
@@ -27,6 +43,10 @@ export class Context extends Ctx {
27
43
  this.id = id;
28
44
  this.caches = caches;
29
45
  }
46
+ public override readonly resources?: {
47
+ clock: number;
48
+ recursions: number[];
49
+ };
30
50
  public override segment: Segment;
31
51
  public local: boolean;
32
52
  public sequential: boolean;
package/src/parser/inline/annotation.test.ts CHANGED
@@ -13,17 +13,17 @@ 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="bracket">(<span class="paren">()</span>)</span>'], '']);
17
- assert.deepStrictEqual(inspect(parser, input('(()))', new Context())), [['<span class="bracket">(<span class="paren">()</span>)</span>'], ')']);
18
- assert.deepStrictEqual(inspect(parser, input('(("))', new Context())), [['<span class="bracket">(<span class="bracket">("))</span></span>'], '']);
19
- assert.deepStrictEqual(inspect(parser, input('((a', new Context())), [['<span class="bracket">(<span class="paren">(a</span></span>'], '']);
20
- assert.deepStrictEqual(inspect(parser, input('((!', new Context())), [['<span class="bracket">(<span class="bracket">(!</span></span>'], '']);
21
- assert.deepStrictEqual(inspect(parser, input('((a)', new Context())), [['<span class="bracket">(<span class="paren">(a)</span></span>'], '']);
22
- assert.deepStrictEqual(inspect(parser, input('((!)', new Context())), [['<span class="bracket">(<span class="bracket">(!)</span></span>'], '']);
23
- assert.deepStrictEqual(inspect(parser, input('((a)b)', new Context())), [['<span class="bracket">(<span class="paren">(a)</span>b)</span>'], '']);
24
- assert.deepStrictEqual(inspect(parser, input('((!)b)', new Context())), [['<span class="bracket">(<span class="bracket">(!)</span>b)</span>'], '']);
25
- assert.deepStrictEqual(inspect(parser, input('(([))', new Context())), [['<span class="bracket">(<span class="bracket">([))</span></span>'], '']);
26
- assert.deepStrictEqual(inspect(parser, input('(([%))', new Context())), [['<span class="bracket">(<span class="bracket">([%))</span></span>'], '']);
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('((a', new Context())), [['<span class="paren">(<span class="paren">(a</span></span>'], '']);
20
+ assert.deepStrictEqual(inspect(parser, input('((!', new Context())), [['<span class="paren">(<span class="paren">(!</span></span>'], '']);
21
+ assert.deepStrictEqual(inspect(parser, input('((a)', new Context())), [['<span class="paren">(<span class="paren">(a)</span></span>'], '']);
22
+ assert.deepStrictEqual(inspect(parser, input('((!)', new Context())), [['<span class="paren">(<span class="paren">(!)</span></span>'], '']);
23
+ assert.deepStrictEqual(inspect(parser, input('((a)b)', new Context())), [['<span class="paren">(<span class="paren">(a)</span>b)</span>'], '']);
24
+ assert.deepStrictEqual(inspect(parser, input('((!)b)', new Context())), [['<span class="paren">(<span class="paren">(!)</span>b)</span>'], '']);
25
+ assert.deepStrictEqual(inspect(parser, input('(([))', new Context())), [['<span class="paren">(<span class="paren">([))</span></span>'], '']);
26
+ assert.deepStrictEqual(inspect(parser, input('(([%))', new Context())), [['<span class="paren">(<span class="paren">([%))</span></span>'], '']);
27
27
  assert.deepStrictEqual(inspect(parser, input('(( ))', new Context())), undefined);
28
28
  assert.deepStrictEqual(inspect(parser, input('(( a))', new Context())), undefined);
29
29
  assert.deepStrictEqual(inspect(parser, input('(( a ))', new Context())), undefined);
@@ -37,13 +37,13 @@ describe('Unit: parser/inline/annotation', () => {
37
37
  assert.deepStrictEqual(inspect(parser, input('((a\nb))', new Context())), [['<span class="bracket">(<span class="bracket">(a<br>b)</span>)</span>'], '']);
38
38
  assert.deepStrictEqual(inspect(parser, input('((a\\\nb))', new Context())), [['<span class="bracket">(<span class="bracket">(a<br>b)</span>)</span>'], '']);
39
39
  assert.deepStrictEqual(inspect(parser, input('((*a\nb*))', new Context())), [['<span class="bracket">(<span class="bracket">(<em>a<br>b</em>)</span>)</span>'], '']);
40
- assert.deepStrictEqual(inspect(parser, input('((\\))', new Context())), [['<span class="bracket">(<span class="bracket">())</span></span>'], '']);
41
- assert.deepStrictEqual(inspect(parser, input('(((a))', new Context())), [['<span class="bracket">(<sup class="annotation"><span>a</span></sup></span>'], '']);
42
- assert.deepStrictEqual(inspect(parser, input('(((!))', new Context())), [['<span class="bracket">(<sup class="annotation"><span>!</span></sup></span>'], '']);
43
- assert.deepStrictEqual(inspect(parser, input('(((*a*))', new Context())), [['<span class="bracket">(<sup class="annotation"><span><em>a</em></span></sup></span>'], '']);
44
- 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>'], '']);
45
- assert.deepStrictEqual(inspect(parser, input('(((((!))))', new Context())), [['<span class="bracket">(<sup class="annotation"><span><sup class="annotation"><span>!</span></sup></span></sup></span>'], '']);
46
- 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>'], '']);
40
+ assert.deepStrictEqual(inspect(parser, input('((\\))', new Context())), [['<span class="paren">(<span class="paren">())</span></span>'], '']);
41
+ assert.deepStrictEqual(inspect(parser, input('(((a))', new Context())), [['<span class="paren">(<sup class="annotation"><span>a</span></sup></span>'], '']);
42
+ assert.deepStrictEqual(inspect(parser, input('(((!))', new Context())), [['<span class="paren">(<sup class="annotation"><span>!</span></sup></span>'], '']);
43
+ assert.deepStrictEqual(inspect(parser, input('(((*a*))', new Context())), [['<span class="paren">(<sup class="annotation"><span><em>a</em></span></sup></span>'], '']);
44
+ assert.deepStrictEqual(inspect(parser, input('(((((a))))', new Context())), [['<span class="paren">(<sup class="annotation"><span><sup class="annotation"><span>a</span></sup></span></sup></span>'], '']);
45
+ assert.deepStrictEqual(inspect(parser, input('(((((!))))', new Context())), [['<span class="paren">(<sup class="annotation"><span><sup class="annotation"><span>!</span></sup></span></sup></span>'], '']);
46
+ assert.deepStrictEqual(inspect(parser, input('(((((*a*))))', new Context())), [['<span class="paren">(<sup class="annotation"><span><sup class="annotation"><span><em>a</em></span></sup></span></sup></span>'], '']);
47
47
  assert.deepStrictEqual(inspect(parser, input(' ((a))', new Context())), undefined);
48
48
  });
49
49
 
@@ -61,7 +61,7 @@ describe('Unit: parser/inline/annotation', () => {
61
61
  assert.deepStrictEqual(inspect(parser, input('((@a))', new Context())), [['<sup class="annotation"><span><a class="account" href="/@a">@a</a></span></sup>'], '']);
62
62
  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>'], '']);
63
63
  assert.deepStrictEqual(inspect(parser, input('((![]{a}))', new Context())), [['<sup class="annotation"><span>!<a class="url" href="a">a</a></span></sup>'], '']);
64
- assert.deepStrictEqual(inspect(parser, input('((a(())))', new Context())), [['<sup class="annotation"><span>a<span class="bracket">(<span class="paren">()</span>)</span></span></sup>'], '']);
64
+ assert.deepStrictEqual(inspect(parser, input('((a(())))', new Context())), [['<sup class="annotation"><span>a<span class="paren">(<span class="paren">()</span>)</span></span></sup>'], '']);
65
65
  assert.deepStrictEqual(inspect(parser, input('((a[[]]))', new Context())), [['<sup class="annotation"><span>a[[]]</span></sup>'], '']);
66
66
  assert.deepStrictEqual(inspect(parser, input('(([[a] ]))', new Context())), [['<sup class="annotation"><span>[[a] ]</span></sup>'], '']);
67
67
  assert.deepStrictEqual(inspect(parser, input('(((a)))', new Context())), [['<sup class="annotation"><span><span class="paren">(a)</span></span></sup>'], '']);
package/src/parser/inline/annotation.ts CHANGED
@@ -3,7 +3,7 @@ import { State, Recursion } from '../context';
3
3
  import { List, Node } from '../../combinator/data/parser';
4
4
  import { union, some, recursions, precedence, constraint, surround, open, lazy } from '../../combinator';
5
5
  import { inline } from '../inline';
6
- import { bracketname, indexA } from './bracket';
6
+ import { bracketname } from './bracket';
7
7
  import { beforeNonblank, trimBlankNodeEnd } from '../visibility';
8
8
  import { unwrap } from '../util';
9
9
  import { html, defrag } from 'typed-dom/dom';
@@ -36,8 +36,8 @@ export const annotation: AnnotationParser = lazy(() => constraint(State.annotati
36
36
  ns.push(new Node(')'));
37
37
  return new List([
38
38
  new Node(html('span',
39
- { class: 'bracket' },
40
- ['(', html('span', { class: 'bracket' }, defrag(unwrap(ns))), ')']))
39
+ { class: bracketname(context, 1, 1) },
40
+ ['(', html('span', { class: bracketname(context, 2, 2) }, defrag(unwrap(ns))), ')']))
41
41
  ]);
42
42
  }
43
43
  const depth = MAX_DEPTH - (resources?.recursions[Recursion.annotation] ?? resources?.recursions.at(-1) ?? MAX_DEPTH);
@@ -71,7 +71,7 @@ export const annotation: AnnotationParser = lazy(() => constraint(State.annotati
71
71
  recursion.add(depth);
72
72
  return new List([
73
73
  new Node(html('span',
74
- { class: 'bracket' },
74
+ { class: 'paren' },
75
75
  ['(', html('sup', { class: 'annotation' }, [html('span', bs.head.value.childNodes)])]))
76
76
  ]);
77
77
  }
@@ -80,7 +80,7 @@ export const annotation: AnnotationParser = lazy(() => constraint(State.annotati
80
80
  recursion.add(depth);
81
81
  return new List([
82
82
  new Node(html('span',
83
- { class: 'bracket' },
83
+ { class: 'paren' },
84
84
  ['(', html('sup', { class: 'annotation' }, [html('span', [bs.head.value])])]))
85
85
  ]);
86
86
  }
@@ -94,7 +94,7 @@ export const annotation: AnnotationParser = lazy(() => constraint(State.annotati
94
94
  }
95
95
  bs = new List([
96
96
  new Node(html('span',
97
- { class: bracketname(context, indexA, 2, context.position - position) },
97
+ { class: bracketname(context, 2, context.position - position) },
98
98
  defrag(unwrap(bs))))
99
99
  ]);
100
100
  bs.unshift(new Node('('));
@@ -103,8 +103,11 @@ export const annotation: AnnotationParser = lazy(() => constraint(State.annotati
103
103
  cs && bs.import(cs);
104
104
  bs.push(new Node(')'));
105
105
  context.position += 1;
106
+ context.range += 1;
106
107
  }
107
- return new List([new Node(html('span', { class: 'bracket' }, defrag(unwrap(bs))))]);
108
+ return new List([new Node(html('span',
109
+ { class: bracketname(context, 1, context.position - position) },
110
+ defrag(unwrap(bs))))]);
108
111
  })));
109
112
 
110
113
  const parser = lazy(() => precedence(1, some(inline, ')', [[')', 1]])));
package/src/parser/inline/bracket.test.ts CHANGED
@@ -23,30 +23,30 @@ describe('Unit: parser/inline/bracket', () => {
23
23
  assert.deepStrictEqual(inspect(parser, input('(1, 2)', new Context())), [['<span class="paren">(1, 2)</span>'], '']);
24
24
  assert.deepStrictEqual(inspect(parser, input('(1.1-1.2)', new Context())), [['<span class="paren">(1.1-1.2)</span>'], '']);
25
25
  assert.deepStrictEqual(inspect(parser, input('(1.1, 1.2)', new Context())), [['<span class="paren">(1.1, 1.2)</span>'], '']);
26
- assert.deepStrictEqual(inspect(parser, input('(1 2)', new Context())), [['<span class="bracket">(1 2)</span>'], '']);
26
+ assert.deepStrictEqual(inspect(parser, input('(1 2)', new Context())), [['<span class="paren">(1 2)</span>'], '']);
27
27
  assert.deepStrictEqual(inspect(parser, input('(1a)', new Context())), [['<span class="paren">(1a)</span>'], '']);
28
28
  assert.deepStrictEqual(inspect(parser, input('(a)', new Context())), [['<span class="paren">(a)</span>'], '']);
29
29
  assert.deepStrictEqual(inspect(parser, input('(a1)', new Context())), [['<span class="paren">(a1)</span>'], '']);
30
30
  assert.deepStrictEqual(inspect(parser, input('(a-1)', new Context())), [['<span class="paren">(a-1)</span>'], '']);
31
31
  assert.deepStrictEqual(inspect(parser, input('(a.1)', new Context())), [['<span class="paren">(a.1)</span>'], '']);
32
- assert.deepStrictEqual(inspect(parser, input('(a b)', new Context())), [['<span class="bracket">(a b)</span>'], '']);
32
+ assert.deepStrictEqual(inspect(parser, input('(a b)', new Context())), [['<span class="paren">(a b)</span>'], '']);
33
33
  assert.deepStrictEqual(inspect(parser, input('(word)', new Context())), [['<span class="paren">(word)</span>'], '']);
34
- 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
35
  assert.deepStrictEqual(inspect(parser, input('(word, word)', new Context())), [['<span class="paren">(word, word)</span>'], '']);
36
36
  assert.deepStrictEqual(inspect(parser, input('(A)', new Context())), [['<span class="paren">(A)</span>'], '']);
37
37
  assert.deepStrictEqual(inspect(parser, input('(Name)', new Context())), [['<span class="paren">(Name)</span>'], '']);
38
- assert.deepStrictEqual(inspect(parser, input('(Word word)', new Context())), [['<span class="bracket">(Word word)</span>'], '']);
39
- 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="paren">(Word word)</span>'], '']);
39
+ assert.deepStrictEqual(inspect(parser, input('(Word Word)', new Context())), [['<span class="paren">(Word Word)</span>'], '']);
40
40
  assert.deepStrictEqual(inspect(parser, input('(Name, Name)', new Context())), [['<span class="paren">(Name, Name)</span>'], '']);
41
41
  assert.deepStrictEqual(inspect(parser, input('(ABBR)', new Context())), [['<span class="paren">(ABBR)</span>'], '']);
42
42
  assert.deepStrictEqual(inspect(parser, input('(ABBR, ABBR)', new Context())), [['<span class="paren">(ABBR, ABBR)</span>'], '']);
43
43
  assert.deepStrictEqual(inspect(parser, input(`(${'0'.repeat(16)})`, new Context())), [[`<span class="paren">(${'0'.repeat(16)})</span>`], '']);
44
44
  assert.deepStrictEqual(inspect(parser, input(`(${'0'.repeat(17)})`, new Context())), [[`<span class="bracket">(${'0'.repeat(17)})</span>`], '']);
45
- assert.deepStrictEqual(inspect(parser, input('(\\a)', new Context())), [['<span class="bracket">(a)</span>'], '']);
46
- assert.deepStrictEqual(inspect(parser, input('(==)', new Context())), [['<span class="bracket">(==)</span>'], '']);
47
- assert.deepStrictEqual(inspect(parser, input('(()', new Context())), [['<span class="bracket">(<span class="paren">()</span></span>'], '']);
45
+ assert.deepStrictEqual(inspect(parser, input('(\\a)', new Context())), [['<span class="paren">(a)</span>'], '']);
46
+ assert.deepStrictEqual(inspect(parser, input('(==)', new Context())), [['<span class="paren">(==)</span>'], '']);
47
+ assert.deepStrictEqual(inspect(parser, input('(()', new Context())), [['<span class="paren">(<span class="paren">()</span></span>'], '']);
48
48
  assert.deepStrictEqual(inspect(parser, input('("(\n))"(")', new Context())), [['<span class="bracket">("<span class="paren">(</span><br>)</span>'], ')"(")']);
49
- assert.deepStrictEqual(inspect(parser, input('($)$', new Context())), [['<span class="bracket">(<span class="math" translate="no" data-src="$)$">$)$</span></span>'], '']);
49
+ assert.deepStrictEqual(inspect(parser, input('($)$', new Context())), [['<span class="paren">(<span class="math" translate="no" data-src="$)$">$)$</span></span>'], '']);
50
50
  assert.deepStrictEqual(inspect(parser, input(')', new Context())), undefined);
51
51
  assert.deepStrictEqual(inspect(parser, input('（１，２）', new Context())), [['<span class="paren">（１，２）</span>'], '']);
52
52
  assert.deepStrictEqual(inspect(parser, input('（０－１）', new Context())), [['<span class="paren">（０－１）</span>'], '']);
@@ -85,8 +85,8 @@ describe('Unit: parser/inline/bracket', () => {
85
85
  assert.deepStrictEqual(inspect(parser, input('"a', new Context())), [['"', 'a'], '']);
86
86
  assert.deepStrictEqual(inspect(parser, input('"a"', new Context())), [['"', 'a', '"'], '']);
87
87
  assert.deepStrictEqual(inspect(parser, input('"(")"', new Context())), [['"', '<span class="paren">(</span>', '"'], ')"']);
88
- assert.deepStrictEqual(inspect(parser, input('"(("', new Context())), [['"', '<span class="bracket">(<span class="paren">(</span></span>', '"'], '']);
89
- assert.deepStrictEqual(inspect(parser, input('"(\\")"', new Context())), [['"', '<span class="bracket">(")</span>', '"'], '']);
88
+ assert.deepStrictEqual(inspect(parser, input('"(("', new Context())), [['"', '<span class="paren">(<span class="paren">(</span></span>', '"'], '']);
89
+ assert.deepStrictEqual(inspect(parser, input('"(\\")"', new Context())), [['"', '<span class="paren">(")</span>', '"'], '']);
90
90
  assert.deepStrictEqual(inspect(parser, input('"(\n)"(")', new Context())), [['"', '<span class="paren">(</span>'], '\n)"(")']);
91
91
  assert.deepStrictEqual(inspect(parser, input('"\n"', new Context())), [['"'], '\n"']);
92
92
  assert.deepStrictEqual(inspect(parser, input('"\n"(")', new Context())), [['"'], '\n"(")']);
package/src/parser/inline/bracket.ts CHANGED
@@ -8,18 +8,9 @@ import { str } from '../source';
8
8
  import { unwrap } from '../util';
9
9
  import { html, defrag } from 'typed-dom/dom';
10
10
 
11
- export const indexA = /^[0-9A-Za-z]+(?:(?:[.-]|, )[0-9A-Za-z]+)*$/;
12
- const indexF = new RegExp(
13
- indexA.source.replace(', ', '[，、]')
14
- .replace(/[09AZaz.]|\-(?!\w)/g, c => String.fromCodePoint(c.codePointAt(0)! + 0xFEE0)),
15
- '');
16
- export function bracketname(context: Context, syntax: RegExp, opener: number, closer: number): string {
17
- const { source, position, range, linebreak } = context;
18
- syntax.lastIndex = position - range + opener;
19
- return range - opener - closer === 0
20
- || linebreak === 0 &&
21
- range - opener - closer <= 16 &&
22
- syntax.test(source.slice(position - range + opener, position - closer))
11
+ export function bracketname(context: Context, opener: number, closer: number): string {
12
+ const { range, linebreak } = context;
13
+ return range - opener - closer === 0 || linebreak === 0 && range - opener - closer <= 16
23
14
  ? 'paren'
24
15
  : 'bracket';
25
16
  }
@@ -53,12 +44,12 @@ const p1 = lazy(() => surround(
53
44
  true, [],
54
45
  ([as, bs = new List(), cs], context) => new List([
55
46
  new Node(html('span',
56
- { class: bracketname(context, indexA, 1, 1) },
47
+ { class: bracketname(context, 1, 1) },
57
48
  defrag(unwrap(as.import(bs as List<Node<string>>).import(cs)))))
58
49
  ]),
59
50
  ([as, bs = new List()], context) => new List([
60
51
  new Node(html('span',
61
- { class: bracketname(context, indexA, 1, 0) },
52
+ { class: bracketname(context, 1, 0) },
62
53
  defrag(unwrap(as.import(bs as List<Node<string>>)))))
63
54
  ])));
64
55
 
@@ -69,12 +60,12 @@ const p2 = lazy(() => surround(
69
60
  true, [],
70
61
  ([as, bs = new List(), cs], context) => new List([
71
62
  new Node(html('span',
72
- { class: bracketname(context, indexF, 1, 1) },
63
+ { class: bracketname(context, 1, 1) },
73
64
  defrag(unwrap(as.import(bs as List<Node<string>>).import(cs)))))
74
65
  ]),
75
66
  ([as, bs = new List()], context) => new List([
76
67
  new Node(html('span',
77
- { class: bracketname(context, indexF, 1, 0) },
68
+ { class: bracketname(context, 1, 0) },
78
69
  defrag(unwrap(as.import(bs as List<Node<string>>)))))
79
70
  ])));
80
71
 
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="bracket">(<em>a</em>)</span></em>'], '']);
55
- assert.deepStrictEqual(inspect(parser, input('*(**a**)*', new Context())), [['<em><span class="bracket">(<strong>a</strong>)</span></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>'], '']);
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="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>'], '']);
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>'], '']);
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="bracket">(<span class="paren">(b)</span>)</span></a>'], '']);
75
+ assert.deepStrictEqual(inspect(parser, input('[#a((b))]', new Context())), [['<a class="index" href="#index::a((b))">a<span class="paren">(<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="bracket">(<i>a</i>)</span></i>'], '']);
70
+ assert.deepStrictEqual(inspect(parser, input('///(///a///)///', new Context())), [['<i><span class="paren">(<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="bracket">(<span class="paren">(a)</span>)</span></a>'], '']);
180
+ assert.deepStrictEqual(inspect(parser, input('[((a))]{b}', new Context())), [['<a class="link" href="b"><span class="paren">(<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
@@ -57,7 +57,7 @@ describe('Unit: parser/inline/reference', () => {
57
57
  assert.deepStrictEqual(inspect(parser, input('[[a[[]]]]', new Context())), [['<sup class="reference"><span>a[[]]</span></sup>'], '']);
58
58
  assert.deepStrictEqual(inspect(parser, input('[[[a]]]', new Context())), [['<sup class="reference"><span>[a]</span></sup>'], '']);
59
59
  assert.deepStrictEqual(inspect(parser, input('[[[[a]]]]', new Context())), [['<sup class="reference"><span>[[a]]</span></sup>'], '']);
60
- assert.deepStrictEqual(inspect(parser, input('[[((a))]]', new Context())), [['<sup class="reference"><span><span class="bracket">(<span class="paren">(a)</span>)</span></span></sup>'], '']);
60
+ assert.deepStrictEqual(inspect(parser, input('[[((a))]]', new Context())), [['<sup class="reference"><span><span class="paren">(<span class="paren">(a)</span>)</span></span></sup>'], '']);
61
61
  });
62
62
 
63
63
  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="bracket">(<em>a</em>)</span></strong>'], '']);
52
- assert.deepStrictEqual(inspect(parser, input('**(**a**)**', new Context())), [['<strong><span class="bracket">(<strong>a</strong>)</span></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>'], '']);
53
53
  });
54
54
 
55
55
  });