svelte-highlight 7.21.1 → 7.23.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 (92) hide show
  1. package/AnsiOutput.svelte +6 -30
  2. package/CodeWindow.svelte +35 -11
  3. package/CodeWindow.svelte.d.ts +7 -1
  4. package/FileTabs.svelte +3 -1
  5. package/HighlightEditable.svelte +115 -143
  6. package/HighlightStream.svelte +44 -48
  7. package/HighlightStyle.svelte +9 -21
  8. package/HighlightVirtual.svelte +82 -4
  9. package/HighlightVirtual.svelte.d.ts +19 -2
  10. package/LangTag.svelte +4 -0
  11. package/LineNumbers.svelte +1 -0
  12. package/MarkdownStream.svelte +209 -0
  13. package/MarkdownStream.svelte.d.ts +100 -0
  14. package/README.md +183 -9
  15. package/ansi-color.js +109 -22
  16. package/ansi-output.js +93 -0
  17. package/ansi.d.ts +18 -0
  18. package/ansi.js +85 -24
  19. package/css-walk.js +9 -12
  20. package/editable-css-paint.js +118 -0
  21. package/editable-dom-paint.js +217 -146
  22. package/editable-line-dom.js +241 -0
  23. package/engine.d.ts +28 -6
  24. package/engine.js +707 -144
  25. package/fence.d.ts +5 -5
  26. package/fence.js +196 -56
  27. package/highlight-theme.js +10 -4
  28. package/incremental-tokenize.js +95 -17
  29. package/index.d.ts +1 -0
  30. package/index.js +1 -0
  31. package/languages/aliases.js +1 -1
  32. package/languages/all.js +23 -1
  33. package/languages/alloy.d.ts +2 -0
  34. package/languages/alloy.js +2 -0
  35. package/languages/asymptote.d.ts +2 -0
  36. package/languages/asymptote.js +2 -0
  37. package/languages/blockdiag.d.ts +2 -0
  38. package/languages/blockdiag.js +2 -0
  39. package/languages/bsv.d.ts +2 -0
  40. package/languages/bsv.js +2 -0
  41. package/languages/casbin.d.ts +2 -0
  42. package/languages/casbin.js +2 -0
  43. package/languages/choicescript.d.ts +2 -0
  44. package/languages/choicescript.js +2 -0
  45. package/languages/dafny.d.ts +2 -0
  46. package/languages/dafny.js +2 -0
  47. package/languages/dbml.d.ts +2 -0
  48. package/languages/dbml.js +2 -0
  49. package/languages/dialog.d.ts +2 -0
  50. package/languages/dialog.js +2 -0
  51. package/languages/fstar.d.ts +2 -0
  52. package/languages/fstar.js +2 -0
  53. package/languages/gnuplot.d.ts +2 -0
  54. package/languages/gnuplot.js +2 -0
  55. package/languages/harlowe.d.ts +2 -0
  56. package/languages/harlowe.js +2 -0
  57. package/languages/index.d.ts +44 -0
  58. package/languages/index.js +22 -0
  59. package/languages/likec4.d.ts +2 -0
  60. package/languages/likec4.js +2 -0
  61. package/languages/nextflow.d.ts +2 -0
  62. package/languages/nextflow.js +2 -0
  63. package/languages/nomnoml.d.ts +2 -0
  64. package/languages/nomnoml.js +2 -0
  65. package/languages/openfga.d.ts +2 -0
  66. package/languages/openfga.js +2 -0
  67. package/languages/pikchr.d.ts +2 -0
  68. package/languages/pikchr.js +2 -0
  69. package/languages/spade.d.ts +2 -0
  70. package/languages/spade.js +2 -0
  71. package/languages/spicedb.d.ts +2 -0
  72. package/languages/spicedb.js +2 -0
  73. package/languages/tlaplus.d.ts +2 -0
  74. package/languages/tlaplus.js +2 -0
  75. package/languages/veryl.d.ts +2 -0
  76. package/languages/veryl.js +2 -0
  77. package/languages/wdl.d.ts +2 -0
  78. package/languages/wdl.js +2 -0
  79. package/package.json +1 -1
  80. package/preprocessor.js +16 -2
  81. package/scoped.js +15 -13
  82. package/search.d.ts +6 -4
  83. package/search.js +427 -85
  84. package/stream-final-highlight.js +52 -0
  85. package/stream-highlighted.js +17 -0
  86. package/stream-preview.js +7 -2
  87. package/stream-regenerate.js +262 -0
  88. package/style-registry.js +60 -0
  89. package/text-diff.js +66 -18
  90. package/tokenized-document.d.ts +8 -0
  91. package/tokenized-document.js +60 -15
  92. package/worker.js +14 -2
