@yozora/tokenizer-image-reference 1.3.0 → 2.0.0-alpha.0

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 (6) hide show
  1. package/lib/cjs/index.js +124 -117
  2. package/lib/esm/index.js +124 -117
  3. package/lib/types/index.d.ts +2 -4
  4. package/lib/types/tokenizer.d.ts +6 -25
  5. package/lib/types/types.d.ts +8 -8
  6. package/package.json +7 -7
package/lib/cjs/index.js CHANGED
@@ -17,133 +17,140 @@ class ImageReferenceTokenizer extends coreTokenizer.BaseInlineTokenizer {
17
17
  name: (_a = props.name) !== null && _a !== void 0 ? _a : uniqueName,
18
18
  priority: (_b = props.priority) !== null && _b !== void 0 ? _b : coreTokenizer.TokenizerPriority.LINKS,
19
19
  });
20
- }
21
- _findDelimiter(startIndex, endIndex, api) {
22
- const nodePoints = api.getNodePoints();
23
- for (let i = startIndex; i < endIndex; ++i) {
24
- const c = nodePoints[i].codePoint;
25
- switch (c) {
26
- case character.AsciiCodePoint.BACKSLASH:
27
- i += 1;
28
- break;
29
- case character.AsciiCodePoint.EXCLAMATION_MARK: {
30
- if (i + 1 >= endIndex ||
31
- nodePoints[i + 1].codePoint !== character.AsciiCodePoint.OPEN_BRACKET) {
32
- break;
20
+ this.match = api => {
21
+ return {
22
+ findDelimiter: () => coreTokenizer.genFindDelimiter(_findDelimiter),
23
+ isDelimiterPair,
24
+ processDelimiterPair,
25
+ };
26
+ function _findDelimiter(startIndex, endIndex) {
27
+ const nodePoints = api.getNodePoints();
28
+ for (let i = startIndex; i < endIndex; ++i) {
29
+ const c = nodePoints[i].codePoint;
30
+ switch (c) {
31
+ case character.AsciiCodePoint.BACKSLASH:
32
+ i += 1;
33
+ break;
34
+ case character.AsciiCodePoint.EXCLAMATION_MARK: {
35
+ if (i + 1 >= endIndex || nodePoints[i + 1].codePoint !== character.AsciiCodePoint.OPEN_BRACKET) {
36
+ break;
37
+ }
38
+ return {
39
+ type: 'opener',
40
+ startIndex: i,
41
+ endIndex: i + 2,
42
+ brackets: [],
43
+ };
44
+ }
45
+ case character.AsciiCodePoint.CLOSE_BRACKET: {
46
+ const delimiter = {
47
+ type: 'closer',
48
+ startIndex: i,
49
+ endIndex: i + 1,
50
+ brackets: [],
51
+ };
52
+ if (i + 1 >= endIndex || nodePoints[i + 1].codePoint !== character.AsciiCodePoint.OPEN_BRACKET) {
53
+ return delimiter;
54
+ }
55
+ const result = coreTokenizer.eatLinkLabel(nodePoints, i + 1, endIndex);
56
+ if (result.nextIndex < 0)
57
+ return delimiter;
58
+ if (result.labelAndIdentifier == null) {
59
+ return {
60
+ type: 'closer',
61
+ startIndex: i,
62
+ endIndex: result.nextIndex,
63
+ brackets: [
64
+ {
65
+ startIndex: i + 1,
66
+ endIndex: result.nextIndex,
67
+ },
68
+ ],
69
+ };
70
+ }
71
+ return {
72
+ type: 'closer',
73
+ startIndex: i,
74
+ endIndex: result.nextIndex,
75
+ brackets: [
76
+ {
77
+ startIndex: i + 1,
78
+ endIndex: result.nextIndex,
79
+ label: result.labelAndIdentifier.label,
80
+ identifier: result.labelAndIdentifier.identifier,
81
+ },
82
+ ],
83
+ };
84
+ }
33
85
  }
34
- return {
35
- type: 'opener',
36
- startIndex: i,
37
- endIndex: i + 2,
38
- brackets: [],
39
- };
40
86
  }
41
- case character.AsciiCodePoint.CLOSE_BRACKET: {
42
- const delimiter = {
43
- type: 'closer',
44
- startIndex: i,
45
- endIndex: i + 1,
46
- brackets: [],
47
- };
48
- if (i + 1 >= endIndex ||
49
- nodePoints[i + 1].codePoint !== character.AsciiCodePoint.OPEN_BRACKET) {
50
- return delimiter;
51
- }
52
- const result = coreTokenizer.eatLinkLabel(nodePoints, i + 1, endIndex);
53
- if (result.nextIndex < 0)
54
- return delimiter;
55
- if (result.labelAndIdentifier == null) {
56
- return {
57
- type: 'closer',
58
- startIndex: i,
59
- endIndex: result.nextIndex,
60
- brackets: [
61
- {
62
- startIndex: i + 1,
63
- endIndex: result.nextIndex,
64
- },
65
- ],
87
+ return null;
88
+ }
89
+ function isDelimiterPair(openerDelimiter, closerDelimiter, internalTokens) {
90
+ const nodePoints = api.getNodePoints();
91
+ const balancedBracketsStatus = tokenizerLink.checkBalancedBracketsStatus(openerDelimiter.endIndex, closerDelimiter.startIndex, internalTokens, nodePoints);
92
+ switch (balancedBracketsStatus) {
93
+ case -1:
94
+ return { paired: false, opener: false, closer: true };
95
+ case 0:
96
+ return { paired: true };
97
+ case 1:
98
+ return { paired: false, opener: true, closer: false };
99
+ }
100
+ }
101
+ function processDelimiterPair(openerDelimiter, closerDelimiter, internalTokens) {
102
+ const nodePoints = api.getNodePoints();
103
+ const bracket = closerDelimiter.brackets[0];
104
+ if (bracket != null && bracket.identifier != null) {
105
+ if (api.hasDefinition(bracket.identifier)) {
106
+ const token = {
107
+ nodeType: ast.ImageReferenceType,
108
+ startIndex: openerDelimiter.startIndex,
109
+ endIndex: bracket.endIndex,
110
+ referenceType: 'full',
111
+ label: bracket.label,
112
+ identifier: bracket.identifier,
113
+ children: api.resolveInternalTokens(internalTokens, openerDelimiter.endIndex, closerDelimiter.startIndex),
66
114
  };
115
+ return { tokens: [token] };
67
116
  }
68
- return {
69
- type: 'closer',
70
- startIndex: i,
71
- endIndex: result.nextIndex,
72
- brackets: [
73
- {
74
- startIndex: i + 1,
75
- endIndex: result.nextIndex,
76
- label: result.labelAndIdentifier.label,
77
- identifier: result.labelAndIdentifier.identifier,
78
- },
79
- ],
117
+ return { tokens: internalTokens };
118
+ }
119
+ const { nextIndex, labelAndIdentifier } = coreTokenizer.eatLinkLabel(nodePoints, openerDelimiter.endIndex - 1, closerDelimiter.startIndex + 1);
120
+ if (nextIndex === closerDelimiter.startIndex + 1 &&
121
+ labelAndIdentifier != null &&
122
+ api.hasDefinition(labelAndIdentifier.identifier)) {
123
+ const token = {
124
+ nodeType: ast.ImageReferenceType,
125
+ startIndex: openerDelimiter.startIndex,
126
+ endIndex: closerDelimiter.endIndex,
127
+ referenceType: bracket == null ? 'shortcut' : 'collapsed',
128
+ label: labelAndIdentifier.label,
129
+ identifier: labelAndIdentifier.identifier,
130
+ children: api.resolveInternalTokens(internalTokens, openerDelimiter.endIndex, closerDelimiter.startIndex),
80
131
  };
132
+ return { tokens: [token] };
81
133
  }
134
+ return { tokens: internalTokens };
82
135
  }
83
- }
84
- return null;
85
- }
86
- isDelimiterPair(openerDelimiter, closerDelimiter, internalTokens, api) {
87
- const nodePoints = api.getNodePoints();
88
- const balancedBracketsStatus = tokenizerLink.checkBalancedBracketsStatus(openerDelimiter.endIndex, closerDelimiter.startIndex, internalTokens, nodePoints);
89
- switch (balancedBracketsStatus) {
90
- case -1:
91
- return { paired: false, opener: false, closer: true };
92
- case 0:
93
- return { paired: true };
94
- case 1:
95
- return { paired: false, opener: true, closer: false };
96
- }
97
- }
98
- processDelimiterPair(openerDelimiter, closerDelimiter, internalTokens, api) {
99
- const nodePoints = api.getNodePoints();
100
- const bracket = closerDelimiter.brackets[0];
101
- if (bracket != null && bracket.identifier != null) {
102
- if (api.hasDefinition(bracket.identifier)) {
103
- const token = {
104
- nodeType: ast.ImageReferenceType,
105
- startIndex: openerDelimiter.startIndex,
106
- endIndex: bracket.endIndex,
107
- referenceType: 'full',
108
- label: bracket.label,
109
- identifier: bracket.identifier,
110
- children: api.resolveInternalTokens(internalTokens, openerDelimiter.endIndex, closerDelimiter.startIndex),
111
- };
112
- return { tokens: [token] };
113
- }
114
- return { tokens: internalTokens };
115
- }
116
- const { nextIndex, labelAndIdentifier } = coreTokenizer.eatLinkLabel(nodePoints, openerDelimiter.endIndex - 1, closerDelimiter.startIndex + 1);
117
- if (nextIndex === closerDelimiter.startIndex + 1 &&
118
- labelAndIdentifier != null &&
119
- api.hasDefinition(labelAndIdentifier.identifier)) {
120
- const token = {
121
- nodeType: ast.ImageReferenceType,
122
- startIndex: openerDelimiter.startIndex,
123
- endIndex: closerDelimiter.endIndex,
124
- referenceType: bracket == null ? 'shortcut' : 'collapsed',
125
- label: labelAndIdentifier.label,
126
- identifier: labelAndIdentifier.identifier,
127
- children: api.resolveInternalTokens(internalTokens, openerDelimiter.endIndex, closerDelimiter.startIndex),
128
- };
129
- return { tokens: [token] };
130
- }
131
- return { tokens: internalTokens };
132
- }
133
- parseInline(token, children) {
134
- const { identifier, label, referenceType } = token;
135
- const alt = tokenizerImage.calcImageAlt(children);
136
- const result = {
137
- type: ast.ImageReferenceType,
138
- identifier,
139
- label,
140
- referenceType,
141
- alt,
142
136
  };
143
- return result;
137
+ this.parse = () => ({
138
+ parse: (token, children) => {
139
+ const { identifier, label, referenceType } = token;
140
+ const alt = tokenizerImage.calcImageAlt(children);
141
+ const result = {
142
+ type: ast.ImageReferenceType,
143
+ identifier,
144
+ label,
145
+ referenceType,
146
+ alt,
147
+ };
148
+ return result;
149
+ },
150
+ });
144
151
  }
145
152
  }
146
153
 
147
154
  exports.ImageReferenceTokenizer = ImageReferenceTokenizer;
148
155
  exports.ImageReferenceTokenizerName = uniqueName;
149
- exports['default'] = ImageReferenceTokenizer;
156
+ exports["default"] = ImageReferenceTokenizer;
package/lib/esm/index.js CHANGED
@@ -1,6 +1,6 @@
1
1
  import { ImageReferenceType } from '@yozora/ast';
2
2
  import { AsciiCodePoint } from '@yozora/character';
3
- import { BaseInlineTokenizer, TokenizerPriority, eatLinkLabel } from '@yozora/core-tokenizer';
3
+ import { BaseInlineTokenizer, TokenizerPriority, genFindDelimiter, eatLinkLabel } from '@yozora/core-tokenizer';
4
4
  import { calcImageAlt } from '@yozora/tokenizer-image';
5
5
  import { checkBalancedBracketsStatus } from '@yozora/tokenizer-link';
6
6
 
@@ -13,130 +13,137 @@ class ImageReferenceTokenizer extends BaseInlineTokenizer {
13
13
  name: (_a = props.name) !== null && _a !== void 0 ? _a : uniqueName,
14
14
  priority: (_b = props.priority) !== null && _b !== void 0 ? _b : TokenizerPriority.LINKS,
15
15
  });
16
- }
17
- _findDelimiter(startIndex, endIndex, api) {
18
- const nodePoints = api.getNodePoints();
19
- for (let i = startIndex; i < endIndex; ++i) {
20
- const c = nodePoints[i].codePoint;
21
- switch (c) {
22
- case AsciiCodePoint.BACKSLASH:
23
- i += 1;
24
- break;
25
- case AsciiCodePoint.EXCLAMATION_MARK: {
26
- if (i + 1 >= endIndex ||
27
- nodePoints[i + 1].codePoint !== AsciiCodePoint.OPEN_BRACKET) {
28
- break;
16
+ this.match = api => {
17
+ return {
18
+ findDelimiter: () => genFindDelimiter(_findDelimiter),
19
+ isDelimiterPair,
20
+ processDelimiterPair,
21
+ };
22
+ function _findDelimiter(startIndex, endIndex) {
23
+ const nodePoints = api.getNodePoints();
24
+ for (let i = startIndex; i < endIndex; ++i) {
25
+ const c = nodePoints[i].codePoint;
26
+ switch (c) {
27
+ case AsciiCodePoint.BACKSLASH:
28
+ i += 1;
29
+ break;
30
+ case AsciiCodePoint.EXCLAMATION_MARK: {
31
+ if (i + 1 >= endIndex || nodePoints[i + 1].codePoint !== AsciiCodePoint.OPEN_BRACKET) {
32
+ break;
33
+ }
34
+ return {
35
+ type: 'opener',
36
+ startIndex: i,
37
+ endIndex: i + 2,
38
+ brackets: [],
39
+ };
40
+ }
41
+ case AsciiCodePoint.CLOSE_BRACKET: {
42
+ const delimiter = {
43
+ type: 'closer',
44
+ startIndex: i,
45
+ endIndex: i + 1,
46
+ brackets: [],
47
+ };
48
+ if (i + 1 >= endIndex || nodePoints[i + 1].codePoint !== AsciiCodePoint.OPEN_BRACKET) {
49
+ return delimiter;
50
+ }
51
+ const result = eatLinkLabel(nodePoints, i + 1, endIndex);
52
+ if (result.nextIndex < 0)
53
+ return delimiter;
54
+ if (result.labelAndIdentifier == null) {
55
+ return {
56
+ type: 'closer',
57
+ startIndex: i,
58
+ endIndex: result.nextIndex,
59
+ brackets: [
60
+ {
61
+ startIndex: i + 1,
62
+ endIndex: result.nextIndex,
63
+ },
64
+ ],
65
+ };
66
+ }
67
+ return {
68
+ type: 'closer',
69
+ startIndex: i,
70
+ endIndex: result.nextIndex,
71
+ brackets: [
72
+ {
73
+ startIndex: i + 1,
74
+ endIndex: result.nextIndex,
75
+ label: result.labelAndIdentifier.label,
76
+ identifier: result.labelAndIdentifier.identifier,
77
+ },
78
+ ],
79
+ };
80
+ }
29
81
  }
30
- return {
31
- type: 'opener',
32
- startIndex: i,
33
- endIndex: i + 2,
34
- brackets: [],
35
- };
36
82
  }
37
- case AsciiCodePoint.CLOSE_BRACKET: {
38
- const delimiter = {
39
- type: 'closer',
40
- startIndex: i,
41
- endIndex: i + 1,
42
- brackets: [],
43
- };
44
- if (i + 1 >= endIndex ||
45
- nodePoints[i + 1].codePoint !== AsciiCodePoint.OPEN_BRACKET) {
46
- return delimiter;
47
- }
48
- const result = eatLinkLabel(nodePoints, i + 1, endIndex);
49
- if (result.nextIndex < 0)
50
- return delimiter;
51
- if (result.labelAndIdentifier == null) {
52
- return {
53
- type: 'closer',
54
- startIndex: i,
55
- endIndex: result.nextIndex,
56
- brackets: [
57
- {
58
- startIndex: i + 1,
59
- endIndex: result.nextIndex,
60
- },
61
- ],
83
+ return null;
84
+ }
85
+ function isDelimiterPair(openerDelimiter, closerDelimiter, internalTokens) {
86
+ const nodePoints = api.getNodePoints();
87
+ const balancedBracketsStatus = checkBalancedBracketsStatus(openerDelimiter.endIndex, closerDelimiter.startIndex, internalTokens, nodePoints);
88
+ switch (balancedBracketsStatus) {
89
+ case -1:
90
+ return { paired: false, opener: false, closer: true };
91
+ case 0:
92
+ return { paired: true };
93
+ case 1:
94
+ return { paired: false, opener: true, closer: false };
95
+ }
96
+ }
97
+ function processDelimiterPair(openerDelimiter, closerDelimiter, internalTokens) {
98
+ const nodePoints = api.getNodePoints();
99
+ const bracket = closerDelimiter.brackets[0];
100
+ if (bracket != null && bracket.identifier != null) {
101
+ if (api.hasDefinition(bracket.identifier)) {
102
+ const token = {
103
+ nodeType: ImageReferenceType,
104
+ startIndex: openerDelimiter.startIndex,
105
+ endIndex: bracket.endIndex,
106
+ referenceType: 'full',
107
+ label: bracket.label,
108
+ identifier: bracket.identifier,
109
+ children: api.resolveInternalTokens(internalTokens, openerDelimiter.endIndex, closerDelimiter.startIndex),
62
110
  };
111
+ return { tokens: [token] };
63
112
  }
64
- return {
65
- type: 'closer',
66
- startIndex: i,
67
- endIndex: result.nextIndex,
68
- brackets: [
69
- {
70
- startIndex: i + 1,
71
- endIndex: result.nextIndex,
72
- label: result.labelAndIdentifier.label,
73
- identifier: result.labelAndIdentifier.identifier,
74
- },
75
- ],
113
+ return { tokens: internalTokens };
114
+ }
115
+ const { nextIndex, labelAndIdentifier } = eatLinkLabel(nodePoints, openerDelimiter.endIndex - 1, closerDelimiter.startIndex + 1);
116
+ if (nextIndex === closerDelimiter.startIndex + 1 &&
117
+ labelAndIdentifier != null &&
118
+ api.hasDefinition(labelAndIdentifier.identifier)) {
119
+ const token = {
120
+ nodeType: ImageReferenceType,
121
+ startIndex: openerDelimiter.startIndex,
122
+ endIndex: closerDelimiter.endIndex,
123
+ referenceType: bracket == null ? 'shortcut' : 'collapsed',
124
+ label: labelAndIdentifier.label,
125
+ identifier: labelAndIdentifier.identifier,
126
+ children: api.resolveInternalTokens(internalTokens, openerDelimiter.endIndex, closerDelimiter.startIndex),
76
127
  };
128
+ return { tokens: [token] };
77
129
  }
130
+ return { tokens: internalTokens };
78
131
  }
79
- }
80
- return null;
81
- }
82
- isDelimiterPair(openerDelimiter, closerDelimiter, internalTokens, api) {
83
- const nodePoints = api.getNodePoints();
84
- const balancedBracketsStatus = checkBalancedBracketsStatus(openerDelimiter.endIndex, closerDelimiter.startIndex, internalTokens, nodePoints);
85
- switch (balancedBracketsStatus) {
86
- case -1:
87
- return { paired: false, opener: false, closer: true };
88
- case 0:
89
- return { paired: true };
90
- case 1:
91
- return { paired: false, opener: true, closer: false };
92
- }
93
- }
94
- processDelimiterPair(openerDelimiter, closerDelimiter, internalTokens, api) {
95
- const nodePoints = api.getNodePoints();
96
- const bracket = closerDelimiter.brackets[0];
97
- if (bracket != null && bracket.identifier != null) {
98
- if (api.hasDefinition(bracket.identifier)) {
99
- const token = {
100
- nodeType: ImageReferenceType,
101
- startIndex: openerDelimiter.startIndex,
102
- endIndex: bracket.endIndex,
103
- referenceType: 'full',
104
- label: bracket.label,
105
- identifier: bracket.identifier,
106
- children: api.resolveInternalTokens(internalTokens, openerDelimiter.endIndex, closerDelimiter.startIndex),
107
- };
108
- return { tokens: [token] };
109
- }
110
- return { tokens: internalTokens };
111
- }
112
- const { nextIndex, labelAndIdentifier } = eatLinkLabel(nodePoints, openerDelimiter.endIndex - 1, closerDelimiter.startIndex + 1);
113
- if (nextIndex === closerDelimiter.startIndex + 1 &&
114
- labelAndIdentifier != null &&
115
- api.hasDefinition(labelAndIdentifier.identifier)) {
116
- const token = {
117
- nodeType: ImageReferenceType,
118
- startIndex: openerDelimiter.startIndex,
119
- endIndex: closerDelimiter.endIndex,
120
- referenceType: bracket == null ? 'shortcut' : 'collapsed',
121
- label: labelAndIdentifier.label,
122
- identifier: labelAndIdentifier.identifier,
123
- children: api.resolveInternalTokens(internalTokens, openerDelimiter.endIndex, closerDelimiter.startIndex),
124
- };
125
- return { tokens: [token] };
126
- }
127
- return { tokens: internalTokens };
128
- }
129
- parseInline(token, children) {
130
- const { identifier, label, referenceType } = token;
131
- const alt = calcImageAlt(children);
132
- const result = {
133
- type: ImageReferenceType,
134
- identifier,
135
- label,
136
- referenceType,
137
- alt,
138
132
  };
139
- return result;
133
+ this.parse = () => ({
134
+ parse: (token, children) => {
135
+ const { identifier, label, referenceType } = token;
136
+ const alt = calcImageAlt(children);
137
+ const result = {
138
+ type: ImageReferenceType,
139
+ identifier,
140
+ label,
141
+ referenceType,
142
+ alt,
143
+ };
144
+ return result;
145
+ },
146
+ });
140
147
  }
141
148
  }
142
149
 
package/lib/types/index.d.ts CHANGED
@@ -1,5 +1,3 @@
1
- import { ImageReferenceTokenizer } from './tokenizer';
2
- export { ImageReferenceTokenizer } from './tokenizer';
1
+ export { ImageReferenceTokenizer, ImageReferenceTokenizer as default } from './tokenizer';
3
2
  export { uniqueName as ImageReferenceTokenizerName } from './types';
4
- export type { Token as ImageReferenceToken, TokenizerProps as ImageReferenceTokenizerProps, } from './types';
5
- export default ImageReferenceTokenizer;
3
+ export type { IToken as IImageReferenceToken, ITokenizerProps as IImageReferenceTokenizerProps, } from './types';
package/lib/types/tokenizer.d.ts CHANGED
@@ -1,7 +1,6 @@
1
- import type { YastNode } from '@yozora/ast';
2
- import type { MatchInlinePhaseApi, ResultOfIsDelimiterPair, ResultOfProcessDelimiterPair, Tokenizer, TokenizerMatchInlineHook, TokenizerParseInlineHook, YastInlineToken } from '@yozora/core-tokenizer';
1
+ import type { IInlineTokenizer, IMatchInlineHookCreator, IParseInlineHookCreator } from '@yozora/core-tokenizer';
3
2
  import { BaseInlineTokenizer } from '@yozora/core-tokenizer';
4
- import type { Delimiter, Node, T, Token, TokenizerProps } from './types';
3
+ import type { IDelimiter, INode, IToken, ITokenizerProps, T } from './types';
5
4
  /**
6
5
  * Lexical Analyzer for ImageReference.
7
6
  *
@@ -34,26 +33,8 @@ import type { Delimiter, Node, T, Token, TokenizerProps } from './types';
34
33
  * @see https://github.com/syntax-tree/mdast#imagereference
35
34
  * @see https://github.github.com/gfm/#images
36
35
  */
37
- export declare class ImageReferenceTokenizer extends BaseInlineTokenizer<Delimiter> implements Tokenizer, TokenizerMatchInlineHook<T, Delimiter, Token>, TokenizerParseInlineHook<T, Token, Node> {
38
- constructor(props?: TokenizerProps);
39
- /**
40
- * @override
41
- * @see BaseInlineTokenizer
42
- */
43
- protected _findDelimiter(startIndex: number, endIndex: number, api: Readonly<MatchInlinePhaseApi>): Delimiter | null;
44
- /**
45
- * @override
46
- * @see TokenizerMatchInlineHook
47
- */
48
- isDelimiterPair(openerDelimiter: Delimiter, closerDelimiter: Delimiter, internalTokens: ReadonlyArray<YastInlineToken>, api: Readonly<MatchInlinePhaseApi>): ResultOfIsDelimiterPair;
49
- /**
50
- * @override
51
- * @see TokenizerMatchInlineHook
52
- */
53
- processDelimiterPair(openerDelimiter: Delimiter, closerDelimiter: Delimiter, internalTokens: ReadonlyArray<YastInlineToken>, api: Readonly<MatchInlinePhaseApi>): ResultOfProcessDelimiterPair<T, Token, Delimiter>;
54
- /**
55
- * @override
56
- * @see TokenizerParseInlineHook
57
- */
58
- parseInline(token: Token, children: YastNode[]): Node;
36
+ export declare class ImageReferenceTokenizer extends BaseInlineTokenizer<T, IDelimiter, IToken, INode> implements IInlineTokenizer<T, IDelimiter, IToken, INode> {
37
+ constructor(props?: ITokenizerProps);
38
+ readonly match: IMatchInlineHookCreator<T, IDelimiter, IToken>;
39
+ readonly parse: IParseInlineHookCreator<T, IToken, INode>;
59
40
  }
package/lib/types/types.d.ts CHANGED
@@ -1,12 +1,12 @@
1
- import type { ImageReference, ImageReferenceType, YastAssociation, YastReference } from '@yozora/ast';
2
- import type { BaseInlineTokenizerProps, PartialYastInlineToken, YastTokenDelimiter } from '@yozora/core-tokenizer';
3
- import type { LinkReferenceDelimiterBracket } from '@yozora/tokenizer-link-reference';
1
+ import type { IImageReference, IYastAssociation, IYastReference, ImageReferenceType } from '@yozora/ast';
2
+ import type { IBaseInlineTokenizerProps, IPartialYastInlineToken, IYastTokenDelimiter } from '@yozora/core-tokenizer';
3
+ import type { ILinkReferenceDelimiterBracket } from '@yozora/tokenizer-link-reference';
4
4
  export declare const uniqueName = "@yozora/tokenizer-image-reference";
5
5
  export declare type T = ImageReferenceType;
6
- export declare type Node = ImageReference;
7
- export interface Token extends PartialYastInlineToken<T>, YastAssociation, YastReference {
6
+ export declare type INode = IImageReference;
7
+ export interface IToken extends IPartialYastInlineToken<T>, IYastAssociation, IYastReference {
8
8
  }
9
- export interface Delimiter extends YastTokenDelimiter {
10
- brackets: LinkReferenceDelimiterBracket[];
9
+ export interface IDelimiter extends IYastTokenDelimiter {
10
+ brackets: ILinkReferenceDelimiterBracket[];
11
11
  }
12
- export declare type TokenizerProps = Partial<BaseInlineTokenizerProps>;
12
+ export declare type ITokenizerProps = Partial<IBaseInlineTokenizerProps>;
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@yozora/tokenizer-image-reference",
3
- "version": "1.3.0",
3
+ "version": "2.0.0-alpha.0",
4
4
  "author": {
5
5
  "name": "guanghechen",
6
6
  "url": "https://github.com/guanghechen/"
@@ -35,11 +35,11 @@
35
35
  "test": "cross-env TS_NODE_FILES=true jest --config ../../jest.config.js --rootDir ."
36
36
  },
37
37
  "dependencies": {
38
- "@yozora/ast": "^1.3.0",
39
- "@yozora/character": "^1.3.0",
40
- "@yozora/core-tokenizer": "^1.3.0",
41
- "@yozora/tokenizer-image": "^1.3.0",
42
- "@yozora/tokenizer-link": "^1.3.0"
38
+ "@yozora/ast": "^2.0.0-alpha.0",
39
+ "@yozora/character": "^2.0.0-alpha.0",
40
+ "@yozora/core-tokenizer": "^2.0.0-alpha.0",
41
+ "@yozora/tokenizer-image": "^2.0.0-alpha.0",
42
+ "@yozora/tokenizer-link": "^2.0.0-alpha.0"
43
43
  },
44
- "gitHead": "18c9b167004ad97718b2f94f25139f80598cbf7a"
44
+ "gitHead": "0171501339c49ffd02ed16a63447fa20a47a29a7"
45
45
  }