@ai-ecoverse/slicc-spectrum 1.104.2 → 1.105.0

package/dist/chunk-X2FGXM6T.js

@@ -0,0 +1,657 @@
+import {
+  BaseStreamTokenizer,
+  DiffsHighlighter
+} from "./chunk-UFGJPRGL.js";
+import "./chunk-KIKLCSNJ.js";
+import {
+  RegisteredCustomLanguages,
+  attachResolvedLanguages,
+  resolveLanguages
+} from "./chunk-B3ZH3IZR.js";
+import {
+  appendItems,
+  createDiffsThemeResolver
+} from "./chunk-KIDTSHLT.js";
+import "./chunk-NEW2Q7FF.js";
+import "./chunk-AXQFWXYZ.js";
+
+// node_modules/@pierre/diffs/dist/editor/utils.js
+function debounce(func, wait) {
+  let timeout;
+  return function(...args) {
+    clearTimeout(timeout);
+    timeout = setTimeout(() => func.apply(this, args), wait);
+  };
+}
+
+// node_modules/@pierre/diffs/dist/highlighter/shiki-editor.js
+var TOKENIZE_TIME_LIMIT = 0;
+var nextTokenizerId = 0;
+var ShikiEditorTokenizer = class {
+  backend;
+  #highlighter;
+  #grammar;
+  #themeName;
+  #colorMap;
+  #textDocument;
+  #tokenizeMaxLineLength;
+  #onDeferTokenize;
+  #matchBrackets;
+  #debug;
+  #isCleanedUp = false;
+  #stateStack = [void 0];
+  #comparisonStateStack = [];
+  #comparisonStateStackStart = 0;
+  #comparisonLineChanges = [];
+  #lastLine = -1;
+  #isStopped = true;
+  #isPaused = false;
+  #backgroundJobId = 0;
+  #tokenizerId = ++nextTokenizerId;
+  #backgroundPrebuildEndLine = -1;
+  #pendingPrebuildEndLine = -1;
+  #backgroundChangedLineRanges;
+  #backgroundChangedRangeIndex = 0;
+  #bracketIgnoredRanges = [];
+  #isMessageListenerAttached = false;
+  #prebuildStateStack = debounce(async (renderRange) => {
+    if (this.#isCleanedUp) return;
+    const { startingLine = 0, totalLines = Infinity } = renderRange ?? {};
+    const endLine = Math.min(totalLines === Infinity ? Infinity : startingLine + totalLines, this.#textDocument.lineCount);
+    if (this.#grammar == null && !isGrammarlessLanguage(this.#textDocument.languageId)) {
+      await this.backend?.loadLanguages([this.#textDocument.languageId]);
+      if (this.#isCleanedUp) return;
+      this.#grammar = this.#highlighter.getLanguage(this.#textDocument.languageId);
+    }
+    this.#ensureActiveTheme();
+    this.#scheduleStatePrebuild(endLine);
+  }, 500);
+  #onMessage = ({ data }) => {
+    if (typeof data !== "object" || data === null) return;
+    const { type, tokenizerId, jobId } = data;
+    if (type === "tokenize" && tokenizerId === this.#tokenizerId && typeof jobId === "number" && jobId === this.#backgroundJobId) {
+      if (this.#backgroundPrebuildEndLine >= 0) this.#backgroundPrebuild(jobId);
+      else this.#backgroundTokenize(jobId);
+    }
+  };
+  getStringCommentRegexpRangesInLine(lineIndex) {
+    if (!this.#matchBrackets || lineIndex < 0 || lineIndex >= this.#textDocument.lineCount) return null;
+    this.#ensureGrammar();
+    if (this.#grammar == null) return null;
+    if (this.#bracketIgnoredRanges[lineIndex] === void 0) {
+      this.#buildStateStack(lineIndex);
+      const state = this.#stateStack[lineIndex] ?? void 0;
+      const result = this.#tokenizeLineAt(lineIndex, state);
+      this.#stateStack[lineIndex + 1] = result.state;
+    }
+    return this.#bracketIgnoredRanges[lineIndex] ?? null;
+  }
+  constructor(highlighter, options, backend) {
+    this.backend = backend;
+    this.#highlighter = highlighter;
+    this.#textDocument = options.textDocument;
+    this.#themeName = options.theme;
+    this.#colorMap = [];
+    this.#tokenizeMaxLineLength = options.tokenizeMaxLineLength ?? 1e3;
+    this.#onDeferTokenize = options.onDeferTokenize;
+    this.#matchBrackets = options.matchBrackets !== false;
+    this.#debug = options.__debug ?? false;
+    this.#ensureGrammar();
+    this.#ensureActiveTheme();
+  }
+  setTheme(themeName) {
+    if (this.#themeName === themeName) return;
+    this.#themeName = themeName;
+    this.#ensureActiveTheme();
+    this.stopBackgroundTokenize();
+    this.#stateStack = [void 0];
+    this.#comparisonStateStack = [];
+    this.#comparisonStateStackStart = 0;
+    this.#comparisonLineChanges = [];
+    if (this.#grammar != null && this.#textDocument.lineCount > 0) this.#scheduleBackgroundTokenize(0);
+  }
+  #ensureActiveTheme() {
+    if (this.#themeName === "") return;
+    this.backend?.getTheme(this.#themeName);
+    const { colorMap } = this.#highlighter.setTheme(this.#themeName);
+    this.#colorMap = colorMap;
+  }
+  dispose() {
+    this.#isCleanedUp = true;
+    this.stopBackgroundTokenize();
+    this.#detachMessageListener();
+  }
+  tokenize(change, renderRange, hostRealignsRows = false) {
+    this.#ensureGrammar();
+    this.#ensureActiveTheme();
+    if (this.#grammar == null && !isGrammarlessLanguage(this.#textDocument.languageId)) throw new Error(`Grammar for language "${this.#textDocument.languageId}" not loaded`);
+    const { lineCount } = this.#textDocument;
+    const { startingLine = 0, totalLines = Infinity } = renderRange ?? {};
+    const renderRangeEndLine = totalLines === Infinity ? lineCount : Math.min(startingLine + totalLines, lineCount);
+    const dirtyStart = change.startLine;
+    const viewStart = Math.max(startingLine, dirtyStart);
+    const crossesRenderRangeEnd = renderRange != null && totalLines !== Infinity && change.lineDelta > 0 && dirtyStart < renderRangeEndLine && change.endLine >= renderRangeEndLine;
+    const canReuseCachedStates = change.lineDelta === 0 && (change.changedLineChanges?.every(([, , lineDelta]) => lineDelta === 0) ?? true);
+    if (this.#matchBrackets && !canReuseCachedStates) this.#bracketIgnoredRanges.length = Math.min(this.#bracketIgnoredRanges.length, change.startLine);
+    const canReuseShiftedStates = hostRealignsRows && change.lineDelta !== 0 && dirtyStart >= startingLine;
+    const canCacheTokenizedStates = canReuseCachedStates || renderRange == null || dirtyStart >= viewStart;
+    const changedLineRanges = change.changedLineRanges ?? [[dirtyStart, change.endLine]];
+    this.#comparisonStateStack = [];
+    this.#comparisonStateStackStart = 0;
+    this.#comparisonLineChanges = [];
+    let offscreenSyncEnd = -1;
+    if (dirtyStart < viewStart) {
+      for (const [rangeStart, rangeEnd] of changedLineRanges) if (rangeStart < viewStart) offscreenSyncEnd = Math.max(offscreenSyncEnd, Math.min(rangeEnd, viewStart - 1));
+    }
+    const shouldFlushOffscreenLines = offscreenSyncEnd >= dirtyStart && (canReuseCachedStates || change.lineDelta < 0);
+    if (canReuseCachedStates) this.#buildStateStack(dirtyStart);
+    else {
+      this.#shiftComparisonStateStack(change);
+      if (renderRange == null || dirtyStart >= viewStart) this.#buildStateStack(viewStart);
+    }
+    let changedRangeIndex = 0;
+    let currentChangedRangeEnd = changedLineRanges[changedRangeIndex][1];
+    let backgroundStartLine;
+    let backgroundChangedRangeIndex = 0;
+    let line = canReuseCachedStates ? changedLineRanges[changedRangeIndex][0] : viewStart;
+    let settled = false;
+    const dirtyLines = /* @__PURE__ */ new Map();
+    const offscreenDirtyLines = shouldFlushOffscreenLines ? /* @__PURE__ */ new Map() : void 0;
+    if (offscreenDirtyLines != null && !canReuseCachedStates) {
+      const offscreenEnd = Math.min(offscreenSyncEnd + 1, viewStart, renderRangeEndLine);
+      if (offscreenEnd > dirtyStart) {
+        this.#buildStateStack(offscreenEnd);
+        let offscreenLine = dirtyStart;
+        let offscreenState = this.#stateStack[offscreenLine] ?? void 0;
+        for (; offscreenLine < offscreenEnd; offscreenLine++) {
+          const resolved = this.#tokenizeLineAt(offscreenLine, offscreenState);
+          offscreenState = resolved.state;
+          offscreenDirtyLines.set(offscreenLine, resolved.resolvedTokens);
+        }
+        this.#stateStack[offscreenEnd] = offscreenState;
+      }
+    }
+    let state = this.#stateStack[line] ?? void 0;
+    for (; line < renderRangeEndLine; ) {
+      const previousNextState = canReuseCachedStates ? this.#stateStack[line + 1] : canReuseShiftedStates ? this.#getPreviousEndState(line + 1) : void 0;
+      if (canCacheTokenizedStates) this.#stateStack[line] = state;
+      const { resolvedTokens, state: nextState } = this.#tokenizeLineAt(line, state);
+      state = nextState;
+      if (line >= viewStart) dirtyLines.set(line, resolvedTokens);
+      else offscreenDirtyLines?.set(line, resolvedTokens);
+      if (canCacheTokenizedStates) this.#stateStack[line + 1] = state;
+      settled = line >= currentChangedRangeEnd && (canReuseCachedStates || canReuseShiftedStates) && previousNextState != null && state.equals(previousNextState);
+      if (settled) {
+        changedRangeIndex++;
+        const nextRange = changedLineRanges[changedRangeIndex];
+        if (nextRange == null) break;
+        if (nextRange[0] >= renderRangeEndLine) {
+          backgroundStartLine = nextRange[0];
+          backgroundChangedRangeIndex = changedRangeIndex;
+          break;
+        }
+        let nextState2 = this.#stateStack[nextRange[0]];
+        if (canReuseShiftedStates) for (let stateLine = line + 2; stateLine <= nextRange[0]; stateLine++) {
+          nextState2 = this.#getPreviousEndState(stateLine);
+          if (nextState2 == null) break;
+          this.#stateStack[stateLine] = nextState2;
+        }
+        if (nextState2 == null) {
+          currentChangedRangeEnd = nextRange[1];
+          line++;
+        } else {
+          line = nextRange[0];
+          state = nextState2;
+          currentChangedRangeEnd = nextRange[1];
+        }
+        settled = false;
+        continue;
+      }
+      line++;
+    }
+    if (canCacheTokenizedStates) {
+      if (line < renderRangeEndLine) this.#stateStack[line + 1] = state;
+      else this.#stateStack[line] = state;
+    }
+    if (settled && canReuseShiftedStates && backgroundStartLine == null) {
+      for (let stateLine = line + 2; stateLine <= lineCount; stateLine++) {
+        const previousState = this.#getPreviousEndState(stateLine);
+        if (previousState == null) break;
+        this.#stateStack[stateLine] = previousState;
+      }
+      this.#comparisonStateStack = [];
+      this.#comparisonStateStackStart = 0;
+      this.#comparisonLineChanges = [];
+    }
+    if (offscreenDirtyLines != null && offscreenDirtyLines.size > 0) this.#onDeferTokenize(offscreenDirtyLines);
+    if (backgroundStartLine != null) {
+      if (this.#matchBrackets && canReuseCachedStates) this.#bracketIgnoredRanges.length = Math.min(this.#bracketIgnoredRanges.length, backgroundStartLine);
+      this.#scheduleBackgroundTokenize(backgroundStartLine, changedLineRanges, backgroundChangedRangeIndex);
+    } else if (!settled && line < lineCount) {
+      const backgroundLine = crossesRenderRangeEnd && dirtyStart >= viewStart ? renderRangeEndLine : dirtyStart < viewStart && !canReuseCachedStates ? dirtyStart : line;
+      if (this.#matchBrackets && canReuseCachedStates) this.#bracketIgnoredRanges.length = Math.min(this.#bracketIgnoredRanges.length, backgroundLine);
+      this.#scheduleBackgroundTokenize(backgroundLine, changedLineRanges, changedRangeIndex);
+    }
+    return dirtyLines;
+  }
+  prebuildStateStack(renderRange) {
+    this.#ensureGrammar();
+    this.#prebuildStateStack(renderRange);
+  }
+  stopBackgroundTokenize() {
+    this.#pendingPrebuildEndLine = -1;
+    if (this.#isStopped) return;
+    this.#isStopped = true;
+    this.#isPaused = false;
+    this.#lastLine = -1;
+    this.#backgroundPrebuildEndLine = -1;
+    this.#backgroundChangedLineRanges = void 0;
+    this.#backgroundChangedRangeIndex = 0;
+    this.#comparisonStateStack = [];
+    this.#comparisonStateStackStart = 0;
+    this.#comparisonLineChanges = [];
+    this.#detachMessageListener();
+  }
+  pauseBackgroundTokenize() {
+    if (this.#isStopped || this.#isPaused) return;
+    if (this.#debug) console.log("[diffs/editor] background tokenization paused", { jobId: this.#backgroundJobId });
+    this.#isPaused = true;
+  }
+  resumeBackgroundTokenize() {
+    if (this.#isStopped || !this.#isPaused || this.#grammar == null || this.#lastLine < 0) return;
+    if (this.#debug) console.log("[diffs/editor] background tokenization resumed", { jobId: this.#backgroundJobId });
+    this.#isPaused = false;
+    this.#postTokenizeMessage(this.#backgroundJobId);
+  }
+  #ensureGrammar() {
+    if (this.#grammar == null && !isGrammarlessLanguage(this.#textDocument.languageId) && this.#highlighter.getLoadedLanguages().includes(this.#textDocument.languageId)) this.#grammar = this.#highlighter.getLanguage(this.#textDocument.languageId);
+  }
+  #attachMessageListener() {
+    if (this.#isMessageListenerAttached) return;
+    globalThis.addEventListener("message", this.#onMessage);
+    this.#isMessageListenerAttached = true;
+  }
+  #detachMessageListener() {
+    if (!this.#isMessageListenerAttached) return;
+    globalThis.removeEventListener("message", this.#onMessage);
+    this.#isMessageListenerAttached = false;
+  }
+  #postTokenizeMessage(jobId) {
+    globalThis.postMessage({
+      type: "tokenize",
+      tokenizerId: this.#tokenizerId,
+      jobId
+    });
+  }
+  #scheduleBackgroundTokenize(startLine, changedLineRanges, changedRangeIndex = 0) {
+    if (isGrammarlessLanguage(this.#textDocument.languageId)) return;
+    const jobId = ++this.#backgroundJobId;
+    if (this.#debug) console.log("[diffs/editor] background tokenization scheduled", {
+      jobId,
+      startLine,
+      changedLineRanges,
+      changedRangeIndex
+    });
+    this.#isStopped = false;
+    this.#isPaused = false;
+    this.#lastLine = startLine;
+    if (this.#backgroundPrebuildEndLine >= 0) this.#pendingPrebuildEndLine = Math.max(this.#pendingPrebuildEndLine, this.#backgroundPrebuildEndLine);
+    this.#backgroundPrebuildEndLine = -1;
+    this.#backgroundChangedLineRanges = changedLineRanges;
+    this.#backgroundChangedRangeIndex = changedRangeIndex;
+    this.#attachMessageListener();
+    this.#postTokenizeMessage(jobId);
+  }
+  #scheduleStatePrebuild(endLine) {
+    if (this.#grammar == null || this.#stateStack.length > endLine) return;
+    if (!this.#isStopped) {
+      if (this.#backgroundPrebuildEndLine >= 0) this.#backgroundPrebuildEndLine = Math.max(this.#backgroundPrebuildEndLine, endLine);
+      else this.#pendingPrebuildEndLine = Math.max(this.#pendingPrebuildEndLine, endLine);
+      return;
+    }
+    const jobId = ++this.#backgroundJobId;
+    this.#isStopped = false;
+    this.#isPaused = false;
+    this.#lastLine = this.#stateStack.length - 1;
+    this.#backgroundPrebuildEndLine = endLine;
+    this.#pendingPrebuildEndLine = -1;
+    this.#backgroundChangedLineRanges = void 0;
+    this.#backgroundChangedRangeIndex = 0;
+    this.#attachMessageListener();
+    this.#postTokenizeMessage(jobId);
+  }
+  #tokenizeLineAt(line, state) {
+    const lineText = this.#textDocument.getLineText(line);
+    if (lineText.length >= this.#tokenizeMaxLineLength) {
+      console.warn(`[diffs] Line(${line}) too long to tokenize: ${lineText.length}`);
+      this.#cacheBracketIgnoredRanges(line, null);
+      return {
+        resolvedTokens: [[
+          0,
+          "",
+          lineText
+        ]],
+        state
+      };
+    }
+    if (this.#grammar == null || lineText === "" || lineText.trim() === "") {
+      this.#cacheBracketIgnoredRanges(line, null);
+      return {
+        resolvedTokens: [[
+          0,
+          "",
+          lineText
+        ]],
+        state
+      };
+    }
+    const result = tokenizeLine(this.#grammar, this.#colorMap, lineText, state, TOKENIZE_TIME_LIMIT, this.#matchBrackets);
+    this.#cacheBracketIgnoredRanges(line, result.bracketIgnoredRanges);
+    return {
+      resolvedTokens: result.resolvedTokens,
+      state: result.ruleStack
+    };
+  }
+  #cacheBracketIgnoredRanges(line, ranges) {
+    if (this.#matchBrackets) this.#bracketIgnoredRanges[line] = ranges;
+  }
+  #shiftComparisonStateStack(change) {
+    const lineChanges = change.changedLineChanges ?? [[
+      change.startLine,
+      change.endLine,
+      change.lineDelta
+    ]];
+    const comparisonStart = change.startLine + 1;
+    if (comparisonStart <= this.#stateStack.length - comparisonStart) {
+      this.#comparisonStateStack = this.#stateStack;
+      this.#comparisonStateStackStart = 0;
+      this.#stateStack = this.#stateStack.slice(0, comparisonStart);
+    } else {
+      this.#comparisonStateStackStart = comparisonStart;
+      this.#comparisonStateStack = this.#stateStack.slice(comparisonStart);
+      this.#stateStack.length = Math.min(this.#stateStack.length, comparisonStart);
+    }
+    this.#comparisonLineChanges = lineChanges;
+  }
+  #getPreviousEndState(line) {
+    let previousLine = line;
+    for (let index = this.#comparisonLineChanges.length - 1; index >= 0; index--) {
+      const [startLine, endLine, lineDelta] = this.#comparisonLineChanges[index];
+      if (lineDelta === 0) continue;
+      if (previousLine > endLine) previousLine -= lineDelta;
+      else if (previousLine > startLine) return this.#stateStack[line];
+    }
+    return this.#comparisonStateStack[previousLine - this.#comparisonStateStackStart] ?? this.#stateStack[line];
+  }
+  #buildStateStack(endAt, timeBudget) {
+    const boundedEndAt = Math.min(Math.max(0, endAt), this.#textDocument.lineCount);
+    if (this.#stateStack.length > boundedEndAt || this.#grammar == null) return true;
+    const startedAt = timeBudget == null ? 0 : performance.now();
+    let line = this.#stateStack.length - 1;
+    let state = this.#stateStack[line] ?? void 0;
+    while (line < boundedEndAt) {
+      this.#stateStack[line] = state;
+      const lineText = this.#textDocument.getLineText(line);
+      if (lineText.length < this.#tokenizeMaxLineLength && lineText !== "" && lineText.trim() !== "") {
+        const result = tokenizeLine(this.#grammar, this.#colorMap, lineText, state, TOKENIZE_TIME_LIMIT, this.#matchBrackets, false);
+        this.#cacheBracketIgnoredRanges(line, result.bracketIgnoredRanges);
+        state = result.ruleStack;
+      } else this.#cacheBracketIgnoredRanges(line, null);
+      line++;
+      this.#stateStack[line] = state;
+      if (timeBudget != null && performance.now() - startedAt > timeBudget) break;
+    }
+    return line >= boundedEndAt;
+  }
+  #backgroundPrebuild(jobId) {
+    if (this.#isStopped || this.#isPaused || this.#grammar == null || jobId !== this.#backgroundJobId) return;
+    this.#ensureActiveTheme();
+    const complete = this.#buildStateStack(this.#backgroundPrebuildEndLine, 1);
+    if (this.#isStopped || this.#isPaused || jobId !== this.#backgroundJobId) return;
+    if (complete) {
+      this.stopBackgroundTokenize();
+      return;
+    }
+    this.#lastLine = this.#stateStack.length - 1;
+    this.#postTokenizeMessage(jobId);
+  }
+  #backgroundTokenize(jobId) {
+    if (this.#isStopped || this.#isPaused || this.#grammar == null || jobId !== this.#backgroundJobId) return;
+    this.#ensureActiveTheme();
+    const t = performance.now();
+    const lines = /* @__PURE__ */ new Map();
+    const totalLines = this.#textDocument.lineCount;
+    const changedLineRanges = this.#backgroundChangedLineRanges;
+    let line = this.#lastLine;
+    let state = this.#stateStack[line] ?? void 0;
+    let settled = false;
+    let changedRangeIndex = this.#backgroundChangedRangeIndex;
+    let currentChangedRangeEnd = changedLineRanges?.[changedRangeIndex]?.[1];
+    for (; line < totalLines; ) {
+      this.#stateStack[line] = state;
+      const previousNextState = currentChangedRangeEnd != null ? this.#getPreviousEndState(line + 1) : void 0;
+      const result = this.#tokenizeLineAt(line, state);
+      lines.set(line, result.resolvedTokens);
+      state = result.state;
+      this.#stateStack[line + 1] = state;
+      settled = currentChangedRangeEnd != null && line >= currentChangedRangeEnd && previousNextState != null && state.equals(previousNextState);
+      line++;
+      if (settled) {
+        changedRangeIndex++;
+        const nextRange = changedLineRanges?.[changedRangeIndex];
+        if (nextRange == null) break;
+        currentChangedRangeEnd = nextRange[1];
+        if (this.#stateStack[nextRange[0]] == null) settled = false;
+        else {
+          line = nextRange[0];
+          state = this.#stateStack[line] ?? state;
+          settled = false;
+          continue;
+        }
+      }
+      if (performance.now() - t > 1) break;
+    }
+    this.#onDeferTokenize(lines);
+    if (this.#isStopped || this.#isPaused || jobId !== this.#backgroundJobId) return;
+    if (settled || line >= totalLines) {
+      const pendingPrebuildEndLine = this.#pendingPrebuildEndLine;
+      this.stopBackgroundTokenize();
+      if (pendingPrebuildEndLine >= 0) this.#scheduleStatePrebuild(pendingPrebuildEndLine);
+      return;
+    }
+    this.#lastLine = line;
+    this.#backgroundChangedRangeIndex = changedRangeIndex;
+    this.#postTokenizeMessage(jobId);
+  }
+};
+function tokenizeLine(grammar, colorMap, lineText, stateStack, timeLimit, collectBracketIgnoredRanges = true, resolveTokens = true) {
+  const result = grammar.tokenizeLine2(lineText, stateStack, timeLimit);
+  if (result.stoppedEarly) console.warn(`[diffs] Time limit reached when tokenizing line: ${lineText.substring(0, 100)}`);
+  const rawTokens = result.tokens;
+  const tokensLength = rawTokens.length / 2;
+  const resolvedTokens = [];
+  const bracketIgnoredRanges = [];
+  if (!resolveTokens && !collectBracketIgnoredRanges) return {
+    ruleStack: result.ruleStack,
+    resolvedTokens,
+    bracketIgnoredRanges
+  };
+  for (let j = 0; j < tokensLength; j++) {
+    const offset = rawTokens[2 * j];
+    const nextOffset = j + 1 < tokensLength ? rawTokens[2 * j + 2] : lineText.length;
+    if (offset === nextOffset) continue;
+    const metadata = rawTokens[2 * j + 1];
+    if (resolveTokens) {
+      const fg = (void 0).getForeground(metadata);
+      resolvedTokens.push([
+        offset,
+        colorMap[fg],
+        lineText.slice(offset, nextOffset)
+      ]);
+    }
+    if (collectBracketIgnoredRanges && (void 0).getTokenType(metadata) > 0) bracketIgnoredRanges.push([offset, nextOffset]);
+  }
+  return {
+    ruleStack: result.ruleStack,
+    resolvedTokens,
+    bracketIgnoredRanges
+  };
+}
+function isGrammarlessLanguage(languageId) {
+  return languageId === "text" || languageId === "ansi";
+}
+
+// node_modules/@pierre/diffs/dist/highlighter/shiki-stream.js
+var ShikiStreamTokenizer = class ShikiStreamTokenizer2 extends BaseStreamTokenizer {
+  highlighter;
+  options;
+  #tail = "";
+  #grammarState;
+  constructor(highlighter, options) {
+    super();
+    this.highlighter = highlighter;
+    this.options = options;
+  }
+  tokenizeChunk(chunk, stable) {
+    const chunkLines = (this.#tail + chunk).split(/(\r\n|\r|\n)/);
+    let unstable = [];
+    for (let i = 0; i < chunkLines.length; i += 2) {
+      const line = chunkLines[i];
+      const result = this.highlighter.codeToTokens(line, {
+        ...this.options,
+        grammarState: this.#grammarState
+      });
+      const tokens = result.tokens[0].map((token) => ({
+        ...token,
+        offset: token.offset + this.stableOffset
+      }));
+      if (i + 1 < chunkLines.length) {
+        appendItems(stable, tokens);
+        this.pushLineBreak(stable, line.length, chunkLines[i + 1]);
+        this.#grammarState = result.grammarState;
+      } else {
+        unstable = tokens;
+        this.#tail = line;
+      }
+    }
+    return {
+      unstable,
+      tailLength: this.#tail.length
+    };
+  }
+  clone() {
+    this.assertActive();
+    const clone = new ShikiStreamTokenizer2(this.highlighter, this.options);
+    this.copyStateTo(clone);
+    clone.#tail = this.#tail;
+    clone.#grammarState = this.#grammarState;
+    return clone;
+  }
+  resetSource() {
+    this.#tail = "";
+    this.#grammarState = void 0;
+  }
+  releaseSource() {
+    this.resetSource();
+  }
+};
+
+// node_modules/@pierre/diffs/dist/highlighter/backends/shiki.js
+var ShikiHighlighter = class ShikiHighlighter2 extends DiffsHighlighter {
+  raw;
+  loadedThemes = /* @__PURE__ */ new Map();
+  attachedLanguages = /* @__PURE__ */ new Set(["text", "ansi"]);
+  static async create(name) {
+    const engine = name === "shiki-wasm" ? (await import("./chunk-E6FGQYBA.js")).createOnigurumaEngine(import("./chunk-E6FGQYBA.js")) : (await import("./chunk-E6FGQYBA.js")).createJavaScriptRegexEngine();
+    const raw = await (void 0)({
+      themes: [],
+      langs: [],
+      engine
+    });
+    return new ShikiHighlighter2(name, raw);
+  }
+  constructor(name, raw) {
+    super(name, createDiffsThemeResolver(name));
+    this.raw = raw;
+  }
+  getTheme(themeName) {
+    this.assertNotDisposed();
+    const loaded = this.loadedThemes.get(themeName);
+    const theme = this.themeResolver.getResolvedTheme(themeName) ?? loaded;
+    if (theme == null) throw new Error(`Theme "${themeName}" has not been resolved`);
+    if (loaded !== theme) {
+      const textmate = theme.textmate ?? (theme.cssVariables != null ? (void 0)(theme.cssVariables) : void 0);
+      if (textmate == null) throw new Error(`Theme "${themeName}" does not support Shiki`);
+      this.raw.setTheme({
+        ...textmate,
+        name: themeName
+      });
+      this.loadedThemes.set(themeName, theme);
+    }
+    return theme;
+  }
+  codeToTokens(code, options) {
+    return this.raw.codeToTokens(code, this.resolveOptions(options));
+  }
+  createEditorTokenizer(options) {
+    return new ShikiEditorTokenizer(this.raw, options, this);
+  }
+  createStreamTokenizer(options) {
+    return new ShikiStreamTokenizer(this.raw, this.resolveOptions(options));
+  }
+  async loadLanguages(languages) {
+    this.assertNotDisposed();
+    const missing = languages.filter((language) => !this.attachedLanguages.has(language));
+    attachResolvedLanguages(await resolveLanguages(missing), this);
+  }
+  hasLoadedLanguages(languages) {
+    if (this.disposed) return false;
+    let loaded;
+    return languages.every((lang) => {
+      if (this.attachedLanguages.has(lang)) return true;
+      if (RegisteredCustomLanguages.has(lang)) return false;
+      loaded ??= this.raw.getLoadedLanguages();
+      return loaded.includes(lang);
+    });
+  }
+  attachLanguages(languages) {
+    this.assertNotDisposed();
+    for (const lang of languages) {
+      if (this.attachedLanguages.has(lang.name)) continue;
+      const grammar = lang.data.find((grammar2) => grammar2.name === lang.name || grammar2.aliases?.includes(lang.name) === true);
+      if (grammar == null) throw new Error(`attachResolvedLanguages: No returned grammar declares "${lang.name}" as its name or an alias.`);
+      this.raw.loadLanguageSync(lang.data);
+      try {
+        this.raw.getLanguage(lang.name);
+      } catch {
+        throw new Error(`attachResolvedLanguages: "${grammar.name}" is already loaded without alias "${lang.name}". Load the alias first or give the grammar a unique name.`);
+      }
+      this.attachedLanguages.add(lang.name);
+    }
+  }
+  releaseResources() {
+    this.loadedThemes.clear();
+    this.attachedLanguages.clear();
+    this.raw.dispose();
+  }
+  resolveOptions({ theme, themes, ...options }) {
+    this.assertNotDisposed();
+    if (theme != null) {
+      this.getTheme(theme);
+      return {
+        ...options,
+        theme
+      };
+    }
+    if (themes == null) throw new Error("A theme or themes option is required");
+    for (const name of Object.values(themes)) this.getTheme(name);
+    return {
+      ...options,
+      themes
+    };
+  }
+};
+export {
+  ShikiHighlighter
+};
+//# sourceMappingURL=chunk-X2FGXM6T.js.map