@seybel/breakhound 0.0.0-stage → 1.0.1

package/dist/source-loader.cjs

@@ -0,0 +1,1650 @@
+"use strict";
+
+// ../source/src/transform.ts
+var import_node_module = require("module");
+var import_node_path = require("path");
+var import_parser = require("@babel/parser");
+
+// ../../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) {
+  do {
+    let clamped = num & 31;
+    num >>>= 5;
+    if (num > 0) clamped |= 32;
+    builder.write(intToChar[clamped]);
+  } while (num > 0);
+}
+function encodeSign(num) {
+  return num < 0 ? -num << 1 | 1 : num << 1;
+}
+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 encodeRangeMappings(decoded) {
+  if (decoded.length === 0) return "";
+  const writer = new StringWriter();
+  for (let i = 0; i < decoded.length; i++) {
+    const indices = decoded[i];
+    if (i > 0) writer.write(semicolon);
+    let index = 0;
+    for (let j = 0; j < indices.length; j++) {
+      const offset = indices[j];
+      encodeInteger(writer, offset - index);
+      index = offset;
+    }
+  }
+  return writer.flush();
+}
+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);
+      encodeInteger(writer, encodeSign(segment[0] - genColumn));
+      genColumn = segment[0];
+      if (segment.length === 1) continue;
+      encodeInteger(writer, encodeSign(segment[1] - sourcesIndex));
+      encodeInteger(writer, encodeSign(segment[2] - sourceLine));
+      encodeInteger(writer, encodeSign(segment[3] - sourceColumn));
+      sourcesIndex = segment[1];
+      sourceLine = segment[2];
+      sourceColumn = segment[3];
+      if (segment.length === 4) continue;
+      encodeInteger(writer, encodeSign(segment[4] - namesIndex));
+      namesIndex = segment[4];
+    }
+  }
+  return writer.flush();
+}
+
+// ../../node_modules/magic-string/dist/index.mjs
+var BitSet = class BitSet2 {
+  constructor(arg) {
+    this.bits = arg instanceof BitSet2 ? 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 Chunk2 {
+  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 Chunk2(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) {
+    fn(this);
+    let chunk = this.next;
+    while (chunk) {
+      fn(chunk);
+      chunk = chunk.next;
+    }
+  }
+  eachPrevious(fn) {
+    fn(this);
+    let chunk = this.previous;
+    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 Chunk2(index, this.end, originalAfter);
+    newChunk.outro = this.outro;
+    this.outro = "";
+    this.end = index;
+    if (this.edited) {
+      newChunk.edit("", false, true);
+      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) {
+        if (this.edited) this.edit(trimmed, this.storeName, true);
+        else this.split(this.start + trimmed.length).edit("", void 0, 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) {
+        if (this.edited) this.edit(trimmed, this.storeName, true);
+        else {
+          this.split(this.end - trimmed.length);
+          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;
+    }
+  }
+};
+var MagicStringError = class extends Error {
+  name = "MagicStringError";
+  constructor(message, options) {
+    super(`[MagicString] ${message}`, options);
+  }
+};
+function getBtoa() {
+  if (typeof globalThis !== "undefined" && typeof globalThis.btoa === "function") return (str) => globalThis.btoa(unescape(encodeURIComponent(str)));
+  const buffer = globalThis["Buffer"];
+  if (buffer) return (str) => buffer.from(str, "utf-8").toString("base64");
+  return () => {
+    throw new MagicStringError("unsupported environment: `btoa` or `Buffer` is required");
+  };
+}
+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 = typeof properties.mappings === "string" ? properties.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;
+    if (typeof properties.rangeMappings !== "undefined") {
+      let shouldOutputRangeMapping = false;
+      for (const line of properties.rangeMappings) if (line.length !== 0) {
+        shouldOutputRangeMapping = true;
+        break;
+      }
+      if (shouldOutputRangeMapping) this.rangeMappings = encodeRangeMappings(properties.rangeMappings);
+    }
+  }
+  /**
+  * Returns the equivalent of `JSON.stringify(map)`
+  */
+  toString() {
+    return JSON.stringify(this);
+  }
+  /**
+  * Returns a DataURI containing the sourcemap. Useful for doing this sort of thing:
+  * `generateMap(options?: SourceMapOptions): SourceMap;`
+  */
+  toUrl() {
+    return `data:application/json;charset=utf-8;base64,${btoa(this.toString())}`;
+  }
+};
+function getLocator(source) {
+  const lineOffsets = [0];
+  for (let i = source.indexOf("\n"); i !== -1; i = source.indexOf("\n", i + 1)) lineOffsets.push(i + 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;
+    return {
+      line,
+      column: index - lineOffsets[line]
+    };
+  };
+}
+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("/");
+}
+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 " ".repeat(min);
+}
+var toString = Object.prototype.toString;
+function isObject(thing) {
+  return toString.call(thing) === "[object Object]";
+}
+var BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar2 = /* @__PURE__ */ (() => {
+  const chars2 = /* @__PURE__ */ new Uint8Array(64);
+  for (let i = 0; i < 64; i++) chars2[i] = BASE64_CHARS.charCodeAt(i);
+  return chars2;
+})();
+var COMMA = 44;
+var SEMICOLON = 59;
+var BUFFER_SIZE = 16384;
+var FLUSH_THRESHOLD = 16348;
+var scratch = /* @__PURE__ */ new Uint8Array(BUFFER_SIZE);
+function writeVlq(pos, num) {
+  num = num < 0 ? -num << 1 | 1 : num << 1;
+  do {
+    let clamped = num & 31;
+    num >>>= 5;
+    if (num > 0) clamped |= 32;
+    scratch[pos++] = intToChar2[clamped];
+  } while (num > 0);
+  return pos;
+}
+var decoder = /* @__PURE__ */ new TextDecoder();
+var MappingsEncoder = class {
+  constructor() {
+    this.out = "";
+    this.pos = 0;
+    this.lines = [];
+    this.buffered = 0;
+    this.needsComma = false;
+    this.prevGenColumn = 0;
+    this.prevSourceIndex = 0;
+    this.prevSourceLine = 0;
+    this.prevSourceColumn = 0;
+    this.prevNameIndex = 0;
+  }
+  endLine(segments) {
+    this.lines.push(segments);
+    this.buffered += segments.length + 1;
+    if (this.buffered >= 4096) this.drain(null);
+  }
+  segments(segments) {
+    this.drain(segments);
+  }
+  finish(segments) {
+    this.drain(segments);
+    this.flush();
+    return this.out;
+  }
+  drain(trailing) {
+    const lines = this.lines;
+    const lineCount = lines.length;
+    for (let l = 0; l <= lineCount; l++) {
+      const line = l < lineCount ? lines[l] : trailing;
+      if (line === null) break;
+      for (let i = 0; i < line.length; i++) {
+        if (this.pos > FLUSH_THRESHOLD) this.flush();
+        const segment = line[i];
+        if (this.needsComma) scratch[this.pos++] = COMMA;
+        this.needsComma = true;
+        this.pos = writeVlq(this.pos, segment[0] - this.prevGenColumn);
+        this.prevGenColumn = segment[0];
+        this.pos = writeVlq(this.pos, segment[1] - this.prevSourceIndex);
+        this.prevSourceIndex = segment[1];
+        this.pos = writeVlq(this.pos, segment[2] - this.prevSourceLine);
+        this.prevSourceLine = segment[2];
+        this.pos = writeVlq(this.pos, segment[3] - this.prevSourceColumn);
+        this.prevSourceColumn = segment[3];
+        if (segment.length === 5) {
+          this.pos = writeVlq(this.pos, segment[4] - this.prevNameIndex);
+          this.prevNameIndex = segment[4];
+        }
+      }
+      if (l < lineCount) {
+        if (this.pos > FLUSH_THRESHOLD) this.flush();
+        scratch[this.pos++] = SEMICOLON;
+        this.needsComma = false;
+        this.prevGenColumn = 0;
+      }
+    }
+    lines.length = 0;
+    this.buffered = 0;
+    this.flush();
+  }
+  flush() {
+    this.out += decoder.decode(scratch.subarray(0, this.pos));
+    this.pos = 0;
+  }
+};
+var NEWLINE_CHAR$1 = 10;
+function isWordCode(code) {
+  return code >= 97 && code <= 122 || code >= 65 && code <= 90 || code >= 48 && code <= 57 || code === 95;
+}
+var Mappings = class {
+  constructor(hires, encoder = null) {
+    this.hires = hires;
+    this.generatedCodeLine = 0;
+    this.generatedCodeColumn = 0;
+    this.raw = [];
+    this.rawSegments = this.raw[this.generatedCodeLine] = [];
+    this.rawRangeMappings = [];
+    this.rawRangeMappingsIndices = this.rawRangeMappings[this.generatedCodeLine] = [];
+    this.encoder = encoder;
+  }
+  nextLine() {
+    if (this.encoder === null) {
+      this.generatedCodeLine += 1;
+      this.raw[this.generatedCodeLine] = this.rawSegments = [];
+    } else {
+      this.encoder.endLine(this.rawSegments);
+      this.rawSegments = [];
+      this.generatedCodeLine += 1;
+    }
+    this.generatedCodeColumn = 0;
+    this.rawRangeMappings[this.generatedCodeLine] = this.rawRangeMappingsIndices = [];
+  }
+  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.nextLine();
+        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));
+    }
+  }
+  addUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) {
+    const end = chunk.end;
+    let i = chunk.start;
+    if (this.hires) {
+      const boundary = this.hires === "boundary";
+      const experimentalRange = this.hires === "experimental-range";
+      const encoder = experimentalRange ? null : this.encoder;
+      let charInHiresBoundary = false;
+      while (i < end) {
+        if (encoder !== null && this.rawSegments.length >= 4096) {
+          encoder.segments(this.rawSegments);
+          this.rawSegments.length = 0;
+        }
+        if (experimentalRange && i + 1 >= end) this.rawSegments.push([
+          this.generatedCodeColumn,
+          sourceIndex,
+          loc.line,
+          loc.column
+        ]);
+        const code = original.charCodeAt(i);
+        if (code === NEWLINE_CHAR$1) {
+          loc.line += 1;
+          loc.column = 0;
+          this.nextLine();
+          charInHiresBoundary = false;
+        } else {
+          if (boundary) {
+            if (isWordCode(code)) {
+              if (!charInHiresBoundary) {
+                this.rawSegments.push([
+                  this.generatedCodeColumn,
+                  sourceIndex,
+                  loc.line,
+                  loc.column
+                ]);
+                charInHiresBoundary = true;
+              }
+            } else {
+              this.rawSegments.push([
+                this.generatedCodeColumn,
+                sourceIndex,
+                loc.line,
+                loc.column
+              ]);
+              charInHiresBoundary = false;
+            }
+          } else if (experimentalRange) {
+            if (i === chunk.start) {
+              this.rawRangeMappingsIndices.push(this.rawSegments.length);
+              this.rawSegments.push([
+                this.generatedCodeColumn,
+                sourceIndex,
+                loc.line,
+                loc.column
+              ]);
+            }
+          } else this.rawSegments.push([
+            this.generatedCodeColumn,
+            sourceIndex,
+            loc.line,
+            loc.column
+          ]);
+          loc.column += 1;
+          this.generatedCodeColumn += 1;
+        }
+        i += 1;
+      }
+    } else {
+      const bits = sourcemapLocations.bits;
+      while (i < end) {
+        let newline = original.indexOf("\n", i);
+        if (newline === -1 || newline > end) newline = end;
+        if (newline > i) {
+          this.rawSegments.push([
+            this.generatedCodeColumn,
+            sourceIndex,
+            loc.line,
+            loc.column
+          ]);
+          for (let w = i + 1 >> 5, last = newline - 1 >> 5; w <= last; w++) {
+            let word = bits[w];
+            if (!word) continue;
+            const base = w << 5;
+            while (word) {
+              const lowest = word & -word;
+              const index = base + 31 - Math.clz32(lowest);
+              if (index > i && index < newline) {
+                const offset = index - i;
+                this.rawSegments.push([
+                  this.generatedCodeColumn + offset,
+                  sourceIndex,
+                  loc.line,
+                  loc.column + offset
+                ]);
+              }
+              word ^= lowest;
+            }
+          }
+          loc.column += newline - i;
+          this.generatedCodeColumn += newline - i;
+        }
+        if (newline === end) break;
+        loc.line += 1;
+        loc.column = 0;
+        this.nextLine();
+        i = newline + 1;
+      }
+    }
+  }
+  advance(str) {
+    if (!str) return;
+    const lastNewline = str.lastIndexOf("\n");
+    for (let i = str.indexOf("\n"); i !== -1; i = str.indexOf("\n", i + 1)) this.nextLine();
+    this.generatedCodeColumn += str.length - lastNewline - 1;
+  }
+};
+var n = "\n";
+var NEWLINE_CHAR = "\n".charCodeAt(0);
+var CR_CHAR = "\r".charCodeAt(0);
+var warned = {
+  insertLeft: false,
+  insertRight: false,
+  storeName: false
+};
+function expandReplacement(replacement, matched, position, str, captures, namedCaptures) {
+  if (!replacement.includes("$")) return replacement;
+  let result = "";
+  let index = 0;
+  while (index < replacement.length) {
+    const dollar = replacement.indexOf("$", index);
+    if (dollar === -1) {
+      result += replacement.slice(index);
+      break;
+    }
+    result += replacement.slice(index, dollar);
+    const char = replacement[dollar + 1];
+    let expansion = "$";
+    let consumed = 1;
+    if (char === "$") consumed = 2;
+    else if (char === "&") {
+      expansion = matched;
+      consumed = 2;
+    } else if (char === "`") {
+      expansion = str.slice(0, position);
+      consumed = 2;
+    } else if (char === "'") {
+      expansion = str.slice(position + matched.length);
+      consumed = 2;
+    } else if (char === "<" && namedCaptures !== void 0) {
+      const close = replacement.indexOf(">", dollar + 2);
+      if (close !== -1) {
+        expansion = namedCaptures[replacement.slice(dollar + 2, close)] ?? "";
+        consumed = close + 1 - dollar;
+      }
+    } else if (char >= "0" && char <= "9") {
+      const second = replacement[dollar + 2];
+      const double = second >= "0" && second <= "9" ? Number(char + second) : NaN;
+      const single = Number(char);
+      if (double >= 1 && double <= captures.length) {
+        expansion = captures[double - 1] ?? "";
+        consumed = 3;
+      } else if (single >= 1 && single <= captures.length) {
+        expansion = captures[single - 1] ?? "";
+        consumed = 2;
+      }
+    }
+    result += expansion;
+    index = dollar + consumed;
+  }
+  return result;
+}
+var MagicString = class MagicString2 {
+  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: /* @__PURE__ */ new Map([[0, chunk]])
+      },
+      byEnd: {
+        writable: true,
+        value: /* @__PURE__ */ new Map([[string.length, chunk]])
+      },
+      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
+      },
+      hasMovedChunks: {
+        writable: true,
+        value: false
+      }
+    });
+  }
+  /**
+  * Adds the specified character index (with respect to the original string) to sourcemap mappings, if `hires` is false.
+  */
+  addSourcemapLocation(char) {
+    this.sourcemapLocations.add(char);
+  }
+  /**
+  * Appends the specified content to the end of the string.
+  */
+  append(content) {
+    if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
+    this.outro += content;
+    return this;
+  }
+  /**
+  * Appends the specified content at the index in the original string.
+  * If a range *ending* with index is subsequently moved, the insert will be moved with it.
+  * See also `s.prependLeft(...)`.
+  */
+  appendLeft(index, content) {
+    index = index + this.offset;
+    if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
+    this._split(index);
+    const chunk = this.byEnd.get(index);
+    if (chunk) chunk.appendLeft(content);
+    else this.intro += content;
+    return this;
+  }
+  /**
+  * Appends the specified content at the index in the original string.
+  * If a range *starting* with index is subsequently moved, the insert will be moved with it.
+  * See also `s.prependRight(...)`.
+  */
+  appendRight(index, content) {
+    index = index + this.offset;
+    if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
+    this._split(index);
+    const chunk = this.byStart.get(index);
+    if (chunk) chunk.appendRight(content);
+    else this.outro += content;
+    return this;
+  }
+  /**
+  * Does what you'd expect.
+  */
+  clone() {
+    const cloned = new MagicString2(this.original, {
+      filename: this.filename,
+      ignoreList: this.ignoreList,
+      offset: this.offset
+    });
+    let originalChunk = this.firstChunk;
+    let clonedChunk = cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone();
+    while (originalChunk) {
+      cloned.byStart.set(clonedChunk.start, clonedChunk);
+      cloned.byEnd.set(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.storedNames = { ...this.storedNames };
+    cloned.intro = this.intro;
+    cloned.outro = this.outro;
+    cloned.hasMovedChunks = this.hasMovedChunks;
+    return cloned;
+  }
+  /**
+  * Generates a sourcemap object with raw mappings in array form, rather than encoded as a string.
+  * Useful if you need to manipulate the sourcemap further, but most of the time you will use `generateMap` instead.
+  */
+  generateDecodedMap(options) {
+    options = options || {};
+    const mappings = new Mappings(options.hires);
+    const names = this._generateMappings(mappings);
+    return {
+      ...this._mapProperties(options, names),
+      mappings: mappings.raw,
+      rangeMappings: mappings.rawRangeMappings
+    };
+  }
+  /**
+  * Generates a version 3 sourcemap.
+  */
+  generateMap(options) {
+    options = options || {};
+    const encoder = new MappingsEncoder();
+    const mappings = new Mappings(options.hires, encoder);
+    const names = this._generateMappings(mappings);
+    return new SourceMap({
+      ...this._mapProperties(options, names),
+      mappings: encoder.finish(mappings.rawSegments),
+      rangeMappings: mappings.rawRangeMappings
+    });
+  }
+  /** @internal */
+  _generateMappings(mappings) {
+    const sourceIndex = 0;
+    const names = Object.keys(this.storedNames);
+    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);
+    });
+    if (this.outro) mappings.advance(this.outro);
+    return names;
+  }
+  /** @internal */
+  _mapProperties(options, names) {
+    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,
+      x_google_ignoreList: this.ignoreList ? [0] : void 0
+    };
+  }
+  /** @internal */
+  _ensureindentStr() {
+    if (this.indentStr === void 0) this.indentStr = guessIndent(this.original);
+  }
+  /** @internal */
+  _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;
+    const resolvedIndentStr = indentStr;
+    options = options || {};
+    const isExcluded = {};
+    if (options.exclude) (typeof options.exclude[0] === "number" ? [options.exclude] : options.exclude).forEach((exclusion) => {
+      for (let i = exclusion[0]; i < exclusion[1]; i += 1) isExcluded[i] = true;
+    });
+    let shouldIndentNextCharacter = options.indentStart !== false;
+    const indentPiece = (str) => {
+      if (str === "") return str;
+      const indented = str.replace(pattern, (match, offset) => offset > 0 || shouldIndentNextCharacter ? `${resolvedIndentStr}${match}` : match);
+      shouldIndentNextCharacter = str[str.length - 1] === "\n";
+      return indented;
+    };
+    this.intro = indentPiece(this.intro);
+    let charIndex = 0;
+    let chunk = this.firstChunk;
+    const indentAt = (index) => {
+      shouldIndentNextCharacter = false;
+      if (index === chunk.start) chunk.appendRight(resolvedIndentStr);
+      else {
+        this._splitChunk(chunk, index);
+        chunk = chunk.next;
+        chunk.prependRight(resolvedIndentStr);
+      }
+    };
+    while (chunk) {
+      const end = chunk.end;
+      if (!isExcluded[chunk.start]) chunk.intro = indentPiece(chunk.intro);
+      if (chunk.edited) {
+        if (!isExcluded[charIndex]) chunk.content = indentPiece(chunk.content);
+      } else if (options.exclude) {
+        charIndex = chunk.start;
+        while (charIndex < end) {
+          if (!isExcluded[charIndex]) {
+            const char = this.original.charCodeAt(charIndex);
+            if (char === NEWLINE_CHAR) shouldIndentNextCharacter = true;
+            else if (char !== CR_CHAR && shouldIndentNextCharacter) indentAt(charIndex);
+          }
+          charIndex += 1;
+        }
+      } else {
+        charIndex = chunk.start;
+        while (charIndex < end) {
+          if (!shouldIndentNextCharacter) {
+            const nextLine = this.original.indexOf(n, charIndex);
+            if (nextLine === -1 || nextLine >= end) break;
+            shouldIndentNextCharacter = true;
+            charIndex = nextLine + 1;
+            continue;
+          }
+          const char = this.original.charCodeAt(charIndex);
+          if (char === NEWLINE_CHAR || char === CR_CHAR) {
+            charIndex += 1;
+            continue;
+          }
+          indentAt(charIndex);
+          charIndex += 1;
+        }
+      }
+      if (!isExcluded[chunk.end - 1]) chunk.outro = indentPiece(chunk.outro);
+      charIndex = chunk.end;
+      chunk = chunk.next;
+    }
+    this.outro = indentPiece(this.outro);
+    return this;
+  }
+  /** @internal */
+  insert() {
+    throw new MagicStringError("insert() is deprecated, use appendLeft() or prependRight()");
+  }
+  /** @internal */
+  insertLeft(index, content) {
+    if (!warned.insertLeft) {
+      console.warn("magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead");
+      warned.insertLeft = true;
+    }
+    return this.appendLeft(index, content);
+  }
+  /** @internal */
+  insertRight(index, content) {
+    if (!warned.insertRight) {
+      console.warn("magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead");
+      warned.insertRight = true;
+    }
+    return this.prependRight(index, content);
+  }
+  /**
+  * Moves the characters from `start` and `end` to `index`.
+  *
+  * `affinity` controls where the range is anchored at `index`. With the
+  * default `'right'`, it is inserted before the content that starts at `index`;
+  * with `'left'`, it is inserted after the content that ends at `index`. The
+  * two differ only when other content has already been moved to that boundary,
+  * mirroring the `appendLeft`/`appendRight` distinction.
+  */
+  move(start, end, index, affinity = "right") {
+    start = start + this.offset;
+    end = end + this.offset;
+    index = index + this.offset;
+    if (start === end) return this;
+    if (index >= start && index <= end) throw new MagicStringError("cannot move a selection inside itself");
+    this._split(start);
+    this._split(end);
+    this._split(index);
+    const first = this.byStart.get(start);
+    const last = this.byEnd.get(end);
+    if (this.hasMovedChunks) {
+      let cursor = first;
+      while (cursor !== last) {
+        cursor = cursor.next;
+        if (!cursor || cursor.start < start || cursor.end > end) throw new MagicStringError(`cannot move ${start} to ${end} because an earlier move split that range`);
+      }
+    }
+    const oldLeft = first.previous;
+    const oldRight = last.next;
+    let newLeft;
+    let newRight;
+    if (affinity === "left") {
+      newLeft = this.byEnd.get(index) ?? null;
+      if (!newLeft) {
+        if (first === this.firstChunk) return this;
+        newRight = this.firstChunk;
+      } else {
+        if (newLeft.next === first) return this;
+        newRight = newLeft.next;
+      }
+    } else {
+      newRight = this.byStart.get(index) ?? null;
+      if (!newRight) {
+        if (last === this.lastChunk) return this;
+        newLeft = this.lastChunk;
+      } else {
+        if (newRight.previous === last) return this;
+        newLeft = newRight.previous;
+      }
+    }
+    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;
+    this.hasMovedChunks = true;
+    return this;
+  }
+  /**
+  * Replaces the characters from `start` to `end` with `content`, along with the appended/prepended content in
+  * that range. The same restrictions as `s.remove()` apply.
+  *
+  * The fourth argument is optional. It can have a storeName property - if true, the original name will be stored
+  * for later inclusion in a sourcemap's names array - and a contentOnly property which determines whether only
+  * the content is overwritten, or anything that was appended/prepended to the range as well.
+  *
+  * It may be preferred to use `s.update(...)` instead if you wish to avoid overwriting the appended/prepended content.
+  */
+  overwrite(start, end, content, options) {
+    const optionObject = typeof options === "object" && options ? options : {};
+    return this.update(start, end, content, {
+      ...optionObject,
+      overwrite: !optionObject.contentOnly
+    });
+  }
+  /**
+  * Replaces the characters from `start` to `end` with `content`. The same restrictions as `s.remove()` apply.
+  *
+  * The fourth argument is optional. It can have a storeName property - if true, the original name will be stored
+  * for later inclusion in a sourcemap's names array - and an overwrite property which determines whether only
+  * the content is overwritten, or anything that was appended/prepended to the range as well.
+  */
+  update(start, end, content, options) {
+    start = start + this.offset;
+    end = end + this.offset;
+    if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
+    if (this.original.length !== 0) {
+      if (start < 0) start = Math.max(0, start + this.original.length);
+      if (end < 0) end = Math.max(0, end + this.original.length);
+    }
+    if (start < 0) throw new MagicStringError(`start ${start} is out of bounds`);
+    if (end > this.original.length) throw new MagicStringError(`end ${end} is out of bounds`);
+    if (start === end) throw new MagicStringError(`cannot overwrite a zero-length range at ${start}, use appendLeft() or prependRight()`);
+    if (start > end) throw new MagicStringError(`end must be greater than start (start: ${start}, end: ${end})`);
+    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 optionObject = typeof options === "object" && options ? options : {};
+    const storeName = optionObject.storeName || false;
+    const overwrite = optionObject.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.get(start);
+    const last = this.byEnd.get(end);
+    if (first) {
+      let chunk = first;
+      while (chunk !== last) {
+        if (chunk.next !== this.byStart.get(chunk.end)) throw new MagicStringError("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;
+  }
+  /**
+  * Prepends the string with the specified content.
+  */
+  prepend(content) {
+    if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
+    this.intro = content + this.intro;
+    return this;
+  }
+  /**
+  * Same as `s.appendLeft(...)`, except that the inserted content will go *before* any previous appends or prepends at index
+  */
+  prependLeft(index, content) {
+    index = index + this.offset;
+    if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
+    this._split(index);
+    const chunk = this.byEnd.get(index);
+    if (chunk) chunk.prependLeft(content);
+    else this.intro = content + this.intro;
+    return this;
+  }
+  /**
+  * Same as `s.appendRight(...)`, except that the inserted content will go *before* any previous appends or prepends at `index`
+  */
+  prependRight(index, content) {
+    index = index + this.offset;
+    if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
+    this._split(index);
+    const chunk = this.byStart.get(index);
+    if (chunk) chunk.prependRight(content);
+    else this.outro = content + this.outro;
+    return this;
+  }
+  /**
+  * Removes the characters from `start` to `end` (of the original string, **not** the generated string).
+  * Content appended or prepended at positions strictly inside the range is removed with it, while
+  * content attached at `start` or `end` is preserved — use `s.overwrite(start, end, '')` to remove
+  * the range including its edge inserts.
+  * Repeated removals and removals with partially overlapping ranges are allowed.
+  */
+  remove(start, end) {
+    start = start + this.offset;
+    end = end + this.offset;
+    if (this.original.length !== 0) {
+      if (start < 0) start = Math.max(0, start + this.original.length);
+      if (end < 0) end = Math.max(0, end + this.original.length);
+    }
+    if (start === end) return this;
+    if (start < 0 || end > this.original.length) throw new MagicStringError(`range ${start}\u2013${end} is out of bounds`);
+    if (start > end) throw new MagicStringError(`end must be greater than start (start: ${start}, end: ${end})`);
+    this._split(start);
+    this._split(end);
+    let chunk = this.byStart.get(start);
+    while (chunk) {
+      if (chunk.start > start) chunk.intro = "";
+      if (chunk.end < end) chunk.outro = "";
+      chunk.edit("", false, true);
+      chunk = end > chunk.end ? this.byStart.get(chunk.end) : null;
+    }
+    return this;
+  }
+  /**
+  * Reset the modified characters from `start` to `end` (of the original string, **not** the generated string).
+  */
+  reset(start, end) {
+    start = start + this.offset;
+    end = end + this.offset;
+    if (this.original.length !== 0) {
+      if (start < 0) start = Math.max(0, start + this.original.length);
+      if (end < 0) end = Math.max(0, end + this.original.length);
+    }
+    if (start === end) return this;
+    if (start < 0 || end > this.original.length) throw new MagicStringError(`range ${start}\u2013${end} is out of bounds`);
+    if (start > end) throw new MagicStringError(`end must be greater than start (start: ${start}, end: ${end})`);
+    this._split(start);
+    this._split(end);
+    let chunk = this.byStart.get(start);
+    while (chunk) {
+      chunk.reset();
+      chunk = end > chunk.end ? this.byStart.get(chunk.end) : null;
+    }
+    return this;
+  }
+  lastChar() {
+    if (this.outro.length) return this.outro[this.outro.length - 1];
+    let chunk = this.lastChunk;
+    while (chunk) {
+      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];
+      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;
+    while (chunk) {
+      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;
+      }
+      chunk = chunk.previous;
+    }
+    lineIndex = this.intro.lastIndexOf(n);
+    if (lineIndex !== -1) return this.intro.substr(lineIndex + 1) + lineStr;
+    return this.intro + lineStr;
+  }
+  /**
+  * Returns the content of the generated string that corresponds to the slice between `start` and `end` of the original string.
+  * Throws error if the indices are for characters that were already removed.
+  */
+  slice(start = 0, end = this.original.length - this.offset) {
+    start = start + this.offset;
+    end = end + this.offset;
+    if (this.original.length !== 0) {
+      if (start < 0) start = Math.max(0, start + this.original.length);
+      if (end < 0) end = Math.max(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 || end === 0 && chunk.start === 0) return result;
+      chunk = chunk.next;
+    }
+    if (chunk && chunk.edited && chunk.start !== start) throw new MagicStringError(`cannot use edited character ${start} as slice start anchor`);
+    const startChunk = chunk;
+    while (chunk) {
+      if (end === 0 && chunk.start === 0) break;
+      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 MagicStringError(`cannot use edited 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;
+  }
+  /**
+  * Returns a clone of `s`, with all content before the `start` and `end` characters of the original string removed.
+  */
+  snip(start, end) {
+    const clone = this.clone();
+    clone.remove(0, start);
+    clone.remove(end, clone.original.length);
+    return clone;
+  }
+  /** @internal */
+  _split(index) {
+    if (this.byStart.get(index) || this.byEnd.get(index)) return;
+    let chunk = this.lastSearchedChunk;
+    let previousChunk = chunk;
+    const searchForward = index > chunk.end;
+    while (chunk) {
+      if (chunk.contains(index)) return this._splitChunk(chunk, index);
+      chunk = searchForward ? this.byStart.get(chunk.end) : this.byEnd.get(chunk.start);
+      if (chunk === previousChunk) return;
+      previousChunk = chunk;
+    }
+  }
+  /** @internal */
+  _splitChunk(chunk, index) {
+    if (chunk.edited && chunk.content.length) {
+      const loc = getLocator(this.original)(index);
+      throw new MagicStringError(`cannot split a chunk that has already been edited (${loc.line}:${loc.column} \u2013 "${chunk.original}")`);
+    }
+    const newChunk = chunk.split(index);
+    this.byEnd.set(index, chunk);
+    this.byStart.set(index, newChunk);
+    this.byEnd.set(newChunk.end, newChunk);
+    if (chunk === this.lastChunk) this.lastChunk = newChunk;
+    this.lastSearchedChunk = chunk;
+    return true;
+  }
+  /**
+  * Returns the generated string.
+  */
+  toString() {
+    let str = this.intro;
+    let chunk = this.firstChunk;
+    while (chunk) {
+      str += chunk.toString();
+      chunk = chunk.next;
+    }
+    return str + this.outro;
+  }
+  /**
+  * Returns true if the resulting source is empty (disregarding white space).
+  */
+  isEmpty() {
+    if (this.intro.length && this.intro.trim()) return false;
+    let chunk = this.firstChunk;
+    while (chunk) {
+      if (chunk.intro.length && chunk.intro.trim() || chunk.content.length && chunk.content.trim() || chunk.outro.length && chunk.outro.trim()) return false;
+      chunk = chunk.next;
+    }
+    if (this.outro.length && this.outro.trim()) return false;
+    return true;
+  }
+  length() {
+    let chunk = this.firstChunk;
+    let length = 0;
+    while (chunk) {
+      length += chunk.intro.length + chunk.content.length + chunk.outro.length;
+      chunk = chunk.next;
+    }
+    return length;
+  }
+  /**
+  * Removes empty lines from the start and end.
+  */
+  trimLines() {
+    return this.trim("[\\r\\n]");
+  }
+  /**
+  * Trims content matching `charType` (defaults to `\s`, i.e. whitespace) from the start and end.
+  */
+  trim(charType) {
+    return this.trimStart(charType).trimEnd(charType);
+  }
+  /** @internal */
+  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.set(chunk.end, chunk);
+        this.byStart.set(chunk.next.start, chunk.next);
+        this.byEnd.set(chunk.next.end, chunk.next);
+      }
+      if (aborted) return true;
+      chunk = chunk.previous;
+    } while (chunk);
+    this.intro = this.intro.replace(rx, "");
+    return this.intro.length > 0;
+  }
+  /**
+  * Trims content matching `charType` (defaults to `\s`, i.e. whitespace) from the end.
+  */
+  trimEnd(charType) {
+    this.trimEndAborted(charType);
+    return this;
+  }
+  /** @internal */
+  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.set(chunk.end, chunk);
+        this.byStart.set(chunk.next.start, chunk.next);
+        this.byEnd.set(chunk.next.end, chunk.next);
+      }
+      if (aborted) return true;
+      chunk = chunk.next;
+    } while (chunk);
+    this.outro = this.outro.replace(rx, "");
+    return this.outro.length > 0;
+  }
+  /**
+  * Trims content matching `charType` (defaults to `\s`, i.e. whitespace) from the start.
+  */
+  trimStart(charType) {
+    this.trimStartAborted(charType);
+    return this;
+  }
+  /**
+  * Indicates if the string has been changed.
+  */
+  hasChanged() {
+    if (this.intro || this.outro) return true;
+    let outputIndex = 0;
+    let chunk = this.firstChunk;
+    while (chunk) {
+      if (chunk.intro || chunk.outro) return true;
+      if (!chunk.edited && chunk.start === outputIndex) outputIndex = chunk.end;
+      else {
+        if (!this.original.startsWith(chunk.content, outputIndex)) return true;
+        outputIndex += chunk.content.length;
+      }
+      chunk = chunk.next;
+    }
+    return outputIndex !== this.original.length;
+  }
+  /**
+  * Whether the original range [start, end) has had any of its characters
+  * removed. `replace`/`replaceAll` search `original`, so a match can land on
+  * text that is no longer in the output - overwriting it would resurrect the
+  * removed characters, so such matches are skipped instead.
+  *
+  * @internal
+  */
+  _hasRemovedContent(start, end) {
+    let chunk = this.byStart.get(start);
+    if (!chunk) {
+      chunk = this.lastSearchedChunk;
+      const searchForward = start >= chunk.end;
+      while (chunk && !chunk.contains(start)) chunk = searchForward ? this.byStart.get(chunk.end) : this.byEnd.get(chunk.start);
+      if (chunk) this.lastSearchedChunk = chunk;
+    }
+    while (chunk && chunk.start < end) {
+      if (chunk.content === "") return true;
+      chunk = this.byStart.get(chunk.end);
+    }
+    return false;
+  }
+  /** @internal */
+  _replaceRegexp(searchValue, replacement) {
+    function getReplacement(match, str) {
+      if (typeof replacement === "string") return expandReplacement(replacement, match[0], match.index, str, match.slice(1), match.groups);
+      else return match.groups === void 0 ? replacement(match[0], ...match.slice(1), match.index, str) : replacement(match[0], ...match.slice(1), match.index, str, match.groups);
+    }
+    const replaceMatch = (match) => {
+      if (match.index == null) return false;
+      if (this._hasRemovedContent(match.index, match.index + match[0].length)) return false;
+      const replacement2 = getReplacement(match, this.original);
+      if (replacement2 === match[0]) return true;
+      if (match[0].length === 0) this.appendRight(match.index, replacement2);
+      else this.overwrite(match.index, match.index + match[0].length, replacement2);
+      return true;
+    };
+    if (searchValue.global) {
+      searchValue.lastIndex = 0;
+      for (const match of this.original.matchAll(searchValue)) replaceMatch(match);
+    } else {
+      const match = this.original.match(searchValue);
+      if (match && !replaceMatch(match)) {
+        const global = new RegExp(searchValue.source, `${searchValue.flags}g`);
+        for (const next of this.original.matchAll(global)) if (replaceMatch(next)) break;
+      }
+    }
+    return this;
+  }
+  /** @internal */
+  _replaceString(string, replacement) {
+    const { original } = this;
+    let index = original.indexOf(string);
+    while (index !== -1) {
+      if (this._hasRemovedContent(index, index + string.length)) {
+        index = original.indexOf(string, index + string.length);
+        continue;
+      }
+      if (typeof replacement === "function") replacement = replacement(string, index, original);
+      else replacement = expandReplacement(replacement, string, index, original, [], void 0);
+      if (string !== replacement) {
+        if (string.length === 0) this.appendRight(index, replacement);
+        else this.overwrite(index, index + string.length, replacement);
+      }
+      break;
+    }
+    return this;
+  }
+  /**
+  * String replacement with RegExp or string.
+  */
+  replace(searchValue, replacement) {
+    if (typeof searchValue === "string") return this._replaceString(searchValue, replacement);
+    return this._replaceRegexp(searchValue, replacement);
+  }
+  /** @internal */
+  _replaceAllString(string, replacement) {
+    const { original } = this;
+    const stringLength = string.length;
+    if (stringLength === 0) {
+      for (let index = 0; index <= original.length; index += 1) {
+        if (this._hasRemovedContent(index, index)) continue;
+        const _replacement = typeof replacement === "function" ? replacement("", index, original) : expandReplacement(replacement, "", index, original, [], void 0);
+        if (_replacement !== "") this.appendRight(index, _replacement);
+      }
+      return this;
+    }
+    for (let index = original.indexOf(string); index !== -1; index = original.indexOf(string, index + stringLength)) {
+      if (this._hasRemovedContent(index, index + stringLength)) continue;
+      const previous = original.slice(index, index + stringLength);
+      const _replacement = typeof replacement === "function" ? replacement(previous, index, original) : expandReplacement(replacement, previous, index, original, [], void 0);
+      if (previous !== _replacement) this.overwrite(index, index + stringLength, _replacement);
+    }
+    return this;
+  }
+  /**
+  * Same as `s.replace`, but replace all matched strings instead of just one.
+  */
+  replaceAll(searchValue, replacement) {
+    if (typeof searchValue === "string") return this._replaceAllString(searchValue, replacement);
+    if (!searchValue.global) throw new MagicStringError("replaceAll() requires a global RegExp");
+    return this._replaceRegexp(searchValue, replacement);
+  }
+};
+
+// ../source/src/transform.ts
+var SOURCE_ATTR = "data-bh-src";
+function walk(node, visit) {
+  if (!node || typeof node !== "object") return;
+  if (typeof node.type === "string" || typeof node.type === "number") visit(node);
+  for (const key of Object.keys(node)) {
+    if (key === "loc" || key === "start" || key === "end" || key === "parent") continue;
+    const value = node[key];
+    if (Array.isArray(value)) for (const child of value) walk(child, visit);
+    else if (value && typeof value === "object") walk(value, visit);
+  }
+}
+function attr(file, line, column) {
+  return ` ${SOURCE_ATTR}="${file}:${line}:${column}"`;
+}
+function jsx(code, file, typescript) {
+  if (code.includes("@react-three/fiber")) return null;
+  let ast;
+  try {
+    ast = (0, import_parser.parse)(code, {
+      sourceType: "module",
+      errorRecovery: true,
+      plugins: typescript ? ["jsx", "typescript", "decorators-legacy"] : ["jsx"]
+    });
+  } catch {
+    return null;
+  }
+  const s = new MagicString(code);
+  let changed = false;
+  walk(ast.program, (n2) => {
+    if (n2.type !== "JSXOpeningElement" || n2.name?.type !== "JSXIdentifier") return;
+    if (!/^[a-z]/.test(n2.name.name)) return;
+    if (n2.attributes.some((a) => a.name?.name === SOURCE_ATTR)) return;
+    s.appendLeft(n2.name.end, attr(file, n2.loc.start.line, n2.loc.start.column + 1));
+    changed = true;
+  });
+  return changed ? s : null;
+}
+function projectRequire(root) {
+  return (0, import_node_module.createRequire)((0, import_node_path.join)(root, "package.json"));
+}
+function vue(code, file, root) {
+  let compiler;
+  try {
+    compiler = projectRequire(root)("vue/compiler-sfc");
+  } catch {
+    return null;
+  }
+  const { descriptor } = compiler.parse(code, { filename: file });
+  const template = descriptor.template;
+  if (!template?.ast || template.lang && template.lang !== "html") return null;
+  const s = new MagicString(code);
+  let changed = false;
+  walk(template.ast, (n2) => {
+    if (n2.type !== 1 || n2.tagType !== 0) return;
+    if (n2.props?.some((p) => p.name === SOURCE_ATTR)) return;
+    const at = n2.loc.start.offset + 1 + n2.tag.length;
+    s.appendLeft(at, attr(file, n2.loc.start.line, n2.loc.start.column));
+    changed = true;
+  });
+  return changed ? s : null;
+}
+function lineColumn(code, offset) {
+  let line = 1;
+  let last = -1;
+  for (let i = code.indexOf("\n"); i !== -1 && i < offset; i = code.indexOf("\n", i + 1)) {
+    line++;
+    last = i;
+  }
+  return [line, offset - last];
+}
+function svelte(code, file, root) {
+  let compiler;
+  try {
+    compiler = projectRequire(root)("svelte/compiler");
+  } catch {
+    return null;
+  }
+  let ast;
+  try {
+    ast = compiler.parse(code, { modern: true });
+  } catch {
+    return null;
+  }
+  const s = new MagicString(code);
+  let changed = false;
+  walk(ast.fragment, (n2) => {
+    if (n2.type !== "RegularElement" && n2.type !== "SvelteElement") return;
+    if (n2.type === "SvelteElement") return;
+    if (n2.attributes?.some((a) => a.name === SOURCE_ATTR)) return;
+    const [line, column] = lineColumn(code, n2.start);
+    s.appendLeft(n2.start + 1 + n2.name.length, attr(file, line, column));
+    changed = true;
+  });
+  return changed ? s : null;
+}
+function wantsFile(id) {
+  if (id.includes("\0") || id.includes("?") || /[\\/]node_modules[\\/]/.test(id)) return false;
+  return /\.(jsx|tsx|vue|svelte)$/.test(id);
+}
+function addSourceAttributes(code, id, root) {
+  if (!wantsFile(id)) return null;
+  const file = (0, import_node_path.relative)(root, id).split(import_node_path.sep).join("/");
+  if (file.startsWith("..")) return null;
+  const ext = (0, import_node_path.extname)(id);
+  const s = ext === ".vue" ? vue(code, file, root) : ext === ".svelte" ? svelte(code, file, root) : jsx(code, file, ext === ".tsx");
+  if (!s) return null;
+  return {
+    code: s.toString(),
+    map: s.generateMap({ source: id, includeContent: true, hires: true })
+  };
+}
+
+// ../source/src/webpack-loader.ts
+function loader(source, map) {
+  const root = this.getOptions?.()?.root ?? this.rootContext ?? process.cwd();
+  const result = addSourceAttributes(source, this.resourcePath, root);
+  if (!result) {
+    this.callback(null, source, map);
+    return;
+  }
+  this.callback(null, result.code, result.map);
+}
+
+// src/source-loader.ts
+module.exports = loader;