@cyberskill/shared 1.199.0 → 1.201.0

package/dist/magic-string.es-CyLHbrL2.js

@@ -0,0 +1,871 @@
+var ft = Object.defineProperty, dt = Object.defineProperties;
+var gt = Object.getOwnPropertyDescriptors;
+var K = Object.getOwnPropertySymbols;
+var pt = Object.prototype.hasOwnProperty, mt = Object.prototype.propertyIsEnumerable;
+var Q = (w, t, e) => t in w ? ft(w, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : w[t] = e, X = (w, t) => {
+  for (var e in t || (t = {}))
+    pt.call(t, e) && Q(w, e, t[e]);
+  if (K)
+    for (var e of K(t))
+      mt.call(t, e) && Q(w, e, t[e]);
+  return w;
+}, Z = (w, t) => dt(w, gt(t));
+var M = { exports: {} }, wt = M.exports, V;
+function bt() {
+  return V || (V = 1, function(w, t) {
+    (function(e, n) {
+      n(t);
+    })(wt, function(e) {
+      const r = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", u = new Uint8Array(64), f = new Uint8Array(128);
+      for (let a = 0; a < r.length; a++) {
+        const h = r.charCodeAt(a);
+        u[a] = h, f[h] = a;
+      }
+      function o(a, h) {
+        let i = 0, l = 0, d = 0;
+        do {
+          const C = a.next();
+          d = f[C], i |= (d & 31) << l, l += 5;
+        } while (d & 32);
+        const g = i & 1;
+        return i >>>= 1, g && (i = -2147483648 | -i), h + i;
+      }
+      function c(a, h, i) {
+        let l = h - i;
+        l = l < 0 ? -l << 1 | 1 : l << 1;
+        do {
+          let d = l & 31;
+          l >>>= 5, l > 0 && (d |= 32), a.write(u[d]);
+        } while (l > 0);
+        return h;
+      }
+      function k(a, h) {
+        return a.pos >= h ? !1 : a.peek() !== 44;
+      }
+      const O = 1024 * 16, z = typeof TextDecoder != "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer != "undefined" ? {
+        decode(a) {
+          return Buffer.from(a.buffer, a.byteOffset, a.byteLength).toString();
+        }
+      } : {
+        decode(a) {
+          let h = "";
+          for (let i = 0; i < a.length; i++)
+            h += String.fromCharCode(a[i]);
+          return h;
+        }
+      };
+      class D {
+        constructor() {
+          this.pos = 0, this.out = "", this.buffer = new Uint8Array(O);
+        }
+        write(h) {
+          const { buffer: i } = this;
+          i[this.pos++] = h, this.pos === O && (this.out += z.decode(i), this.pos = 0);
+        }
+        flush() {
+          const { buffer: h, out: i, pos: l } = this;
+          return l > 0 ? i + z.decode(h.subarray(0, l)) : i;
+        }
+      }
+      class G {
+        constructor(h) {
+          this.pos = 0, this.buffer = h;
+        }
+        next() {
+          return this.buffer.charCodeAt(this.pos++);
+        }
+        peek() {
+          return this.buffer.charCodeAt(this.pos);
+        }
+        indexOf(h) {
+          const { buffer: i, pos: l } = this, d = i.indexOf(h, l);
+          return d === -1 ? i.length : d;
+        }
+      }
+      const F = [];
+      function nt(a) {
+        const { length: h } = a, i = new G(a), l = [], d = [];
+        let g = 0;
+        for (; i.pos < h; i.pos++) {
+          g = o(i, g);
+          const C = o(i, 0);
+          if (!k(i, h)) {
+            const x = d.pop();
+            x[2] = g, x[3] = C;
+            continue;
+          }
+          const m = o(i, 0), b = o(i, 0) & 1 ? [g, C, 0, 0, m, o(i, 0)] : [g, C, 0, 0, m];
+          let v = F;
+          if (k(i, h)) {
+            v = [];
+            do {
+              const x = o(i, 0);
+              v.push(x);
+            } while (k(i, h));
+          }
+          b.vars = v, l.push(b), d.push(b);
+        }
+        return l;
+      }
+      function it(a) {
+        const h = new D();
+        for (let i = 0; i < a.length; )
+          i = H(a, i, h, [0]);
+        return h.flush();
+      }
+      function H(a, h, i, l) {
+        const d = a[h], { 0: g, 1: C, 2: m, 3: y, 4: S, vars: b } = d;
+        h > 0 && i.write(44), l[0] = c(i, g, l[0]), c(i, C, 0), c(i, S, 0);
+        const v = d.length === 6 ? 1 : 0;
+        c(i, v, 0), d.length === 6 && c(i, d[5], 0);
+        for (const x of b)
+          c(i, x, 0);
+        for (h++; h < a.length; ) {
+          const x = a[h], { 0: p, 1: E } = x;
+          if (p > m || p === m && E >= y)
+            break;
+          h = H(a, h, i, l);
+        }
+        return i.write(44), l[0] = c(i, m, l[0]), c(i, y, 0), h;
+      }
+      function st(a) {
+        const { length: h } = a, i = new G(a), l = [], d = [];
+        let g = 0, C = 0, m = 0, y = 0, S = 0, b = 0, v = 0, x = 0;
+        do {
+          const p = i.indexOf(";");
+          let E = 0;
+          for (; i.pos < p; i.pos++) {
+            if (E = o(i, E), !k(i, p)) {
+              const L = d.pop();
+              L[2] = g, L[3] = E;
+              continue;
+            }
+            const R = o(i, 0), B = R & 1, A = R & 2, T = R & 4;
+            let Y = null, q = F, _;
+            if (B) {
+              const L = o(i, C);
+              m = o(i, C === L ? m : 0), C = L, _ = [g, E, 0, 0, L, m];
+            } else
+              _ = [g, E, 0, 0];
+            if (_.isScope = !!T, A) {
+              const L = y, I = S;
+              y = o(i, y);
+              const j = L === y;
+              S = o(i, j ? S : 0), b = o(i, j && I === S ? b : 0), Y = [y, S, b];
+            }
+            if (_.callsite = Y, k(i, p)) {
+              q = [];
+              do {
+                v = g, x = E;
+                const L = o(i, 0);
+                let I;
+                if (L < -1) {
+                  I = [[o(i, 0)]];
+                  for (let j = -1; j > L; j--) {
+                    const ct = v;
+                    v = o(i, v), x = o(i, v === ct ? x : 0);
+                    const at = o(i, 0);
+                    I.push([at, v, x]);
+                  }
+                } else
+                  I = [[L]];
+                q.push(I);
+              } while (k(i, p));
+            }
+            _.bindings = q, l.push(_), d.push(_);
+          }
+          g++, i.pos = p + 1;
+        } while (i.pos < h);
+        return l;
+      }
+      function rt(a) {
+        if (a.length === 0)
+          return "";
+        const h = new D();
+        for (let i = 0; i < a.length; )
+          i = J(a, i, h, [0, 0, 0, 0, 0, 0, 0]);
+        return h.flush();
+      }
+      function J(a, h, i, l) {
+        const d = a[h], { 0: g, 1: C, 2: m, 3: y, isScope: S, callsite: b, bindings: v } = d;
+        l[0] < g ? (W(i, l[0], g), l[0] = g, l[1] = 0) : h > 0 && i.write(44), l[1] = c(i, d[1], l[1]);
+        const x = (d.length === 6 ? 1 : 0) | (b ? 2 : 0) | (S ? 4 : 0);
+        if (c(i, x, 0), d.length === 6) {
+          const { 4: p, 5: E } = d;
+          p !== l[2] && (l[3] = 0), l[2] = c(i, p, l[2]), l[3] = c(i, E, l[3]);
+        }
+        if (b) {
+          const { 0: p, 1: E, 2: R } = d.callsite;
+          p !== l[4] ? (l[5] = 0, l[6] = 0) : E !== l[5] && (l[6] = 0), l[4] = c(i, p, l[4]), l[5] = c(i, E, l[5]), l[6] = c(i, R, l[6]);
+        }
+        if (v)
+          for (const p of v) {
+            p.length > 1 && c(i, -p.length, 0);
+            const E = p[0][0];
+            c(i, E, 0);
+            let R = g, B = C;
+            for (let A = 1; A < p.length; A++) {
+              const T = p[A];
+              R = c(i, T[1], R), B = c(i, T[2], B), c(i, T[0], 0);
+            }
+          }
+        for (h++; h < a.length; ) {
+          const p = a[h], { 0: E, 1: R } = p;
+          if (E > m || E === m && R >= y)
+            break;
+          h = J(a, h, i, l);
+        }
+        return l[0] < m ? (W(i, l[0], m), l[0] = m, l[1] = 0) : i.write(44), l[1] = c(i, y, l[1]), h;
+      }
+      function W(a, h, i) {
+        do
+          a.write(59);
+        while (++h < i);
+      }
+      function ot(a) {
+        const { length: h } = a, i = new G(a), l = [];
+        let d = 0, g = 0, C = 0, m = 0, y = 0;
+        do {
+          const S = i.indexOf(";"), b = [];
+          let v = !0, x = 0;
+          for (d = 0; i.pos < S; ) {
+            let p;
+            d = o(i, d), d < x && (v = !1), x = d, k(i, S) ? (g = o(i, g), C = o(i, C), m = o(i, m), k(i, S) ? (y = o(i, y), p = [d, g, C, m, y]) : p = [d, g, C, m]) : p = [d], b.push(p), i.pos++;
+          }
+          v || ht(b), l.push(b), i.pos = S + 1;
+        } while (i.pos <= h);
+        return l;
+      }
+      function ht(a) {
+        a.sort(lt);
+      }
+      function lt(a, h) {
+        return a[0] - h[0];
+      }
+      function ut(a) {
+        const h = new D();
+        let i = 0, l = 0, d = 0, g = 0;
+        for (let C = 0; C < a.length; C++) {
+          const m = a[C];
+          if (C > 0 && h.write(59), m.length === 0)
+            continue;
+          let y = 0;
+          for (let S = 0; S < m.length; S++) {
+            const b = m[S];
+            S > 0 && h.write(44), y = c(h, b[0], y), b.length !== 1 && (i = c(h, b[1], i), l = c(h, b[2], l), d = c(h, b[3], d), b.length !== 4 && (g = c(h, b[4], g)));
+          }
+        }
+        return h.flush();
+      }
+      e.decode = ot, e.decodeGeneratedRanges = st, e.decodeOriginalScopes = nt, e.encode = ut, e.encodeGeneratedRanges = rt, e.encodeOriginalScopes = it, Object.defineProperty(e, "__esModule", { value: !0 });
+    });
+  }(M, M.exports)), M.exports;
+}
+var Ct = bt();
+class P {
+  constructor(t) {
+    this.bits = t instanceof P ? t.bits.slice() : [];
+  }
+  add(t) {
+    this.bits[t >> 5] |= 1 << (t & 31);
+  }
+  has(t) {
+    return !!(this.bits[t >> 5] & 1 << (t & 31));
+  }
+}
+class U {
+  constructor(t, e, n) {
+    this.start = t, this.end = e, this.original = n, this.intro = "", this.outro = "", this.content = n, this.storeName = !1, this.edited = !1, this.previous = null, this.next = null;
+  }
+  appendLeft(t) {
+    this.outro += t;
+  }
+  appendRight(t) {
+    this.intro = this.intro + t;
+  }
+  clone() {
+    const t = new U(this.start, this.end, this.original);
+    return t.intro = this.intro, t.outro = this.outro, t.content = this.content, t.storeName = this.storeName, t.edited = this.edited, t;
+  }
+  contains(t) {
+    return this.start < t && t < this.end;
+  }
+  eachNext(t) {
+    let e = this;
+    for (; e; )
+      t(e), e = e.next;
+  }
+  eachPrevious(t) {
+    let e = this;
+    for (; e; )
+      t(e), e = e.previous;
+  }
+  edit(t, e, n) {
+    return this.content = t, n || (this.intro = "", this.outro = ""), this.storeName = e, this.edited = !0, this;
+  }
+  prependLeft(t) {
+    this.outro = t + this.outro;
+  }
+  prependRight(t) {
+    this.intro = t + this.intro;
+  }
+  reset() {
+    this.intro = "", this.outro = "", this.edited && (this.content = this.original, this.storeName = !1, this.edited = !1);
+  }
+  split(t) {
+    const e = t - this.start, n = this.original.slice(0, e), s = this.original.slice(e);
+    this.original = n;
+    const r = new U(t, this.end, s);
+    return r.outro = this.outro, this.outro = "", this.end = t, this.edited ? (r.edit("", !1), this.content = "") : this.content = n, r.next = this.next, r.next && (r.next.previous = r), r.previous = this, this.next = r, r;
+  }
+  toString() {
+    return this.intro + this.content + this.outro;
+  }
+  trimEnd(t) {
+    if (this.outro = this.outro.replace(t, ""), this.outro.length) return !0;
+    const e = this.content.replace(t, "");
+    if (e.length)
+      return e !== this.content && (this.split(this.start + e.length).edit("", void 0, !0), this.edited && this.edit(e, this.storeName, !0)), !0;
+    if (this.edit("", void 0, !0), this.intro = this.intro.replace(t, ""), this.intro.length) return !0;
+  }
+  trimStart(t) {
+    if (this.intro = this.intro.replace(t, ""), this.intro.length) return !0;
+    const e = this.content.replace(t, "");
+    if (e.length) {
+      if (e !== this.content) {
+        const n = this.split(this.end - e.length);
+        this.edited && n.edit(e, this.storeName, !0), this.edit("", void 0, !0);
+      }
+      return !0;
+    } else if (this.edit("", void 0, !0), this.outro = this.outro.replace(t, ""), this.outro.length) return !0;
+  }
+}
+function St() {
+  return typeof globalThis != "undefined" && typeof globalThis.btoa == "function" ? (w) => globalThis.btoa(unescape(encodeURIComponent(w))) : typeof Buffer == "function" ? (w) => Buffer.from(w, "utf-8").toString("base64") : () => {
+    throw new Error("Unsupported environment: `window.btoa` or `Buffer` should be supported.");
+  };
+}
+const yt = /* @__PURE__ */ St();
+class vt {
+  constructor(t) {
+    this.version = 3, this.file = t.file, this.sources = t.sources, this.sourcesContent = t.sourcesContent, this.names = t.names, this.mappings = Ct.encode(t.mappings), typeof t.x_google_ignoreList != "undefined" && (this.x_google_ignoreList = t.x_google_ignoreList), typeof t.debugId != "undefined" && (this.debugId = t.debugId);
+  }
+  toString() {
+    return JSON.stringify(this);
+  }
+  toUrl() {
+    return "data:application/json;charset=utf-8;base64," + yt(this.toString());
+  }
+}
+function xt(w) {
+  const t = w.split(`
+`), e = t.filter((r) => /^\t+/.test(r)), n = t.filter((r) => /^ {2,}/.test(r));
+  if (e.length === 0 && n.length === 0)
+    return null;
+  if (e.length >= n.length)
+    return "	";
+  const s = n.reduce((r, u) => {
+    const f = /^ +/.exec(u)[0].length;
+    return Math.min(f, r);
+  }, 1 / 0);
+  return new Array(s + 1).join(" ");
+}
+function Et(w, t) {
+  const e = w.split(/[/\\]/), n = t.split(/[/\\]/);
+  for (e.pop(); e[0] === n[0]; )
+    e.shift(), n.shift();
+  if (e.length) {
+    let s = e.length;
+    for (; s--; ) e[s] = "..";
+  }
+  return e.concat(n).join("/");
+}
+const kt = Object.prototype.toString;
+function Lt(w) {
+  return kt.call(w) === "[object Object]";
+}
+function tt(w) {
+  const t = w.split(`
+`), e = [];
+  for (let n = 0, s = 0; n < t.length; n++)
+    e.push(s), s += t[n].length + 1;
+  return function(s) {
+    let r = 0, u = e.length;
+    for (; r < u; ) {
+      const c = r + u >> 1;
+      s < e[c] ? u = c : r = c + 1;
+    }
+    const f = r - 1, o = s - e[f];
+    return { line: f, column: o };
+  };
+}
+const Rt = /\w/;
+class _t {
+  constructor(t) {
+    this.hires = t, this.generatedCodeLine = 0, this.generatedCodeColumn = 0, this.raw = [], this.rawSegments = this.raw[this.generatedCodeLine] = [], this.pending = null;
+  }
+  addEdit(t, e, n, s) {
+    if (e.length) {
+      const r = e.length - 1;
+      let u = e.indexOf(`
+`, 0), f = -1;
+      for (; u >= 0 && r > u; ) {
+        const c = [this.generatedCodeColumn, t, n.line, n.column];
+        s >= 0 && c.push(s), this.rawSegments.push(c), this.generatedCodeLine += 1, this.raw[this.generatedCodeLine] = this.rawSegments = [], this.generatedCodeColumn = 0, f = u, u = e.indexOf(`
+`, u + 1);
+      }
+      const o = [this.generatedCodeColumn, t, n.line, n.column];
+      s >= 0 && o.push(s), this.rawSegments.push(o), this.advance(e.slice(f + 1));
+    } else this.pending && (this.rawSegments.push(this.pending), this.advance(e));
+    this.pending = null;
+  }
+  addUneditedChunk(t, e, n, s, r) {
+    let u = e.start, f = !0, o = !1;
+    for (; u < e.end; ) {
+      if (n[u] === `
+`)
+        s.line += 1, s.column = 0, this.generatedCodeLine += 1, this.raw[this.generatedCodeLine] = this.rawSegments = [], this.generatedCodeColumn = 0, f = !0, o = !1;
+      else {
+        if (this.hires || f || r.has(u)) {
+          const c = [this.generatedCodeColumn, t, s.line, s.column];
+          this.hires === "boundary" ? Rt.test(n[u]) ? o || (this.rawSegments.push(c), o = !0) : (this.rawSegments.push(c), o = !1) : this.rawSegments.push(c);
+        }
+        s.column += 1, this.generatedCodeColumn += 1, f = !1;
+      }
+      u += 1;
+    }
+    this.pending = null;
+  }
+  advance(t) {
+    if (!t) return;
+    const e = t.split(`
+`);
+    if (e.length > 1) {
+      for (let n = 0; n < e.length - 1; n++)
+        this.generatedCodeLine++, this.raw[this.generatedCodeLine] = this.rawSegments = [];
+      this.generatedCodeColumn = 0;
+    }
+    this.generatedCodeColumn += e[e.length - 1].length;
+  }
+}
+const $ = `
+`, N = {
+  insertLeft: !1,
+  insertRight: !1,
+  storeName: !1
+};
+class et {
+  constructor(t, e = {}) {
+    const n = new U(0, t.length, t);
+    Object.defineProperties(this, {
+      original: { writable: !0, value: t },
+      outro: { writable: !0, value: "" },
+      intro: { writable: !0, value: "" },
+      firstChunk: { writable: !0, value: n },
+      lastChunk: { writable: !0, value: n },
+      lastSearchedChunk: { writable: !0, value: n },
+      byStart: { writable: !0, value: {} },
+      byEnd: { writable: !0, value: {} },
+      filename: { writable: !0, value: e.filename },
+      indentExclusionRanges: { writable: !0, value: e.indentExclusionRanges },
+      sourcemapLocations: { writable: !0, value: new P() },
+      storedNames: { writable: !0, value: {} },
+      indentStr: { writable: !0, value: void 0 },
+      ignoreList: { writable: !0, value: e.ignoreList },
+      offset: { writable: !0, value: e.offset || 0 }
+    }), this.byStart[0] = n, this.byEnd[t.length] = n;
+  }
+  addSourcemapLocation(t) {
+    this.sourcemapLocations.add(t);
+  }
+  append(t) {
+    if (typeof t != "string") throw new TypeError("outro content must be a string");
+    return this.outro += t, this;
+  }
+  appendLeft(t, e) {
+    if (t = t + this.offset, typeof e != "string") throw new TypeError("inserted content must be a string");
+    this._split(t);
+    const n = this.byEnd[t];
+    return n ? n.appendLeft(e) : this.intro += e, this;
+  }
+  appendRight(t, e) {
+    if (t = t + this.offset, typeof e != "string") throw new TypeError("inserted content must be a string");
+    this._split(t);
+    const n = this.byStart[t];
+    return n ? n.appendRight(e) : this.outro += e, this;
+  }
+  clone() {
+    const t = new et(this.original, { filename: this.filename, offset: this.offset });
+    let e = this.firstChunk, n = t.firstChunk = t.lastSearchedChunk = e.clone();
+    for (; e; ) {
+      t.byStart[n.start] = n, t.byEnd[n.end] = n;
+      const s = e.next, r = s && s.clone();
+      r && (n.next = r, r.previous = n, n = r), e = s;
+    }
+    return t.lastChunk = n, this.indentExclusionRanges && (t.indentExclusionRanges = this.indentExclusionRanges.slice()), t.sourcemapLocations = new P(this.sourcemapLocations), t.intro = this.intro, t.outro = this.outro, t;
+  }
+  generateDecodedMap(t) {
+    t = t || {};
+    const e = 0, n = Object.keys(this.storedNames), s = new _t(t.hires), r = tt(this.original);
+    return this.intro && s.advance(this.intro), this.firstChunk.eachNext((u) => {
+      const f = r(u.start);
+      u.intro.length && s.advance(u.intro), u.edited ? s.addEdit(
+        e,
+        u.content,
+        f,
+        u.storeName ? n.indexOf(u.original) : -1
+      ) : s.addUneditedChunk(e, u, this.original, f, this.sourcemapLocations), u.outro.length && s.advance(u.outro);
+    }), {
+      file: t.file ? t.file.split(/[/\\]/).pop() : void 0,
+      sources: [
+        t.source ? Et(t.file || "", t.source) : t.file || ""
+      ],
+      sourcesContent: t.includeContent ? [this.original] : void 0,
+      names: n,
+      mappings: s.raw,
+      x_google_ignoreList: this.ignoreList ? [e] : void 0
+    };
+  }
+  generateMap(t) {
+    return new vt(this.generateDecodedMap(t));
+  }
+  _ensureindentStr() {
+    this.indentStr === void 0 && (this.indentStr = xt(this.original));
+  }
+  _getRawIndentString() {
+    return this._ensureindentStr(), this.indentStr;
+  }
+  getIndentString() {
+    return this._ensureindentStr(), this.indentStr === null ? "	" : this.indentStr;
+  }
+  indent(t, e) {
+    const n = /^[^\r\n]/gm;
+    if (Lt(t) && (e = t, t = void 0), t === void 0 && (this._ensureindentStr(), t = this.indentStr || "	"), t === "") return this;
+    e = e || {};
+    const s = {};
+    e.exclude && (typeof e.exclude[0] == "number" ? [e.exclude] : e.exclude).forEach((k) => {
+      for (let O = k[0]; O < k[1]; O += 1)
+        s[O] = !0;
+    });
+    let r = e.indentStart !== !1;
+    const u = (c) => r ? `${t}${c}` : (r = !0, c);
+    this.intro = this.intro.replace(n, u);
+    let f = 0, o = this.firstChunk;
+    for (; o; ) {
+      const c = o.end;
+      if (o.edited)
+        s[f] || (o.content = o.content.replace(n, u), o.content.length && (r = o.content[o.content.length - 1] === `
+`));
+      else
+        for (f = o.start; f < c; ) {
+          if (!s[f]) {
+            const k = this.original[f];
+            k === `
+` ? r = !0 : k !== "\r" && r && (r = !1, f === o.start || (this._splitChunk(o, f), o = o.next), o.prependRight(t));
+          }
+          f += 1;
+        }
+      f = o.end, o = o.next;
+    }
+    return this.outro = this.outro.replace(n, u), this;
+  }
+  insert() {
+    throw new Error(
+      "magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)"
+    );
+  }
+  insertLeft(t, e) {
+    return N.insertLeft || (console.warn(
+      "magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead"
+    ), N.insertLeft = !0), this.appendLeft(t, e);
+  }
+  insertRight(t, e) {
+    return N.insertRight || (console.warn(
+      "magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead"
+    ), N.insertRight = !0), this.prependRight(t, e);
+  }
+  move(t, e, n) {
+    if (t = t + this.offset, e = e + this.offset, n = n + this.offset, n >= t && n <= e) throw new Error("Cannot move a selection inside itself");
+    this._split(t), this._split(e), this._split(n);
+    const s = this.byStart[t], r = this.byEnd[e], u = s.previous, f = r.next, o = this.byStart[n];
+    if (!o && r === this.lastChunk) return this;
+    const c = o ? o.previous : this.lastChunk;
+    return u && (u.next = f), f && (f.previous = u), c && (c.next = s), o && (o.previous = r), s.previous || (this.firstChunk = r.next), r.next || (this.lastChunk = s.previous, this.lastChunk.next = null), s.previous = c, r.next = o || null, c || (this.firstChunk = s), o || (this.lastChunk = r), this;
+  }
+  overwrite(t, e, n, s) {
+    return s = s || {}, this.update(t, e, n, Z(X({}, s), { overwrite: !s.contentOnly }));
+  }
+  update(t, e, n, s) {
+    if (t = t + this.offset, e = e + this.offset, typeof n != "string") throw new TypeError("replacement content must be a string");
+    if (this.original.length !== 0) {
+      for (; t < 0; ) t += this.original.length;
+      for (; e < 0; ) e += this.original.length;
+    }
+    if (e > this.original.length) throw new Error("end is out of bounds");
+    if (t === e)
+      throw new Error(
+        "Cannot overwrite a zero-length range – use appendLeft or prependRight instead"
+      );
+    this._split(t), this._split(e), s === !0 && (N.storeName || (console.warn(
+      "The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string"
+    ), N.storeName = !0), s = { storeName: !0 });
+    const r = s !== void 0 ? s.storeName : !1, u = s !== void 0 ? s.overwrite : !1;
+    if (r) {
+      const c = this.original.slice(t, e);
+      Object.defineProperty(this.storedNames, c, {
+        writable: !0,
+        value: !0,
+        enumerable: !0
+      });
+    }
+    const f = this.byStart[t], o = this.byEnd[e];
+    if (f) {
+      let c = f;
+      for (; c !== o; ) {
+        if (c.next !== this.byStart[c.end])
+          throw new Error("Cannot overwrite across a split point");
+        c = c.next, c.edit("", !1);
+      }
+      f.edit(n, r, !u);
+    } else {
+      const c = new U(t, e, "").edit(n, r);
+      o.next = c, c.previous = o;
+    }
+    return this;
+  }
+  prepend(t) {
+    if (typeof t != "string") throw new TypeError("outro content must be a string");
+    return this.intro = t + this.intro, this;
+  }
+  prependLeft(t, e) {
+    if (t = t + this.offset, typeof e != "string") throw new TypeError("inserted content must be a string");
+    this._split(t);
+    const n = this.byEnd[t];
+    return n ? n.prependLeft(e) : this.intro = e + this.intro, this;
+  }
+  prependRight(t, e) {
+    if (t = t + this.offset, typeof e != "string") throw new TypeError("inserted content must be a string");
+    this._split(t);
+    const n = this.byStart[t];
+    return n ? n.prependRight(e) : this.outro = e + this.outro, this;
+  }
+  remove(t, e) {
+    if (t = t + this.offset, e = e + this.offset, this.original.length !== 0) {
+      for (; t < 0; ) t += this.original.length;
+      for (; e < 0; ) e += this.original.length;
+    }
+    if (t === e) return this;
+    if (t < 0 || e > this.original.length) throw new Error("Character is out of bounds");
+    if (t > e) throw new Error("end must be greater than start");
+    this._split(t), this._split(e);
+    let n = this.byStart[t];
+    for (; n; )
+      n.intro = "", n.outro = "", n.edit(""), n = e > n.end ? this.byStart[n.end] : null;
+    return this;
+  }
+  reset(t, e) {
+    if (t = t + this.offset, e = e + this.offset, this.original.length !== 0) {
+      for (; t < 0; ) t += this.original.length;
+      for (; e < 0; ) e += this.original.length;
+    }
+    if (t === e) return this;
+    if (t < 0 || e > this.original.length) throw new Error("Character is out of bounds");
+    if (t > e) throw new Error("end must be greater than start");
+    this._split(t), this._split(e);
+    let n = this.byStart[t];
+    for (; n; )
+      n.reset(), n = e > n.end ? this.byStart[n.end] : null;
+    return this;
+  }
+  lastChar() {
+    if (this.outro.length) return this.outro[this.outro.length - 1];
+    let t = this.lastChunk;
+    do {
+      if (t.outro.length) return t.outro[t.outro.length - 1];
+      if (t.content.length) return t.content[t.content.length - 1];
+      if (t.intro.length) return t.intro[t.intro.length - 1];
+    } while (t = t.previous);
+    return this.intro.length ? this.intro[this.intro.length - 1] : "";
+  }
+  lastLine() {
+    let t = this.outro.lastIndexOf($);
+    if (t !== -1) return this.outro.substr(t + 1);
+    let e = this.outro, n = this.lastChunk;
+    do {
+      if (n.outro.length > 0) {
+        if (t = n.outro.lastIndexOf($), t !== -1) return n.outro.substr(t + 1) + e;
+        e = n.outro + e;
+      }
+      if (n.content.length > 0) {
+        if (t = n.content.lastIndexOf($), t !== -1) return n.content.substr(t + 1) + e;
+        e = n.content + e;
+      }
+      if (n.intro.length > 0) {
+        if (t = n.intro.lastIndexOf($), t !== -1) return n.intro.substr(t + 1) + e;
+        e = n.intro + e;
+      }
+    } while (n = n.previous);
+    return t = this.intro.lastIndexOf($), t !== -1 ? this.intro.substr(t + 1) + e : this.intro + e;
+  }
+  slice(t = 0, e = this.original.length - this.offset) {
+    if (t = t + this.offset, e = e + this.offset, this.original.length !== 0) {
+      for (; t < 0; ) t += this.original.length;
+      for (; e < 0; ) e += this.original.length;
+    }
+    let n = "", s = this.firstChunk;
+    for (; s && (s.start > t || s.end <= t); ) {
+      if (s.start < e && s.end >= e)
+        return n;
+      s = s.next;
+    }
+    if (s && s.edited && s.start !== t)
+      throw new Error(`Cannot use replaced character ${t} as slice start anchor.`);
+    const r = s;
+    for (; s; ) {
+      s.intro && (r !== s || s.start === t) && (n += s.intro);
+      const u = s.start < e && s.end >= e;
+      if (u && s.edited && s.end !== e)
+        throw new Error(`Cannot use replaced character ${e} as slice end anchor.`);
+      const f = r === s ? t - s.start : 0, o = u ? s.content.length + e - s.end : s.content.length;
+      if (n += s.content.slice(f, o), s.outro && (!u || s.end === e) && (n += s.outro), u)
+        break;
+      s = s.next;
+    }
+    return n;
+  }
+  // TODO deprecate this? not really very useful
+  snip(t, e) {
+    const n = this.clone();
+    return n.remove(0, t), n.remove(e, n.original.length), n;
+  }
+  _split(t) {
+    if (this.byStart[t] || this.byEnd[t]) return;
+    let e = this.lastSearchedChunk;
+    const n = t > e.end;
+    for (; e; ) {
+      if (e.contains(t)) return this._splitChunk(e, t);
+      e = n ? this.byStart[e.end] : this.byEnd[e.start];
+    }
+  }
+  _splitChunk(t, e) {
+    if (t.edited && t.content.length) {
+      const s = tt(this.original)(e);
+      throw new Error(
+        `Cannot split a chunk that has already been edited (${s.line}:${s.column} – "${t.original}")`
+      );
+    }
+    const n = t.split(e);
+    return this.byEnd[e] = t, this.byStart[e] = n, this.byEnd[n.end] = n, t === this.lastChunk && (this.lastChunk = n), this.lastSearchedChunk = t, !0;
+  }
+  toString() {
+    let t = this.intro, e = this.firstChunk;
+    for (; e; )
+      t += e.toString(), e = e.next;
+    return t + this.outro;
+  }
+  isEmpty() {
+    let t = this.firstChunk;
+    do
+      if (t.intro.length && t.intro.trim() || t.content.length && t.content.trim() || t.outro.length && t.outro.trim())
+        return !1;
+    while (t = t.next);
+    return !0;
+  }
+  length() {
+    let t = this.firstChunk, e = 0;
+    do
+      e += t.intro.length + t.content.length + t.outro.length;
+    while (t = t.next);
+    return e;
+  }
+  trimLines() {
+    return this.trim("[\\r\\n]");
+  }
+  trim(t) {
+    return this.trimStart(t).trimEnd(t);
+  }
+  trimEndAborted(t) {
+    const e = new RegExp((t || "\\s") + "+$");
+    if (this.outro = this.outro.replace(e, ""), this.outro.length) return !0;
+    let n = this.lastChunk;
+    do {
+      const s = n.end, r = n.trimEnd(e);
+      if (n.end !== s && (this.lastChunk === n && (this.lastChunk = n.next), this.byEnd[n.end] = n, this.byStart[n.next.start] = n.next, this.byEnd[n.next.end] = n.next), r) return !0;
+      n = n.previous;
+    } while (n);
+    return !1;
+  }
+  trimEnd(t) {
+    return this.trimEndAborted(t), this;
+  }
+  trimStartAborted(t) {
+    const e = new RegExp("^" + (t || "\\s") + "+");
+    if (this.intro = this.intro.replace(e, ""), this.intro.length) return !0;
+    let n = this.firstChunk;
+    do {
+      const s = n.end, r = n.trimStart(e);
+      if (n.end !== s && (n === this.lastChunk && (this.lastChunk = n.next), this.byEnd[n.end] = n, this.byStart[n.next.start] = n.next, this.byEnd[n.next.end] = n.next), r) return !0;
+      n = n.next;
+    } while (n);
+    return !1;
+  }
+  trimStart(t) {
+    return this.trimStartAborted(t), this;
+  }
+  hasChanged() {
+    return this.original !== this.toString();
+  }
+  _replaceRegexp(t, e) {
+    function n(r, u) {
+      return typeof e == "string" ? e.replace(/\$(\$|&|\d+)/g, (f, o) => o === "$" ? "$" : o === "&" ? r[0] : +o < r.length ? r[+o] : `$${o}`) : e(...r, r.index, u, r.groups);
+    }
+    function s(r, u) {
+      let f;
+      const o = [];
+      for (; f = r.exec(u); )
+        o.push(f);
+      return o;
+    }
+    if (t.global)
+      s(t, this.original).forEach((u) => {
+        if (u.index != null) {
+          const f = n(u, this.original);
+          f !== u[0] && this.overwrite(u.index, u.index + u[0].length, f);
+        }
+      });
+    else {
+      const r = this.original.match(t);
+      if (r && r.index != null) {
+        const u = n(r, this.original);
+        u !== r[0] && this.overwrite(r.index, r.index + r[0].length, u);
+      }
+    }
+    return this;
+  }
+  _replaceString(t, e) {
+    const { original: n } = this, s = n.indexOf(t);
+    return s !== -1 && this.overwrite(s, s + t.length, e), this;
+  }
+  replace(t, e) {
+    return typeof t == "string" ? this._replaceString(t, e) : this._replaceRegexp(t, e);
+  }
+  _replaceAllString(t, e) {
+    const { original: n } = this, s = t.length;
+    for (let r = n.indexOf(t); r !== -1; r = n.indexOf(t, r + s))
+      n.slice(r, r + s) !== e && this.overwrite(r, r + s, e);
+    return this;
+  }
+  replaceAll(t, e) {
+    if (typeof t == "string")
+      return this._replaceAllString(t, e);
+    if (!t.global)
+      throw new TypeError(
+        "MagicString.prototype.replaceAll called with a non-global RegExp argument"
+      );
+    return this._replaceRegexp(t, e);
+  }
+}
+export {
+  vt as SourceMap,
+  et as default
+};