@@ -66,8 +66,10 @@
66
66
  import { createEventDispatcher, onMount, tick } from "svelte";
67
67
  import { extendLines } from "./engine.js";
68
68
  import { ensureRegistered, registry } from "./registry.js";
69
+ import { createFinalHighlighter } from "./stream-final-highlight.js";
69
70
  import { createCompletedHtmlBuffer } from "./stream-highlighted.js";
70
71
  import { computeStagedTailPreview } from "./stream-preview.js";
72
+ import { regenerate } from "./stream-regenerate.js";
71
73
  import {
72
74
  buildSealedChunkHtml,
73
75
  pushSealedChunk,
@@ -160,6 +162,8 @@
160
162
  // so `on:highlight` stays live mid-line; that concat copies the completed
161
163
  // string but avoids rebuilding it from sealed DOM chunks.
162
164
  const completedHtml = createCompletedHtmlBuffer();
165
+ // The `done` pass's full re-parse; see stream-final-highlight.js.
166
+ const finalHighlighter = createFinalHighlighter();
163
167
  // Completed lines not yet folded into a sealed chunk - bounded by
164
168
  // `SEAL_CHUNK_LINES`, so touching it every repaint stays O(1).
165
169
  /** @type {string[]} */
@@ -179,49 +183,41 @@
179
183
  ensureRegistered(language);
180
184
  if (session && sessionLanguageName === language.name) {
181
185
  // Not a pure append (an LLM "regenerate the last paragraph", say):
182
- // patch just the changed middle region instead of restarting the
183
- // whole session and losing every sealed chunk.
184
- const common = Math.min(code.length, fedCode.length);
185
- let prefixLen = 0;
186
- while (
187
- prefixLen < common &&
188
- code.charCodeAt(prefixLen) === fedCode.charCodeAt(prefixLen)
189
- ) {
190
- prefixLen++;
191
- }
192
- let suffixLen = 0;
193
- const maxSuffix = common - prefixLen;
194
- while (
195
- suffixLen < maxSuffix &&
196
- code.charCodeAt(code.length - 1 - suffixLen) ===
197
- fedCode.charCodeAt(fedCode.length - 1 - suffixLen)
198
- ) {
199
- suffixLen++;
200
- }
201
- session.replace(
202
- prefixLen,
203
- fedCode.length - suffixLen,
204
- code.slice(prefixLen, code.length - suffixLen),
205
- );
186
+ // patch the session in place instead of restarting it and losing
187
+ // every sealed chunk.
188
+ const next = regenerate({
189
+ session,
190
+ fedCode,
191
+ code,
192
+ sealedChunks,
193
+ completedHtml,
194
+ chunkLines: SEAL_CHUNK_LINES,
195
+ });
206
196
  fedCode = code;
207
197
  previewCache = undefined;
208
-
209
- const events = session.events();
210
- const result = extendLines(events, [], "");
211
- finalizedPendingHtml = result.pendingHtml;
212
- finalizedOpenScopes = result.openScopes;
213
- renderedCommittedCount = events.length;
214
- completedHtml.reset();
215
- completedHtml.appendLines(result.completedLines);
216
- sealedChunks = [];
217
- sealedLineCount = 0;
218
- unsealedLines = result.completedLines;
219
- while (unsealedLines.length >= SEAL_CHUNK_LINES) sealChunk();
198
+ finalizedPendingHtml = next.pendingHtml;
199
+ finalizedOpenScopes = next.openScopes;
200
+ renderedCommittedCount = next.committedCount;
201
+ sealedChunks = next.sealedChunks;
202
+ sealedLineCount = next.sealedLineCount;
203
+ unsealedLines = next.unsealedLines;
220
204
  tailLines = unsealedLines;
221
205
  return;
222
206
  }
207
+ resetStreamingState();
223
208
  session = registry.createSession(language.name);
224
209
  sessionLanguageName = language.name;
210
+ }
211
+
212
+ // Drops the session and everything rendered from it. Also runs after the
213
+ // done pass: from then on the template shows only `highlighted`, and a
214
+ // repeat done pass reuses the memoized final HTML without a session, so a
215
+ // closed stream holds little more than its final HTML. If streaming
216
+ // resumes, ensureSession starts over from the whole buffer, which renders
217
+ // the same lines - bench/markdown-stream.bench.ts.
218
+ function resetStreamingState() {
219
+ session = undefined;
220
+ sessionLanguageName = "";
225
221
  fedCode = "";
226
222
  finalizedPendingHtml = "";
227
223
  finalizedOpenScopes = [];
@@ -249,16 +245,18 @@
249
245
  }
