markstream-vue2 0.0.50 → 0.0.52

package/dist/chunks/index-fce73667.js

@@ -0,0 +1,1702 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __knownSymbol = (name, symbol) => {
+  if (symbol = Symbol[name])
+    return symbol;
+  throw Error("Symbol." + name + " is not defined");
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
+var TextAccumulator = class {
+  constructor() {
+    __publicField(this, "chunks", []);
+    __publicField(this, "cached", "");
+    __publicField(this, "dirty", false);
+    __publicField(this, "length", 0);
+  }
+  append(chunk) {
+    if (!chunk)
+      return;
+    this.chunks.push(chunk);
+    this.length += chunk.length;
+    this.dirty = true;
+    if (this.chunks.length > 256)
+      this.compact();
+  }
+  clear(initial = "") {
+    this.chunks = initial ? [initial] : [];
+    this.cached = initial;
+    this.dirty = false;
+    this.length = initial.length;
+  }
+  toString() {
+    if (this.dirty) {
+      this.cached = this.chunks.join("");
+      this.dirty = false;
+    }
+    return this.cached;
+  }
+  compact() {
+    this.chunks = [this.chunks.join("")];
+  }
+};
+function createShell(container, maxHeight) {
+  container.replaceChildren();
+  const shell = document.createElement("div");
+  shell.className = "stream-diffs-shell";
+  shell.style.overflow = "auto";
+  shell.style.maxHeight = typeof maxHeight === "number" ? `${maxHeight}px` : maxHeight != null ? maxHeight : "none";
+  const surface = document.createElement("div");
+  surface.className = "stream-diffs-surface";
+  shell.appendChild(surface);
+  container.appendChild(shell);
+  return {
+    shell,
+    surface
+  };
+}
+function fileContents(name, contents, language) {
+  return {
+    name,
+    contents,
+    lang: language
+  };
+}
+var DiffSurfaceController = class {
+  constructor(input) {
+    __publicField(this, "input");
+    __publicField(this, "container");
+    __publicField(this, "surface");
+    __publicField(this, "instance");
+    __publicField(this, "diff");
+    __publicField(this, "selectedLines", null);
+    __publicField(this, "disposed", false);
+    __publicField(this, "renderListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "visualRevision", 0);
+    __publicField(this, "visualReadyPromise", Promise.resolve(false));
+    __publicField(this, "resolveVisualReady");
+    __publicField(this, "module");
+    this.input = input;
+  }
+  mount(container) {
+    return __async(this, null, function* () {
+      this.disposed = false;
+      this.container = container;
+      this.surface = createShell(container).surface;
+      yield this.render();
+    });
+  }
+  update(input) {
+    return __async(this, null, function* () {
+      this.input = input;
+      if (this.surface)
+        yield this.render(true);
+    });
+  }
+  updateFile(file, annotations) {
+    return this.update({
+      kind: "file",
+      file,
+      annotations,
+      options: this.input.kind === "file" ? this.input.options : void 0,
+      workerManager: this.input.kind === "file" ? this.input.workerManager : void 0
+    });
+  }
+  updateDiff(oldFile, newFile, annotations) {
+    return this.update({
+      kind: "diff",
+      oldFile,
+      newFile,
+      annotations,
+      options: isDiffInput(this.input) ? this.input.options : void 0,
+      workerManager: isDiffInput(this.input) ? this.input.workerManager : void 0
+    });
+  }
+  updateParsedDiff(fileDiff, annotations) {
+    return this.update({
+      kind: "diff",
+      fileDiff,
+      annotations,
+      options: isDiffInput(this.input) ? this.input.options : void 0,
+      workerManager: isDiffInput(this.input) ? this.input.workerManager : void 0
+    });
+  }
+  updatePatch(patch, fileIndex = 0, annotations, patchIndex = 0) {
+    return this.update({
+      kind: "patch",
+      patch,
+      patchIndex,
+      fileIndex,
+      annotations,
+      options: this.input.kind === "patch" ? this.input.options : void 0,
+      workerManager: this.input.kind === "patch" ? this.input.workerManager : void 0
+    });
+  }
+  updateMergeConflict(file, annotations) {
+    return this.update({
+      kind: "merge-conflict",
+      file,
+      annotations,
+      options: this.input.kind === "merge-conflict" ? this.input.options : void 0,
+      workerManager: this.input.kind === "merge-conflict" ? this.input.workerManager : void 0
+    });
+  }
+  setSelectedLines(range) {
+    var _a;
+    this.selectedLines = range;
+    (_a = this.instance) == null ? void 0 : _a.setSelectedLines(range);
+  }
+  setAnnotations(annotations) {
+    if (!this.instance)
+      return;
+    if (this.input.kind === "file") {
+      this.input.annotations = annotations;
+      this.instance.setLineAnnotations(this.input.annotations);
+    } else {
+      this.input.annotations = annotations;
+      this.instance.setLineAnnotations(this.input.annotations);
+    }
+    this.emitRender();
+  }
+  setThemeType(themeType) {
+    var _a;
+    if (this.input.options)
+      this.input.options = __spreadProps(__spreadValues({}, this.input.options), {
+        themeType
+      });
+    else
+      this.input.options = { themeType };
+    (_a = this.instance) == null ? void 0 : _a.setThemeType(themeType);
+  }
+  setTheme(theme) {
+    return __async(this, null, function* () {
+      if (this.input.options)
+        this.input.options = __spreadProps(__spreadValues({}, this.input.options), {
+          theme
+        });
+      else
+        this.input.options = { theme };
+      if (this.surface)
+        yield this.render(false);
+    });
+  }
+  setOptions(options) {
+    return __async(this, null, function* () {
+      this.input.options = options;
+      if (this.surface)
+        yield this.render(false);
+    });
+  }
+  acceptReject(hunkIndex, action) {
+    if (!isDiffInput(this.input) || !this.diff)
+      throw new Error("acceptReject() requires a diff view");
+    const { diffAcceptRejectHunk } = this.module;
+    this.diff = diffAcceptRejectHunk(this.diff, hunkIndex, action);
+    this.instance.render({
+      fileDiff: this.diff,
+      containerWrapper: this.surface,
+      lineAnnotations: this.input.annotations
+    });
+    return this.diff;
+  }
+  resolveConflict(conflictIndex, resolution) {
+    if (this.input.kind !== "merge-conflict")
+      throw new Error("resolveConflict() requires a merge-conflict view");
+    const result = this.instance.resolveConflict(conflictIndex, resolution);
+    if (result) {
+      this.input.file = result.file;
+      this.diff = result.fileDiff;
+    }
+    return result == null ? void 0 : result.file;
+  }
+  getResolvedFile() {
+    var _a, _b;
+    if (!isDiffInput(this.input) || !this.diff || this.diff.isPartial)
+      return void 0;
+    const source = "newFile" in this.input ? this.input.newFile : void 0;
+    return {
+      name: (_a = source == null ? void 0 : source.name) != null ? _a : this.diff.name,
+      contents: this.diff.additionLines.join(""),
+      lang: (_b = source == null ? void 0 : source.lang) != null ? _b : this.diff.lang
+    };
+  }
+  getDiff() {
+    return this.diff;
+  }
+  getInput() {
+    return this.input;
+  }
+  getNativeInstance() {
+    return this.instance;
+  }
+  onDidRender(listener) {
+    this.renderListeners.add(listener);
+    return { dispose: () => this.renderListeners.delete(listener) };
+  }
+  whenVisualReady() {
+    return __async(this, null, function* () {
+      let pending = this.visualReadyPromise;
+      for (; ; ) {
+        const ready = yield pending;
+        if (pending === this.visualReadyPromise)
+          return ready;
+        pending = this.visualReadyPromise;
+      }
+    });
+  }
+  dispose() {
+    var _a, _b;
+    this.disposed = true;
+    this.invalidateVisualReady();
+    (_a = this.instance) == null ? void 0 : _a.cleanUp();
+    this.instance = void 0;
+    this.surface = void 0;
+    (_b = this.container) == null ? void 0 : _b.replaceChildren();
+    this.container = void 0;
+    this.renderListeners.clear();
+  }
+  render(resetDiff = true) {
+    return __async(this, null, function* () {
+      var _a, _b, _c, _d, _e, _f, _g;
+      const surface = this.surface;
+      if (!surface || this.disposed)
+        return;
+      const visualRevision = this.beginVisualRender();
+      const mod = (_a = this.module) != null ? _a : this.module = yield import("./index-42602bc0.js");
+      if (this.disposed || surface !== this.surface)
+        return;
+      (_b = this.instance) == null ? void 0 : _b.cleanUp();
+      surface.replaceChildren();
+      if (this.input.kind === "file") {
+        const instance2 = new mod.File(withInternalPostRender(this.input.options, () => this.markVisualReady(visualRevision)), this.input.workerManager);
+        instance2.render({
+          file: this.input.file,
+          containerWrapper: surface,
+          lineAnnotations: this.input.annotations
+        });
+        this.instance = instance2;
+        instance2.setSelectedLines(this.selectedLines);
+        this.diff = void 0;
+        return;
+      }
+      if (isDiffInput(this.input)) {
+        if (resetDiff || !this.diff)
+          if (this.input.kind === "patch") {
+            const patch = mod.parsePatchFiles(this.input.patch)[(_c = this.input.patchIndex) != null ? _c : 0];
+            if (!patch)
+              throw new Error(`Patch does not contain patch index ${(_d = this.input.patchIndex) != null ? _d : 0}`);
+            const fileDiff = patch.files[(_e = this.input.fileIndex) != null ? _e : 0];
+            if (!fileDiff)
+              throw new Error(`Patch does not contain file index ${(_f = this.input.fileIndex) != null ? _f : 0}`);
+            this.diff = fileDiff;
+          } else if ("fileDiff" in this.input)
+            this.diff = this.input.fileDiff;
+          else
+            this.diff = mod.parseDiffFromFile(this.input.oldFile, this.input.newFile, (_g = this.input.options) == null ? void 0 : _g.parseDiffOptions);
+        const instance2 = new mod.FileDiff(withInternalPostRender(this.input.options, () => this.markVisualReady(visualRevision)), this.input.workerManager);
+        instance2.render({
+          fileDiff: this.diff,
+          containerWrapper: surface,
+          lineAnnotations: this.input.annotations
+        });
+        this.instance = instance2;
+        instance2.setSelectedLines(this.selectedLines);
+        return;
+      }
+      const instance = new mod.UnresolvedFile(withInternalPostRender(this.input.options, () => this.markVisualReady(visualRevision)), this.input.workerManager);
+      instance.render({
+        file: this.input.file,
+        containerWrapper: surface,
+        lineAnnotations: this.input.annotations
+      });
+      this.instance = instance;
+      instance.setSelectedLines(this.selectedLines);
+      this.diff = instance.fileDiff;
+    });
+  }
+  emitRender() {
+    for (const listener of this.renderListeners)
+      listener();
+  }
+  beginVisualRender() {
+    var _a;
+    (_a = this.resolveVisualReady) == null ? void 0 : _a.call(this, false);
+    const revision = ++this.visualRevision;
+    this.visualReadyPromise = new Promise((resolve) => {
+      this.resolveVisualReady = resolve;
+    });
+    return revision;
+  }
+  markVisualReady(revision) {
+    var _a;
+    if (this.disposed || revision !== this.visualRevision)
+      return;
+    (_a = this.resolveVisualReady) == null ? void 0 : _a.call(this, true);
+    this.resolveVisualReady = void 0;
+    this.emitRender();
+  }
+  invalidateVisualReady() {
+    var _a;
+    this.visualRevision++;
+    (_a = this.resolveVisualReady) == null ? void 0 : _a.call(this, false);
+    this.resolveVisualReady = void 0;
+  }
+};
+function createDiffSurface(input) {
+  return new DiffSurfaceController(input);
+}
+function withTokenTransformer(options) {
+  if (!options || options.useTokenTransformer === true)
+    return options;
+  if (!options.onTokenClick && !options.onTokenEnter && !options.onTokenLeave)
+    return options;
+  return __spreadProps(__spreadValues({}, options), {
+    useTokenTransformer: true
+  });
+}
+function withInternalPostRender(options, onRender) {
+  const transformed = withTokenTransformer(options);
+  const userPostRender = transformed == null ? void 0 : transformed.onPostRender;
+  return __spreadProps(__spreadValues({}, transformed), {
+    onPostRender(...args) {
+      userPostRender == null ? void 0 : userPostRender(...args);
+      onRender();
+    }
+  });
+}
+function isDiffInput(input) {
+  return input.kind === "diff" || input.kind === "patch";
+}
+var CodeStreamController = class {
+  constructor(options = {}) {
+    __publicField(this, "options");
+    __publicField(this, "state", "idle");
+    __publicField(this, "stats", {
+      characters: 0,
+      lines: 0,
+      writes: 0,
+      resets: 0,
+      renderMode: "plain-text",
+      overflowed: false
+    });
+    __publicField(this, "text", new TextAccumulator());
+    __publicField(this, "pending", []);
+    __publicField(this, "scheduled");
+    __publicField(this, "generation", 0);
+    __publicField(this, "container");
+    __publicField(this, "shell");
+    __publicField(this, "surface");
+    __publicField(this, "finalizedSurface");
+    __publicField(this, "plainText");
+    __publicField(this, "finalizePromise");
+    __publicField(this, "renderListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "finalizedRenderSubscription");
+    this.options = options;
+  }
+  mount(container) {
+    return __async(this, null, function* () {
+      var _a, _b, _c, _d, _e;
+      if (this.state === "disposed")
+        throw new Error("Cannot mount a disposed code stream. Create a new controller instead.");
+      ++this.generation;
+      this.cancelScheduledFlush();
+      (_a = this.finalizedSurface) == null ? void 0 : _a.dispose();
+      (_b = this.finalizedRenderSubscription) == null ? void 0 : _b.dispose();
+      (_c = this.container) == null ? void 0 : _c.replaceChildren();
+      this.finalizedSurface = void 0;
+      this.finalizedRenderSubscription = void 0;
+      this.plainText = void 0;
+      this.pending = [];
+      this.setState("mounting");
+      this.container = container;
+      const { shell, surface } = createShell(container, this.options.maxHeight);
+      this.shell = shell;
+      this.surface = surface;
+      this.mountPlainText(surface);
+      (_e = (_d = this.stats).startedAt) != null ? _e : _d.startedAt = performance.now();
+      this.setState("streaming");
+    });
+  }
+  append(chunk) {
+    if (!chunk)
+      return;
+    if (this.state === "finalized" || this.state === "finalizing" || this.state === "disposed")
+      throw new Error(`Cannot append while stream is ${this.state}`);
+    this.text.append(chunk);
+    this.stats.characters = this.text.length;
+    this.stats.lines += countNewlines(chunk) + (this.stats.lines === 0 ? 1 : 0);
+    this.pending.push(chunk);
+    this.scheduleFlush();
+  }
+  updateSnapshot(content) {
+    var _a;
+    const previous = this.text.toString();
+    if (content.startsWith(previous)) {
+      this.append(content.slice(previous.length));
+      return;
+    }
+    const behavior = (_a = this.options.nonAppendBehavior) != null ? _a : "reset";
+    if (behavior === "ignore")
+      return;
+    if (behavior === "throw")
+      throw new Error("Snapshot violates the append-only stream contract");
+    return this.reset(content);
+  }
+  consume(source) {
+    return __async(this, null, function* () {
+      try {
+        if (Symbol.asyncIterator in source)
+          try {
+            for (var iter = __forAwait(source), more, temp, error; more = !(temp = yield iter.next()).done; more = false) {
+              const chunk = temp.value;
+              this.append(chunk);
+            }
+          } catch (temp) {
+            error = [temp];
+          } finally {
+            try {
+              more && (temp = iter.return) && (yield temp.call(iter));
+            } finally {
+              if (error)
+                throw error[0];
+            }
+          }
+        else {
+          const reader = source.getReader();
+          try {
+            while (true) {
+              const { done, value } = yield reader.read();
+              if (done)
+                break;
+              this.append(value);
+            }
+          } finally {
+            reader.releaseLock();
+          }
+        }
+      } catch (error2) {
+        this.fail(error2);
+        throw error2;
+      }
+    });
+  }
+  flush() {
+    return __async(this, null, function* () {
+      var _a;
+      this.cancelScheduledFlush();
+      if (!this.pending.length)
+        return;
+      const shouldFollow = this.shouldFollowViewport();
+      const batch = this.pending.join("");
+      this.pending.length = 0;
+      (_a = this.plainText) == null ? void 0 : _a.append(batch);
+      this.stats.writes++;
+      this.followViewport(shouldFollow);
+      this.emitRender();
+    });
+  }
+  finalize(options = { view: "stream" }) {
+    if (this.state === "finalized")
+      return Promise.resolve();
+    if (this.finalizePromise)
+      return this.finalizePromise;
+    const promise = this.performFinalize(options).finally(() => {
+      if (this.finalizePromise === promise)
+        this.finalizePromise = void 0;
+    });
+    this.finalizePromise = promise;
+    return promise;
+  }
+  performFinalize(options) {
+    return __async(this, null, function* () {
+      var _a, _b, _e, _f;
+      if (this.state === "disposed")
+        throw new Error("Cannot finalize a disposed code stream");
+      const generation = this.generation;
+      this.setState("finalizing");
+      yield this.flush();
+      if (generation !== this.generation)
+        return;
+      this.stats.finalizedAt = performance.now();
+      if (!options.view || options.view === "stream") {
+        this.setState("finalized");
+        return;
+      }
+      const surface = this.surface;
+      if (!surface)
+        throw new Error("Mount the stream before finalizing to a file or diff view");
+      const name = (_b = this.options.fileName) != null ? _b : `code.${(_a = this.options.language) != null ? _a : "txt"}`;
+      const current = fileContents(name, this.getText(), this.options.language);
+      let finalizedSurface;
+      if (options.view === "file") {
+        const _c = options, { annotations, workerManager, view: _ } = _c, fileOptions = __objRest(_c, ["annotations", "workerManager", "view"]);
+        finalizedSurface = createDiffSurface({
+          kind: "file",
+          file: current,
+          annotations,
+          options: __spreadValues({
+            theme: this.options.theme,
+            themeType: this.options.themeType
+          }, fileOptions),
+          workerManager: workerManager != null ? workerManager : this.options.workerManager
+        });
+      } else {
+        const _d = options, { annotations, original, workerManager, view: _ } = _d, diffOptions = __objRest(_d, ["annotations", "original", "workerManager", "view"]);
+        finalizedSurface = createDiffSurface({
+          kind: "diff",
+          oldFile: fileContents(name, original, this.options.language),
+          newFile: current,
+          annotations,
+          options: __spreadValues({
+            theme: this.options.theme,
+            themeType: this.options.themeType
+          }, diffOptions),
+          workerManager: workerManager != null ? workerManager : this.options.workerManager
+        });
+      }
+      const staging = document.createElement("div");
+      staging.className = "stream-diffs-finalized";
+      yield finalizedSurface.mount(staging);
+      if (generation !== this.generation) {
+        finalizedSurface.dispose();
+        return;
+      }
+      const shell = this.shell;
+      const scrollTop = (_e = shell == null ? void 0 : shell.scrollTop) != null ? _e : 0;
+      const distanceToBottom = shell ? shell.scrollHeight - shell.scrollTop - shell.clientHeight : 0;
+      surface.replaceWith(staging);
+      this.surface = staging;
+      this.plainText = void 0;
+      this.finalizedSurface = finalizedSurface;
+      this.finalizedRenderSubscription = finalizedSurface.onDidRender(() => this.emitRender());
+      if (shell)
+        if (this.options.autoScroll === "always" || this.options.autoScroll !== "never" && distanceToBottom <= ((_f = this.options.autoScrollThresholdPx) != null ? _f : 32))
+          shell.scrollTop = shell.scrollHeight;
+        else
+          shell.scrollTop = scrollTop;
+      this.setState("finalized");
+      this.emitRender();
+    });
+  }
+  reset(initialContent = "") {
+    return __async(this, null, function* () {
+      var _a, _b;
+      const container = this.container;
+      ++this.generation;
+      this.cancelScheduledFlush();
+      (_a = this.finalizedSurface) == null ? void 0 : _a.dispose();
+      (_b = this.finalizedRenderSubscription) == null ? void 0 : _b.dispose();
+      this.finalizedSurface = void 0;
+      this.finalizedRenderSubscription = void 0;
+      this.plainText = void 0;
+      this.pending = [];
+      this.finalizePromise = void 0;
+      this.text.clear();
+      this.stats.resets++;
+      this.stats.characters = 0;
+      this.stats.lines = 0;
+      this.stats.renderMode = "plain-text";
+      this.stats.overflowed = false;
+      this.setState("idle");
+      if (initialContent)
+        this.append(initialContent);
+      if (container)
+        yield this.mount(container);
+    });
+  }
+  setThemeType(type) {
+    var _a;
+    this.options.themeType = type;
+    (_a = this.finalizedSurface) == null ? void 0 : _a.setThemeType(type);
+  }
+  setTheme(theme) {
+    return __async(this, null, function* () {
+      this.options.theme = theme;
+      if (this.finalizedSurface)
+        yield this.finalizedSurface.setTheme(theme);
+    });
+  }
+  setLanguage(language) {
+    return __async(this, null, function* () {
+      if (language === this.options.language)
+        return;
+      this.options.language = language;
+      if (!this.finalizedSurface)
+        return;
+      const input = this.finalizedSurface.getInput();
+      if (input.kind === "file")
+        yield this.finalizedSurface.updateFile(__spreadProps(__spreadValues({}, input.file), {
+          lang: language
+        }), input.annotations);
+      else if (input.kind === "diff" && "oldFile" in input)
+        yield this.finalizedSurface.updateDiff(__spreadProps(__spreadValues({}, input.oldFile), {
+          lang: language
+        }), __spreadProps(__spreadValues({}, input.newFile), {
+          lang: language
+        }), input.annotations);
+    });
+  }
+  getText() {
+    return this.text.toString();
+  }
+  getState() {
+    return this.state;
+  }
+  getStats() {
+    return __spreadValues({}, this.stats);
+  }
+  getElement() {
+    return this.shell;
+  }
+  getFinalizedSurface() {
+    return this.finalizedSurface;
+  }
+  onDidRender(listener) {
+    this.renderListeners.add(listener);
+    return { dispose: () => this.renderListeners.delete(listener) };
+  }
+  dispose() {
+    var _a, _b, _c;
+    ++this.generation;
+    this.cancelScheduledFlush();
+    (_a = this.finalizedSurface) == null ? void 0 : _a.dispose();
+    (_b = this.finalizedRenderSubscription) == null ? void 0 : _b.dispose();
+    (_c = this.container) == null ? void 0 : _c.replaceChildren();
+    this.plainText = void 0;
+    this.container = void 0;
+    this.surface = void 0;
+    this.shell = void 0;
+    this.finalizedSurface = void 0;
+    this.finalizedRenderSubscription = void 0;
+    this.finalizePromise = void 0;
+    this.renderListeners.clear();
+    this.setState("disposed");
+  }
+  scheduleFlush() {
+    var _a;
+    if (this.scheduled != null || !this.plainText)
+      return;
+    const strategy = (_a = this.options.flushStrategy) != null ? _a : "raf";
+    if (strategy === "raf" && typeof requestAnimationFrame === "function")
+      this.scheduled = requestAnimationFrame(() => void this.flush());
+    else
+      this.scheduled = globalThis.setTimeout(() => void this.flush(), strategy === "raf" ? 0 : strategy.intervalMs);
+  }
+  cancelScheduledFlush() {
+    if (this.scheduled == null)
+      return;
+    if (typeof cancelAnimationFrame === "function")
+      cancelAnimationFrame(this.scheduled);
+    clearTimeout(this.scheduled);
+    this.scheduled = void 0;
+  }
+  shouldFollowViewport() {
+    var _a;
+    const shell = this.shell;
+    if (!shell || this.options.autoScroll === "never")
+      return false;
+    if (this.options.autoScroll === "always")
+      return true;
+    return shell.scrollHeight - shell.scrollTop - shell.clientHeight <= ((_a = this.options.autoScrollThresholdPx) != null ? _a : 32);
+  }
+  followViewport(shouldFollow = this.shouldFollowViewport()) {
+    if (this.shell && shouldFollow)
+      this.shell.scrollTop = this.shell.scrollHeight;
+  }
+  mountPlainText(surface) {
+    const pre = document.createElement("pre");
+    pre.className = "stream-diffs-plain-text";
+    pre.dataset.streamDiffsState = "streaming";
+    pre.style.margin = "0";
+    pre.style.whiteSpace = this.options.wrap ? "pre-wrap" : "pre";
+    pre.style.overflowWrap = this.options.wrap ? "anywhere" : "normal";
+    pre.textContent = this.getText();
+    surface.replaceChildren(pre);
+    this.plainText = pre;
+  }
+  setState(state) {
+    var _a, _b;
+    this.state = state;
+    (_b = (_a = this.options).onStateChange) == null ? void 0 : _b.call(_a, state);
+  }
+  emitRender() {
+    for (const listener of this.renderListeners)
+      listener();
+  }
+  fail(error) {
+    var _a, _b;
+    if (this.state === "disposed")
+      return;
+    this.setState("error");
+    (_b = (_a = this.options).onError) == null ? void 0 : _b.call(_a, error);
+  }
+};
+function countNewlines(value) {
+  let count = 0;
+  for (let index = 0; index < value.length; index++)
+    if (value.charCodeAt(index) === 10)
+      count++;
+  return count;
+}
+function createCodeStream(options) {
+  return new CodeStreamController(options);
+}
+var DiffStreamController = class {
+  constructor(options = {}) {
+    __publicField(this, "options");
+    __publicField(this, "state", "idle");
+    __publicField(this, "generation", 0);
+    __publicField(this, "original", "");
+    __publicField(this, "modified", "");
+    __publicField(this, "container");
+    __publicField(this, "shell");
+    __publicField(this, "surface");
+    __publicField(this, "finalizedSurface");
+    __publicField(this, "finalizePromise");
+    __publicField(this, "renderListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "finalizedRenderSubscription");
+    this.options = options;
+  }
+  mount(_0) {
+    return __async(this, arguments, function* (container, original = this.original, modified = this.modified) {
+      var _a, _b, _c;
+      if (this.state === "disposed")
+        throw new Error("Cannot mount a disposed diff stream. Create a new controller instead.");
+      ++this.generation;
+      this.original = original;
+      this.modified = modified;
+      (_a = this.finalizedSurface) == null ? void 0 : _a.dispose();
+      (_b = this.finalizedRenderSubscription) == null ? void 0 : _b.dispose();
+      (_c = this.container) == null ? void 0 : _c.replaceChildren();
+      this.finalizedSurface = void 0;
+      this.finalizedRenderSubscription = void 0;
+      this.setState("mounting");
+      this.container = container;
+      const { shell, surface } = createShell(container, this.options.maxHeight);
+      this.shell = shell;
+      this.surface = surface;
+      this.renderPre();
+      this.setState("streaming");
+    });
+  }
+  update(original, modified) {
+    if (this.state === "disposed")
+      throw new Error("Cannot update a disposed diff stream");
+    this.original = original;
+    this.modified = modified;
+    if (this.finalizedSurface)
+      return this.finalizedSurface.updateDiff(this.asFile(original), this.asFile(modified));
+    this.renderPre();
+    this.emitRender();
+    return Promise.resolve();
+  }
+  finalize(annotations) {
+    if (this.state === "finalized")
+      return Promise.resolve(this.finalizedSurface);
+    if (this.finalizePromise)
+      return this.finalizePromise;
+    const promise = this.performFinalize(annotations).finally(() => {
+      if (this.finalizePromise === promise)
+        this.finalizePromise = void 0;
+    });
+    this.finalizePromise = promise;
+    return promise;
+  }
+  performFinalize(annotations) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      if (this.state === "disposed")
+        throw new Error("Cannot finalize a disposed diff stream");
+      const surface = this.surface;
+      if (!surface)
+        throw new Error("Mount the diff stream before finalizing it");
+      const generation = this.generation;
+      this.setState("finalizing");
+      const finalized = createDiffSurface({
+        kind: "diff",
+        oldFile: this.asFile(this.original),
+        newFile: this.asFile(this.modified),
+        annotations,
+        options: __spreadProps(__spreadValues({}, this.options), {
+          diffStyle: (_a = this.options.diffStyle) != null ? _a : "unified"
+        }),
+        workerManager: this.options.workerManager
+      });
+      const staging = document.createElement("div");
+      staging.className = "stream-diffs-finalized";
+      yield finalized.mount(staging);
+      if (generation !== this.generation) {
+        finalized.dispose();
+        return;
+      }
+      const shell = this.shell;
+      const scrollTop = (_b = shell == null ? void 0 : shell.scrollTop) != null ? _b : 0;
+      surface.replaceWith(staging);
+      this.surface = staging;
+      this.finalizedSurface = finalized;
+      this.finalizedRenderSubscription = finalized.onDidRender(() => this.emitRender());
+      if (shell)
+        shell.scrollTop = scrollTop;
+      this.setState("finalized");
+      this.emitRender();
+      return finalized;
+    });
+  }
+  setThemeType(type) {
+    var _a;
+    this.options.themeType = type;
+    (_a = this.finalizedSurface) == null ? void 0 : _a.setThemeType(type);
+  }
+  setTheme(theme) {
+    return __async(this, null, function* () {
+      this.options.theme = theme;
+      if (this.finalizedSurface)
+        yield this.finalizedSurface.setTheme(theme);
+    });
+  }
+  setLanguage(language) {
+    return __async(this, null, function* () {
+      if (language === this.options.language)
+        return;
+      this.options.language = language;
+      if (this.finalizedSurface) {
+        const input = this.finalizedSurface.getInput();
+        if (input.kind === "diff" && "oldFile" in input)
+          yield this.finalizedSurface.updateDiff(__spreadProps(__spreadValues({}, input.oldFile), {
+            lang: language
+          }), __spreadProps(__spreadValues({}, input.newFile), {
+            lang: language
+          }), input.annotations);
+        return;
+      }
+      this.renderPre();
+    });
+  }
+  getOriginal() {
+    return this.original;
+  }
+  getModified() {
+    return this.modified;
+  }
+  getState() {
+    return this.state;
+  }
+  getElement() {
+    return this.shell;
+  }
+  getFinalizedSurface() {
+    return this.finalizedSurface;
+  }
+  onDidRender(listener) {
+    this.renderListeners.add(listener);
+    return { dispose: () => this.renderListeners.delete(listener) };
+  }
+  dispose() {
+    var _a, _b, _c;
+    ++this.generation;
+    (_a = this.finalizedSurface) == null ? void 0 : _a.dispose();
+    (_b = this.finalizedRenderSubscription) == null ? void 0 : _b.dispose();
+    (_c = this.container) == null ? void 0 : _c.replaceChildren();
+    this.container = void 0;
+    this.shell = void 0;
+    this.surface = void 0;
+    this.finalizedSurface = void 0;
+    this.finalizedRenderSubscription = void 0;
+    this.finalizePromise = void 0;
+    this.renderListeners.clear();
+    this.setState("disposed");
+  }
+  renderPre() {
+    var _a, _b;
+    const surface = this.surface;
+    if (!surface || this.finalizedSurface)
+      return;
+    const root = document.createElement("div");
+    root.className = `stream-diffs-diff-pre stream-diffs-diff-pre--${(_a = this.options.diffStyle) != null ? _a : "unified"}`;
+    root.dataset.streamDiffsState = "streaming";
+    root.style.minWidth = "max-content";
+    if (((_b = this.options.diffStyle) != null ? _b : "unified") === "split") {
+      root.style.display = "grid";
+      root.style.gridTemplateColumns = "minmax(0, 1fr) minmax(0, 1fr)";
+      root.append(this.createPre(this.original, "deletions"), this.createPre(this.modified, "additions"));
+    } else
+      root.append(this.createPre(createUnifiedPreview(this.original, this.modified), "unified"));
+    surface.replaceChildren(root);
+  }
+  createPre(text, side) {
+    const pre = document.createElement("pre");
+    pre.className = `stream-diffs-diff-pre__pane stream-diffs-diff-pre__pane--${side}`;
+    pre.dataset.side = side;
+    pre.style.margin = "0";
+    pre.style.whiteSpace = this.options.wrap ? "pre-wrap" : "pre";
+    pre.style.overflowWrap = this.options.wrap ? "anywhere" : "normal";
+    pre.textContent = text;
+    return pre;
+  }
+  asFile(contents) {
+    var _a, _b;
+    return fileContents((_b = this.options.fileName) != null ? _b : `code.${(_a = this.options.language) != null ? _a : "txt"}`, contents, this.options.language);
+  }
+  setState(state) {
+    var _a, _b;
+    this.state = state;
+    (_b = (_a = this.options).onStateChange) == null ? void 0 : _b.call(_a, state);
+  }
+  emitRender() {
+    for (const listener of this.renderListeners)
+      listener();
+  }
+};
+function createUnifiedPreview(original, modified) {
+  const before = original.split("\n");
+  const after = modified.split("\n");
+  let prefix = 0;
+  while (prefix < before.length && prefix < after.length && before[prefix] === after[prefix])
+    prefix++;
+  let suffix = 0;
+  while (suffix < before.length - prefix && suffix < after.length - prefix && before[before.length - suffix - 1] === after[after.length - suffix - 1])
+    suffix++;
+  return [
+    ...before.slice(0, prefix).map((line) => `  ${line}`),
+    ...before.slice(prefix, before.length - suffix).map((line) => `- ${line}`),
+    ...after.slice(prefix, after.length - suffix).map((line) => `+ ${line}`),
+    ...before.slice(before.length - suffix).map((line) => `  ${line}`)
+  ].join("\n");
+}
+function createDiffStream(options) {
+  return new DiffStreamController(options);
+}
+function useMonaco(options = {}) {
+  let stream;
+  let diffStream;
+  let surface;
+  let editorAdapter;
+  let diffAdapter;
+  let language = "text";
+  let original = "";
+  let modified = "";
+  let container;
+  let visualRevision = 0;
+  let themeType = "system";
+  let appliedTheme = resolveTheme(options);
+  let appliedThemePairKey = getThemePairKey(options);
+  const shared = {
+    disableLineNumbers: options.lineNumbers === false,
+    overflow: options.wordWrap === "on" ? "wrap" : "scroll",
+    enableLineSelection: options.enableLineSelection
+  };
+  const sharedOptions = () => __spreadProps(__spreadValues({}, shared), {
+    theme: appliedTheme,
+    themeType
+  });
+  function createEditor(target, code, lang) {
+    return __async(this, null, function* () {
+      var _a2;
+      cleanupEditor();
+      const revision = visualRevision;
+      applyEditorStyles(target, options);
+      container = target;
+      language = normalizeSurfaceLanguage(lang);
+      if (shouldRenderMergeConflict(code))
+        return createMergeConflictEditor(target, code, language);
+      if (options.stream === false)
+        return createStaticFileEditor(target, code, language);
+      const createdStream = new CodeStreamController(__spreadProps(__spreadValues(__spreadValues({}, sharedOptions()), pickPierreOptions(options)), {
+        fileName: `code.${language}`,
+        language,
+        maxHeight: options.MAX_HEIGHT,
+        autoScroll: options.autoScrollOnUpdate === false ? "never" : "near-bottom",
+        autoScrollThresholdPx: options.autoScrollThresholdPx,
+        workerManager: options.workerManager
+      }));
+      stream = createdStream;
+      createdStream.append(code);
+      yield createdStream.mount(target);
+      if (revision !== visualRevision || stream !== createdStream || container !== target) {
+        createdStream.dispose();
+        throw new Error("Editor creation was cancelled");
+      }
+      (_a2 = options.onController) == null ? void 0 : _a2.call(options, createdStream);
+      editorAdapter = createEditorAdapter(() => createdStream.getText(), target, () => createdStream.getFinalizedSurface(), (listener) => createdStream.onDidRender(listener));
+      return editorAdapter;
+    });
+  }
+  function createDiffEditor(target, oldCode, newCode, lang) {
+    return __async(this, null, function* () {
+      var _a2, _b, _c, _d;
+      cleanupEditor();
+      const revision = visualRevision;
+      applyEditorStyles(target, options);
+      container = target;
+      language = normalizeSurfaceLanguage(lang);
+      original = oldCode;
+      modified = newCode;
+      let createdSurface;
+      let createdDiffStream;
+      if (options.stream === false) {
+        createdSurface = createDiffSurface({
+          kind: "diff",
+          oldFile: asFile(oldCode),
+          newFile: asFile(newCode),
+          annotations: options.lineAnnotations,
+          workerManager: options.workerManager,
+          options: __spreadValues(__spreadProps(__spreadValues({}, sharedOptions()), {
+            diffStyle: (_a2 = options.diffStyle) != null ? _a2 : options.renderSideBySide === false ? "unified" : "split"
+          }), pickPierreOptions(options))
+        });
+        surface = createdSurface;
+        yield createdSurface.mount(target);
+        if (revision !== visualRevision || surface !== createdSurface || container !== target) {
+          createdSurface.dispose();
+          throw new Error("Editor creation was cancelled");
+        }
+        (_b = options.onController) == null ? void 0 : _b.call(options, createdSurface);
+      } else {
+        createdDiffStream = new DiffStreamController(__spreadProps(__spreadValues(__spreadValues({}, sharedOptions()), pickPierreOptions(options)), {
+          fileName: `code.${language}`,
+          language,
+          diffStyle: (_c = options.diffStyle) != null ? _c : options.renderSideBySide === false ? "unified" : "split",
+          maxHeight: options.MAX_HEIGHT,
+          wrap: options.wordWrap === "on",
+          workerManager: options.workerManager
+        }));
+        diffStream = createdDiffStream;
+        yield createdDiffStream.mount(target, oldCode, newCode);
+        if (revision !== visualRevision || diffStream !== createdDiffStream || container !== target) {
+          createdDiffStream.dispose();
+          throw new Error("Editor creation was cancelled");
+        }
+        (_d = options.onController) == null ? void 0 : _d.call(options, createdDiffStream);
+      }
+      diffAdapter = createDiffAdapter(() => original, () => modified, target, () => createdSurface != null ? createdSurface : createdDiffStream == null ? void 0 : createdDiffStream.getFinalizedSurface());
+      return diffAdapter;
+    });
+  }
+  function updateCode(_0) {
+    return __async(this, arguments, function* (code, lang = language) {
+      const nextLanguage = normalizeSurfaceLanguage(lang);
+      if (shouldRenderMergeConflict(code)) {
+        if ((surface == null ? void 0 : surface.getInput().kind) === "merge-conflict") {
+          language = nextLanguage;
+          yield surface.updateMergeConflict(asFile(code), options.lineAnnotations);
+        } else if (container)
+          yield createMergeConflictEditor(container, code, nextLanguage);
+        return;
+      }
+      if (options.stream === false) {
+        if ((surface == null ? void 0 : surface.getInput().kind) === "file") {
+          language = nextLanguage;
+          yield surface.updateFile(asFile(code), options.lineAnnotations);
+        } else if (container)
+          yield createStaticFileEditor(container, code, nextLanguage);
+        return;
+      }
+      if (!stream) {
+        if (container)
+          yield createEditor(container, code, nextLanguage);
+        return;
+      }
+      if (stream.getState() === "finalized") {
+        if (code !== stream.getText())
+          yield stream.reset(code);
+        return;
+      }
+      if (nextLanguage !== language) {
+        language = nextLanguage;
+        yield stream.setLanguage(nextLanguage);
+        if (code !== stream.getText())
+          yield stream.reset(code);
+        return;
+      }
+      const previous = stream.getText();
+      if (code.startsWith(previous))
+        stream.append(code.slice(previous.length));
+      else
+        yield stream.reset(code);
+    });
+  }
+  function updateDiff(_0, _1) {
+    return __async(this, arguments, function* (oldCode, newCode, lang = language) {
+      original = oldCode;
+      modified = newCode;
+      language = normalizeSurfaceLanguage(lang);
+      if (diffStream) {
+        yield diffStream.update(oldCode, newCode);
+        return;
+      }
+      if (!surface) {
+        if (container)
+          yield createDiffEditor(container, oldCode, newCode, lang);
+        return;
+      }
+      yield surface.updateDiff(asFile(oldCode), asFile(newCode));
+    });
+  }
+  function cleanupEditor() {
+    visualRevision++;
+    stream == null ? void 0 : stream.dispose();
+    diffStream == null ? void 0 : diffStream.dispose();
+    if (!diffStream)
+      surface == null ? void 0 : surface.dispose();
+    stream = void 0;
+    diffStream = void 0;
+    surface = void 0;
+    editorAdapter = void 0;
+    diffAdapter = void 0;
+    container = void 0;
+  }
+  function createStaticFileEditor(target, code, lang) {
+    return __async(this, null, function* () {
+      var _a2;
+      cleanupEditor();
+      const revision = visualRevision;
+      container = target;
+      language = lang;
+      const createdSurface = createDiffSurface({
+        kind: "file",
+        file: asFile(code),
+        annotations: options.lineAnnotations,
+        workerManager: options.workerManager,
+        options: __spreadValues(__spreadValues({}, sharedOptions()), pickPierreOptions(options))
+      });
+      surface = createdSurface;
+      yield createdSurface.mount(target);
+      if (revision !== visualRevision || surface !== createdSurface || container !== target) {
+        createdSurface.dispose();
+        throw new Error("Editor creation was cancelled");
+      }
+      (_a2 = options.onController) == null ? void 0 : _a2.call(options, createdSurface);
+      editorAdapter = createEditorAdapter(() => {
+        var _a3;
+        return (_a3 = getSurfaceFileContents(createdSurface)) != null ? _a3 : code;
+      }, target, () => createdSurface, (listener) => createdSurface.onDidRender(listener));
+      return editorAdapter;
+    });
+  }
+  function createMergeConflictEditor(target, code, lang) {
+    return __async(this, null, function* () {
+      var _a2;
+      cleanupEditor();
+      const revision = visualRevision;
+      container = target;
+      language = lang;
+      const createdSurface = createDiffSurface({
+        kind: "merge-conflict",
+        file: asFile(code),
+        annotations: options.lineAnnotations,
+        workerManager: options.workerManager,
+        options: __spreadValues(__spreadValues({}, sharedOptions()), pickPierreOptions(options))
+      });
+      surface = createdSurface;
+      yield createdSurface.mount(target);
+      if (revision !== visualRevision || surface !== createdSurface || container !== target) {
+        createdSurface.dispose();
+        throw new Error("Editor creation was cancelled");
+      }
+      (_a2 = options.onController) == null ? void 0 : _a2.call(options, createdSurface);
+      editorAdapter = createEditorAdapter(() => {
+        var _a3;
+        return (_a3 = getSurfaceFileContents(createdSurface)) != null ? _a3 : code;
+      }, target, () => createdSurface, (listener) => createdSurface.onDidRender(listener));
+      return editorAdapter;
+    });
+  }
+  function shouldRenderMergeConflict(code) {
+    if (options.mergeConflict === false)
+      return false;
+    return /^<<<<<<< .+$/m.test(code) && /^=======$/m.test(code) && /^>>>>>>> .+$/m.test(code);
+  }
+  function setTheme(nextTheme) {
+    return __async(this, null, function* () {
+      if (!nextTheme)
+        return;
+      if (typeof nextTheme === "string") {
+        const themes = options.themes;
+        if ((themes == null ? void 0 : themes[0]) === nextTheme) {
+          yield applyThemePairIfChanged();
+          themeType = "dark";
+          stream == null ? void 0 : stream.setThemeType("dark");
+          diffStream == null ? void 0 : diffStream.setThemeType("dark");
+          surface == null ? void 0 : surface.setThemeType("dark");
+          return;
+        }
+        if ((themes == null ? void 0 : themes[1]) === nextTheme) {
+          yield applyThemePairIfChanged();
+          themeType = "light";
+          stream == null ? void 0 : stream.setThemeType("light");
+          diffStream == null ? void 0 : diffStream.setThemeType("light");
+          surface == null ? void 0 : surface.setThemeType("light");
+          return;
+        }
+      }
+      appliedThemePairKey = void 0;
+      appliedTheme = nextTheme;
+      yield applyTheme(nextTheme);
+    });
+  }
+  function applyThemePairIfChanged() {
+    return __async(this, null, function* () {
+      const pairKey = getThemePairKey(options);
+      if (!pairKey || pairKey === appliedThemePairKey)
+        return;
+      appliedThemePairKey = pairKey;
+      appliedTheme = resolveTheme(options);
+      yield applyTheme(appliedTheme);
+    });
+  }
+  function applyTheme(nextTheme) {
+    return __async(this, null, function* () {
+      yield stream == null ? void 0 : stream.setTheme(nextTheme);
+      yield diffStream == null ? void 0 : diffStream.setTheme(nextTheme);
+      yield surface == null ? void 0 : surface.setTheme(nextTheme);
+    });
+  }
+  function asFile(contents) {
+    return fileContents(`code.${language || "txt"}`, contents, language);
+  }
+  return {
+    runtimeKind: "stream-diffs",
+    createEditor,
+    createDiffEditor,
+    updateCode,
+    appendCode(chunk) {
+      stream == null ? void 0 : stream.append(chunk);
+    },
+    finalizeCode() {
+      return __async(this, null, function* () {
+        if (!stream || stream.getState() === "finalized")
+          return stream == null ? void 0 : stream.getFinalizedSurface();
+        const nativeOptions = pickPierreOptions(options);
+        delete nativeOptions.lineAnnotations;
+        yield stream.finalize(__spreadProps(__spreadValues({
+          view: "file"
+        }, nativeOptions), {
+          theme: appliedTheme,
+          themeType,
+          annotations: options.lineAnnotations,
+          workerManager: options.workerManager
+        }));
+        return stream.getFinalizedSurface();
+      });
+    },
+    finalizeDiff() {
+      return __async(this, null, function* () {
+        if (!diffStream)
+          return surface;
+        surface = yield diffStream.finalize(options.lineAnnotations);
+        return surface;
+      });
+    },
+    updateDiff,
+    updateOriginal(code, lang = language) {
+      return updateDiff(code, modified, lang);
+    },
+    updateModified(code, lang = language) {
+      return updateDiff(original, code, lang);
+    },
+    appendOriginal(chunk, lang = language) {
+      return updateDiff(original + chunk, modified, lang);
+    },
+    appendModified(chunk, lang = language) {
+      return updateDiff(original, modified + chunk, lang);
+    },
+    cleanupEditor,
+    safeClean: cleanupEditor,
+    setTheme,
+    setLanguage(next) {
+      return __async(this, null, function* () {
+        language = normalizeSurfaceLanguage(next);
+        yield stream == null ? void 0 : stream.setLanguage(language);
+        yield diffStream == null ? void 0 : diffStream.setLanguage(language);
+        if (surface && !diffStream) {
+          const input = surface.getInput();
+          if (input.kind === "file" || input.kind === "merge-conflict")
+            yield surface.update(__spreadProps(__spreadValues({}, input), {
+              file: __spreadProps(__spreadValues({}, input.file), {
+                lang: language
+              })
+            }));
+          else if (input.kind === "diff" && "oldFile" in input)
+            yield surface.update(__spreadProps(__spreadValues({}, input), {
+              oldFile: __spreadProps(__spreadValues({}, input.oldFile), {
+                lang: language
+              }),
+              newFile: __spreadProps(__spreadValues({}, input.newFile), {
+                lang: language
+              })
+            }));
+        }
+      });
+    },
+    getCurrentTheme: () => appliedTheme,
+    getEditor: () => EDITOR_NAMESPACE,
+    getEditorView: () => editorAdapter != null ? editorAdapter : null,
+    getDiffEditorView: () => diffAdapter != null ? diffAdapter : null,
+    getDiffModels: () => ({
+      original: createModel(() => original),
+      modified: createModel(() => {
+        var _a2, _b, _c;
+        return (_c = (_b = (_a2 = surface == null ? void 0 : surface.getResolvedFile()) == null ? void 0 : _a2.contents) != null ? _b : diffStream == null ? void 0 : diffStream.getModified()) != null ? _c : modified;
+      })
+    }),
+    getCode: () => {
+      var _a2, _b, _c;
+      const input = surface == null ? void 0 : surface.getInput();
+      if ((input == null ? void 0 : input.kind) === "diff" || (input == null ? void 0 : input.kind) === "patch")
+        return {
+          original,
+          modified: (_b = (_a2 = surface == null ? void 0 : surface.getResolvedFile()) == null ? void 0 : _a2.contents) != null ? _b : modified
+        };
+      if ((input == null ? void 0 : input.kind) === "file" || (input == null ? void 0 : input.kind) === "merge-conflict")
+        return input.file.contents;
+      if (diffStream)
+        return {
+          original: diffStream.getOriginal(),
+          modified: diffStream.getModified()
+        };
+      return (_c = stream == null ? void 0 : stream.getText()) != null ? _c : null;
+    },
+    refreshDiffPresentation: () => surface == null ? void 0 : surface.update(surface.getInput()),
+    whenVisualReady: () => __async(this, null, function* () {
+      var _a2;
+      const target = container;
+      const revision = visualRevision;
+      const renderedSurface = (_a2 = surface != null ? surface : stream == null ? void 0 : stream.getFinalizedSurface()) != null ? _a2 : diffStream == null ? void 0 : diffStream.getFinalizedSurface();
+      if (!renderedSurface || !(yield renderedSurface.whenVisualReady()))
+        return false;
+      return waitForVisualReady(target, () => {
+        var _a3;
+        return revision === visualRevision && target === container && renderedSurface === ((_a3 = surface != null ? surface : stream == null ? void 0 : stream.getFinalizedSurface()) != null ? _a3 : diffStream == null ? void 0 : diffStream.getFinalizedSurface());
+      }, () => {
+        var _a3;
+        return isSurfaceRenderComplete((_a3 = surface != null ? surface : stream == null ? void 0 : stream.getFinalizedSurface()) != null ? _a3 : diffStream == null ? void 0 : diffStream.getFinalizedSurface());
+      });
+    })
+  };
+}
+function waitForVisualReady(container, isCurrent, isRenderComplete) {
+  return __async(this, null, function* () {
+    var _a, _b, _c;
+    if (!container || typeof window === "undefined")
+      return false;
+    let previousSignature = "";
+    let previousPre;
+    let stableFrames = 0;
+    for (let frame = 0; frame < 120; frame += 1) {
+      if (!isCurrent())
+        return false;
+      const shell = container.querySelector(".stream-diffs-shell");
+      const pre = (_b = (_a = shell == null ? void 0 : shell.querySelector("diffs-container")) == null ? void 0 : _a.shadowRoot) == null ? void 0 : _b.querySelector("pre");
+      const rect = shell == null ? void 0 : shell.getBoundingClientRect();
+      const text = (_c = pre == null ? void 0 : pre.textContent) != null ? _c : "";
+      if (!!rect && rect.width > 0 && rect.height > 0 && !!pre && isRenderComplete()) {
+        const signature = `${Math.round(rect.width)}:${Math.round(rect.height)}:${pre.scrollWidth}:${pre.scrollHeight}:${text.length}`;
+        stableFrames = pre === previousPre && signature === previousSignature ? stableFrames + 1 : 1;
+        previousPre = pre;
+        previousSignature = signature;
+        if (stableFrames >= 2)
+          return true;
+      } else {
+        previousSignature = "";
+        previousPre = void 0;
+        stableFrames = 0;
+      }
+      yield nextVisualFrame();
+    }
+    return false;
+  });
+}
+function isSurfaceRenderComplete(surface) {
+  var _a, _b, _c, _d, _e;
+  if (!surface)
+    return true;
+  const instance = surface.getNativeInstance();
+  const renderer = (_a = instance == null ? void 0 : instance.fileRenderer) != null ? _a : instance == null ? void 0 : instance.hunksRenderer;
+  if (!renderer)
+    return true;
+  const cache = renderer.renderCache;
+  if (!(cache == null ? void 0 : cache.result))
+    return false;
+  if (cache.highlighted === true)
+    return true;
+  const input = surface.getInput();
+  if (normalizeSurfaceLanguage(input.kind === "file" || input.kind === "merge-conflict" ? input.file.lang : "oldFile" in input ? (_b = input.oldFile.lang) != null ? _b : input.newFile.lang : (_c = surface.getDiff()) == null ? void 0 : _c.lang) === "text")
+    return true;
+  const tokenizeMaxLength = Number((_e = (_d = renderer.getTokenizeMaxLength) == null ? void 0 : _d.call(renderer)) != null ? _e : 1e5);
+  if (input.kind === "file" || input.kind === "merge-conflict")
+    return countLines(input.file.contents) > tokenizeMaxLength;
+  const diff = surface.getDiff();
+  return !!diff && Math.max(diff.additionLines.length, diff.deletionLines.length) > tokenizeMaxLength;
+}
+function normalizeSurfaceLanguage(language) {
+  return !language || /^(?:text|txt|plain|plaintext)$/i.test(language) ? "text" : language;
+}
+function countLines(value) {
+  if (!value)
+    return 0;
+  let lines = 1;
+  for (let index = 0; index < value.length; index += 1)
+    if (value.charCodeAt(index) === 10)
+      lines += 1;
+  return lines;
+}
+function nextVisualFrame() {
+  return new Promise((resolve) => {
+    let settled = false;
+    const done = () => {
+      if (settled)
+        return;
+      settled = true;
+      window.clearTimeout(timeout);
+      window.cancelAnimationFrame(frame);
+      resolve();
+    };
+    const frame = window.requestAnimationFrame(done);
+    const timeout = window.setTimeout(done, 50);
+  });
+}
+function resolveTheme(options) {
+  var _a, _b;
+  if (((_a = options.themes) == null ? void 0 : _a.length) && typeof options.themes[0] === "string" && typeof options.themes[1] === "string")
+    return {
+      dark: options.themes[0],
+      light: options.themes[1]
+    };
+  return (_b = options.theme) != null ? _b : void 0;
+}
+function getThemePairKey(options) {
+  var _a, _b;
+  if (typeof ((_a = options.themes) == null ? void 0 : _a[0]) !== "string" || typeof ((_b = options.themes) == null ? void 0 : _b[1]) !== "string")
+    return void 0;
+  return `${options.themes[0]}
+${options.themes[1]}`;
+}
+function pickPierreOptions(options) {
+  var _a, _b, _c;
+  const hostKeys = /* @__PURE__ */ new Set([
+    "MAX_HEIGHT",
+    "theme",
+    "themes",
+    "readOnly",
+    "lineNumbers",
+    "wordWrap",
+    "renderSideBySide",
+    "autoScrollOnUpdate",
+    "autoScrollThresholdPx",
+    "stream",
+    "mergeConflict",
+    "lineAnnotations",
+    "onController",
+    "workerManager",
+    "languages",
+    "onThemeChange"
+  ]);
+  const nativeOptions = Object.fromEntries(Object.entries(options).filter(([key]) => !hostKeys.has(key)));
+  const legacyFolding = options.diffHideUnchangedRegions;
+  delete nativeOptions.diffHideUnchangedRegions;
+  const foldingOptions = typeof legacyFolding === "object" && legacyFolding ? legacyFolding : void 0;
+  const foldingEnabled = (foldingOptions == null ? void 0 : foldingOptions.enabled) !== false;
+  if (legacyFolding === false || foldingOptions && !foldingEnabled)
+    (_a = nativeOptions.expandUnchanged) != null ? _a : nativeOptions.expandUnchanged = true;
+  else if (legacyFolding === true || foldingOptions) {
+    (_b = nativeOptions.expandUnchanged) != null ? _b : nativeOptions.expandUnchanged = false;
+    if (foldingOptions) {
+      const context = Number(foldingOptions.contextLineCount);
+      if (Number.isFinite(context) && context >= 0)
+        nativeOptions.parseDiffOptions = __spreadValues({
+          context
+        }, nativeOptions.parseDiffOptions);
+      const minimumLineCount = Number(foldingOptions.minimumLineCount);
+      if (Number.isFinite(minimumLineCount) && minimumLineCount >= 1)
+        (_c = nativeOptions.collapsedContextThreshold) != null ? _c : nativeOptions.collapsedContextThreshold = Math.max(0, Math.floor(minimumLineCount) - 1);
+    }
+  }
+  return nativeOptions;
+}
+function createModel(getValue) {
+  return {
+    getValue,
+    getLineCount: () => getValue().split("\n").length
+  };
+}
+function getSurfaceFileContents(surface) {
+  const input = surface == null ? void 0 : surface.getInput();
+  return (input == null ? void 0 : input.kind) === "file" || (input == null ? void 0 : input.kind) === "merge-conflict" ? input.file.contents : void 0;
+}
+function createEditorAdapter(getValue, container, getSurface = () => void 0, subscribeRender) {
+  const readFontSize = () => Number.parseFloat(container.style.fontSize) || 14;
+  return {
+    getModel: () => createModel(getValue),
+    getContentHeight: () => {
+      var _a, _b;
+      return (_b = (_a = container.querySelector(".stream-diffs-shell")) == null ? void 0 : _a.scrollHeight) != null ? _b : container.scrollHeight;
+    },
+    layout: () => {
+    },
+    getOption(key) {
+      if (key === EDITOR_OPTION.fontInfo)
+        return { fontSize: readFontSize() };
+      if (key === EDITOR_OPTION.lineHeight)
+        return Number.parseFloat(container.style.lineHeight) || Math.round(readFontSize() * 1.5);
+    },
+    updateOptions(next) {
+      applyEditorStyles(container, next);
+    },
+    onDidContentSizeChange: (listener) => {
+      var _a;
+      return (_a = subscribeRender == null ? void 0 : subscribeRender(listener)) != null ? _a : { dispose() {
+      } };
+    },
+    onDidLayoutChange: (listener) => {
+      var _a;
+      return (_a = subscribeRender == null ? void 0 : subscribeRender(listener)) != null ? _a : { dispose() {
+      } };
+    },
+    setSelectedLines: (range) => {
+      var _a;
+      return (_a = getSurface()) == null ? void 0 : _a.setSelectedLines(range);
+    },
+    setAnnotations: (annotations) => {
+      var _a;
+      return (_a = getSurface()) == null ? void 0 : _a.setAnnotations(annotations);
+    },
+    acceptReject: (hunkIndex, action) => {
+      var _a;
+      return (_a = getSurface()) == null ? void 0 : _a.acceptReject(hunkIndex, action);
+    },
+    resolveConflict: (conflictIndex, resolution) => {
+      var _a;
+      return (_a = getSurface()) == null ? void 0 : _a.resolveConflict(conflictIndex, resolution);
+    }
+  };
+}
+function createDiffAdapter(getOriginal, getModified, container, getSurface) {
+  return __spreadProps(__spreadValues({}, createEditorAdapter(getModified, container, getSurface, (listener) => {
+    var _a, _b;
+    return (_b = (_a = getSurface()) == null ? void 0 : _a.onDidRender(listener)) != null ? _b : { dispose() {
+    } };
+  })), {
+    getOriginalEditor: () => createEditorAdapter(getOriginal, container, getSurface, (listener) => {
+      var _a, _b;
+      return (_b = (_a = getSurface()) == null ? void 0 : _a.onDidRender(listener)) != null ? _b : { dispose() {
+      } };
+    }),
+    getModifiedEditor: () => createEditorAdapter(getModified, container, getSurface, (listener) => {
+      var _a, _b;
+      return (_b = (_a = getSurface()) == null ? void 0 : _a.onDidRender(listener)) != null ? _b : { dispose() {
+      } };
+    }),
+    getLineChanges: () => {
+      var _a, _b, _c;
+      return (_c = (_b = (_a = getSurface()) == null ? void 0 : _a.getDiff()) == null ? void 0 : _b.hunks.map((hunk) => ({
+        originalStartLineNumber: hunk.deletionStart,
+        originalEndLineNumber: hunk.deletionStart + hunk.deletionCount - 1,
+        modifiedStartLineNumber: hunk.additionStart,
+        modifiedEndLineNumber: hunk.additionStart + hunk.additionCount - 1
+      }))) != null ? _c : [];
+    },
+    onDidUpdateDiff: (listener) => {
+      var _a, _b;
+      return (_b = (_a = getSurface()) == null ? void 0 : _a.onDidRender(listener)) != null ? _b : { dispose() {
+      } };
+    }
+  });
+}
+const EDITOR_OPTION = {
+  fontInfo: 0,
+  lineHeight: 1
+};
+const EDITOR_NAMESPACE = { EditorOption: EDITOR_OPTION };
+function applyEditorStyles(container, options) {
+  const { style } = container;
+  if (typeof options.fontSize === "number") {
+    style.fontSize = `${options.fontSize}px`;
+    style.setProperty("--diffs-font-size", `${options.fontSize}px`);
+  }
+  if (typeof options.lineHeight === "number") {
+    style.lineHeight = `${options.lineHeight}px`;
+    style.setProperty("--diffs-line-height", `${options.lineHeight}px`);
+  }
+  if (typeof options.fontFamily === "string") {
+    style.fontFamily = options.fontFamily;
+    style.setProperty("--diffs-font-family", options.fontFamily);
+  }
+}
+function preloadMonacoWorkers() {
+  return __async(this, null, function* () {
+  });
+}
+function detectLanguage(code) {
+  if (/^\s*</.test(code))
+    return "html";
+  if (/\b(interface|type|enum)\s+\w+|:\s*(string|number|boolean)\b/.test(code))
+    return "typescript";
+  if (/\b(const|let|function|import|export)\b/.test(code))
+    return "javascript";
+  if (/\b(def|from|lambda|None|True|False)\b/.test(code))
+    return "python";
+  return "text";
+}
+export {
+  CodeStreamController,
+  DiffStreamController,
+  DiffSurfaceController,
+  createCodeStream,
+  createDiffStream,
+  createDiffSurface,
+  detectLanguage,
+  preloadMonacoWorkers,
+  useMonaco
+};