tickets

15.2 KB

1. // markdown.hl — MARKDOWN IN TEXT FIELDS (ticket tickets.worldapi.org#6, mission 014; CONCEPT.md
2. // "Data formats": Markdown inside text fields). The summary, comment texts and state notes are
3. // Markdown; the ticket page renders them. Statics only, server realm.
4. //
5. // SAFE BY CONSTRUCTION: the text is parsed HERE into plain data — blocks of spans — and the
6. // View (components/markdown.hl) builds elements from it. Every character of the source ends
7. // up in a TEXT node (hl:web escapes it); there is no HTML string anywhere, so raw HTML in the
8. // source (`<script>`, `<img onerror>`) is shown as the text it is. A link's href is taken only
9. // if `safeHref` accepts it: http(s):, mailto:, a same-site path (`/…`, not `//…`) or `#…`;
10. // anything else (`javascript:`, `data:`, `vbscript:`, relative `foo`, quotes, spaces, control
11. // characters) stays plain text.
12. //
13. // WHAT IS UNDERSTOOD (the subset ticket #6 names — headings, lists, code, links, emphasis):
14. // blocks: `#`…`######` headings, `-`/`*`/`+` and `1.`/`1)` list items (one level; deeper
15. // indentation is flattened; a list may interrupt a paragraph — the import writes
16. // them that way), ``` / ~~~ fenced code, paragraphs (blank-line separated; their
17. // single line breaks are KEPT — the page showed them before, `white-space: pre-wrap`)
18. // inline: `code` (any backtick run), [text](url), <https://…>, bare http(s):// URLs,
19. // *em* _em_ **strong** __strong__ ***both***, backslash escapes of punctuation
20. // Not understood (shown as typed): block quotes, tables, images, nested lists, HTML.
21. //
22. // A block: { isP | isH1 | isH2 | isH3 | isUl | isOl | isCode, spans, items: [{ spans }],
23. // start (ol), code (text of a code block) }
24. // A span: { text, isText | isStrong | isEm | isStrongEm | isCode | isLink, href }
26. static NL = "
27. "
29. static isSpaceC = (c) => { return c == 32 || c == 9 || c == 10 || c == 13 }
30. static isAlnumC = (c) => { return (c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || c > 127 }
31. static isPunctC = (c) => { return (c >= 33 && c <= 47) || (c >= 58 && c <= 64) || (c >= 91 && c <= 96) || (c >= 123 && c <= 126) }
33. // ---- links ------------------------------------------------------------------------------
34. // the href of a link, or null when it is not one we let through
35. static safeHref = (u) => {
36. if (u == null) { return null }
37. t = ('' + u).trim()
38. if (t == '' || t.length > 2000) { return null }
39. let i = 0
40. while (i < t.length) {
41. let c = t.charCodeAt(i)
42. // no spaces / control characters, no quotes, no < > ` and no backslash
43. if (c <= 32 || c == 127 || c == 34 || c == 39 || c == 60 || c == 62 || c == 96 || c == 92) { return null }
44. i = i + 1
45. }
46. low = t.toLowerCase()
47. if (low.startsWith('https://') && t.length > 8) { return t }
48. if (low.startsWith('http://') && t.length > 7) { return t }
49. if (low.startsWith('mailto:') && t.length > 7) { return t }
50. if (t.startsWith('/') && !t.startsWith('//')) { return t }
51. if (t.startsWith('#')) { return t }
52. return null
53. }
55. static isUrlStart = (s, i) => {
56. low = s.slice(i, i + 8).toLowerCase()
57. return low.startsWith('https://') || low.startsWith('http://')
58. }
60. // where a bare URL starting at i ends: up to whitespace or < > " `, minus trailing punctuation
61. // (and a closing parenthesis that has no opening one inside the URL)
62. static isUrlStop = (c) => { return isSpaceC(c) || c == 60 || c == 62 || c == 34 || c == 96 }
63. static urlEnd = (s, i) => {
64. let end = i
65. while (end < s.length && !isUrlStop(s.charCodeAt(end))) { end = end + 1 }
66. let trimming = true
67. while (trimming && end > i) {
68. let c = s.charCodeAt(end - 1)
69. if (c == 46 || c == 44 || c == 59 || c == 58 || c == 33 || c == 63 || c == 39 || c == 42 || c == 95) {
70. end = end - 1
71. } else if (c == 41) {
72. let opens = 0
73. let closes = 0
74. let k = i
75. while (k < end) {
76. if (s.charCodeAt(k) == 40) { opens = opens + 1 }
77. if (s.charCodeAt(k) == 41) { closes = closes + 1 }
78. k = k + 1
79. }
80. if (closes > opens) { end = end - 1 } else { trimming = false }
81. } else {
82. trimming = false
83. }
84. }
85. return end
86. }
88. // `[label](url)` at i → { label, href (null = not allowed), end } or null (not a link)
89. static linkAt = (s, i) => {
90. let j = i + 1
91. let found = -1
92. while (j < s.length && found < 0) {
93. let c = s.charCodeAt(j)
94. if (c == 91) { return null }
95. if (c == 93) { found = j }
96. j = j + 1
97. }
98. if (found < 0 || found == i + 1) { return null }
99. if (found + 1 >= s.length || s.charCodeAt(found + 1) != 40) { return null }
100. k = s.indexOf(')', found + 2)
101. if (k < 0) { return null }
102. let target = s.slice(found + 2, k).trim()
103. // an optional title after a space is dropped: [x](url "title")
104. sp = target.indexOf(' ')
105. if (sp > 0) { target = target.slice(0, sp) }
106. return { label = s.slice(i + 1, found) href = safeHref(target) end = k + 1 }
107. }
109. // ---- spans --------------------------------------------------------------------------------
110. static textSpan = (t, strong, em) => {
111. return { text = t isText = !strong && !em isStrong = strong && !em isEm = em && !strong isStrongEm = strong && em isCode = false isLink = false href = '' }
112. }
113. static codeSpan = (t) => {
114. return { text = t isText = false isStrong = false isEm = false isStrongEm = false isCode = true isLink = false href = '' }
115. }
116. static linkSpan = (t, h) => {
117. return { text = t isText = false isStrong = false isEm = false isStrongEm = false isCode = false isLink = true href = h }
118. }
120. // the index of a run of EXACTLY n characters c at or after `at`, or -1. `esc`: a character
121. // after a backslash does not count (emphasis; inside `code` a backslash is just a backslash)
122. static runAt = (s, at, c, n, esc) => {
123. let i = at
124. while (i < s.length) {
125. if (esc && s.charCodeAt(i) == 92) {
126. i = i + 2
127. } else if (s.charCodeAt(i) == c) {
128. let k = i
129. while (k < s.length && s.charCodeAt(k) == c) { k = k + 1 }
130. if (k - i == n) { return i }
131. i = k
132. } else {
133. i = i + 1
134. }
135. }
136. return -1
137. }
139. // is there a CLOSING delimiter run (exactly n of c, not after a space; `_` not before a
140. // letter/digit) after `at`?
141. static hasCloser = (s, at, c, n) => {
142. let i = at
143. while (i < s.length) {
144. let r = runAt(s, i, c, n, true)
145. if (r < 0) { return false }
146. let prev = r > 0 ? s.charCodeAt(r - 1) : 32
147. let next = r + n < s.length ? s.charCodeAt(r + n) : 32
148. if (r > at && !isSpaceC(prev) && (c != 95 || !isAlnumC(next))) { return true }
149. i = r + n
150. }
151. return false
152. }
154. static inlineSpans = (src) => {
155. out = []
156. if (src == null || src == '') { return out }
157. s = '' + src
158. n = s.length
159. let buf = ''
160. let strong = false
161. let em = false
162. let strongC = 0
163. let emC = 0
164. let i = 0
165. while (i < n) {
166. let c = s.charCodeAt(i)
167. if (c == 92 && i + 1 < n && isPunctC(s.charCodeAt(i + 1))) {
168. // a backslash escape: the next punctuation character as itself
169. buf = buf + s[i + 1]
170. i = i + 2
171. } else if (c == 96) {
172. // `code`: a run of backticks up to the same run
173. let k = i
174. while (k < n && s.charCodeAt(k) == 96) { k = k + 1 }
175. let close = runAt(s, k, 96, k - i, false)
176. if (close < 0) {
177. buf = buf + s.slice(i, k)
178. i = k
179. } else {
180. if (buf != '') { out.push(textSpan(buf, strong, em)) }
181. buf = ''
182. let code = s.slice(k, close).replaceAll(NL, ' ')
183. if (code.length > 2 && code.startsWith(' ') && code.endsWith(' ') && code.trim() != '') { code = code.slice(1, code.length - 1) }
184. out.push(codeSpan(code))
185. i = close + (k - i)
186. }
187. } else if (c == 91) {
188. // [label](url)
189. let l = linkAt(s, i)
190. if (l == null) {
191. buf = buf + '['
192. i = i + 1
193. } else if (l.href == null) {
194. buf = buf + s.slice(i, l.end)
195. i = l.end
196. } else {
197. if (buf != '') { out.push(textSpan(buf, strong, em)) }
198. buf = ''
199. out.push(linkSpan(l.label, l.href))
200. i = l.end
201. }
202. } else if (c == 60 && i + 1 < n && isUrlStart(s, i + 1)) {
203. // <https://…>
204. let e = s.indexOf('>', i + 1)
205. let url = e > 0 ? s.slice(i + 1, e) : ''
206. let h = safeHref(url)
207. if (e < 0 || h == null) {
208. buf = buf + '<'
209. i = i + 1
210. } else {
211. if (buf != '') { out.push(textSpan(buf, strong, em)) }
212. buf = ''
213. out.push(linkSpan(url, h))
214. i = e + 1
215. }
216. } else if ((c == 104 || c == 72) && (i == 0 || !isAlnumC(s.charCodeAt(i - 1))) && isUrlStart(s, i)) {
217. // a bare http(s):// URL
218. let e = urlEnd(s, i)
219. let url = s.slice(i, e)
220. let h = safeHref(url)
221. if (h == null) {
222. buf = buf + s[i]
223. i = i + 1
224. } else {
225. if (buf != '') { out.push(textSpan(buf, strong, em)) }
226. buf = ''
227. out.push(linkSpan(url, h))
228. i = e
229. }
230. } else if (c == 42 || c == 95) {
231. // * and _: emphasis (1), strong (2), both (3)
232. let k = i
233. while (k < n && s.charCodeAt(k) == c) { k = k + 1 }
234. let run = k - i
235. let prev = i > 0 ? s.charCodeAt(i - 1) : 32
236. let next = k < n ? s.charCodeAt(k) : 32
237. let wantStrong = run == 2 || run == 3
238. let wantEm = run == 1 || run == 3
239. let canOpen = !isSpaceC(next) && (c == 42 || !isAlnumC(prev))
240. let canClose = !isSpaceC(prev) && (c == 42 || !isAlnumC(next))
241. let closes = canClose && run <= 3 && (!wantStrong || (strong && strongC == c)) && (!wantEm || (em && emC == c))
242. let opens = !closes && canOpen && run <= 3 && (!wantStrong || !strong) && (!wantEm || !em) && hasCloser(s, k, c, run)
243. if (closes || opens) {
244. if (buf != '') { out.push(textSpan(buf, strong, em)) }
245. buf = ''
246. if (wantStrong) {
247. strong = opens
248. strongC = c
249. }
250. if (wantEm) {
251. em = opens
252. emC = c
253. }
254. } else {
255. buf = buf + s.slice(i, k)
256. }
257. i = k
258. } else {
259. buf = buf + s[i]
260. i = i + 1
261. }
262. }
263. if (buf != '') { out.push(textSpan(buf, strong, em)) }
264. return out
265. }
267. // ---- blocks -------------------------------------------------------------------------------
268. static noCr = (line) => { return line.length > 0 && line.charCodeAt(line.length - 1) == 13 ? line.slice(0, line.length - 1) : line }
269. static indentOf = (line) => {
270. let i = 0
271. while (i < line.length && (line.charCodeAt(i) == 32 || line.charCodeAt(i) == 9)) { i = i + 1 }
272. return i
273. }
275. // a heading line (≤ 3 spaces in, 1–6 '#', a space or the end) → { level, text } or null
276. static headingOf = (line) => {
277. if (indentOf(line) > 3) { return null }
278. t = line.trim()
279. let k = 0
280. while (k < t.length && t.charCodeAt(k) == 35) { k = k + 1 }
281. if (k == 0 || k > 6) { return null }
282. if (k < t.length && t.charCodeAt(k) != 32 && t.charCodeAt(k) != 9) { return null }
283. let body = t.slice(k).trim()
284. // a closing run of '#' after a space goes
285. let e = body.length
286. while (e > 0 && body.charCodeAt(e - 1) == 35) { e = e - 1 }
287. if (e == 0) { body = '' } else if (e < body.length && (body.charCodeAt(e - 1) == 32 || body.charCodeAt(e - 1) == 9)) { body = body.slice(0, e).trim() }
288. return { level = k text = body }
289. }
291. // a list item line → { ordered, start, text } or null
292. static itemOf = (line) => {
293. t = line.trim()
294. if (t.length >= 2 && (t.charCodeAt(0) == 45 || t.charCodeAt(0) == 42 || t.charCodeAt(0) == 43) && (t.charCodeAt(1) == 32 || t.charCodeAt(1) == 9)) {
295. return { ordered = false start = 1 text = t.slice(2).trim() }
296. }
297. if (t.length == 1 && (t == '-' || t == '*' || t == '+')) { return { ordered = false start = 1 text = '' } }
298. let k = 0
299. while (k < t.length && k < 9 && t.charCodeAt(k) >= 48 && t.charCodeAt(k) <= 57) { k = k + 1 }
300. if (k == 0 || k >= t.length) { return null }
301. d = t.charCodeAt(k)
302. if (d != 46 && d != 41) { return null }
303. if (k + 1 < t.length && t.charCodeAt(k + 1) != 32 && t.charCodeAt(k + 1) != 9) { return null }
304. return { ordered = true start = toNumber(t.slice(0, k)) text = t.slice(k + 1).trim() }
305. }
307. // a code fence line (``` or ~~~, ≥ 3) → its run (e.g. '````') or null
308. static fenceOf = (line) => {
309. if (indentOf(line) > 3) { return null }
310. t = line.trim()
311. if (t.length < 3) { return null }
312. c = t.charCodeAt(0)
313. if (c != 96 && c != 126) { return null }
314. let k = 0
315. while (k < t.length && t.charCodeAt(k) == c) { k = k + 1 }
316. if (k < 3) { return null }
317. // an info string after ``` must not contain a backtick
318. if (c == 96 && t.slice(k).includes('`')) { return null }
319. return t.slice(0, k)
320. }
322. static paraBlock = (lines) => {
323. let spans = inlineSpans(lines.join(NL))
324. return { isP = true isH1 = false isH2 = false isH3 = false isUl = false isOl = false isCode = false spans = spans items = [] start = 1 code = '' }
325. }
326. static headingBlock = (level, text) => {
327. let spans = inlineSpans(text)
328. return { isP = false isH1 = level == 1 isH2 = level == 2 isH3 = level >= 3 isUl = false isOl = false isCode = false spans = spans items = [] start = 1 code = '' }
329. }
330. static codeBlock = (lines) => {
331. text = lines.join(NL)
332. return { isP = false isH1 = false isH2 = false isH3 = false isUl = false isOl = false isCode = true spans = [] items = [] start = 1 code = text }
333. }
334. static listBlock = (ordered, first, itemLines) => {
335. let items = []
336. for (lines of itemLines) {
337. let spans = inlineSpans(lines.join(NL))
338. items.push({ spans = spans })
339. }
340. return { isP = false isH1 = false isH2 = false isH3 = false isUl = !ordered isOl = ordered isCode = false spans = [] items = items start = first code = '' }
341. }
343. // the Markdown text → blocks (see the header)
344. static markdownBlocks = (text) => {
345. out = []
346. if (text == null || text == '') { return out }
347. lines = ('' + text).split(NL)
348. let para = []
349. let inList = false
350. let listOrdered = false
351. let listStart = 1
352. let items = []
353. let blankBefore = false
354. let i = 0
355. while (i < lines.length) {
356. let line = noCr(lines[i])
357. let fence = fenceOf(line)
358. let h = fence == null ? headingOf(line) : null
359. let it = fence == null && h == null ? itemOf(line) : null
360. if (fence != null) {
361. if (para.length > 0) { out.push(paraBlock(para)) }
362. para = []
363. if (inList) { out.push(listBlock(listOrdered, listStart, items)) }
364. inList = false
365. items = []
366. let code = []
367. let j = i + 1
368. let closed = false
369. let fc = fence.charCodeAt(0)
370. while (j < lines.length && !closed) {
371. let l = noCr(lines[j])
372. let f = fenceOf(l)
373. if (f != null && f.charCodeAt(0) == fc && f.length >= fence.length && l.trim() == f) {
374. closed = true
375. } else {
376. code.push(l)
377. }
378. j = j + 1
379. }
380. out.push(codeBlock(code))
381. i = j
382. blankBefore = false
383. } else if (line.trim() == '') {
384. if (para.length > 0) { out.push(paraBlock(para)) }
385. para = []
386. blankBefore = true
387. i = i + 1
388. } else if (h != null) {
389. if (para.length > 0) { out.push(paraBlock(para)) }
390. para = []
391. if (inList) { out.push(listBlock(listOrdered, listStart, items)) }
392. inList = false
393. items = []
394. out.push(headingBlock(h.level, h.text))
395. blankBefore = false
396. i = i + 1
397. } else if (it != null) {
398. if (para.length > 0) { out.push(paraBlock(para)) }
399. para = []
400. if (inList && listOrdered != it.ordered) {
401. out.push(listBlock(listOrdered, listStart, items))
402. inList = false
403. items = []
404. }
405. if (!inList) {
406. inList = true
407. listOrdered = it.ordered
408. listStart = it.start
409. items = []
410. }
411. items.push([it.text])
412. blankBefore = false
413. i = i + 1
414. } else if (inList && (!blankBefore || indentOf(line) >= 2)) {
415. // a wrapped item line (or an indented paragraph of the item): onto the last item
416. let last = items[items.length - 1]
417. last.push(line.trim())
418. items[items.length - 1] = last
419. blankBefore = false
420. i = i + 1
421. } else {
422. if (inList) { out.push(listBlock(listOrdered, listStart, items)) }
423. inList = false
424. items = []
425. para.push(line.trim())
426. blankBefore = false
427. i = i + 1
428. }
429. }
430. if (para.length > 0) { out.push(paraBlock(para)) }
431. if (inList) { out.push(listBlock(listOrdered, listStart, items)) }
432. return out
433. }