250
246
 
251
247
  function repaint() {
252
- ensureSession();
253
- if (code.length > fedCode.length) {
254
- session.append(code.slice(fedCode.length));
255
- fedCode = code;
256
- }
257
-
258
248
  if (done) {
259
249
  // Full re-parse for multi-line lookahead (heredocs, etc.).
260
- highlighted = session.finish({ canonicalize: true }).value;
250
+ ensureRegistered(language);
251
+ highlighted = finalHighlighter.highlight(registry, code, language.name);
252
+ if (session) resetStreamingState();
261
253
  } else {
254
+ ensureSession();
255
+ if (code.length > fedCode.length) {
256
+ session.append(code.slice(fedCode.length));
257
+ fedCode = code;
258
+ }
259
+
262
260
  // Newly committed events (append only tokenizes complete lines).
263
261
  const committed = session.events();
264
262
  if (committed.length > renderedCommittedCount) {
@@ -371,11 +369,9 @@
371
369
  dispatchedWindowStart = vStart;
372
370
  dispatchedWindowEnd = vEnd;
373
371
  dispatchedWindowLineCount = vLineCount;
374
- dispatch("windowchange", {
375
- start: vStart,
376
- end: vEnd,
377
- lineCount: vLineCount,
378
- });
372
+ // Dispatch once the new rows are in the DOM (see HighlightVirtual).
373
+ const detail = { start: vStart, end: vEnd, lineCount: vLineCount };
374
+ tick().then(() => dispatch("windowchange", detail));
379
375
  }
380
376
  }
381
377
 
@@ -1,25 +1,11 @@
1
1
  <script context="module">
2
- import { writable } from "svelte/store";
2
+ import { createStyleRegistry } from "./style-registry.js";
3
3
 
4
4
  const isBrowser = typeof document !== "undefined";
5
5
 
6
- // Instances sharing a key queue up in registration order; only the oldest
7
- // still-mounted instance renders the `<style>`. A store (rather than a
8
- // plain ref count) means that when that instance unmounts, the remaining
9
- // subscribers reactively re-derive a new owner instead of the tag being
10
- // dropped while siblings still need it.
11
- /** @type {Map<string, import("svelte/store").Writable<symbol[]>>} */
12
- const registries = new Map();
13
-
14
- /** @param {string} key */
15
- function registryFor(key) {
16
- let registry = registries.get(key);
17
- if (!registry) {
18
- registry = writable([]);
19
- registries.set(key, registry);
20
- }
21
- return registry;
22
- }
6
+ // Shared across instances: identical styles render one `<style>` tag,
7
+ // owned by the oldest still-mounted instance (see style-registry.js).
8
+ const styleRegistry = createStyleRegistry();
23
9
  </script>
24
10
 
25
11
  <script>
@@ -132,7 +118,7 @@
132
118
  let registry;
133
119
 
134
120
  function unregister() {
135
- registry?.update((owners) => owners.filter((owner) => owner !== token));
121
+ if (registry) styleRegistry.unregister(registeredKey, registry, token);
136
122
  }
137
123
 
138
124
  $: {
@@ -140,8 +126,10 @@
140
126
  if (key !== registeredKey) {
141
127
  unregister();
142
128
  registeredKey = key;
143
- registry = isBrowser && key !== undefined ? registryFor(key) : undefined;
144
- registry?.update((owners) => [...owners, token]);
129
+ registry =
130
+ isBrowser && key !== undefined
131
+ ? styleRegistry.register(key, token)
132
+ : undefined;
145
133
  }
146
134
  }
147
135
 
@@ -21,6 +21,16 @@
21
21
  */
22
22
  export let checkpointInterval = 100;
23
23
 
24
+ /**
25
+ * Tokenize the rest of the document in idle time after the first paint,
26
+ * so a far jump (scrollToLine, dragging the scrollbar) doesn't stall on
27
+ * tokenizing everything before it. Off by default: the engine session
28
+ * keeps every event it produces, so a full pass retains about 117 MB
29
+ * per 100k lines of TypeScript, even if nobody scrolls.
30
+ * @type {boolean}
31
+ */
32
+ export let tokenizeAhead = false;
33
+
24
34
  import { createEventDispatcher, onMount, tick } from "svelte";
25
35
  import { createTokenizedDocument } from "./tokenized-document.js";
26
36
  import { watchLineHeight, windowRange } from "./virtual-window.js";
@@ -107,7 +117,11 @@
107
117
  dispatchedWindowStart = start;
108
118
  dispatchedWindowEnd = end;
109
119
  dispatchedWindowLineCount = lineCount;
110
- dispatch("windowchange", { start, end, lineCount });
120
+ // Dispatch once the new rows are in the DOM, so a listener that paints
121
+ // into them (e.g. search's highlightMatches) doesn't paint the old
122
+ // rows Svelte is about to replace.
123
+ const detail = { start, end, lineCount };
124
+ tick().then(() => dispatch("windowchange", detail));
111
125
  }
