@cloudflare/vite-plugin 0.0.0-229d00fce

package/dist/index.js

@@ -0,0 +1,2403 @@
+// src/index.ts
+import assert7 from "node:assert";
+import * as fs4 from "node:fs";
+import * as path6 from "node:path";
+import { createMiddleware } from "@hattip/adapter-node";
+import { Miniflare } from "miniflare";
+import "vite";
+
+// src/cloudflare-environment.ts
+import assert from "node:assert";
+import { builtinModules } from "node:module";
+import * as vite2 from "vite";
+
+// src/node-js-compat.ts
+import { createRequire } from "node:module";
+
+// ../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
+var comma = ",".charCodeAt(0);
+var semicolon = ";".charCodeAt(0);
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+  const c = chars.charCodeAt(i);
+  intToChar[i] = c;
+  charToInt[c] = i;
+}
+function encodeInteger(builder, num, relative4) {
+  let delta = num - relative4;
+  delta = delta < 0 ? -delta << 1 | 1 : delta << 1;
+  do {
+    let clamped = delta & 31;
+    delta >>>= 5;
+    if (delta > 0)
+      clamped |= 32;
+    builder.write(intToChar[clamped]);
+  } while (delta > 0);
+  return num;
+}
+var bufLength = 1024 * 16;
+var td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? {
+  decode(buf) {
+    const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+    return out.toString();
+  }
+} : {
+  decode(buf) {
+    let out = "";
+    for (let i = 0; i < buf.length; i++) {
+      out += String.fromCharCode(buf[i]);
+    }
+    return out;
+  }
+};
+var StringWriter = class {
+  constructor() {
+    this.pos = 0;
+    this.out = "";
+    this.buffer = new Uint8Array(bufLength);
+  }
+  write(v) {
+    const { buffer } = this;
+    buffer[this.pos++] = v;
+    if (this.pos === bufLength) {
+      this.out += td.decode(buffer);
+      this.pos = 0;
+    }
+  }
+  flush() {
+    const { buffer, out, pos } = this;
+    return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+  }
+};
+function encode(decoded) {
+  const writer = new StringWriter();
+  let sourcesIndex = 0;
+  let sourceLine = 0;
+  let sourceColumn = 0;
+  let namesIndex = 0;
+  for (let i = 0; i < decoded.length; i++) {
+    const line = decoded[i];
+    if (i > 0)
+      writer.write(semicolon);
+    if (line.length === 0)
+      continue;
+    let genColumn = 0;
+    for (let j = 0; j < line.length; j++) {
+      const segment = line[j];
+      if (j > 0)
+        writer.write(comma);
+      genColumn = encodeInteger(writer, segment[0], genColumn);
+      if (segment.length === 1)
+        continue;
+      sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
+      sourceLine = encodeInteger(writer, segment[2], sourceLine);
+      sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
+      if (segment.length === 4)
+        continue;
+      namesIndex = encodeInteger(writer, segment[4], namesIndex);
+    }
+  }
+  return writer.flush();
+}
+
+// ../../node_modules/.pnpm/magic-string@0.30.17/node_modules/magic-string/dist/magic-string.es.mjs
+var BitSet = class _BitSet {
+  constructor(arg) {
+    this.bits = arg instanceof _BitSet ? arg.bits.slice() : [];
+  }
+  add(n2) {
+    this.bits[n2 >> 5] |= 1 << (n2 & 31);
+  }
+  has(n2) {
+    return !!(this.bits[n2 >> 5] & 1 << (n2 & 31));
+  }
+};
+var Chunk = class _Chunk {
+  constructor(start, end, content) {
+    this.start = start;
+    this.end = end;
+    this.original = content;
+    this.intro = "";
+    this.outro = "";
+    this.content = content;
+    this.storeName = false;
+    this.edited = false;
+    {
+      this.previous = null;
+      this.next = null;
+    }
+  }
+  appendLeft(content) {
+    this.outro += content;
+  }
+  appendRight(content) {
+    this.intro = this.intro + content;
+  }
+  clone() {
+    const chunk = new _Chunk(this.start, this.end, this.original);
+    chunk.intro = this.intro;
+    chunk.outro = this.outro;
+    chunk.content = this.content;
+    chunk.storeName = this.storeName;
+    chunk.edited = this.edited;
+    return chunk;
+  }
+  contains(index) {
+    return this.start < index && index < this.end;
+  }
+  eachNext(fn) {
+    let chunk = this;
+    while (chunk) {
+      fn(chunk);
+      chunk = chunk.next;
+    }
+  }
+  eachPrevious(fn) {
+    let chunk = this;
+    while (chunk) {
+      fn(chunk);
+      chunk = chunk.previous;
+    }
+  }
+  edit(content, storeName, contentOnly) {
+    this.content = content;
+    if (!contentOnly) {
+      this.intro = "";
+      this.outro = "";
+    }
+    this.storeName = storeName;
+    this.edited = true;
+    return this;
+  }
+  prependLeft(content) {
+    this.outro = content + this.outro;
+  }
+  prependRight(content) {
+    this.intro = content + this.intro;
+  }
+  reset() {
+    this.intro = "";
+    this.outro = "";
+    if (this.edited) {
+      this.content = this.original;
+      this.storeName = false;
+      this.edited = false;
+    }
+  }
+  split(index) {
+    const sliceIndex = index - this.start;
+    const originalBefore = this.original.slice(0, sliceIndex);
+    const originalAfter = this.original.slice(sliceIndex);
+    this.original = originalBefore;
+    const newChunk = new _Chunk(index, this.end, originalAfter);
+    newChunk.outro = this.outro;
+    this.outro = "";
+    this.end = index;
+    if (this.edited) {
+      newChunk.edit("", false);
+      this.content = "";
+    } else {
+      this.content = originalBefore;
+    }
+    newChunk.next = this.next;
+    if (newChunk.next) newChunk.next.previous = newChunk;
+    newChunk.previous = this;
+    this.next = newChunk;
+    return newChunk;
+  }
+  toString() {
+    return this.intro + this.content + this.outro;
+  }
+  trimEnd(rx) {
+    this.outro = this.outro.replace(rx, "");
+    if (this.outro.length) return true;
+    const trimmed = this.content.replace(rx, "");
+    if (trimmed.length) {
+      if (trimmed !== this.content) {
+        this.split(this.start + trimmed.length).edit("", void 0, true);
+        if (this.edited) {
+          this.edit(trimmed, this.storeName, true);
+        }
+      }
+      return true;
+    } else {
+      this.edit("", void 0, true);
+      this.intro = this.intro.replace(rx, "");
+      if (this.intro.length) return true;
+    }
+  }
+  trimStart(rx) {
+    this.intro = this.intro.replace(rx, "");
+    if (this.intro.length) return true;
+    const trimmed = this.content.replace(rx, "");
+    if (trimmed.length) {
+      if (trimmed !== this.content) {
+        const newChunk = this.split(this.end - trimmed.length);
+        if (this.edited) {
+          newChunk.edit(trimmed, this.storeName, true);
+        }
+        this.edit("", void 0, true);
+      }
+      return true;
+    } else {
+      this.edit("", void 0, true);
+      this.outro = this.outro.replace(rx, "");
+      if (this.outro.length) return true;
+    }
+  }
+};
+function getBtoa() {
+  if (typeof globalThis !== "undefined" && typeof globalThis.btoa === "function") {
+    return (str) => globalThis.btoa(unescape(encodeURIComponent(str)));
+  } else if (typeof Buffer === "function") {
+    return (str) => Buffer.from(str, "utf-8").toString("base64");
+  } else {
+    return () => {
+      throw new Error("Unsupported environment: `window.btoa` or `Buffer` should be supported.");
+    };
+  }
+}
+var btoa = /* @__PURE__ */ getBtoa();
+var SourceMap = class {
+  constructor(properties) {
+    this.version = 3;
+    this.file = properties.file;
+    this.sources = properties.sources;
+    this.sourcesContent = properties.sourcesContent;
+    this.names = properties.names;
+    this.mappings = encode(properties.mappings);
+    if (typeof properties.x_google_ignoreList !== "undefined") {
+      this.x_google_ignoreList = properties.x_google_ignoreList;
+    }
+    if (typeof properties.debugId !== "undefined") {
+      this.debugId = properties.debugId;
+    }
+  }
+  toString() {
+    return JSON.stringify(this);
+  }
+  toUrl() {
+    return "data:application/json;charset=utf-8;base64," + btoa(this.toString());
+  }
+};
+function guessIndent(code) {
+  const lines = code.split("\n");
+  const tabbed = lines.filter((line) => /^\t+/.test(line));
+  const spaced = lines.filter((line) => /^ {2,}/.test(line));
+  if (tabbed.length === 0 && spaced.length === 0) {
+    return null;
+  }
+  if (tabbed.length >= spaced.length) {
+    return "	";
+  }
+  const min = spaced.reduce((previous, current) => {
+    const numSpaces = /^ +/.exec(current)[0].length;
+    return Math.min(numSpaces, previous);
+  }, Infinity);
+  return new Array(min + 1).join(" ");
+}
+function getRelativePath(from, to) {
+  const fromParts = from.split(/[/\\]/);
+  const toParts = to.split(/[/\\]/);
+  fromParts.pop();
+  while (fromParts[0] === toParts[0]) {
+    fromParts.shift();
+    toParts.shift();
+  }
+  if (fromParts.length) {
+    let i = fromParts.length;
+    while (i--) fromParts[i] = "..";
+  }
+  return fromParts.concat(toParts).join("/");
+}
+var toString = Object.prototype.toString;
+function isObject(thing) {
+  return toString.call(thing) === "[object Object]";
+}
+function getLocator(source) {
+  const originalLines = source.split("\n");
+  const lineOffsets = [];
+  for (let i = 0, pos = 0; i < originalLines.length; i++) {
+    lineOffsets.push(pos);
+    pos += originalLines[i].length + 1;
+  }
+  return function locate(index) {
+    let i = 0;
+    let j = lineOffsets.length;
+    while (i < j) {
+      const m = i + j >> 1;
+      if (index < lineOffsets[m]) {
+        j = m;
+      } else {
+        i = m + 1;
+      }
+    }
+    const line = i - 1;
+    const column = index - lineOffsets[line];
+    return { line, column };
+  };
+}
+var wordRegex = /\w/;
+var Mappings = class {
+  constructor(hires) {
+    this.hires = hires;
+    this.generatedCodeLine = 0;
+    this.generatedCodeColumn = 0;
+    this.raw = [];
+    this.rawSegments = this.raw[this.generatedCodeLine] = [];
+    this.pending = null;
+  }
+  addEdit(sourceIndex, content, loc, nameIndex) {
+    if (content.length) {
+      const contentLengthMinusOne = content.length - 1;
+      let contentLineEnd = content.indexOf("\n", 0);
+      let previousContentLineEnd = -1;
+      while (contentLineEnd >= 0 && contentLengthMinusOne > contentLineEnd) {
+        const segment2 = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+        if (nameIndex >= 0) {
+          segment2.push(nameIndex);
+        }
+        this.rawSegments.push(segment2);
+        this.generatedCodeLine += 1;
+        this.raw[this.generatedCodeLine] = this.rawSegments = [];
+        this.generatedCodeColumn = 0;
+        previousContentLineEnd = contentLineEnd;
+        contentLineEnd = content.indexOf("\n", contentLineEnd + 1);
+      }
+      const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+      if (nameIndex >= 0) {
+        segment.push(nameIndex);
+      }
+      this.rawSegments.push(segment);
+      this.advance(content.slice(previousContentLineEnd + 1));
+    } else if (this.pending) {
+      this.rawSegments.push(this.pending);
+      this.advance(content);
+    }
+    this.pending = null;
+  }
+  addUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) {
+    let originalCharIndex = chunk.start;
+    let first = true;
+    let charInHiresBoundary = false;
+    while (originalCharIndex < chunk.end) {
+      if (original[originalCharIndex] === "\n") {
+        loc.line += 1;
+        loc.column = 0;
+        this.generatedCodeLine += 1;
+        this.raw[this.generatedCodeLine] = this.rawSegments = [];
+        this.generatedCodeColumn = 0;
+        first = true;
+        charInHiresBoundary = false;
+      } else {
+        if (this.hires || first || sourcemapLocations.has(originalCharIndex)) {
+          const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+          if (this.hires === "boundary") {
+            if (wordRegex.test(original[originalCharIndex])) {
+              if (!charInHiresBoundary) {
+                this.rawSegments.push(segment);
+                charInHiresBoundary = true;
+              }
+            } else {
+              this.rawSegments.push(segment);
+              charInHiresBoundary = false;
+            }
+          } else {
+            this.rawSegments.push(segment);
+          }
+        }
+        loc.column += 1;
+        this.generatedCodeColumn += 1;
+        first = false;
+      }
+      originalCharIndex += 1;
+    }
+    this.pending = null;
+  }
+  advance(str) {
+    if (!str) return;
+    const lines = str.split("\n");
+    if (lines.length > 1) {
+      for (let i = 0; i < lines.length - 1; i++) {
+        this.generatedCodeLine++;
+        this.raw[this.generatedCodeLine] = this.rawSegments = [];
+      }
+      this.generatedCodeColumn = 0;
+    }
+    this.generatedCodeColumn += lines[lines.length - 1].length;
+  }
+};
+var n = "\n";
+var warned = {
+  insertLeft: false,
+  insertRight: false,
+  storeName: false
+};
+var MagicString = class _MagicString {
+  constructor(string, options = {}) {
+    const chunk = new Chunk(0, string.length, string);
+    Object.defineProperties(this, {
+      original: { writable: true, value: string },
+      outro: { writable: true, value: "" },
+      intro: { writable: true, value: "" },
+      firstChunk: { writable: true, value: chunk },
+      lastChunk: { writable: true, value: chunk },
+      lastSearchedChunk: { writable: true, value: chunk },
+      byStart: { writable: true, value: {} },
+      byEnd: { writable: true, value: {} },
+      filename: { writable: true, value: options.filename },
+      indentExclusionRanges: { writable: true, value: options.indentExclusionRanges },
+      sourcemapLocations: { writable: true, value: new BitSet() },
+      storedNames: { writable: true, value: {} },
+      indentStr: { writable: true, value: void 0 },
+      ignoreList: { writable: true, value: options.ignoreList },
+      offset: { writable: true, value: options.offset || 0 }
+    });
+    this.byStart[0] = chunk;
+    this.byEnd[string.length] = chunk;
+  }
+  addSourcemapLocation(char) {
+    this.sourcemapLocations.add(char);
+  }
+  append(content) {
+    if (typeof content !== "string") throw new TypeError("outro content must be a string");
+    this.outro += content;
+    return this;
+  }
+  appendLeft(index, content) {
+    index = index + this.offset;
+    if (typeof content !== "string") throw new TypeError("inserted content must be a string");
+    this._split(index);
+    const chunk = this.byEnd[index];
+    if (chunk) {
+      chunk.appendLeft(content);
+    } else {
+      this.intro += content;
+    }
+    return this;
+  }
+  appendRight(index, content) {
+    index = index + this.offset;
+    if (typeof content !== "string") throw new TypeError("inserted content must be a string");
+    this._split(index);
+    const chunk = this.byStart[index];
+    if (chunk) {
+      chunk.appendRight(content);
+    } else {
+      this.outro += content;
+    }
+    return this;
+  }
+  clone() {
+    const cloned = new _MagicString(this.original, { filename: this.filename, offset: this.offset });
+    let originalChunk = this.firstChunk;
+    let clonedChunk = cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone();
+    while (originalChunk) {
+      cloned.byStart[clonedChunk.start] = clonedChunk;
+      cloned.byEnd[clonedChunk.end] = clonedChunk;
+      const nextOriginalChunk = originalChunk.next;
+      const nextClonedChunk = nextOriginalChunk && nextOriginalChunk.clone();
+      if (nextClonedChunk) {
+        clonedChunk.next = nextClonedChunk;
+        nextClonedChunk.previous = clonedChunk;
+        clonedChunk = nextClonedChunk;
+      }
+      originalChunk = nextOriginalChunk;
+    }
+    cloned.lastChunk = clonedChunk;
+    if (this.indentExclusionRanges) {
+      cloned.indentExclusionRanges = this.indentExclusionRanges.slice();
+    }
+    cloned.sourcemapLocations = new BitSet(this.sourcemapLocations);
+    cloned.intro = this.intro;
+    cloned.outro = this.outro;
+    return cloned;
+  }
+  generateDecodedMap(options) {
+    options = options || {};
+    const sourceIndex = 0;
+    const names = Object.keys(this.storedNames);
+    const mappings = new Mappings(options.hires);
+    const locate = getLocator(this.original);
+    if (this.intro) {
+      mappings.advance(this.intro);
+    }
+    this.firstChunk.eachNext((chunk) => {
+      const loc = locate(chunk.start);
+      if (chunk.intro.length) mappings.advance(chunk.intro);
+      if (chunk.edited) {
+        mappings.addEdit(
+          sourceIndex,
+          chunk.content,
+          loc,
+          chunk.storeName ? names.indexOf(chunk.original) : -1
+        );
+      } else {
+        mappings.addUneditedChunk(sourceIndex, chunk, this.original, loc, this.sourcemapLocations);
+      }
+      if (chunk.outro.length) mappings.advance(chunk.outro);
+    });
+    return {
+      file: options.file ? options.file.split(/[/\\]/).pop() : void 0,
+      sources: [
+        options.source ? getRelativePath(options.file || "", options.source) : options.file || ""
+      ],
+      sourcesContent: options.includeContent ? [this.original] : void 0,
+      names,
+      mappings: mappings.raw,
+      x_google_ignoreList: this.ignoreList ? [sourceIndex] : void 0
+    };
+  }
+  generateMap(options) {
+    return new SourceMap(this.generateDecodedMap(options));
+  }
+  _ensureindentStr() {
+    if (this.indentStr === void 0) {
+      this.indentStr = guessIndent(this.original);
+    }
+  }
+  _getRawIndentString() {
+    this._ensureindentStr();
+    return this.indentStr;
+  }
+  getIndentString() {
+    this._ensureindentStr();
+    return this.indentStr === null ? "	" : this.indentStr;
+  }
+  indent(indentStr, options) {
+    const pattern = /^[^\r\n]/gm;
+    if (isObject(indentStr)) {
+      options = indentStr;
+      indentStr = void 0;
+    }
+    if (indentStr === void 0) {
+      this._ensureindentStr();
+      indentStr = this.indentStr || "	";
+    }
+    if (indentStr === "") return this;
+    options = options || {};
+    const isExcluded = {};
+    if (options.exclude) {
+      const exclusions = typeof options.exclude[0] === "number" ? [options.exclude] : options.exclude;
+      exclusions.forEach((exclusion) => {
+        for (let i = exclusion[0]; i < exclusion[1]; i += 1) {
+          isExcluded[i] = true;
+        }
+      });
+    }
+    let shouldIndentNextCharacter = options.indentStart !== false;
+    const replacer = (match) => {
+      if (shouldIndentNextCharacter) return `${indentStr}${match}`;
+      shouldIndentNextCharacter = true;
+      return match;
+    };
+    this.intro = this.intro.replace(pattern, replacer);
+    let charIndex = 0;
+    let chunk = this.firstChunk;
+    while (chunk) {
+      const end = chunk.end;
+      if (chunk.edited) {
+        if (!isExcluded[charIndex]) {
+          chunk.content = chunk.content.replace(pattern, replacer);
+          if (chunk.content.length) {
+            shouldIndentNextCharacter = chunk.content[chunk.content.length - 1] === "\n";
+          }
+        }
+      } else {
+        charIndex = chunk.start;
+        while (charIndex < end) {
+          if (!isExcluded[charIndex]) {
+            const char = this.original[charIndex];
+            if (char === "\n") {
+              shouldIndentNextCharacter = true;
+            } else if (char !== "\r" && shouldIndentNextCharacter) {
+              shouldIndentNextCharacter = false;
+              if (charIndex === chunk.start) {
+                chunk.prependRight(indentStr);
+              } else {
+                this._splitChunk(chunk, charIndex);
+                chunk = chunk.next;
+                chunk.prependRight(indentStr);
+              }
+            }
+          }
+          charIndex += 1;
+        }
+      }
+      charIndex = chunk.end;
+      chunk = chunk.next;
+    }
+    this.outro = this.outro.replace(pattern, replacer);
+    return this;
+  }
+  insert() {
+    throw new Error(
+      "magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)"
+    );
+  }
+  insertLeft(index, content) {
+    if (!warned.insertLeft) {
+      console.warn(
+        "magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead"
+      );
+      warned.insertLeft = true;
+    }
+    return this.appendLeft(index, content);
+  }
+  insertRight(index, content) {
+    if (!warned.insertRight) {
+      console.warn(
+        "magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead"
+      );
+      warned.insertRight = true;
+    }
+    return this.prependRight(index, content);
+  }
+  move(start, end, index) {
+    start = start + this.offset;
+    end = end + this.offset;
+    index = index + this.offset;
+    if (index >= start && index <= end) throw new Error("Cannot move a selection inside itself");
+    this._split(start);
+    this._split(end);
+    this._split(index);
+    const first = this.byStart[start];
+    const last = this.byEnd[end];
+    const oldLeft = first.previous;
+    const oldRight = last.next;
+    const newRight = this.byStart[index];
+    if (!newRight && last === this.lastChunk) return this;
+    const newLeft = newRight ? newRight.previous : this.lastChunk;
+    if (oldLeft) oldLeft.next = oldRight;
+    if (oldRight) oldRight.previous = oldLeft;
+    if (newLeft) newLeft.next = first;
+    if (newRight) newRight.previous = last;
+    if (!first.previous) this.firstChunk = last.next;
+    if (!last.next) {
+      this.lastChunk = first.previous;
+      this.lastChunk.next = null;
+    }
+    first.previous = newLeft;
+    last.next = newRight || null;
+    if (!newLeft) this.firstChunk = first;
+    if (!newRight) this.lastChunk = last;
+    return this;
+  }
+  overwrite(start, end, content, options) {
+    options = options || {};
+    return this.update(start, end, content, { ...options, overwrite: !options.contentOnly });
+  }
+  update(start, end, content, options) {
+    start = start + this.offset;
+    end = end + this.offset;
+    if (typeof content !== "string") throw new TypeError("replacement content must be a string");
+    if (this.original.length !== 0) {
+      while (start < 0) start += this.original.length;
+      while (end < 0) end += this.original.length;
+    }
+    if (end > this.original.length) throw new Error("end is out of bounds");
+    if (start === end)
+      throw new Error(
+        "Cannot overwrite a zero-length range \u2013 use appendLeft or prependRight instead"
+      );
+    this._split(start);
+    this._split(end);
+    if (options === true) {
+      if (!warned.storeName) {
+        console.warn(
+          "The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string"
+        );
+        warned.storeName = true;
+      }
+      options = { storeName: true };
+    }
+    const storeName = options !== void 0 ? options.storeName : false;
+    const overwrite = options !== void 0 ? options.overwrite : false;
+    if (storeName) {
+      const original = this.original.slice(start, end);
+      Object.defineProperty(this.storedNames, original, {
+        writable: true,
+        value: true,
+        enumerable: true
+      });
+    }
+    const first = this.byStart[start];
+    const last = this.byEnd[end];
+    if (first) {
+      let chunk = first;
+      while (chunk !== last) {
+        if (chunk.next !== this.byStart[chunk.end]) {
+          throw new Error("Cannot overwrite across a split point");
+        }
+        chunk = chunk.next;
+        chunk.edit("", false);
+      }
+      first.edit(content, storeName, !overwrite);
+    } else {
+      const newChunk = new Chunk(start, end, "").edit(content, storeName);
+      last.next = newChunk;
+      newChunk.previous = last;
+    }
+    return this;
+  }
+  prepend(content) {
+    if (typeof content !== "string") throw new TypeError("outro content must be a string");
+    this.intro = content + this.intro;
+    return this;
+  }
+  prependLeft(index, content) {
+    index = index + this.offset;
+    if (typeof content !== "string") throw new TypeError("inserted content must be a string");
+    this._split(index);
+    const chunk = this.byEnd[index];
+    if (chunk) {
+      chunk.prependLeft(content);
+    } else {
+      this.intro = content + this.intro;
+    }
+    return this;
+  }
+  prependRight(index, content) {
+    index = index + this.offset;
+    if (typeof content !== "string") throw new TypeError("inserted content must be a string");
+    this._split(index);
+    const chunk = this.byStart[index];
+    if (chunk) {
+      chunk.prependRight(content);
+    } else {
+      this.outro = content + this.outro;
+    }
+    return this;
+  }
+  remove(start, end) {
+    start = start + this.offset;
+    end = end + this.offset;
+    if (this.original.length !== 0) {
+      while (start < 0) start += this.original.length;
+      while (end < 0) end += this.original.length;
+    }
+    if (start === end) return this;
+    if (start < 0 || end > this.original.length) throw new Error("Character is out of bounds");
+    if (start > end) throw new Error("end must be greater than start");
+    this._split(start);
+    this._split(end);
+    let chunk = this.byStart[start];
+    while (chunk) {
+      chunk.intro = "";
+      chunk.outro = "";
+      chunk.edit("");
+      chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+    }
+    return this;
+  }
+  reset(start, end) {
+    start = start + this.offset;
+    end = end + this.offset;
+    if (this.original.length !== 0) {
+      while (start < 0) start += this.original.length;
+      while (end < 0) end += this.original.length;
+    }
+    if (start === end) return this;
+    if (start < 0 || end > this.original.length) throw new Error("Character is out of bounds");
+    if (start > end) throw new Error("end must be greater than start");
+    this._split(start);
+    this._split(end);
+    let chunk = this.byStart[start];
+    while (chunk) {
+      chunk.reset();
+      chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+    }
+    return this;
+  }
+  lastChar() {
+    if (this.outro.length) return this.outro[this.outro.length - 1];
+    let chunk = this.lastChunk;
+    do {
+      if (chunk.outro.length) return chunk.outro[chunk.outro.length - 1];
+      if (chunk.content.length) return chunk.content[chunk.content.length - 1];
+      if (chunk.intro.length) return chunk.intro[chunk.intro.length - 1];
+    } while (chunk = chunk.previous);
+    if (this.intro.length) return this.intro[this.intro.length - 1];
+    return "";
+  }
+  lastLine() {
+    let lineIndex = this.outro.lastIndexOf(n);
+    if (lineIndex !== -1) return this.outro.substr(lineIndex + 1);
+    let lineStr = this.outro;
+    let chunk = this.lastChunk;
+    do {
+      if (chunk.outro.length > 0) {
+        lineIndex = chunk.outro.lastIndexOf(n);
+        if (lineIndex !== -1) return chunk.outro.substr(lineIndex + 1) + lineStr;
+        lineStr = chunk.outro + lineStr;
+      }
+      if (chunk.content.length > 0) {
+        lineIndex = chunk.content.lastIndexOf(n);
+        if (lineIndex !== -1) return chunk.content.substr(lineIndex + 1) + lineStr;
+        lineStr = chunk.content + lineStr;
+      }
+      if (chunk.intro.length > 0) {
+        lineIndex = chunk.intro.lastIndexOf(n);
+        if (lineIndex !== -1) return chunk.intro.substr(lineIndex + 1) + lineStr;
+        lineStr = chunk.intro + lineStr;
+      }
+    } while (chunk = chunk.previous);
+    lineIndex = this.intro.lastIndexOf(n);
+    if (lineIndex !== -1) return this.intro.substr(lineIndex + 1) + lineStr;
+    return this.intro + lineStr;
+  }
+  slice(start = 0, end = this.original.length - this.offset) {
+    start = start + this.offset;
+    end = end + this.offset;
+    if (this.original.length !== 0) {
+      while (start < 0) start += this.original.length;
+      while (end < 0) end += this.original.length;
+    }
+    let result = "";
+    let chunk = this.firstChunk;
+    while (chunk && (chunk.start > start || chunk.end <= start)) {
+      if (chunk.start < end && chunk.end >= end) {
+        return result;
+      }
+      chunk = chunk.next;
+    }
+    if (chunk && chunk.edited && chunk.start !== start)
+      throw new Error(`Cannot use replaced character ${start} as slice start anchor.`);
+    const startChunk = chunk;
+    while (chunk) {
+      if (chunk.intro && (startChunk !== chunk || chunk.start === start)) {
+        result += chunk.intro;
+      }
+      const containsEnd = chunk.start < end && chunk.end >= end;
+      if (containsEnd && chunk.edited && chunk.end !== end)
+        throw new Error(`Cannot use replaced character ${end} as slice end anchor.`);
+      const sliceStart = startChunk === chunk ? start - chunk.start : 0;
+      const sliceEnd = containsEnd ? chunk.content.length + end - chunk.end : chunk.content.length;
+      result += chunk.content.slice(sliceStart, sliceEnd);
+      if (chunk.outro && (!containsEnd || chunk.end === end)) {
+        result += chunk.outro;
+      }
+      if (containsEnd) {
+        break;
+      }
+      chunk = chunk.next;
+    }
+    return result;
+  }
+  // TODO deprecate this? not really very useful
+  snip(start, end) {
+    const clone = this.clone();
+    clone.remove(0, start);
+    clone.remove(end, clone.original.length);
+    return clone;
+  }
+  _split(index) {
+    if (this.byStart[index] || this.byEnd[index]) return;
+    let chunk = this.lastSearchedChunk;
+    const searchForward = index > chunk.end;
+    while (chunk) {
+      if (chunk.contains(index)) return this._splitChunk(chunk, index);
+      chunk = searchForward ? this.byStart[chunk.end] : this.byEnd[chunk.start];
+    }
+  }
+  _splitChunk(chunk, index) {
+    if (chunk.edited && chunk.content.length) {
+      const loc = getLocator(this.original)(index);
+      throw new Error(
+        `Cannot split a chunk that has already been edited (${loc.line}:${loc.column} \u2013 "${chunk.original}")`
+      );
+    }
+    const newChunk = chunk.split(index);
+    this.byEnd[index] = chunk;
+    this.byStart[index] = newChunk;
+    this.byEnd[newChunk.end] = newChunk;
+    if (chunk === this.lastChunk) this.lastChunk = newChunk;
+    this.lastSearchedChunk = chunk;
+    return true;
+  }
+  toString() {
+    let str = this.intro;
+    let chunk = this.firstChunk;
+    while (chunk) {
+      str += chunk.toString();
+      chunk = chunk.next;
+    }
+    return str + this.outro;
+  }
+  isEmpty() {
+    let chunk = this.firstChunk;
+    do {
+      if (chunk.intro.length && chunk.intro.trim() || chunk.content.length && chunk.content.trim() || chunk.outro.length && chunk.outro.trim())
+        return false;
+    } while (chunk = chunk.next);
+    return true;
+  }
+  length() {
+    let chunk = this.firstChunk;
+    let length = 0;
+    do {
+      length += chunk.intro.length + chunk.content.length + chunk.outro.length;
+    } while (chunk = chunk.next);
+    return length;
+  }
+  trimLines() {
+    return this.trim("[\\r\\n]");
+  }
+  trim(charType) {
+    return this.trimStart(charType).trimEnd(charType);
+  }
+  trimEndAborted(charType) {
+    const rx = new RegExp((charType || "\\s") + "+$");
+    this.outro = this.outro.replace(rx, "");
+    if (this.outro.length) return true;
+    let chunk = this.lastChunk;
+    do {
+      const end = chunk.end;
+      const aborted = chunk.trimEnd(rx);
+      if (chunk.end !== end) {
+        if (this.lastChunk === chunk) {
+          this.lastChunk = chunk.next;
+        }
+        this.byEnd[chunk.end] = chunk;
+        this.byStart[chunk.next.start] = chunk.next;
+        this.byEnd[chunk.next.end] = chunk.next;
+      }
+      if (aborted) return true;
+      chunk = chunk.previous;
+    } while (chunk);
+    return false;
+  }
+  trimEnd(charType) {
+    this.trimEndAborted(charType);
+    return this;
+  }
+  trimStartAborted(charType) {
+    const rx = new RegExp("^" + (charType || "\\s") + "+");
+    this.intro = this.intro.replace(rx, "");
+    if (this.intro.length) return true;
+    let chunk = this.firstChunk;
+    do {
+      const end = chunk.end;
+      const aborted = chunk.trimStart(rx);
+      if (chunk.end !== end) {
+        if (chunk === this.lastChunk) this.lastChunk = chunk.next;
+        this.byEnd[chunk.end] = chunk;
+        this.byStart[chunk.next.start] = chunk.next;
+        this.byEnd[chunk.next.end] = chunk.next;
+      }
+      if (aborted) return true;
+      chunk = chunk.next;
+    } while (chunk);
+    return false;
+  }
+  trimStart(charType) {
+    this.trimStartAborted(charType);
+    return this;
+  }
+  hasChanged() {
+    return this.original !== this.toString();
+  }
+  _replaceRegexp(searchValue, replacement) {
+    function getReplacement(match, str) {
+      if (typeof replacement === "string") {
+        return replacement.replace(/\$(\$|&|\d+)/g, (_, i) => {
+          if (i === "$") return "$";
+          if (i === "&") return match[0];
+          const num = +i;
+          if (num < match.length) return match[+i];
+          return `$${i}`;
+        });
+      } else {
+        return replacement(...match, match.index, str, match.groups);
+      }
+    }
+    function matchAll(re, str) {
+      let match;
+      const matches = [];
+      while (match = re.exec(str)) {
+        matches.push(match);
+      }
+      return matches;
+    }
+    if (searchValue.global) {
+      const matches = matchAll(searchValue, this.original);
+      matches.forEach((match) => {
+        if (match.index != null) {
+          const replacement2 = getReplacement(match, this.original);
+          if (replacement2 !== match[0]) {
+            this.overwrite(match.index, match.index + match[0].length, replacement2);
+          }
+        }
+      });
+    } else {
+      const match = this.original.match(searchValue);
+      if (match && match.index != null) {
+        const replacement2 = getReplacement(match, this.original);
+        if (replacement2 !== match[0]) {
+          this.overwrite(match.index, match.index + match[0].length, replacement2);
+        }
+      }
+    }
+    return this;
+  }
+  _replaceString(string, replacement) {
+    const { original } = this;
+    const index = original.indexOf(string);
+    if (index !== -1) {
+      this.overwrite(index, index + string.length, replacement);
+    }
+    return this;
+  }
+  replace(searchValue, replacement) {
+    if (typeof searchValue === "string") {
+      return this._replaceString(searchValue, replacement);
+    }
+    return this._replaceRegexp(searchValue, replacement);
+  }
+  _replaceAllString(string, replacement) {
+    const { original } = this;
+    const stringLength = string.length;
+    for (let index = original.indexOf(string); index !== -1; index = original.indexOf(string, index + stringLength)) {
+      const previous = original.slice(index, index + stringLength);
+      if (previous !== replacement) this.overwrite(index, index + stringLength, replacement);
+    }
+    return this;
+  }
+  replaceAll(searchValue, replacement) {
+    if (typeof searchValue === "string") {
+      return this._replaceAllString(searchValue, replacement);
+    }
+    if (!searchValue.global) {
+      throw new TypeError(
+        "MagicString.prototype.replaceAll called with a non-global RegExp argument"
+      );
+    }
+    return this._replaceRegexp(searchValue, replacement);
+  }
+};
+
+// src/node-js-compat.ts
+import { getNodeCompat } from "miniflare";
+import * as unenv from "unenv";
+var require2 = createRequire(import.meta.url);
+var preset = unenv.env(unenv.nodeless, unenv.cloudflare);
+var CLOUDFLARE_VIRTUAL_PREFIX = "\0cloudflare-";
+function isNodeCompat({
+  compatibility_date,
+  compatibility_flags
+}) {
+  const nodeCompatMode = getNodeCompat(
+    compatibility_date,
+    compatibility_flags ?? []
+  ).mode;
+  if (nodeCompatMode === "v2") {
+    return true;
+  }
+  if (nodeCompatMode === "legacy") {
+    throw new Error(
+      "Unsupported Node.js compat mode (legacy). Remove the `node_compat` setting and add the `nodejs_compat` flag instead."
+    );
+  }
+  if (nodeCompatMode === "v1") {
+    throw new Error(
+      `Unsupported Node.js compat mode (v1). Only the v2 mode is supported, either change your compat date to "2024-09-23" or later, or set the "nodejs_compat_v2" compatibility flag`
+    );
+  }
+  return false;
+}
+function injectGlobalCode(id, code, workerConfig) {
+  if (!isNodeCompat(workerConfig)) {
+    return;
+  }
+  const injectedCode = Object.entries(preset.inject).map(([globalName, globalInject]) => {
+    if (typeof globalInject === "string") {
+      const moduleSpecifier2 = globalInject;
+      return `import var_${globalName} from "${moduleSpecifier2}";
+globalThis.${globalName} = var_${globalName};
+`;
+    }
+    const [moduleSpecifier, exportName] = globalInject;
+    return `import var_${globalName} from "${moduleSpecifier}";
+globalThis.${globalName} = var_${globalName}.${exportName};
+`;
+  }).join("\n");
+  const modified = new MagicString(code);
+  modified.prepend(injectedCode);
+  return {
+    code: modified.toString(),
+    map: modified.generateMap({ hires: "boundary", source: id })
+  };
+}
+function getNodeCompatAliases() {
+  const aliases = {};
+  Object.keys(preset.alias).forEach((key) => {
+    if (!preset.external.includes(key)) {
+      aliases[key] = CLOUDFLARE_VIRTUAL_PREFIX + key;
+    }
+  });
+  return aliases;
+}
+function resolveNodeCompatId(environment, workerConfig, id) {
+  const aliased = resolveNodeAliases(id, workerConfig) ?? id;
+  if (aliased.startsWith("unenv/")) {
+    const resolvedDep = require2.resolve(aliased).replace(/\.cjs$/, ".mjs");
+    if (environment.mode === "dev" && environment.depsOptimizer) {
+      const dep = environment.depsOptimizer.registerMissingImport(
+        aliased,
+        resolvedDep
+      );
+      return dep.id;
+    } else {
+      return resolvedDep;
+    }
+  }
+}
+function getNodeCompatExternals() {
+  return preset.external;
+}
+function resolveNodeAliases(source, workerConfig) {
+  if (!source.startsWith(CLOUDFLARE_VIRTUAL_PREFIX) || !isNodeCompat(workerConfig)) {
+    return;
+  }
+  const from = source.slice(CLOUDFLARE_VIRTUAL_PREFIX.length);
+  const alias = preset.alias[from];
+  if (alias && preset.external.includes(alias)) {
+    throw new Error(`Alias to external: ${source} -> ${alias}`);
+  }
+  return alias;
+}
+
+// src/shared.ts
+var UNKNOWN_HOST = "http://localhost";
+var INIT_PATH = "/__vite_plugin_cloudflare_init__";
+
+// src/utils.ts
+import * as path from "node:path";
+import { Request as MiniflareRequest } from "miniflare";
+import "vite";
+function getOutputDirectory(userConfig, environmentName) {
+  const rootOutputDirectory = userConfig.build?.outDir ?? "dist";
+  return userConfig.environments?.[environmentName]?.build?.outDir ?? path.join(rootOutputDirectory, environmentName);
+}
+function toMiniflareRequest(request) {
+  return new MiniflareRequest(request.url, {
+    method: request.method,
+    headers: [["accept-encoding", "identity"], ...request.headers],
+    body: request.body,
+    duplex: "half"
+  });
+}
+function nodeHeadersToWebHeaders(nodeHeaders) {
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(nodeHeaders)) {
+    if (typeof value === "string") {
+      headers.append(key, value);
+    } else if (Array.isArray(value)) {
+      for (const item of value) {
+        headers.append(key, item);
+      }
+    }
+  }
+  return headers;
+}
+
+// src/cloudflare-environment.ts
+var webSocketUndefinedError = "The WebSocket is undefined";
+function createHotChannel(webSocketContainer) {
+  const listenersMap = /* @__PURE__ */ new Map();
+  const client = {
+    send(payload) {
+      const webSocket = webSocketContainer.webSocket;
+      assert(webSocket, webSocketUndefinedError);
+      webSocket.send(JSON.stringify(payload));
+    }
+  };
+  function onMessage(event) {
+    const payload = JSON.parse(event.data.toString());
+    const listeners = listenersMap.get(payload.event) ?? /* @__PURE__ */ new Set();
+    for (const listener of listeners) {
+      listener(payload.data, client);
+    }
+  }
+  return {
+    send(payload) {
+      const webSocket = webSocketContainer.webSocket;
+      assert(webSocket, webSocketUndefinedError);
+      webSocket.send(JSON.stringify(payload));
+    },
+    on(event, listener) {
+      const listeners = listenersMap.get(event) ?? /* @__PURE__ */ new Set();
+      listeners.add(listener);
+      listenersMap.set(event, listeners);
+    },
+    off(event, listener) {
+      listenersMap.get(event)?.delete(listener);
+    },
+    listen() {
+      const webSocket = webSocketContainer.webSocket;
+      assert(webSocket, webSocketUndefinedError);
+      webSocket.addEventListener("message", onMessage);
+    },
+    close() {
+      const webSocket = webSocketContainer.webSocket;
+      assert(webSocket, webSocketUndefinedError);
+      webSocket.removeEventListener("message", onMessage);
+    }
+  };
+}
+var CloudflareDevEnvironment = class extends vite2.DevEnvironment {
+  #webSocketContainer;
+  #worker;
+  constructor(name2, config) {
+    const webSocketContainer = {};
+    super(name2, config, {
+      hot: true,
+      transport: createHotChannel(webSocketContainer)
+    });
+    this.#webSocketContainer = webSocketContainer;
+  }
+  async initRunner(worker) {
+    this.#worker = worker;
+    const response = await this.#worker.fetch(
+      new URL(INIT_PATH, UNKNOWN_HOST),
+      {
+        headers: {
+          upgrade: "websocket"
+        }
+      }
+    );
+    assert(response.ok, "Failed to initialize module runner");
+    const webSocket = response.webSocket;
+    assert(webSocket, "Failed to establish WebSocket");
+    webSocket.accept();
+    this.#webSocketContainer.webSocket = webSocket;
+  }
+};
+var cloudflareBuiltInModules = [
+  "cloudflare:email",
+  "cloudflare:sockets",
+  "cloudflare:workers",
+  "cloudflare:workflows"
+];
+function createCloudflareEnvironmentOptions(workerConfig, userConfig, environmentName) {
+  return {
+    resolve: {
+      // Note: in order for ssr pre-bundling to take effect we need to ask vite to treat all
+      //       dependencies as not external
+      noExternal: true,
+      // We want to use `workerd` package exports if available (e.g. for postgres).
+      conditions: ["workerd", "module", "browser", "development|production"]
+    },
+    dev: {
+      createEnvironment(name2, config) {
+        return new CloudflareDevEnvironment(name2, config);
+      }
+    },
+    build: {
+      createEnvironment(name2, config) {
+        return new vite2.BuildEnvironment(name2, config);
+      },
+      outDir: getOutputDirectory(userConfig, environmentName),
+      ssr: true,
+      rollupOptions: {
+        // Note: vite starts dev pre-bundling crawling from either optimizeDeps.entries or rollupOptions.input
+        //       so the input value here serves both as the build input as well as the starting point for
+        //       dev pre-bundling crawling (were we not to set this input field we'd have to appropriately set
+        //       optimizeDeps.entries in the dev config)
+        input: workerConfig.main,
+        external: [...cloudflareBuiltInModules, ...getNodeCompatExternals()]
+      }
+    },
+    optimizeDeps: {
+      // Note: ssr pre-bundling is opt-in and we need to enable it by setting `noDiscovery` to false
+      noDiscovery: false,
+      exclude: [
+        ...cloudflareBuiltInModules,
+        // we have to exclude all node modules to work in dev-mode not just the unenv externals...
+        ...builtinModules.concat(builtinModules.map((m) => `node:${m}`))
+      ],
+      esbuildOptions: {
+        platform: "neutral",
+        resolveExtensions: [
+          ".mjs",
+          ".js",
+          ".mts",
+          ".ts",
+          ".jsx",
+          ".tsx",
+          ".json",
+          ".cjs",
+          ".cts",
+          ".ctx"
+        ]
+      }
+    },
+    keepProcessEnv: false
+  };
+}
+function initRunners(resolvedPluginConfig, viteDevServer, miniflare) {
+  if (resolvedPluginConfig.type === "assets-only") {
+    return;
+  }
+  return Promise.all(
+    Object.entries(resolvedPluginConfig.workers).map(
+      async ([environmentName, workerConfig]) => {
+        const worker = await miniflare.getWorker(workerConfig.name);
+        return viteDevServer.environments[environmentName].initRunner(worker);
+      }
+    )
+  );
+}
+
+// src/deploy-config.ts
+import assert2 from "node:assert";
+import * as fs from "node:fs";
+import * as path2 from "node:path";
+import "vite";
+function getDeployConfigPath(root) {
+  return path2.resolve(root, ".wrangler", "deploy", "config.json");
+}
+function getWorkerConfigPaths(root) {
+  const deployConfigPath = getDeployConfigPath(root);
+  const deployConfig = JSON.parse(
+    fs.readFileSync(deployConfigPath, "utf-8")
+  );
+  return [
+    { configPath: deployConfig.configPath },
+    ...deployConfig.auxiliaryWorkers
+  ].map(
+    ({ configPath }) => path2.resolve(path2.dirname(deployConfigPath), configPath)
+  );
+}
+function getRelativePathToWorkerConfig(deployConfigDirectory, root, outputDirectory) {
+  return path2.relative(
+    deployConfigDirectory,
+    path2.resolve(root, outputDirectory, "wrangler.json")
+  );
+}
+function writeDeployConfig(resolvedPluginConfig, resolvedViteConfig) {
+  const deployConfigPath = getDeployConfigPath(resolvedViteConfig.root);
+  const deployConfigDirectory = path2.dirname(deployConfigPath);
+  fs.mkdirSync(deployConfigDirectory, { recursive: true });
+  if (resolvedPluginConfig.type === "assets-only") {
+    const clientOutputDirectory = resolvedViteConfig.environments.client?.build.outDir;
+    assert2(
+      clientOutputDirectory,
+      "Unexpected error: client environment output directory is undefined"
+    );
+    const deployConfig = {
+      configPath: getRelativePathToWorkerConfig(
+        deployConfigDirectory,
+        resolvedViteConfig.root,
+        clientOutputDirectory
+      ),
+      auxiliaryWorkers: []
+    };
+    fs.writeFileSync(deployConfigPath, JSON.stringify(deployConfig));
+  } else {
+    const workerConfigPaths = Object.fromEntries(
+      Object.keys(resolvedPluginConfig.workers).map((environmentName) => {
+        const outputDirectory = resolvedViteConfig.environments[environmentName]?.build.outDir;
+        assert2(
+          outputDirectory,
+          `Unexpected error: ${environmentName} environment output directory is undefined`
+        );
+        return [
+          environmentName,
+          getRelativePathToWorkerConfig(
+            deployConfigDirectory,
+            resolvedViteConfig.root,
+            outputDirectory
+          )
+        ];
+      })
+    );
+    const { entryWorkerEnvironmentName } = resolvedPluginConfig;
+    const configPath = workerConfigPaths[entryWorkerEnvironmentName];
+    assert2(
+      configPath,
+      `Unexpected error: ${entryWorkerEnvironmentName} environment output directory is undefined`
+    );
+    const auxiliaryWorkers = Object.entries(workerConfigPaths).filter(
+      ([environmentName]) => environmentName !== entryWorkerEnvironmentName
+    ).map(([_, configPath2]) => ({ configPath: configPath2 }));
+    const deployConfig = { configPath, auxiliaryWorkers };
+    fs.writeFileSync(deployConfigPath, JSON.stringify(deployConfig));
+  }
+}
+
+// src/dev.ts
+import assert3 from "node:assert";
+
+// src/constants.ts
+var ROUTER_WORKER_NAME = "__router-worker__";
+var ASSET_WORKER_NAME = "__asset-worker__";
+var ASSET_WORKERS_COMPATIBILITY_DATE = "2024-10-04";
+
+// src/dev.ts
+function getDevEntryWorker(resolvedPluginConfig, miniflare) {
+  const entryWorkerConfig = resolvedPluginConfig.type === "assets-only" ? resolvedPluginConfig.config : resolvedPluginConfig.workers[resolvedPluginConfig.entryWorkerEnvironmentName];
+  assert3(entryWorkerConfig, "Unexpected error: No entry worker configuration");
+  return entryWorkerConfig.assets ? miniflare.getWorker(ROUTER_WORKER_NAME) : miniflare.getWorker(entryWorkerConfig.name);
+}
+
+// src/miniflare-options.ts
+import assert4 from "node:assert";
+import * as fs2 from "node:fs";
+import * as fsp from "node:fs/promises";
+import * as path3 from "node:path";
+import { fileURLToPath } from "node:url";
+import { Log, LogLevel, Response as MiniflareResponse } from "miniflare";
+import "vite";
+import {
+  unstable_getMiniflareWorkerOptions,
+  unstable_readConfig
+} from "wrangler";
+function getPersistence(root, persistState) {
+  if (persistState === false) {
+    return {};
+  }
+  const defaultPersistPath = ".wrangler/state";
+  const persistPath = path3.resolve(
+    root,
+    typeof persistState === "object" ? persistState.path : defaultPersistPath,
+    "v3"
+  );
+  return {
+    cachePersist: path3.join(persistPath, "cache"),
+    d1Persist: path3.join(persistPath, "d1"),
+    durableObjectsPersist: path3.join(persistPath, "do"),
+    kvPersist: path3.join(persistPath, "kv"),
+    r2Persist: path3.join(persistPath, "r2"),
+    workflowsPersist: path3.join(persistPath, "workflows")
+  };
+}
+function missingWorkerErrorMessage(workerName) {
+  return `${workerName} does not match a worker name.`;
+}
+function getWorkerToWorkerEntrypointNamesMap(workers) {
+  const workerToWorkerEntrypointNamesMap = new Map(
+    workers.map((workerOptions) => [workerOptions.name, /* @__PURE__ */ new Set()])
+  );
+  for (const worker of workers) {
+    for (const value of Object.values(worker.serviceBindings ?? {})) {
+      if (typeof value === "object" && "name" in value && typeof value.name === "string" && value.entrypoint !== void 0 && value.entrypoint !== "default") {
+        const entrypointNames = workerToWorkerEntrypointNamesMap.get(
+          value.name
+        );
+        assert4(entrypointNames, missingWorkerErrorMessage(value.name));
+        entrypointNames.add(value.entrypoint);
+      }
+    }
+  }
+  return workerToWorkerEntrypointNamesMap;
+}
+function getWorkerToDurableObjectClassNamesMap(workers) {
+  const workerToDurableObjectClassNamesMap = new Map(
+    workers.map((workerOptions) => [workerOptions.name, /* @__PURE__ */ new Set()])
+  );
+  for (const worker of workers) {
+    for (const value of Object.values(worker.durableObjects ?? {})) {
+      if (typeof value === "string") {
+        const classNames = workerToDurableObjectClassNamesMap.get(worker.name);
+        assert4(classNames, missingWorkerErrorMessage(worker.name));
+        classNames.add(value);
+      } else if (typeof value === "object") {
+        if (value.scriptName) {
+          const classNames = workerToDurableObjectClassNamesMap.get(
+            value.scriptName
+          );
+          assert4(classNames, missingWorkerErrorMessage(value.scriptName));
+          classNames.add(value.className);
+        } else {
+          const classNames = workerToDurableObjectClassNamesMap.get(
+            worker.name
+          );
+          assert4(classNames, missingWorkerErrorMessage(worker.name));
+          classNames.add(value.className);
+        }
+      }
+    }
+  }
+  return workerToDurableObjectClassNamesMap;
+}
+function getWorkerToWorkflowEntrypointClassNamesMap(workers) {
+  const workerToWorkflowEntrypointClassNamesMap = new Map(
+    workers.map((workerOptions) => [workerOptions.name, /* @__PURE__ */ new Set()])
+  );
+  for (const worker of workers) {
+    for (const value of Object.values(worker.workflows ?? {})) {
+      if (value.scriptName) {
+        const classNames = workerToWorkflowEntrypointClassNamesMap.get(
+          value.scriptName
+        );
+        assert4(classNames, missingWorkerErrorMessage(value.scriptName));
+        classNames.add(value.className);
+      } else {
+        const classNames = workerToWorkflowEntrypointClassNamesMap.get(
+          worker.name
+        );
+        assert4(classNames, missingWorkerErrorMessage(worker.name));
+        classNames.add(value.className);
+      }
+    }
+  }
+  return workerToWorkflowEntrypointClassNamesMap;
+}
+var miniflareModulesRoot = process.platform === "win32" ? "Z:\\" : "/";
+var ROUTER_WORKER_PATH = "./asset-workers/router-worker.js";
+var ASSET_WORKER_PATH = "./asset-workers/asset-worker.js";
+var WRAPPER_PATH = "__VITE_WORKER_ENTRY__";
+var RUNNER_PATH = "./runner-worker/index.js";
+function getEntryWorkerConfig(resolvedPluginConfig) {
+  if (resolvedPluginConfig.type === "assets-only") {
+    return;
+  }
+  return resolvedPluginConfig.workers[resolvedPluginConfig.entryWorkerEnvironmentName];
+}
+function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
+  const resolvedViteConfig = viteDevServer.config;
+  const entryWorkerConfig = getEntryWorkerConfig(resolvedPluginConfig);
+  const assetsConfig = resolvedPluginConfig.type === "assets-only" ? resolvedPluginConfig.config.assets : entryWorkerConfig?.assets;
+  const assetWorkers = [
+    {
+      name: ROUTER_WORKER_NAME,
+      compatibilityDate: ASSET_WORKERS_COMPATIBILITY_DATE,
+      modulesRoot: miniflareModulesRoot,
+      modules: [
+        {
+          type: "ESModule",
+          path: path3.join(miniflareModulesRoot, ROUTER_WORKER_PATH),
+          contents: fs2.readFileSync(
+            fileURLToPath(new URL(ROUTER_WORKER_PATH, import.meta.url))
+          )
+        }
+      ],
+      bindings: {
+        CONFIG: {
+          has_user_worker: resolvedPluginConfig.type === "workers"
+        }
+      },
+      serviceBindings: {
+        ASSET_WORKER: ASSET_WORKER_NAME,
+        ...entryWorkerConfig ? { USER_WORKER: entryWorkerConfig.name } : {}
+      }
+    },
+    {
+      name: ASSET_WORKER_NAME,
+      compatibilityDate: ASSET_WORKERS_COMPATIBILITY_DATE,
+      modulesRoot: miniflareModulesRoot,
+      modules: [
+        {
+          type: "ESModule",
+          path: path3.join(miniflareModulesRoot, ASSET_WORKER_PATH),
+          contents: fs2.readFileSync(
+            fileURLToPath(new URL(ASSET_WORKER_PATH, import.meta.url))
+          )
+        }
+      ],
+      bindings: {
+        CONFIG: {
+          ...assetsConfig?.html_handling ? { html_handling: assetsConfig.html_handling } : {},
+          ...assetsConfig?.not_found_handling ? { not_found_handling: assetsConfig.not_found_handling } : {}
+        }
+      },
+      serviceBindings: {
+        __VITE_ASSET_EXISTS__: async (request) => {
+          const { pathname } = new URL(request.url);
+          const filePath = path3.join(resolvedViteConfig.root, pathname);
+          let exists;
+          try {
+            exists = fs2.statSync(filePath).isFile();
+          } catch (error) {
+            exists = false;
+          }
+          return MiniflareResponse.json(exists);
+        },
+        __VITE_FETCH_ASSET__: async (request) => {
+          const { pathname } = new URL(request.url);
+          const filePath = path3.join(resolvedViteConfig.root, pathname);
+          try {
+            let html = await fsp.readFile(filePath, "utf-8");
+            html = await viteDevServer.transformIndexHtml(pathname, html);
+            return new MiniflareResponse(html, {
+              headers: { "Content-Type": "text/html" }
+            });
+          } catch (error) {
+            throw new Error(`Unexpected error. Failed to load ${pathname}`);
+          }
+        }
+      }
+    }
+  ];
+  const userWorkers = resolvedPluginConfig.type === "workers" ? Object.entries(resolvedPluginConfig.workers).map(
+    ([environmentName, workerConfig]) => {
+      const miniflareWorkerOptions = unstable_getMiniflareWorkerOptions({
+        ...workerConfig,
+        assets: void 0
+      });
+      const { ratelimits, ...workerOptions } = miniflareWorkerOptions.workerOptions;
+      return {
+        ...workerOptions,
+        // We have to add the name again because `unstable_getMiniflareWorkerOptions` sets it to `undefined`
+        name: workerConfig.name,
+        modulesRoot: miniflareModulesRoot,
+        unsafeEvalBinding: "__VITE_UNSAFE_EVAL__",
+        bindings: {
+          ...workerOptions.bindings,
+          __VITE_ROOT__: resolvedViteConfig.root,
+          __VITE_ENTRY_PATH__: workerConfig.main
+        },
+        serviceBindings: {
+          ...workerOptions.serviceBindings,
+          ...environmentName === resolvedPluginConfig.entryWorkerEnvironmentName && workerConfig.assets?.binding ? {
+            [workerConfig.assets.binding]: ASSET_WORKER_NAME
+          } : {},
+          __VITE_INVOKE_MODULE__: async (request) => {
+            const payload = await request.json();
+            const invokePayloadData = payload.data;
+            assert4(
+              invokePayloadData.name === "fetchModule",
+              `Invalid invoke event: ${invokePayloadData.name}`
+            );
+            const [moduleId] = invokePayloadData.data;
+            if (moduleId.startsWith("cloudflare:")) {
+              const result2 = {
+                externalize: moduleId,
+                type: "builtin"
+              };
+              return new MiniflareResponse(JSON.stringify({ result: result2 }));
+            }
+            const devEnvironment = viteDevServer.environments[environmentName];
+            const result = await devEnvironment.hot.handleInvoke(payload);
+            return new MiniflareResponse(JSON.stringify(result));
+          }
+        }
+      };
+    }
+  ) : [];
+  const workerToWorkerEntrypointNamesMap = getWorkerToWorkerEntrypointNamesMap(userWorkers);
+  const workerToDurableObjectClassNamesMap = getWorkerToDurableObjectClassNamesMap(userWorkers);
+  const workerToWorkflowEntrypointClassNamesMap = getWorkerToWorkflowEntrypointClassNamesMap(userWorkers);
+  const logger = new ViteMiniflareLogger(resolvedViteConfig);
+  return {
+    log: logger,
+    handleRuntimeStdio(stdout, stderr) {
+      const decoder = new TextDecoder();
+      stdout.forEach((data) => logger.info(decoder.decode(data)));
+      stderr.forEach(
+        (error) => logger.logWithLevel(LogLevel.ERROR, decoder.decode(error))
+      );
+    },
+    ...getPersistence(
+      resolvedViteConfig.root,
+      resolvedPluginConfig.persistState
+    ),
+    workers: [
+      ...assetWorkers,
+      ...userWorkers.map((workerOptions) => {
+        const wrappers = [
+          `import { createWorkerEntrypointWrapper, createDurableObjectWrapper, createWorkflowEntrypointWrapper } from '${RUNNER_PATH}';`,
+          `export default createWorkerEntrypointWrapper('default');`
+        ];
+        const workerEntrypointNames = workerToWorkerEntrypointNamesMap.get(
+          workerOptions.name
+        );
+        assert4(
+          workerEntrypointNames,
+          `WorkerEntrypoint names not found for worker ${workerOptions.name}`
+        );
+        for (const entrypointName of [...workerEntrypointNames].sort()) {
+          wrappers.push(
+            `export const ${entrypointName} = createWorkerEntrypointWrapper('${entrypointName}');`
+          );
+        }
+        const durableObjectClassNames = workerToDurableObjectClassNamesMap.get(
+          workerOptions.name
+        );
+        assert4(
+          durableObjectClassNames,
+          `DurableObject class names not found for worker ${workerOptions.name}`
+        );
+        for (const className of [...durableObjectClassNames].sort()) {
+          wrappers.push(
+            `export const ${className} = createDurableObjectWrapper('${className}');`
+          );
+        }
+        const workflowEntrypointClassNames = workerToWorkflowEntrypointClassNamesMap.get(workerOptions.name);
+        assert4(
+          workflowEntrypointClassNames,
+          `WorkflowEntrypoint class names not found for worker ${workerOptions.name}`
+        );
+        for (const className of [...workflowEntrypointClassNames].sort()) {
+          wrappers.push(
+            `export const ${className} = createWorkflowEntrypointWrapper('${className}');`
+          );
+        }
+        return {
+          ...workerOptions,
+          modules: [
+            {
+              type: "ESModule",
+              path: path3.join(miniflareModulesRoot, WRAPPER_PATH),
+              contents: wrappers.join("\n")
+            },
+            {
+              type: "ESModule",
+              path: path3.join(miniflareModulesRoot, RUNNER_PATH),
+              contents: fs2.readFileSync(
+                fileURLToPath(new URL(RUNNER_PATH, import.meta.url))
+              )
+            }
+          ]
+        };
+      })
+    ]
+  };
+}
+function getPreviewMiniflareOptions(vitePreviewServer, persistState) {
+  const resolvedViteConfig = vitePreviewServer.config;
+  const configPaths = getWorkerConfigPaths(resolvedViteConfig.root);
+  const workerConfigs = configPaths.map(
+    (configPath) => unstable_readConfig({ config: configPath })
+  );
+  const workers = workerConfigs.map((config) => {
+    const miniflareWorkerOptions = unstable_getMiniflareWorkerOptions(config);
+    const { ratelimits, ...workerOptions } = miniflareWorkerOptions.workerOptions;
+    return {
+      ...workerOptions,
+      // We have to add the name again because `unstable_getMiniflareWorkerOptions` sets it to `undefined`
+      name: config.name,
+      modules: true,
+      ...miniflareWorkerOptions.main ? { scriptPath: miniflareWorkerOptions.main } : { script: "" }
+    };
+  });
+  const logger = new ViteMiniflareLogger(resolvedViteConfig);
+  return {
+    log: logger,
+    handleRuntimeStdio(stdout, stderr) {
+      const decoder = new TextDecoder();
+      stdout.forEach((data) => logger.info(decoder.decode(data)));
+      stderr.forEach(
+        (error) => logger.logWithLevel(LogLevel.ERROR, decoder.decode(error))
+      );
+    },
+    ...getPersistence(resolvedViteConfig.root, persistState),
+    workers
+  };
+}
+var ViteMiniflareLogger = class extends Log {
+  logger;
+  constructor(config) {
+    super(miniflareLogLevelFromViteLogLevel(config.logLevel));
+    this.logger = config.logger;
+  }
+  logWithLevel(level, message) {
+    if (/^Ready on http/.test(message)) {
+      level = LogLevel.DEBUG;
+    }
+    switch (level) {
+      case LogLevel.ERROR:
+        return this.logger.error(message);
+      case LogLevel.WARN:
+        return this.logger.warn(message);
+      case LogLevel.INFO:
+        return this.logger.info(message);
+    }
+  }
+};
+function miniflareLogLevelFromViteLogLevel(level = "info") {
+  switch (level) {
+    case "error":
+      return LogLevel.ERROR;
+    case "warn":
+      return LogLevel.WARN;
+    case "info":
+      return LogLevel.INFO;
+    case "silent":
+      return LogLevel.NONE;
+  }
+}
+
+// src/plugin-config.ts
+import assert6 from "node:assert";
+import * as path5 from "node:path";
+import * as vite5 from "vite";
+
+// src/workers-configs.ts
+import assert5 from "node:assert";
+import * as fs3 from "node:fs";
+import * as path4 from "node:path";
+import { unstable_readConfig as unstable_readConfig2 } from "wrangler";
+
+// package.json
+var name = "@cloudflare/vite-plugin";
+
+// src/workers-configs.ts
+var nonApplicableWorkerConfigs = {
+  /**
+   * Object containing configs that have a vite replacement, the object's field contain details about the config's replacement
+   */
+  replacedByVite: {
+    alias: {
+      viteReplacement: "resolve.alias",
+      viteDocs: "https://vite.dev/config/shared-options.html#resolve-alias"
+    },
+    define: {
+      viteReplacement: "define",
+      viteDocs: "https://vite.dev/config/shared-options.html#define"
+    },
+    minify: {
+      viteReplacement: "build.minify",
+      viteDocs: "https://vite.dev/config/build-options.html#build-minify"
+    }
+  },
+  /**
+   * All the configs that are not relevant when using Vite (meaning that in the context of a Vite
+   * application they lose their purpose/meaning)
+   */
+  notRelevant: [
+    "base_dir",
+    "build",
+    "find_additional_modules",
+    "no_bundle",
+    "node_compat",
+    "preserve_file_names",
+    "site",
+    "tsconfig",
+    "upload_source_maps"
+  ],
+  /**
+   * All the configs that get overridden by our plugin
+   */
+  overridden: ["rules"]
+};
+var nullableNonApplicable = [
+  "alias",
+  "base_dir",
+  "find_additional_modules",
+  "minify",
+  "no_bundle",
+  "node_compat",
+  "preserve_file_names",
+  "site",
+  "tsconfig",
+  "upload_source_maps"
+];
+function readWorkerConfig(configPath, env2) {
+  const nonApplicable = {
+    replacedByVite: /* @__PURE__ */ new Set(),
+    notRelevant: /* @__PURE__ */ new Set(),
+    overridden: /* @__PURE__ */ new Set()
+  };
+  const config = unstable_readConfig2({ config: configPath, env: env2 }, {});
+  const raw = structuredClone(config);
+  nullableNonApplicable.forEach((prop) => {
+    if (config[prop] !== void 0) {
+      if (isReplacedByVite(prop)) {
+        nonApplicable.replacedByVite.add(prop);
+      }
+      if (isNotRelevant(prop)) {
+        nonApplicable.notRelevant.add(prop);
+      }
+      if (isOverridden(prop)) {
+        nonApplicable.overridden.add(prop);
+      }
+    }
+    delete config[prop];
+  });
+  if (config.build && (config.build.command || config.build.cwd)) {
+    nonApplicable.notRelevant.add("build");
+  }
+  delete config["build"];
+  if (config.define && Object.keys(config.define).length > 0) {
+    nonApplicable.replacedByVite.add("define");
+  }
+  delete config["define"];
+  if (config.rules.length > 0) {
+    nonApplicable.overridden.add("rules");
+  }
+  return {
+    raw,
+    nonApplicable,
+    config
+  };
+}
+function getWarningForWorkersConfigs(configs) {
+  if (!("auxiliaryWorkers" in configs) || configs.auxiliaryWorkers.length === 0) {
+    const nonApplicableLines = getWorkerNonApplicableWarnLines(
+      configs.entryWorker,
+      `  - `
+    );
+    if (nonApplicableLines.length === 0) {
+      return;
+    }
+    const lines2 = [
+      `
+
+\x1B[43mWARNING\x1B[0m: your worker config${configs.entryWorker.config.configPath ? ` (at \`${path4.relative("", configs.entryWorker.config.configPath)}\`)` : ""} contains the following configuration options which are ignored since they are not applicable when using Vite:`
+    ];
+    nonApplicableLines.forEach((line) => lines2.push(line));
+    lines2.push("");
+    return lines2.join("\n");
+  }
+  const lines = [];
+  const processWorkerConfig = (workerConfig, isEntryWorker = false) => {
+    const nonApplicableLines = getWorkerNonApplicableWarnLines(
+      workerConfig,
+      `    - `
+    );
+    if (nonApplicableLines.length > 0) {
+      lines.push(
+        `  - (${isEntryWorker ? "entry" : "auxiliary"}) worker${workerConfig.config.name ? ` "${workerConfig.config.name}"` : ""}${workerConfig.config.configPath ? ` (config at \`${path4.relative("", workerConfig.config.configPath)}\`)` : ""}`
+      );
+      nonApplicableLines.forEach((line) => lines.push(line));
+    }
+  };
+  processWorkerConfig(configs.entryWorker, true);
+  configs.auxiliaryWorkers.forEach((config) => processWorkerConfig(config));
+  if (lines.length === 0) {
+    return;
+  }
+  return [
+    "\n\x1B[43mWARNING\x1B[0m: your workers configs contain configuration options which are ignored since they are not applicable when using Vite:",
+    ...lines,
+    ""
+  ].join("\n");
+}
+function getWorkerNonApplicableWarnLines(workerConfig, linePrefix) {
+  const lines = [];
+  const { replacedByVite, notRelevant, overridden } = workerConfig.nonApplicable;
+  for (const config of replacedByVite) {
+    lines.push(
+      `${linePrefix}\`${config}\` which is replaced by Vite's \`${nonApplicableWorkerConfigs.replacedByVite[config].viteReplacement}\` (docs: ${nonApplicableWorkerConfigs.replacedByVite[config].viteDocs})`
+    );
+  }
+  if (notRelevant.size > 0)
+    lines.push(
+      `${linePrefix}${[...notRelevant].map((config) => `\`${config}\``).join(", ")} which ${notRelevant.size > 1 ? "are" : "is"} not relevant in the context of a Vite project`
+    );
+  if (overridden.size > 0)
+    lines.push(
+      `${linePrefix}${[...overridden].map((config) => `\`${config}\``).join(", ")} which ${overridden.size > 1 ? "are" : "is"} overridden by \`${name}\``
+    );
+  return lines;
+}
+function isReplacedByVite(configName) {
+  return configName in nonApplicableWorkerConfigs["replacedByVite"];
+}
+function isNotRelevant(configName) {
+  return nonApplicableWorkerConfigs.notRelevant.includes(configName);
+}
+function isOverridden(configName) {
+  return nonApplicableWorkerConfigs.overridden.includes(configName);
+}
+function missingFieldErrorMessage(field, configPath, env2) {
+  return `No ${field} field provided in '${configPath}'${env2 ? ` for '${env2}' environment` : ""}`;
+}
+function getWorkerConfig(configPath, env2, opts) {
+  if (opts?.visitedConfigPaths?.has(configPath)) {
+    throw new Error(`Duplicate Wrangler config path found: ${configPath}`);
+  }
+  const { raw, config, nonApplicable } = readWorkerConfig(configPath, env2);
+  opts?.visitedConfigPaths?.add(configPath);
+  assert5(
+    config.topLevelName,
+    missingFieldErrorMessage(`top-level 'name'`, configPath, env2)
+  );
+  assert5(config.name, missingFieldErrorMessage(`'name'`, configPath, env2));
+  assert5(
+    config.compatibility_date,
+    missingFieldErrorMessage(`'compatibility_date'`, configPath, env2)
+  );
+  if (opts?.isEntryWorker && !config.main) {
+    assert5(
+      config.assets,
+      missingFieldErrorMessage(`'main' or 'assets'`, configPath, env2)
+    );
+    return {
+      type: "assets-only",
+      raw,
+      config: {
+        ...config,
+        topLevelName: config.topLevelName,
+        name: config.name,
+        compatibility_date: config.compatibility_date,
+        assets: config.assets
+      },
+      nonApplicable
+    };
+  }
+  assert5(config.main, missingFieldErrorMessage(`'main'`, configPath, env2));
+  return {
+    type: "worker",
+    raw,
+    config: {
+      ...config,
+      topLevelName: config.topLevelName,
+      name: config.name,
+      compatibility_date: config.compatibility_date,
+      main: config.main
+    },
+    nonApplicable
+  };
+}
+function findWranglerConfig(root) {
+  for (const extension of ["json", "jsonc", "toml"]) {
+    const configPath = path4.join(root, `wrangler.${extension}`);
+    if (fs3.existsSync(configPath)) {
+      return configPath;
+    }
+  }
+}
+
+// src/plugin-config.ts
+function workerNameToEnvironmentName(workerName) {
+  return workerName.replaceAll("-", "_");
+}
+function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
+  const configPaths = /* @__PURE__ */ new Set();
+  const persistState = pluginConfig.persistState ?? true;
+  const root = userConfig.root ? path5.resolve(userConfig.root) : process.cwd();
+  const { CLOUDFLARE_ENV } = vite5.loadEnv(viteEnv.mode, root, "");
+  const configPath = pluginConfig.configPath ? path5.resolve(root, pluginConfig.configPath) : findWranglerConfig(root);
+  assert6(
+    configPath,
+    `Config not found. Have you created a wrangler.json(c) or wrangler.toml file?`
+  );
+  const entryWorkerResolvedConfig = getWorkerConfig(
+    configPath,
+    CLOUDFLARE_ENV,
+    {
+      visitedConfigPaths: configPaths,
+      isEntryWorker: true
+    }
+  );
+  if (entryWorkerResolvedConfig.type === "assets-only") {
+    return {
+      type: "assets-only",
+      config: entryWorkerResolvedConfig.config,
+      configPaths,
+      persistState,
+      rawConfigs: {
+        entryWorker: entryWorkerResolvedConfig
+      }
+    };
+  }
+  const entryWorkerConfig = entryWorkerResolvedConfig.config;
+  const entryWorkerEnvironmentName = pluginConfig.viteEnvironment?.name ?? workerNameToEnvironmentName(entryWorkerConfig.topLevelName);
+  const workers = {
+    [entryWorkerEnvironmentName]: entryWorkerConfig
+  };
+  const auxiliaryWorkersResolvedConfigs = [];
+  for (const auxiliaryWorker of pluginConfig.auxiliaryWorkers ?? []) {
+    const workerResolvedConfig = getWorkerConfig(
+      path5.resolve(root, auxiliaryWorker.configPath),
+      CLOUDFLARE_ENV,
+      {
+        visitedConfigPaths: configPaths
+      }
+    );
+    auxiliaryWorkersResolvedConfigs.push(workerResolvedConfig);
+    assert6(
+      workerResolvedConfig.type === "worker",
+      "Unexpected error: received AssetsOnlyResult with auxiliary workers."
+    );
+    const workerConfig = workerResolvedConfig.config;
+    const workerEnvironmentName = auxiliaryWorker.viteEnvironment?.name ?? workerNameToEnvironmentName(workerConfig.topLevelName);
+    if (workers[workerEnvironmentName]) {
+      throw new Error(
+        `Duplicate Vite environment name found: ${workerEnvironmentName}`
+      );
+    }
+    workers[workerEnvironmentName] = workerConfig;
+  }
+  return {
+    type: "workers",
+    configPaths,
+    persistState,
+    workers,
+    entryWorkerEnvironmentName,
+    rawConfigs: {
+      entryWorker: entryWorkerResolvedConfig,
+      auxiliaryWorkers: auxiliaryWorkersResolvedConfigs
+    }
+  };
+}
+
+// src/websockets.ts
+import ws from "ws";
+function handleWebSocket(httpServer, fetcher, logger) {
+  const nodeWebSocket = new ws.Server({ noServer: true });
+  httpServer.on(
+    "upgrade",
+    async (request, socket, head) => {
+      const url = new URL(request.url ?? "", UNKNOWN_HOST);
+      if (request.headers["sec-websocket-protocol"]?.startsWith("vite")) {
+        return;
+      }
+      const headers = nodeHeadersToWebHeaders(request.headers);
+      const response = await fetcher(url, {
+        headers,
+        method: request.method
+      });
+      const workerWebSocket = response.webSocket;
+      if (!workerWebSocket) {
+        socket.destroy();
+        return;
+      }
+      nodeWebSocket.handleUpgrade(
+        request,
+        socket,
+        head,
+        async (clientWebSocket) => {
+          workerWebSocket.accept();
+          workerWebSocket.addEventListener("message", (event) => {
+            clientWebSocket.send(event.data);
+          });
+          workerWebSocket.addEventListener("error", (event) => {
+            logger.error(
+              `WebSocket error:
+${event.error?.stack || event.error?.message}`,
+              { error: event.error }
+            );
+          });
+          workerWebSocket.addEventListener("close", () => {
+            clientWebSocket.close();
+          });
+          clientWebSocket.on("message", (event) => {
+            workerWebSocket.send(event);
+          });
+          clientWebSocket.on("error", (error) => {
+            logger.error(`WebSocket error:
+${error.stack || error.message}`, {
+              error
+            });
+          });
+          clientWebSocket.on("close", () => {
+            workerWebSocket.close();
+          });
+          nodeWebSocket.emit("connection", clientWebSocket, request);
+        }
+      );
+    }
+  );
+}
+
+// src/index.ts
+function cloudflare2(pluginConfig = {}) {
+  let resolvedPluginConfig;
+  let resolvedViteConfig;
+  let miniflare;
+  let workersConfigsWarningShown = false;
+  return {
+    name: "vite-plugin-cloudflare",
+    config(userConfig, env2) {
+      if (env2.isPreview) {
+        return { appType: "custom" };
+      }
+      resolvedPluginConfig = resolvePluginConfig(pluginConfig, userConfig, env2);
+      if (!workersConfigsWarningShown) {
+        workersConfigsWarningShown = true;
+        const workersConfigsWarning = getWarningForWorkersConfigs(
+          resolvedPluginConfig.rawConfigs
+        );
+        if (workersConfigsWarning) {
+          console.warn(workersConfigsWarning);
+        }
+      }
+      return {
+        appType: "custom",
+        resolve: {
+          alias: getNodeCompatAliases()
+        },
+        environments: resolvedPluginConfig.type === "workers" ? {
+          ...Object.fromEntries(
+            Object.entries(resolvedPluginConfig.workers).map(
+              ([environmentName, workerConfig]) => {
+                return [
+                  environmentName,
+                  createCloudflareEnvironmentOptions(
+                    workerConfig,
+                    userConfig,
+                    environmentName
+                  )
+                ];
+              }
+            )
+          ),
+          client: {
+            build: {
+              outDir: getOutputDirectory(userConfig, "client")
+            }
+          }
+        } : void 0,
+        builder: {
+          async buildApp(builder) {
+            const clientEnvironment = builder.environments.client;
+            const defaultHtmlPath = path6.resolve(
+              builder.config.root,
+              "index.html"
+            );
+            if (clientEnvironment && (clientEnvironment.config.build.rollupOptions.input || fs4.existsSync(defaultHtmlPath))) {
+              await builder.build(clientEnvironment);
+            }
+            if (resolvedPluginConfig.type === "workers") {
+              const workerEnvironments = Object.keys(
+                resolvedPluginConfig.workers
+              ).map((environmentName) => {
+                const environment = builder.environments[environmentName];
+                assert7(environment, `${environmentName} environment not found`);
+                return environment;
+              });
+              await Promise.all(
+                workerEnvironments.map(
+                  (environment) => builder.build(environment)
+                )
+              );
+            }
+            writeDeployConfig(resolvedPluginConfig, resolvedViteConfig);
+          }
+        }
+      };
+    },
+    configResolved(config) {
+      resolvedViteConfig = config;
+    },
+    async resolveId(source) {
+      if (resolvedPluginConfig.type === "assets-only") {
+        return;
+      }
+      const workerConfig = resolvedPluginConfig.workers[this.environment.name];
+      if (!workerConfig) {
+        return;
+      }
+      return resolveNodeCompatId(this.environment, workerConfig, source);
+    },
+    async transform(code, id) {
+      if (resolvedPluginConfig.type === "assets-only") {
+        return;
+      }
+      const workerConfig = resolvedPluginConfig.workers[this.environment.name];
+      if (!workerConfig) {
+        return;
+      }
+      const resolvedId = await this.resolve(workerConfig.main);
+      if (id === resolvedId?.id) {
+        return injectGlobalCode(id, code, workerConfig);
+      }
+    },
+    generateBundle(_, bundle) {
+      let config;
+      if (resolvedPluginConfig.type === "workers") {
+        const workerConfig = resolvedPluginConfig.workers[this.environment.name];
+        const entryChunk = Object.entries(bundle).find(
+          ([_2, chunk]) => chunk.type === "chunk" && chunk.isEntry
+        );
+        if (!workerConfig || !entryChunk) {
+          return;
+        }
+        workerConfig.main = entryChunk[0];
+        const isEntryWorker = this.environment.name === resolvedPluginConfig.entryWorkerEnvironmentName;
+        if (isEntryWorker && workerConfig.assets) {
+          const workerOutputDirectory = this.environment.config.build.outDir;
+          const clientOutputDirectory = resolvedViteConfig.environments.client?.build.outDir;
+          assert7(
+            clientOutputDirectory,
+            "Unexpected error: client output directory is undefined"
+          );
+          workerConfig.assets.directory = path6.relative(
+            path6.resolve(resolvedViteConfig.root, workerOutputDirectory),
+            path6.resolve(resolvedViteConfig.root, clientOutputDirectory)
+          );
+        }
+        config = workerConfig;
+      } else if (this.environment.name === "client") {
+        const assetsOnlyConfig = resolvedPluginConfig.config;
+        assetsOnlyConfig.assets.directory = ".";
+        this.emitFile({
+          type: "asset",
+          fileName: ".assetsignore",
+          source: "wrangler.json"
+        });
+        config = assetsOnlyConfig;
+      }
+      if (!config) {
+        return;
+      }
+      config.no_bundle = true;
+      config.rules = [{ type: "ESModule", globs: ["**/*.js"] }];
+      config.unsafe = void 0;
+      this.emitFile({
+        type: "asset",
+        fileName: "wrangler.json",
+        source: JSON.stringify(config)
+      });
+    },
+    handleHotUpdate(options) {
+      if (resolvedPluginConfig.configPaths.has(options.file)) {
+        options.server.restart();
+      }
+    },
+    async buildEnd() {
+      if (miniflare) {
+        await miniflare.dispose();
+        miniflare = void 0;
+      }
+    },
+    async configureServer(viteDevServer) {
+      assert7(viteDevServer.httpServer, "Unexpected error: No Vite HTTP server");
+      miniflare = new Miniflare(
+        getDevMiniflareOptions(resolvedPluginConfig, viteDevServer)
+      );
+      await initRunners(resolvedPluginConfig, viteDevServer, miniflare);
+      const entryWorker = await getDevEntryWorker(
+        resolvedPluginConfig,
+        miniflare
+      );
+      const middleware = createMiddleware(({ request }) => {
+        return entryWorker.fetch(toMiniflareRequest(request), {
+          redirect: "manual"
+        });
+      });
+      handleWebSocket(
+        viteDevServer.httpServer,
+        entryWorker.fetch,
+        viteDevServer.config.logger
+      );
+      return () => {
+        viteDevServer.middlewares.use((req, res, next) => {
+          middleware(req, res, next);
+        });
+      };
+    },
+    configurePreviewServer(vitePreviewServer) {
+      const miniflare2 = new Miniflare(
+        getPreviewMiniflareOptions(
+          vitePreviewServer,
+          pluginConfig.persistState ?? true
+        )
+      );
+      const middleware = createMiddleware(({ request }) => {
+        return miniflare2.dispatchFetch(toMiniflareRequest(request), {
+          redirect: "manual"
+        });
+      });
+      handleWebSocket(
+        vitePreviewServer.httpServer,
+        miniflare2.dispatchFetch,
+        vitePreviewServer.config.logger
+      );
+      return () => {
+        vitePreviewServer.middlewares.use((req, res, next) => {
+          middleware(req, res, next);
+        });
+      };
+    }
+  };
+}
+export {
+  cloudflare2 as cloudflare
+};