1
+ /**
2
+ * @typedef {import('mdast').Literal } Literal
3
+ * @typedef {import('mdast-util-from-markdown').Extension } FromMarkdownExtension
4
+ * @typedef {import('mdast-util-from-markdown').Handle } FromMarkdownHandle
5
+ * @typedef {import('mdast-util-to-markdown').Options } ToMarkdownExtension
6
+ * @typedef {import('mdast-util-to-markdown').Handle } ToMarkdownHandle
7
+ *
8
+ * @typedef {Literal & {type: 'math', lang?: string|null, meta?: string|null} } Math
9
+ * @typedef {Literal & {type: 'inlineMath'} } InlineMath
10
+ */
11
+
1
12
import { longestStreak } from 'longest-streak'
2
- import safe from 'mdast-util-to-markdown/lib/util/safe.js'
13
+ import { safe } from 'mdast-util-to-markdown/lib/util/safe.js'
3
14
15
+ /** @type {FromMarkdownExtension } */
4
16
export const mathFromMarkdown = {
5
17
enter : {
6
18
mathFlow : enterMathFlow ,
@@ -17,6 +29,7 @@ export const mathFromMarkdown = {
17
29
}
18
30
}
19
31
32
+ /** @type {ToMarkdownExtension } */
20
33
export const mathToMarkdown = {
21
34
unsafe : [
22
35
{ character : '\r' , inConstruct : [ 'mathFlowMeta' ] } ,
@@ -29,79 +42,94 @@ export const mathToMarkdown = {
29
42
30
43
inlineMath . peek = inlineMathPeek
31
44
45
+ /** @type {FromMarkdownHandle } */
32
46
function enterMathFlow ( token ) {
33
- this . enter (
34
- {
35
- type : 'math' ,
36
- meta : null ,
37
- value : '' ,
38
- data : {
39
- hName : 'div' ,
40
- hProperties : { className : [ 'math' , 'math-display' ] } ,
41
- hChildren : [ { type : 'text' , value : '' } ]
42
- }
43
- } ,
44
- token
45
- )
47
+ /** @type { Math } */
48
+ const node = {
49
+ type : 'math' ,
50
+ meta : null ,
51
+ value : '' ,
52
+ data : {
53
+ hName : 'div' ,
54
+ hProperties : { className : [ 'math' , 'math-display' ] } ,
55
+ hChildren : [ { type : 'text' , value : '' } ]
56
+ }
57
+ }
58
+ // @ts -expect-error: custom node.
59
+ this . enter ( node , token )
46
60
}
47
61
62
+ /** @type {FromMarkdownHandle } */
48
63
function enterMathFlowMeta ( ) {
49
64
this . buffer ( )
50
65
}
51
66
67
+ /** @type {FromMarkdownHandle } */
52
68
function exitMathFlowMeta ( ) {
53
69
const data = this . resume ( )
54
70
this . stack [ this . stack . length - 1 ] . meta = data
55
71
}
56
72
73
+ /** @type {FromMarkdownHandle } */
57
74
function exitMathFlowFence ( ) {
58
75
// Exit if this is the closing fence.
59
76
if ( this . getData ( 'mathFlowInside' ) ) return
60
77
this . buffer ( )
61
78
this . setData ( 'mathFlowInside' , true )
62
79
}
63
80
81
+ /** @type {FromMarkdownHandle } */
64
82
function exitMathFlow ( token ) {
65
83
const data = this . resume ( ) . replace ( / ^ ( \r ? \n | \r ) | ( \r ? \n | \r ) $ / g, '' )
66
84
const node = this . exit ( token )
67
85
node . value = data
86
+ // @ts -expect-error: we defined it.
68
87
node . data . hChildren [ 0 ] . value = data
69
88
this . setData ( 'mathFlowInside' )
70
89
}
71
90
91
+ /** @type {FromMarkdownHandle } */
72
92
function enterMathText ( token ) {
73
- this . enter (
74
- {
75
- type : 'inlineMath' ,
76
- value : '' ,
77
- data : {
78
- hName : 'span' ,
79
- hProperties : { className : [ 'math' , 'math-inline' ] } ,
80
- hChildren : [ { type : 'text' , value : '' } ]
81
- }
82
- } ,
83
- token
84
- )
93
+ /** @type { InlineMath } */
94
+ const node = {
95
+ type : 'inlineMath' ,
96
+ value : '' ,
97
+ data : {
98
+ hName : 'span' ,
99
+ hProperties : { className : [ 'math' , 'math-inline' ] } ,
100
+ hChildren : [ { type : 'text' , value : '' } ]
101
+ }
102
+ }
103
+ // @ts -expect-error: custom node.
104
+ this . enter ( node , token )
85
105
this . buffer ( )
86
106
}
87
107
108
+ /** @type {FromMarkdownHandle } */
88
109
function exitMathText ( token ) {
89
110
const data = this . resume ( )
90
111
const node = this . exit ( token )
91
112
node . value = data
113
+ // @ts -expect-error: we defined it.
92
114
node . data . hChildren [ 0 ] . value = data
93
115
}
94
116
117
+ /** @type {FromMarkdownHandle } */
95
118
function exitMathData ( token ) {
96
119
this . config . enter . data . call ( this , token )
97
120
this . config . exit . data . call ( this , token )
98
121
}
99
122
123
+ /**
124
+ * @type {ToMarkdownHandle }
125
+ * @param {Math } node
126
+ */
100
127
function math ( node , _ , context ) {
101
128
const raw = node . value || ''
102
129
const fence = '$' . repeat ( Math . max ( longestStreak ( raw , '$' ) + 1 , 2 ) )
103
130
const exit = context . enter ( 'mathFlow' )
104
131
let value = fence
132
+ /** @type {ReturnType<context['enter']> } */
105
133
let subexit
106
134
107
135
if ( node . meta ) {
@@ -121,6 +149,10 @@ function math(node, _, context) {
121
149
return value
122
150
}
123
151
152
+ /**
153
+ * @type {ToMarkdownHandle }
154
+ * @param {InlineMath } node
155
+ */
124
156
function inlineMath ( node ) {
125
157
const value = node . value || ''
126
158
let size = 1
@@ -147,6 +179,7 @@ function inlineMath(node) {
147
179
return sequence + pad + value + pad + sequence
148
180
}
149
181
182
+ /** @type {ToMarkdownHandle } */
150
183
function inlineMathPeek ( ) {
151
184
return '$'
152
185
}
0 commit comments