112
126
  }
113
127
 
@@ -167,6 +181,62 @@
167
181
  lineCount = doc.lineCount();
168
182
  computeWindow();
169
183
  syncFromContainer();
184
+ scheduleTokenizeAhead();
185
+ }
186
+
187
+ $: if (hydrated) {
188
+ if (tokenizeAhead) scheduleTokenizeAhead();
189
+ else cancelTokenizeAhead();
190
+ }
191
+
192
+ // Idle-time tokenizing ahead. A first jump to the end of a 500k-line file
193
+ // otherwise tokenizes ~24 MB synchronously (seconds); after this pass,
194
+ // checkpoints cover the whole document and any jump is a few ms.
195
+ const requestIdle =
196
+ typeof requestIdleCallback === "function"
197
+ ? (/** @type {IdleRequestCallback} */ callback) =>
198
+ requestIdleCallback(callback, { timeout: 1000 })
199
+ : (/** @type {IdleRequestCallback} */ callback) =>
200
+ setTimeout(
201
+ () => callback({ didTimeout: false, timeRemaining: () => 8 }),
202
+ 16,
203
+ );
204
+ const cancelIdle =
205
+ typeof cancelIdleCallback === "function"
206
+ ? cancelIdleCallback
207
+ : clearTimeout;
208
+
209
+ /** @type {any} */
210
+ let aheadHandle;
211
+ // Bumped on every (re)schedule so a callback from an older document stops.
212
+ let aheadGeneration = 0;
213
+
214
+ function cancelTokenizeAhead() {
215
+ aheadGeneration++;
216
+ if (aheadHandle !== undefined) cancelIdle(aheadHandle);
217
+ aheadHandle = undefined;
218
+ }
219
+
220
+ function scheduleTokenizeAhead() {
221
+ cancelTokenizeAhead();
222
+ if (!tokenizeAhead || !doc) return;
223
+ const generation = aheadGeneration;
224
+ /** @param {IdleDeadline} deadline */
225
+ const step = (deadline) => {
226
+ aheadHandle = undefined;
227
+ if (generation !== aheadGeneration || !doc) return;
228
+ let done = false;
229
+ // At least one batch per callback, so a busy page still progresses.
230
+ do {
231
+ done = doc.tokenizeThrough(doc.tokenizedThrough() + checkpointInterval);
232
+ } while (!done && deadline.timeRemaining() > 2);
233
+ dispatch("tokenize", {
234
+ through: done ? doc.lineCount() : doc.tokenizedThrough(),
235
+ lineCount: doc.lineCount(),
236
+ });
237
+ if (!done) aheadHandle = requestIdle(step);
238
+ };
239
+ aheadHandle = requestIdle(step);
170
240
  }
