@colibri-social/bridge-core 0.1.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.
- package/README.md +19 -0
- package/dist/.tsbuildinfo +1 -0
- package/dist/auth.d.ts +12 -0
- package/dist/auth.d.ts.map +1 -0
- package/dist/auth.js +29 -0
- package/dist/auth.js.map +1 -0
- package/dist/bridge.d.ts +102 -0
- package/dist/bridge.d.ts.map +1 -0
- package/dist/bridge.js +1209 -0
- package/dist/bridge.js.map +1 -0
- package/dist/client.d.ts +186 -0
- package/dist/client.d.ts.map +1 -0
- package/dist/client.js +133 -0
- package/dist/client.js.map +1 -0
- package/dist/connector.d.ts +202 -0
- package/dist/connector.d.ts.map +1 -0
- package/dist/connector.js +12 -0
- package/dist/connector.js.map +1 -0
- package/dist/events.d.ts +32 -0
- package/dist/events.d.ts.map +1 -0
- package/dist/events.js +102 -0
- package/dist/events.js.map +1 -0
- package/dist/identity.d.ts +12 -0
- package/dist/identity.d.ts.map +1 -0
- package/dist/identity.js +13 -0
- package/dist/identity.js.map +1 -0
- package/dist/index.d.ts +10 -0
- package/dist/index.d.ts.map +1 -0
- package/dist/index.js +10 -0
- package/dist/index.js.map +1 -0
- package/dist/markdown.d.ts +47 -0
- package/dist/markdown.d.ts.map +1 -0
- package/dist/markdown.js +742 -0
- package/dist/markdown.js.map +1 -0
- package/dist/store.d.ts +93 -0
- package/dist/store.d.ts.map +1 -0
- package/dist/store.js +165 -0
- package/dist/store.js.map +1 -0
- package/dist/text.d.ts +18 -0
- package/dist/text.d.ts.map +1 -0
- package/dist/text.js +58 -0
- package/dist/text.js.map +1 -0
- package/package.json +46 -0
package/dist/markdown.js
ADDED
|
@@ -0,0 +1,742 @@
|
|
|
1
|
+
import { fromMarkdown } from "mdast-util-from-markdown";
|
|
2
|
+
import { gfmStrikethroughFromMarkdown } from "mdast-util-gfm-strikethrough";
|
|
3
|
+
import { gfmStrikethrough } from "micromark-extension-gfm-strikethrough";
|
|
4
|
+
const FROM_MARKDOWN_OPTIONS = {
|
|
5
|
+
extensions: [gfmStrikethrough({ singleTilde: false })],
|
|
6
|
+
mdastExtensions: [gfmStrikethroughFromMarkdown()],
|
|
7
|
+
};
|
|
8
|
+
const FEATURE_TYPE = {
|
|
9
|
+
bold: "social.colibri.beta.richtext.facet#bold",
|
|
10
|
+
italic: "social.colibri.beta.richtext.facet#italic",
|
|
11
|
+
underline: "social.colibri.beta.richtext.facet#underline",
|
|
12
|
+
strikethrough: "social.colibri.beta.richtext.facet#strikethrough",
|
|
13
|
+
code: "social.colibri.beta.richtext.facet#code",
|
|
14
|
+
codeblock: "social.colibri.beta.richtext.facet#codeblock",
|
|
15
|
+
quote: "social.colibri.beta.richtext.facet#quote",
|
|
16
|
+
link: "social.colibri.beta.richtext.facet#link",
|
|
17
|
+
heading: "social.colibri.beta.richtext.facet#heading",
|
|
18
|
+
list: "social.colibri.beta.richtext.facet#list",
|
|
19
|
+
subtext: "social.colibri.beta.richtext.facet#subtext",
|
|
20
|
+
spoiler: "social.colibri.beta.richtext.facet#spoiler",
|
|
21
|
+
};
|
|
22
|
+
const INLINE_MARKER = {
|
|
23
|
+
bold: "**",
|
|
24
|
+
italic: "*",
|
|
25
|
+
underline: "__",
|
|
26
|
+
strikethrough: "~~",
|
|
27
|
+
code: "`",
|
|
28
|
+
spoiler: "||",
|
|
29
|
+
};
|
|
30
|
+
const encoder = new TextEncoder();
|
|
31
|
+
const offset = (node) => node.position?.start.offset ?? 0;
|
|
32
|
+
const endOffset = (node) => node.position?.end.offset ?? 0;
|
|
33
|
+
const wrapMarkers = (node) => {
|
|
34
|
+
const first = node.children[0];
|
|
35
|
+
const last = node.children.at(-1);
|
|
36
|
+
if (!first || !last)
|
|
37
|
+
return null;
|
|
38
|
+
const contentStart = offset(first);
|
|
39
|
+
const contentEnd = endOffset(last);
|
|
40
|
+
return {
|
|
41
|
+
markers: [
|
|
42
|
+
[offset(node), contentStart],
|
|
43
|
+
[contentEnd, endOffset(node)],
|
|
44
|
+
],
|
|
45
|
+
content: [contentStart, contentEnd],
|
|
46
|
+
};
|
|
47
|
+
};
|
|
48
|
+
const QUOTE_MARKER_MAX_INDENT = 3;
|
|
49
|
+
const FENCE_LINE = /^ {0,3}(?:`{3,}|~{3,})/;
|
|
50
|
+
const scanQuoteLines = (source) => {
|
|
51
|
+
const runs = [];
|
|
52
|
+
const markers = [];
|
|
53
|
+
let runStart = -1;
|
|
54
|
+
let runEnd = -1;
|
|
55
|
+
let fenceOpen = false;
|
|
56
|
+
let fenceQuoted = false;
|
|
57
|
+
let lineStart = 0;
|
|
58
|
+
for (;;) {
|
|
59
|
+
const nl = source.indexOf("\n", lineStart);
|
|
60
|
+
const lineEnd = nl === -1 ? source.length : nl;
|
|
61
|
+
let p = lineStart;
|
|
62
|
+
while (p < lineEnd && source[p] === " " && p - lineStart < QUOTE_MARKER_MAX_INDENT) {
|
|
63
|
+
p++;
|
|
64
|
+
}
|
|
65
|
+
let quoted = false;
|
|
66
|
+
let markerEnd = lineStart;
|
|
67
|
+
if (p < lineEnd && source[p] === ">") {
|
|
68
|
+
const after = p + 1;
|
|
69
|
+
const atLineEnd = after >= lineEnd || (source[after] === "\r" && after + 1 === lineEnd);
|
|
70
|
+
if (source[after] === " " || atLineEnd) {
|
|
71
|
+
quoted = !(fenceOpen && !fenceQuoted);
|
|
72
|
+
markerEnd = source[after] === " " ? after + 1 : after;
|
|
73
|
+
}
|
|
74
|
+
}
|
|
75
|
+
if (quoted) {
|
|
76
|
+
markers.push([lineStart, markerEnd]);
|
|
77
|
+
if (runStart === -1)
|
|
78
|
+
runStart = lineStart;
|
|
79
|
+
runEnd = lineEnd;
|
|
80
|
+
}
|
|
81
|
+
else if (runStart !== -1) {
|
|
82
|
+
runs.push([runStart, runEnd]);
|
|
83
|
+
runStart = -1;
|
|
84
|
+
if (fenceQuoted) {
|
|
85
|
+
fenceOpen = false;
|
|
86
|
+
fenceQuoted = false;
|
|
87
|
+
}
|
|
88
|
+
}
|
|
89
|
+
const contentStart = quoted ? markerEnd : lineStart;
|
|
90
|
+
if (FENCE_LINE.test(source.slice(contentStart, lineEnd))) {
|
|
91
|
+
if (fenceOpen) {
|
|
92
|
+
fenceOpen = false;
|
|
93
|
+
fenceQuoted = false;
|
|
94
|
+
}
|
|
95
|
+
else {
|
|
96
|
+
fenceOpen = true;
|
|
97
|
+
fenceQuoted = quoted;
|
|
98
|
+
}
|
|
99
|
+
}
|
|
100
|
+
if (nl === -1)
|
|
101
|
+
break;
|
|
102
|
+
lineStart = nl + 1;
|
|
103
|
+
}
|
|
104
|
+
if (runStart !== -1)
|
|
105
|
+
runs.push([runStart, runEnd]);
|
|
106
|
+
return { runs, markers };
|
|
107
|
+
};
|
|
108
|
+
const stripQuoteMarkers = (source, markers) => {
|
|
109
|
+
let stripped = "";
|
|
110
|
+
const toSource = [];
|
|
111
|
+
let cursor = 0;
|
|
112
|
+
for (const [start, end] of markers) {
|
|
113
|
+
for (let i = cursor; i < start; i++) {
|
|
114
|
+
toSource.push(i);
|
|
115
|
+
stripped += source[i];
|
|
116
|
+
}
|
|
117
|
+
cursor = Math.max(cursor, end);
|
|
118
|
+
}
|
|
119
|
+
for (let i = cursor; i < source.length; i++) {
|
|
120
|
+
toSource.push(i);
|
|
121
|
+
stripped += source[i];
|
|
122
|
+
}
|
|
123
|
+
toSource.push(source.length);
|
|
124
|
+
return { stripped, toSource };
|
|
125
|
+
};
|
|
126
|
+
const MULTILINE_BLOCK_KINDS = new Set([
|
|
127
|
+
"codeblock",
|
|
128
|
+
"heading",
|
|
129
|
+
"list",
|
|
130
|
+
"subtext",
|
|
131
|
+
]);
|
|
132
|
+
const crossesQuoteBoundary = (token, runs) => {
|
|
133
|
+
if (!MULTILINE_BLOCK_KINDS.has(token.kind))
|
|
134
|
+
return false;
|
|
135
|
+
const inQuote = (index) => runs.some(([start, end]) => index >= start && index < end);
|
|
136
|
+
const [start, end] = token.content;
|
|
137
|
+
return inQuote(start) !== inQuote(Math.max(start, end - 1));
|
|
138
|
+
};
|
|
139
|
+
export const tokenizeMarkdown = (source) => {
|
|
140
|
+
const { runs, markers } = scanQuoteLines(source);
|
|
141
|
+
if (markers.length === 0)
|
|
142
|
+
return tokenizeUnquoted(source);
|
|
143
|
+
const { stripped, toSource } = stripQuoteMarkers(source, markers);
|
|
144
|
+
const at = (index) => toSource[index] ?? source.length;
|
|
145
|
+
const tokens = [];
|
|
146
|
+
for (const token of tokenizeUnquoted(stripped)) {
|
|
147
|
+
const mapped = {
|
|
148
|
+
...token,
|
|
149
|
+
markers: token.markers.map(([start, end]) => [at(start), at(end)]),
|
|
150
|
+
content: [at(token.content[0]), at(token.content[1])],
|
|
151
|
+
};
|
|
152
|
+
if (crossesQuoteBoundary(mapped, runs))
|
|
153
|
+
continue;
|
|
154
|
+
tokens.push(mapped);
|
|
155
|
+
}
|
|
156
|
+
for (const [start, end] of runs) {
|
|
157
|
+
tokens.push({
|
|
158
|
+
kind: "quote",
|
|
159
|
+
markers: markers.filter(([markerStart]) => markerStart >= start && markerStart < end),
|
|
160
|
+
content: [start, end],
|
|
161
|
+
});
|
|
162
|
+
}
|
|
163
|
+
return tokens.sort((a, b) => a.content[0] - b.content[0]);
|
|
164
|
+
};
|
|
165
|
+
const tokenizeUnquoted = (source) => {
|
|
166
|
+
const tree = fromMarkdown(source, FROM_MARKDOWN_OPTIONS);
|
|
167
|
+
const tokens = [];
|
|
168
|
+
const visit = (node, depth = 0) => {
|
|
169
|
+
switch (node.type) {
|
|
170
|
+
case "strong": {
|
|
171
|
+
const w = wrapMarkers(node);
|
|
172
|
+
if (w) {
|
|
173
|
+
tokens.push({
|
|
174
|
+
kind: source[offset(node)] === "_" ? "underline" : "bold",
|
|
175
|
+
...w,
|
|
176
|
+
});
|
|
177
|
+
}
|
|
178
|
+
break;
|
|
179
|
+
}
|
|
180
|
+
case "emphasis": {
|
|
181
|
+
const w = wrapMarkers(node);
|
|
182
|
+
if (w)
|
|
183
|
+
tokens.push({ kind: "italic", ...w });
|
|
184
|
+
break;
|
|
185
|
+
}
|
|
186
|
+
case "delete": {
|
|
187
|
+
const w = wrapMarkers(node);
|
|
188
|
+
if (w)
|
|
189
|
+
tokens.push({ kind: "strikethrough", ...w });
|
|
190
|
+
break;
|
|
191
|
+
}
|
|
192
|
+
case "inlineCode": {
|
|
193
|
+
const start = offset(node);
|
|
194
|
+
const end = endOffset(node);
|
|
195
|
+
let n = 0;
|
|
196
|
+
while (source[start + n] === "`")
|
|
197
|
+
n++;
|
|
198
|
+
const contentStart = start + n;
|
|
199
|
+
const contentEnd = end - n;
|
|
200
|
+
if (contentEnd > contentStart) {
|
|
201
|
+
tokens.push({
|
|
202
|
+
kind: "code",
|
|
203
|
+
markers: [
|
|
204
|
+
[start, contentStart],
|
|
205
|
+
[contentEnd, end],
|
|
206
|
+
],
|
|
207
|
+
content: [contentStart, contentEnd],
|
|
208
|
+
});
|
|
209
|
+
}
|
|
210
|
+
break;
|
|
211
|
+
}
|
|
212
|
+
case "link": {
|
|
213
|
+
const first = node.children[0];
|
|
214
|
+
const last = node.children.at(-1);
|
|
215
|
+
if (first && last && node.url) {
|
|
216
|
+
const contentStart = offset(first);
|
|
217
|
+
const contentEnd = endOffset(last);
|
|
218
|
+
tokens.push({
|
|
219
|
+
kind: "link",
|
|
220
|
+
markers: [
|
|
221
|
+
[offset(node), contentStart],
|
|
222
|
+
[contentEnd, endOffset(node)],
|
|
223
|
+
],
|
|
224
|
+
content: [contentStart, contentEnd],
|
|
225
|
+
uri: node.url,
|
|
226
|
+
});
|
|
227
|
+
}
|
|
228
|
+
break;
|
|
229
|
+
}
|
|
230
|
+
case "code": {
|
|
231
|
+
const start = offset(node);
|
|
232
|
+
const end = endOffset(node);
|
|
233
|
+
const fenceChar = source[start];
|
|
234
|
+
if (fenceChar === "`" || fenceChar === "~") {
|
|
235
|
+
const firstNewline = source.indexOf("\n", start);
|
|
236
|
+
if (firstNewline !== -1 && firstNewline < end) {
|
|
237
|
+
const contentStart = firstNewline + 1;
|
|
238
|
+
let contentEnd = source.lastIndexOf("\n", end - 1);
|
|
239
|
+
if (contentEnd < contentStart)
|
|
240
|
+
contentEnd = contentStart;
|
|
241
|
+
tokens.push({
|
|
242
|
+
kind: "codeblock",
|
|
243
|
+
markers: [
|
|
244
|
+
[start, contentStart],
|
|
245
|
+
[contentEnd, end],
|
|
246
|
+
],
|
|
247
|
+
content: [contentStart, contentEnd],
|
|
248
|
+
lang: node.lang || undefined,
|
|
249
|
+
});
|
|
250
|
+
}
|
|
251
|
+
}
|
|
252
|
+
break;
|
|
253
|
+
}
|
|
254
|
+
case "heading": {
|
|
255
|
+
if (node.depth > 3 || source[offset(node)] !== "#")
|
|
256
|
+
break;
|
|
257
|
+
const w = wrapMarkers(node);
|
|
258
|
+
if (w)
|
|
259
|
+
tokens.push({ kind: "heading", level: node.depth, ...w });
|
|
260
|
+
break;
|
|
261
|
+
}
|
|
262
|
+
case "list": {
|
|
263
|
+
for (const item of node.children) {
|
|
264
|
+
if (item.type !== "listItem")
|
|
265
|
+
continue;
|
|
266
|
+
const para = item.children.find((k) => k.type === "paragraph") ?? item.children[0];
|
|
267
|
+
if (!para)
|
|
268
|
+
continue;
|
|
269
|
+
const contentStart = offset(para);
|
|
270
|
+
let contentEnd = endOffset(para);
|
|
271
|
+
const nl = source.indexOf("\n", contentStart);
|
|
272
|
+
if (nl !== -1 && nl < contentEnd)
|
|
273
|
+
contentEnd = nl;
|
|
274
|
+
if (contentEnd <= contentStart)
|
|
275
|
+
continue;
|
|
276
|
+
tokens.push({
|
|
277
|
+
kind: "list",
|
|
278
|
+
ordered: Boolean(node.ordered),
|
|
279
|
+
indent: depth,
|
|
280
|
+
markers: [[offset(item), contentStart]],
|
|
281
|
+
content: [contentStart, contentEnd],
|
|
282
|
+
});
|
|
283
|
+
}
|
|
284
|
+
break;
|
|
285
|
+
}
|
|
286
|
+
}
|
|
287
|
+
if ("children" in node) {
|
|
288
|
+
const childDepth = node.type === "list" ? depth + 1 : depth;
|
|
289
|
+
for (const child of node.children)
|
|
290
|
+
visit(child, childDepth);
|
|
291
|
+
}
|
|
292
|
+
};
|
|
293
|
+
visit(tree);
|
|
294
|
+
const codeRanges = tokens
|
|
295
|
+
.filter((t) => t.kind === "code" || t.kind === "codeblock")
|
|
296
|
+
.map((t) => [t.markers[0]?.[0] ?? 0, (t.markers[1] ?? t.markers[0])?.[1] ?? 0]);
|
|
297
|
+
const insideCode = (index) => codeRanges.some(([s, e]) => index >= s && index < e);
|
|
298
|
+
const subtextRe = /(^|\n)([ \t]{0,3}-#[ \t])([^\n]*)/g;
|
|
299
|
+
for (const sub of source.matchAll(subtextRe)) {
|
|
300
|
+
const lineStart = sub.index + (sub[1] ?? "").length;
|
|
301
|
+
const markerEnd = lineStart + (sub[2] ?? "").length;
|
|
302
|
+
const contentEnd = markerEnd + (sub[3] ?? "").length;
|
|
303
|
+
if (contentEnd <= markerEnd || insideCode(lineStart))
|
|
304
|
+
continue;
|
|
305
|
+
tokens.push({
|
|
306
|
+
kind: "subtext",
|
|
307
|
+
markers: [[lineStart, markerEnd]],
|
|
308
|
+
content: [markerEnd, contentEnd],
|
|
309
|
+
});
|
|
310
|
+
}
|
|
311
|
+
const spoilerRe = /\|\|([^\n]+?)\|\|/g;
|
|
312
|
+
for (const sp of source.matchAll(spoilerRe)) {
|
|
313
|
+
const start = sp.index;
|
|
314
|
+
const end = start + sp[0].length;
|
|
315
|
+
const contentStart = start + 2;
|
|
316
|
+
const contentEnd = end - 2;
|
|
317
|
+
if (contentEnd <= contentStart || insideCode(start))
|
|
318
|
+
continue;
|
|
319
|
+
tokens.push({
|
|
320
|
+
kind: "spoiler",
|
|
321
|
+
markers: [
|
|
322
|
+
[start, contentStart],
|
|
323
|
+
[contentEnd, end],
|
|
324
|
+
],
|
|
325
|
+
content: [contentStart, contentEnd],
|
|
326
|
+
});
|
|
327
|
+
}
|
|
328
|
+
return tokens.sort((a, b) => a.content[0] - b.content[0]);
|
|
329
|
+
};
|
|
330
|
+
const buildFeature = (token) => {
|
|
331
|
+
switch (token.kind) {
|
|
332
|
+
case "codeblock":
|
|
333
|
+
return {
|
|
334
|
+
$type: "social.colibri.beta.richtext.facet#codeblock",
|
|
335
|
+
...(token.lang ? { lang: token.lang } : {}),
|
|
336
|
+
};
|
|
337
|
+
case "link":
|
|
338
|
+
return {
|
|
339
|
+
$type: "social.colibri.beta.richtext.facet#link",
|
|
340
|
+
uri: token.uri ?? "",
|
|
341
|
+
};
|
|
342
|
+
case "heading":
|
|
343
|
+
return {
|
|
344
|
+
$type: "social.colibri.beta.richtext.facet#heading",
|
|
345
|
+
level: token.level ?? 1,
|
|
346
|
+
};
|
|
347
|
+
case "list":
|
|
348
|
+
return {
|
|
349
|
+
$type: "social.colibri.beta.richtext.facet#list",
|
|
350
|
+
ordered: Boolean(token.ordered),
|
|
351
|
+
...(token.indent ? { indent: token.indent } : {}),
|
|
352
|
+
};
|
|
353
|
+
default:
|
|
354
|
+
return { $type: FEATURE_TYPE[token.kind] };
|
|
355
|
+
}
|
|
356
|
+
};
|
|
357
|
+
const mergeSpans = (spans) => {
|
|
358
|
+
const sorted = [...spans]
|
|
359
|
+
.filter(([start, end]) => end > start)
|
|
360
|
+
.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
|
|
361
|
+
const merged = [];
|
|
362
|
+
for (const [start, end] of sorted) {
|
|
363
|
+
const last = merged[merged.length - 1];
|
|
364
|
+
if (last && start <= last[1]) {
|
|
365
|
+
if (end > last[1])
|
|
366
|
+
last[1] = end;
|
|
367
|
+
}
|
|
368
|
+
else {
|
|
369
|
+
merged.push([start, end]);
|
|
370
|
+
}
|
|
371
|
+
}
|
|
372
|
+
return merged;
|
|
373
|
+
};
|
|
374
|
+
const removeRanges = (source, ranges) => {
|
|
375
|
+
const removed = mergeSpans(ranges);
|
|
376
|
+
let text = "";
|
|
377
|
+
let cursor = 0;
|
|
378
|
+
for (const [start, end] of removed) {
|
|
379
|
+
text += source.slice(cursor, start);
|
|
380
|
+
cursor = end;
|
|
381
|
+
}
|
|
382
|
+
text += source.slice(cursor);
|
|
383
|
+
const mapToClean = (index) => {
|
|
384
|
+
let delta = 0;
|
|
385
|
+
for (const [start, end] of removed) {
|
|
386
|
+
if (end <= index)
|
|
387
|
+
delta += end - start;
|
|
388
|
+
else if (start < index)
|
|
389
|
+
delta += index - start;
|
|
390
|
+
}
|
|
391
|
+
return index - delta;
|
|
392
|
+
};
|
|
393
|
+
return { text, mapToClean };
|
|
394
|
+
};
|
|
395
|
+
export const parseMarkdown = (source, extra = [], options) => {
|
|
396
|
+
const allowLink = options?.allowLink;
|
|
397
|
+
const tokens = tokenizeMarkdown(source).filter((t) => t.kind !== "link" ||
|
|
398
|
+
!allowLink ||
|
|
399
|
+
allowLink(source.slice(t.content[0], t.content[1]), t.uri ?? ""));
|
|
400
|
+
const { text, mapToClean } = removeRanges(source, tokens.flatMap((t) => t.markers));
|
|
401
|
+
const cleanToByte = (index) => encoder.encode(text.slice(0, index)).length;
|
|
402
|
+
const facets = [];
|
|
403
|
+
const pushFacet = (startStr, endStr, features) => {
|
|
404
|
+
const cleanStart = mapToClean(startStr);
|
|
405
|
+
const cleanEnd = mapToClean(endStr);
|
|
406
|
+
if (cleanEnd <= cleanStart)
|
|
407
|
+
return;
|
|
408
|
+
facets.push({
|
|
409
|
+
$type: "social.colibri.beta.richtext.facet",
|
|
410
|
+
index: {
|
|
411
|
+
$type: "social.colibri.beta.richtext.facet#byteSlice",
|
|
412
|
+
byteStart: cleanToByte(cleanStart),
|
|
413
|
+
byteEnd: cleanToByte(cleanEnd),
|
|
414
|
+
},
|
|
415
|
+
features,
|
|
416
|
+
});
|
|
417
|
+
};
|
|
418
|
+
for (const token of tokens) {
|
|
419
|
+
if (token.content[1] <= token.content[0])
|
|
420
|
+
continue;
|
|
421
|
+
pushFacet(token.content[0], token.content[1], [buildFeature(token)]);
|
|
422
|
+
}
|
|
423
|
+
for (const ex of extra) {
|
|
424
|
+
pushFacet(ex.start, ex.end, ex.features);
|
|
425
|
+
}
|
|
426
|
+
facets.sort((a, b) => a.index.byteStart - b.index.byteStart || a.index.byteEnd - b.index.byteEnd);
|
|
427
|
+
return { text, facets };
|
|
428
|
+
};
|
|
429
|
+
const byteIndexMap = (text) => {
|
|
430
|
+
const map = new Map();
|
|
431
|
+
let byte = 0;
|
|
432
|
+
let i = 0;
|
|
433
|
+
while (i < text.length) {
|
|
434
|
+
map.set(byte, i);
|
|
435
|
+
const codePoint = text.codePointAt(i);
|
|
436
|
+
byte += codePoint < 0x80 ? 1 : codePoint < 0x800 ? 2 : codePoint < 0x10000 ? 3 : 4;
|
|
437
|
+
i += codePoint > 0xffff ? 2 : 1;
|
|
438
|
+
}
|
|
439
|
+
map.set(byte, i);
|
|
440
|
+
return map;
|
|
441
|
+
};
|
|
442
|
+
const featureKind = (feature) => (feature.$type ?? "").split("#")[1] ?? "";
|
|
443
|
+
const scanLines = (text) => {
|
|
444
|
+
const lines = [];
|
|
445
|
+
let start = 0;
|
|
446
|
+
for (;;) {
|
|
447
|
+
const nl = text.indexOf("\n", start);
|
|
448
|
+
const end = nl === -1 ? text.length : nl;
|
|
449
|
+
let content = end;
|
|
450
|
+
while (content > start && /[ \t\r]/.test(text[content - 1] ?? ""))
|
|
451
|
+
content--;
|
|
452
|
+
lines.push({ start, end, blank: content === start });
|
|
453
|
+
if (nl === -1)
|
|
454
|
+
break;
|
|
455
|
+
start = nl + 1;
|
|
456
|
+
}
|
|
457
|
+
return lines;
|
|
458
|
+
};
|
|
459
|
+
export const normalizeWhitespace = (input) => {
|
|
460
|
+
const { text, facets } = input;
|
|
461
|
+
if (!text)
|
|
462
|
+
return input;
|
|
463
|
+
const byteToStr = byteIndexMap(text);
|
|
464
|
+
const toStr = (byte) => byteToStr.get(byte) ?? text.length;
|
|
465
|
+
const protectedRanges = [];
|
|
466
|
+
const headingEnds = [];
|
|
467
|
+
for (const facet of facets) {
|
|
468
|
+
for (const feature of facet.features) {
|
|
469
|
+
const kind = featureKind(feature);
|
|
470
|
+
if (kind === "codeblock") {
|
|
471
|
+
protectedRanges.push([toStr(facet.index.byteStart), toStr(facet.index.byteEnd) + 1]);
|
|
472
|
+
}
|
|
473
|
+
else if (kind === "heading") {
|
|
474
|
+
headingEnds.push(toStr(facet.index.byteEnd));
|
|
475
|
+
}
|
|
476
|
+
}
|
|
477
|
+
}
|
|
478
|
+
const isProtected = (from, to) => protectedRanges.some(([start, end]) => from < end && to > start);
|
|
479
|
+
const lines = scanLines(text);
|
|
480
|
+
const ranges = [];
|
|
481
|
+
const headingLines = new Set();
|
|
482
|
+
for (const end of headingEnds) {
|
|
483
|
+
const index = lines.findIndex((line) => end >= line.start && end <= line.end);
|
|
484
|
+
if (index !== -1)
|
|
485
|
+
headingLines.add(index);
|
|
486
|
+
}
|
|
487
|
+
let blankRunStart = -1;
|
|
488
|
+
for (const [i, line] of lines.entries()) {
|
|
489
|
+
if (!line.blank) {
|
|
490
|
+
let content = line.end;
|
|
491
|
+
while (content > line.start && /[ \t\r]/.test(text[content - 1] ?? "")) {
|
|
492
|
+
content--;
|
|
493
|
+
}
|
|
494
|
+
if (content < line.end && !isProtected(content, line.end)) {
|
|
495
|
+
ranges.push([content, line.end]);
|
|
496
|
+
}
|
|
497
|
+
blankRunStart = -1;
|
|
498
|
+
continue;
|
|
499
|
+
}
|
|
500
|
+
if (blankRunStart === -1)
|
|
501
|
+
blankRunStart = i;
|
|
502
|
+
if (isProtected(line.start, line.end + 1))
|
|
503
|
+
continue;
|
|
504
|
+
const underHeading = headingLines.has(blankRunStart - 1);
|
|
505
|
+
if (underHeading || i > blankRunStart) {
|
|
506
|
+
ranges.push([line.start, Math.min(line.end + 1, text.length)]);
|
|
507
|
+
}
|
|
508
|
+
else if (line.end > line.start) {
|
|
509
|
+
ranges.push([line.start, line.end]);
|
|
510
|
+
}
|
|
511
|
+
}
|
|
512
|
+
const leading = text.length - text.trimStart().length;
|
|
513
|
+
if (leading > 0 && !isProtected(0, leading))
|
|
514
|
+
ranges.push([0, leading]);
|
|
515
|
+
const trailing = text.length - text.trimEnd().length;
|
|
516
|
+
if (trailing > 0 && !isProtected(text.length - trailing, text.length)) {
|
|
517
|
+
ranges.push([text.length - trailing, text.length]);
|
|
518
|
+
}
|
|
519
|
+
if (ranges.length === 0)
|
|
520
|
+
return input;
|
|
521
|
+
const { text: cleaned, mapToClean } = removeRanges(text, ranges);
|
|
522
|
+
const cleanToByte = (index) => encoder.encode(cleaned.slice(0, index)).length;
|
|
523
|
+
const mapped = [];
|
|
524
|
+
for (const facet of facets) {
|
|
525
|
+
const byteStart = cleanToByte(mapToClean(toStr(facet.index.byteStart)));
|
|
526
|
+
const byteEnd = cleanToByte(mapToClean(toStr(facet.index.byteEnd)));
|
|
527
|
+
if (byteEnd <= byteStart)
|
|
528
|
+
continue;
|
|
529
|
+
mapped.push({ ...facet, index: { ...facet.index, byteStart, byteEnd } });
|
|
530
|
+
}
|
|
531
|
+
return { text: cleaned, facets: mapped };
|
|
532
|
+
};
|
|
533
|
+
const ATOM_KIND = new Set(["mention", "bridgedMention", "channel", "role", "time"]);
|
|
534
|
+
export const resolveListDepths = (items) => {
|
|
535
|
+
if (items.some((item) => item.indent !== undefined)) {
|
|
536
|
+
return items.map((item) => Math.max(0, item.indent ?? 0));
|
|
537
|
+
}
|
|
538
|
+
const widths = [];
|
|
539
|
+
return items.map((item) => {
|
|
540
|
+
while (widths.length && (widths.at(-1) ?? 0) > item.indentWidth) {
|
|
541
|
+
widths.pop();
|
|
542
|
+
}
|
|
543
|
+
if (!widths.length || (widths.at(-1) ?? 0) < item.indentWidth) {
|
|
544
|
+
widths.push(item.indentWidth);
|
|
545
|
+
}
|
|
546
|
+
return widths.length - 1;
|
|
547
|
+
});
|
|
548
|
+
};
|
|
549
|
+
const TAB_WIDTH = 4;
|
|
550
|
+
export const indentWidthAt = (charAt, index) => {
|
|
551
|
+
let lineStart = index;
|
|
552
|
+
while (lineStart > 0 && charAt(lineStart - 1) !== "\n")
|
|
553
|
+
lineStart--;
|
|
554
|
+
let width = 0;
|
|
555
|
+
for (let i = lineStart; i < index; i++) {
|
|
556
|
+
const char = charAt(i);
|
|
557
|
+
if (char === " ")
|
|
558
|
+
width += 1;
|
|
559
|
+
else if (char === "\t")
|
|
560
|
+
width += TAB_WIDTH;
|
|
561
|
+
else
|
|
562
|
+
return 0;
|
|
563
|
+
}
|
|
564
|
+
return width;
|
|
565
|
+
};
|
|
566
|
+
export const isSingleLineGap = (charAt, from, to) => {
|
|
567
|
+
let breaks = 0;
|
|
568
|
+
for (let i = from; i < to; i++) {
|
|
569
|
+
const char = charAt(i);
|
|
570
|
+
if (char === "\n")
|
|
571
|
+
breaks++;
|
|
572
|
+
else if (char !== " " && char !== "\t" && char !== "\r")
|
|
573
|
+
return false;
|
|
574
|
+
}
|
|
575
|
+
return breaks === 1;
|
|
576
|
+
};
|
|
577
|
+
export const facetsToSource = (text, facets) => {
|
|
578
|
+
const byteToStr = byteIndexMap(text);
|
|
579
|
+
const toStr = (byte) => byteToStr.get(byte) ?? text.length;
|
|
580
|
+
const charAt = (index) => text[index];
|
|
581
|
+
const opensAt = new Map();
|
|
582
|
+
const closesAt = new Map();
|
|
583
|
+
const addMarker = (map, index, value) => {
|
|
584
|
+
const arr = map.get(index);
|
|
585
|
+
if (arr)
|
|
586
|
+
arr.push(value);
|
|
587
|
+
else
|
|
588
|
+
map.set(index, [value]);
|
|
589
|
+
};
|
|
590
|
+
const blockPrefixAt = new Map();
|
|
591
|
+
const setPrefix = (index, kind, value) => {
|
|
592
|
+
const prefix = blockPrefixAt.get(index);
|
|
593
|
+
if (!prefix) {
|
|
594
|
+
blockPrefixAt.set(index, { [kind]: value });
|
|
595
|
+
}
|
|
596
|
+
else if (prefix[kind] === undefined) {
|
|
597
|
+
prefix[kind] = value;
|
|
598
|
+
}
|
|
599
|
+
};
|
|
600
|
+
const codeblocks = [];
|
|
601
|
+
const atomStarts = new Map();
|
|
602
|
+
const listFacets = [];
|
|
603
|
+
const quoteRanges = [];
|
|
604
|
+
for (const facet of facets) {
|
|
605
|
+
const start = toStr(facet.index.byteStart);
|
|
606
|
+
const end = toStr(facet.index.byteEnd);
|
|
607
|
+
for (const feature of facet.features) {
|
|
608
|
+
const kind = featureKind(feature);
|
|
609
|
+
const inline = INLINE_MARKER[kind];
|
|
610
|
+
if (inline) {
|
|
611
|
+
addMarker(opensAt, start, inline);
|
|
612
|
+
addMarker(closesAt, end, inline);
|
|
613
|
+
}
|
|
614
|
+
else if (kind === "link") {
|
|
615
|
+
addMarker(opensAt, start, "[");
|
|
616
|
+
addMarker(closesAt, end, `](${"uri" in feature ? feature.uri : ""})`);
|
|
617
|
+
}
|
|
618
|
+
else if (kind === "codeblock") {
|
|
619
|
+
if (end > start) {
|
|
620
|
+
codeblocks.push([start, end, "lang" in feature && feature.lang ? feature.lang : ""]);
|
|
621
|
+
}
|
|
622
|
+
}
|
|
623
|
+
else if (kind === "heading") {
|
|
624
|
+
const level = "level" in feature ? Number(feature.level) || 1 : 1;
|
|
625
|
+
setPrefix(start, "heading", `${"#".repeat(Math.min(3, level))} `);
|
|
626
|
+
}
|
|
627
|
+
else if (kind === "subtext") {
|
|
628
|
+
setPrefix(start, "subtext", "-# ");
|
|
629
|
+
}
|
|
630
|
+
else if (kind === "list") {
|
|
631
|
+
listFacets.push({
|
|
632
|
+
start,
|
|
633
|
+
end,
|
|
634
|
+
ordered: "ordered" in feature && Boolean(feature.ordered),
|
|
635
|
+
indent: "indent" in feature && feature.indent !== undefined
|
|
636
|
+
? Number(feature.indent)
|
|
637
|
+
: undefined,
|
|
638
|
+
indentWidth: indentWidthAt(charAt, start),
|
|
639
|
+
});
|
|
640
|
+
}
|
|
641
|
+
else if (kind === "quote") {
|
|
642
|
+
quoteRanges.push([start, end]);
|
|
643
|
+
}
|
|
644
|
+
else if (ATOM_KIND.has(kind)) {
|
|
645
|
+
atomStarts.set(start, { end, feature });
|
|
646
|
+
}
|
|
647
|
+
}
|
|
648
|
+
}
|
|
649
|
+
listFacets.sort((a, b) => a.start - b.start);
|
|
650
|
+
const depths = resolveListDepths(listFacets);
|
|
651
|
+
const counters = [];
|
|
652
|
+
let prevEnd = -1;
|
|
653
|
+
let prevStart = -1;
|
|
654
|
+
for (const [i, lf] of listFacets.entries()) {
|
|
655
|
+
if (lf.start === prevStart)
|
|
656
|
+
continue;
|
|
657
|
+
const depth = depths[i] ?? 0;
|
|
658
|
+
if (prevEnd < 0 || !isSingleLineGap(charAt, prevEnd, lf.start)) {
|
|
659
|
+
counters.length = 0;
|
|
660
|
+
}
|
|
661
|
+
else if (counters.length > depth + 1) {
|
|
662
|
+
counters.length = depth + 1;
|
|
663
|
+
}
|
|
664
|
+
if (lf.ordered) {
|
|
665
|
+
counters[depth] = (counters[depth] ?? 0) + 1;
|
|
666
|
+
setPrefix(lf.start, "list", `${counters[depth]}. `);
|
|
667
|
+
}
|
|
668
|
+
else {
|
|
669
|
+
counters[depth] = 0;
|
|
670
|
+
setPrefix(lf.start, "list", "- ");
|
|
671
|
+
}
|
|
672
|
+
prevEnd = lf.end;
|
|
673
|
+
prevStart = lf.start;
|
|
674
|
+
}
|
|
675
|
+
codeblocks.sort((a, b) => a[0] - b[0]);
|
|
676
|
+
const quoteLineStarts = new Set();
|
|
677
|
+
for (const [qs, qe] of quoteRanges) {
|
|
678
|
+
quoteLineStarts.add(qs);
|
|
679
|
+
for (let p = qs; p < qe; p++) {
|
|
680
|
+
if (text[p] === "\n")
|
|
681
|
+
quoteLineStarts.add(p + 1);
|
|
682
|
+
}
|
|
683
|
+
}
|
|
684
|
+
const insideQuote = (index) => quoteRanges.some(([qs, qe]) => index >= qs && index < qe);
|
|
685
|
+
let out = "";
|
|
686
|
+
let i = 0;
|
|
687
|
+
const atoms = [];
|
|
688
|
+
let pending = null;
|
|
689
|
+
while (i <= text.length) {
|
|
690
|
+
const fence = codeblocks.find(([s]) => s === i);
|
|
691
|
+
if (pending && i === pending.cleanEnd) {
|
|
692
|
+
atoms.push({
|
|
693
|
+
start: pending.sourceStart,
|
|
694
|
+
end: out.length,
|
|
695
|
+
feature: pending.feature,
|
|
696
|
+
});
|
|
697
|
+
pending = null;
|
|
698
|
+
}
|
|
699
|
+
const closers = closesAt.get(i);
|
|
700
|
+
if (closers)
|
|
701
|
+
for (const m of [...closers].reverse())
|
|
702
|
+
out += m;
|
|
703
|
+
if (quoteLineStarts.has(i))
|
|
704
|
+
out += "> ";
|
|
705
|
+
if (i === text.length)
|
|
706
|
+
break;
|
|
707
|
+
if (fence) {
|
|
708
|
+
const prefix = insideQuote(i) ? "> " : "";
|
|
709
|
+
out += `\`\`\`${fence[2]}\n`;
|
|
710
|
+
out += text
|
|
711
|
+
.slice(i, fence[1])
|
|
712
|
+
.split("\n")
|
|
713
|
+
.map((line) => prefix + line)
|
|
714
|
+
.join("\n");
|
|
715
|
+
out += `\n${prefix}\`\`\``;
|
|
716
|
+
i = Math.max(fence[1], i + 1);
|
|
717
|
+
continue;
|
|
718
|
+
}
|
|
719
|
+
const blockPrefix = blockPrefixAt.get(i);
|
|
720
|
+
if (blockPrefix) {
|
|
721
|
+
out += blockPrefix.list ?? "";
|
|
722
|
+
out += blockPrefix.heading ?? "";
|
|
723
|
+
out += blockPrefix.subtext ?? "";
|
|
724
|
+
}
|
|
725
|
+
const openers = opensAt.get(i);
|
|
726
|
+
if (openers)
|
|
727
|
+
for (const m of openers)
|
|
728
|
+
out += m;
|
|
729
|
+
const atom = atomStarts.get(i);
|
|
730
|
+
if (atom) {
|
|
731
|
+
pending = {
|
|
732
|
+
cleanEnd: atom.end,
|
|
733
|
+
feature: atom.feature,
|
|
734
|
+
sourceStart: out.length,
|
|
735
|
+
};
|
|
736
|
+
}
|
|
737
|
+
out += text[i];
|
|
738
|
+
i++;
|
|
739
|
+
}
|
|
740
|
+
return { source: out, atoms };
|
|
741
|
+
};
|
|
742
|
+
//# sourceMappingURL=markdown.js.map
|