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