171
241
 
172
242
  // Scroll/resize/overscan/lineHeight-driven window recompute.
@@ -180,12 +250,19 @@
180
250
  }
181
251
 
182
252
  /**
183
- * Scroll a given line into the rendered window.
253
+ * Scroll a given line into the rendered window. Jumps instantly (sets
254
+ * `scrollTop`), so there's no scroll animation.
184
255
  * @param {number} line
256
+ * @param {{ align?: "start" | "center" }} [options] Where the line lands
257
+ * in the viewport: the top edge (default) or the middle.
185
258
  */
186
- export function scrollToLine(line) {
259
+ export function scrollToLine(line, options = {}) {
187
260
  if (!container) return;
188
- const target = Math.max(0, Math.min(line, lineCount)) * lineHeight;
261
+ const lineTop = Math.max(0, Math.min(line, lineCount)) * lineHeight;
262
+ const target =
263
+ options.align === "center"
264
+ ? lineTop - (container.clientHeight - lineHeight) / 2
265
+ : lineTop;
189
266
  const maxScrollTop = Math.max(
190
267
  0,
191
268
  container.scrollHeight - container.clientHeight,
@@ -209,6 +286,7 @@
209
286
 
210
287
  return () => {
211
288
  cancelFrame();
289
+ cancelTokenizeAhead();
212
290
  resizeObserver?.disconnect();
213
291
  };
214
292
  });
@@ -27,6 +27,13 @@ export type HighlightVirtualProps = HTMLAttributes<HTMLPreElement> & {
27
27
  * @default 100
28
28
  */
29
29
  checkpointInterval?: number;
30
+
31
+ /**
32
+ * Tokenize the rest of the document in idle time after the first paint,
33
+ * so far jumps don't stall. Costs memory for the whole document up front.
34
+ * @default false
35
+ */
36
+ tokenizeAhead?: boolean;
30
37
  };
31
38
 
32
39
  export type HighlightVirtualEvents = {
@@ -34,6 +41,12 @@ export type HighlightVirtualEvents = {
34
41
  * Fired whenever the rendered window changes.
35
42
  */
36
43
  windowchange: CustomEvent<{ start: number; end: number; lineCount: number }>;
44
+
45
+ /**
46
+ * Fired after each idle slice of `tokenizeAhead`, with how many lines
47
+ * are tokenized so far. `through === lineCount` once it's done.
48
+ */
49
+ tokenize: CustomEvent<{ through: number; lineCount: number }>;
37
50
  };
38
51
 
39
52
  export default class HighlightVirtual extends SvelteComponentTyped<
@@ -41,6 +54,10 @@ export default class HighlightVirtual extends SvelteComponentTyped<
41
54
  HighlightVirtualEvents,
42
55
  Record<string, never>
43
56
  > {
44
- /** Scroll a given line into the rendered window. */
45
- scrollToLine(line: number): void;
57
+ /**
58
+ * Scroll a given line into the rendered window, without animation.
59
+ * `align` places the line at the viewport's top edge (default) or
60
+ * middle.
61
+ */
62
+ scrollToLine(line: number, options?: { align?: "start" | "center" }): void;
46
63
  }
package/LangTag.svelte CHANGED
@@ -32,4 +32,8 @@
32
32
 
33
33
  <style>
34
34
  @import "./langtag.css";
35
+
36
+ pre {
37
+ direction: ltr;
38
+ }
35
39
  </style>
@@ -140,6 +140,7 @@
140
140
 
141
141
  pre {
142
142
  margin: 0;
143
+ direction: ltr;
143
144
  }
144
145
 
145
146
  table,
@@ -0,0 +1,209 @@
1
+ <script>
2
+ /**
3
+ * Growing Markdown buffer. On change, `splitter.append` is used when the
4
+ * new value starts with the previous one; otherwise the whole buffer is
5
+ * replaced via `splitter.set`.
6
+ * @type {string}
7
+ */
8
+ export let text = "";
9
+
10
+ /**
11
+ * Stream finished: forwarded to every fence's `HighlightStream` as
12
+ * `done || !segment.open`.
13
+ * @type {boolean}
14
+ */
15
+ export let done = false;
16
+
17
+ /**
18
+ * Resolves a fence's language. Cached per canonical name for the
19
+ * component's lifetime.
20
+ * @type {(lang: string | undefined, segment: import("./fence.d.ts").FenceSegment) => import("./languages").LanguageType<string> | Promise<import("./languages").LanguageType<string>> | undefined}
21
+ */
22
+ export let resolveLanguage = defaultResolveLanguage;
23
+
24
+ /** @type {boolean} */
25
+ export let caret = true;
26
+
27
+ /** @type {boolean} */
28
+ export let autoScroll = true;
29
+
30
+ /**
31
+ * Announced once, by the last fence only, when `done` becomes `true`.
32
+ * @type {string}
33
+ */
34
+ export let doneText = "Code finished streaming";
35
+
36
+ import { createEventDispatcher } from "svelte";
37
+ import { createFenceSplitter } from "./fence.js";
38
+ import HighlightStream from "./HighlightStream.svelte";
39
+ import plaintext from "./languages/plaintext.js";
40
+ import { loadLanguage } from "./load-language.js";
41
+
42
+ /**
43
+ * @param {string | undefined} lang
44
+ * @returns {Promise<import("./languages").LanguageType<string> | undefined>}
45
+ */
46
+ async function defaultResolveLanguage(lang) {
47
+ if (!lang) return undefined;
48
+ try {
49
+ return await loadLanguage(
50
+ /** @type {import("./languages").LanguageName} */ (lang),
51
+ );
52
+ } catch {
53
+ return undefined;
54
+ }
55
+ }
56
+
57
+ const dispatch = createEventDispatcher();
58
+ const splitter = createFenceSplitter();
59
+
60
+ let previousText = "";
61
+ /** @type {readonly import("./fence.d.ts").MarkdownSegment[]} */
62
+ let segments = splitter.segments();
63
+
64
+ // Fence ids already reported via the `fence` event -- an id is only ever
65
+ // seen once, even if the splitter later rebuilds the segment object (a
66
+ // regenerated buffer keeps the id per the splitter's contract).
67
+ /** @type {Set<number>} */
68
+ const seenFenceIds = new Set();
69
+
70
+ // Resolved languages by canonical name, plus in-flight names so a second
71
+ // fence sharing a language doesn't re-invoke `resolveLanguage`.
72
+ /** @type {Record<string, import("./languages").LanguageType<string>>} */
73
+ let resolvedLanguages = {};
74
+ /** @type {Set<string>} */
75
+ const pendingLanguages = new Set();
76
+
77
+ /** @param {string | undefined} lang */
78
+ function cacheKey(lang) {
79
+ return lang === undefined ? "\0" : lang;
80
+ }
81
+
82
+ /** @param {import("./fence.d.ts").FenceSegment} segment */
83
+ function ensureLanguage(segment) {
84
+ const key = cacheKey(segment.lang);
85
+ if (pendingLanguages.has(key)) return;
86
+ pendingLanguages.add(key);
87
+ Promise.resolve(resolveLanguage(segment.lang, segment))
88
+ .then((language) => {
89
+ resolvedLanguages = {
90
+ ...resolvedLanguages,
91
+ [key]: language ?? plaintext,
92
+ };
93
+ })
94
+ .catch(() => {
95
+ resolvedLanguages = { ...resolvedLanguages, [key]: plaintext };
96
+ });
97
+ }
98
+
99
+ /**
100
+ * `languages` is passed in so the template tracks the cache. A helper
101
+ * that only closed over `resolvedLanguages` would not re-run when a
102
+ * grammar finished loading (Svelte 3/4, and Svelte 5's `untrack` of
103
+ * helper bodies).
104
+ *
105
+ * Takes the cache key, not the segment, so the result doesn't depend on
106
+ * the segment object. Svelte 5's legacy mode marks every keyed `{#each}`
107
+ * item as changed whenever `segments` changes, and treats any object as
108
+ * changed. A `language` read off the segment would reach every closed
109
+ * fence's HighlightStream on every chunk. Through the (string) key, it
110
+ * only changes when the key or a grammar does -
111
+ * tests/markdown-stream-updates.test.ts.
112
+ * @param {Record<string, import("./languages").LanguageType<string>>} languages
113
+ * @param {string} key
114
+ */
115
+ function languageFor(languages, key) {
116
+ return languages[key] ?? plaintext;
117
+ }
118
+
119
+ // Feed the splitter, then re-read its (identity-stable) segment list.
120
+ $: {
121
+ if (text !== previousText) {
122
+ if (text.startsWith(previousText)) {
123
+ splitter.append(text.slice(previousText.length));
124
+ } else {
125
+ splitter.set(text);
126
+ }
127
+ previousText = text;
128
+ segments = splitter.segments();
129
+ }
130
+ }
131
+
132
+ $: for (const segment of segments) {
133
+ if (segment.kind !== "fence") continue;
134
+ if (!seenFenceIds.has(segment.id)) {
135
+ seenFenceIds.add(segment.id);
136
+ dispatch("fence", { id: segment.id, lang: segment.lang });
137
+ }
138
+ ensureLanguage(segment);
139
+ }
140
+
141
+ let doneDispatched = false;
142
+ $: if (done) {
143
+ if (!doneDispatched) {
144
+ doneDispatched = true;
145
+ dispatch("done");
146
+ }
147
+ } else {
148
+ doneDispatched = false;
149
+ }
150
+
151
+ // Only the trailing segment can be an open fence (the parser is still
152
+ // inside it), so caret placement never needs to scan the whole document.
153
+ $: lastSegment = segments[segments.length - 1];
154
+ $: lastOpenFenceId =
155
+ lastSegment !== undefined &&
156
+ lastSegment.kind === "fence" &&
157
+ lastSegment.open
158
+ ? lastSegment.id
159
+ : undefined;
160
+
161
+ $: lastFenceId = findLastFenceId(segments);
162
+
163
+ /** @param {readonly import("./fence.d.ts").MarkdownSegment[]} list */
164
+ function findLastFenceId(list) {
165
+ for (let i = list.length - 1; i >= 0; i -= 1) {
166
+ const segment = /** @type {import("./fence.d.ts").MarkdownSegment} */ (
167
+ list[i]
168
+ );
169
+ if (segment.kind === "fence") return segment.id;
170
+ }
171
+ return undefined;
172
+ }
173
+ </script>
174
+
175
+ <div class="shl-md" aria-busy={!done} {...$$restProps}>
176
+ {#each segments as segment (segment.id)}
177
+ {@const languageKey =
178
+ segment.kind === "fence" ? cacheKey(segment.lang) : ""}
179
+ {@const language = languageFor(resolvedLanguages, languageKey)}
180
+ {#if segment.kind === "text"}
181
+ <slot name="text" {segment}>
182
+ <div class="shl-md-text">{segment.text}</div>
183
+ </slot>
184
+ {:else}
185
+ <slot name="fence" {segment} {language}>
186
+ <HighlightStream
187
+ code={segment.code}
188
+ {language}
189
+ done={done || !segment.open}
190
+ caret={caret && segment.id === lastOpenFenceId}
191
+ {autoScroll}
192
+ doneText={segment.id === lastFenceId ? doneText : ""}
193
+ />
194
+ </slot>
195
+ {/if}
196
+ {/each}
197
+ </div>
198
+
199
+ <style>
200
+ .shl-md {
201
+ display: flex;
202
+ flex-direction: column;
203
+ gap: var(--md-gap, 1em);
204
+ }
205
+
206
+ .shl-md-text {
207
+ white-space: var(--md-text-white-space, pre-wrap);
208
+ }
209
+ </style>
@@ -0,0 +1,100 @@
1
+ import type { SvelteComponentTyped } from "svelte";
2
+ import type { HTMLAttributes } from "svelte/elements";
3
+ import type { FenceSegment, MarkdownSegment } from "./fence";
4
+ import type { LanguageType } from "./languages";
5
+
6
+ export type MarkdownStreamProps = HTMLAttributes<HTMLDivElement> & {
7
+ /**
8
+ * Growing Markdown buffer. On change, `splitter.append` is used when the
9
+ * new value starts with the previous one; otherwise the whole buffer is
10
+ * replaced via `splitter.set` (a regenerated reply, say).
11
+ * @default ""
12
+ */
13
+ text?: string;
14
+
15
+ /**
16
+ * Stream finished. Forwarded to every fence's `HighlightStream` as
17
+ * `done || !segment.open`, so a trailing open fence is treated as closed
18
+ * once the overall stream ends.
19
+ * @default false
20
+ */
21
+ done?: boolean;
22
+
23
+ /**
24
+ * Resolves a fence's language. The default dynamically imports the
25
+ * grammar via `loadLanguage`, falling back to plaintext while loading and
26
+ * whenever `lang` is `undefined`, unrecognized, or the returned promise
27
+ * rejects -- it never throws. Results are cached per canonical name for
28
+ * the component's lifetime.
29
+ * @default resolves via `loadLanguage`, falling back to plaintext
30
+ */
31
+ resolveLanguage?: (
32
+ lang: string | undefined,
33
+ segment: FenceSegment,
34
+ ) => LanguageType<string> | Promise<LanguageType<string>> | undefined;
35
+
36
+ /**
37
+ * Show a blinking caret at the end of the last open fence while streaming.
38
+ * @default true
39
+ */
40
+ caret?: boolean;
41
+
42
+ /**
43
+ * Keep each streaming fence scrolled to the bottom, unless the user has
44
+ * scrolled away from it.
45
+ * @default true
46
+ */
47
+ autoScroll?: boolean;
48
+
49
+ /**
50
+ * Announced by the last fence's visually-hidden live region once `done`
51
+ * becomes `true` -- every other fence gets `""` so completion is
52
+ * announced only once. Set to `""` to disable the announcement.
53
+ * @default "Code finished streaming"
54
+ */
55
+ doneText?: string;
56
+
57
+ /**
58
+ * Space between prose and fence segments.
59
+ * @default "1em"
60
+ */
61
+ "--md-gap"?: string;
62
+
63
+ /**
64
+ * `white-space` of the default prose block.
65
+ * @default "pre-wrap"
66
+ */
67
+ "--md-text-white-space"?: string;
68
+ };
69
+
70
+ export type MarkdownStreamEvents = {
71
+ /**
72
+ * Fires once, the first time a fence segment appears.
73
+ */
74
+ fence: CustomEvent<{
75
+ id: number;
76
+ lang: string | undefined;
77
+ }>;
78
+
79
+ /**
80
+ * Fires once when `done` becomes `true`.
81
+ */
82
+ done: CustomEvent<null>;
83
+ };
84
+
85
+ export type MarkdownStreamSlots = {
86
+ text: {
87
+ segment: MarkdownSegment & { kind: "text" };
88
+ };
89
+ fence: {
90
+ segment: FenceSegment;
91
+ /** The resolved language, or plaintext while loading/unknown. */
92
+ language: LanguageType<string>;
93
+ };
94
+ };
95
+
96
+ export default class MarkdownStream extends SvelteComponentTyped<
97
+ MarkdownStreamProps,
98
+ MarkdownStreamEvents,
99
+ MarkdownStreamSlots
100
+ > {}