@nuasite/cli 0.51.0 → 0.53.0

package/dist/index.js

@@ -22648,7 +22648,8 @@ function formatCheckReport(report) {
   for (const [file, findings] of byFile) {
     lines.push(file);
     for (const finding of findings) {
-      lines.push(`  ${finding.severity === "error" ? "error" : "warn "}  ${finding.message}  [${finding.code}]`);
+      const at = finding.line === undefined ? "" : `${finding.line}:${finding.column ?? 0}`;
+      lines.push(`  ${at.padEnd(8)}${(finding.severity === "error" ? "error" : "warn").padEnd(6)} ${finding.message}  [${finding.code}]`);
     }
   }
   return lines.join(`
@@ -23826,40 +23827,878 @@ var init_src2 = __esm(() => {
   init_project_config_ast();
 });
 
+// ../../node_modules/@astrojs/compiler/dist/chunk-W5DTLHV4.js
+import g from "crypto";
+import _ from "fs";
+import { TextDecoder as b, TextEncoder as v } from "util";
+var y, w, d = class {
+  constructor() {
+    this.argv = ["js"], this.env = {}, this.exit = (t) => {
+      t !== 0 && console.warn("exit code:", t);
+    }, this._exitPromise = new Promise((t) => {
+      this._resolveExitPromise = t;
+    }), this._pendingEvent = null, this._scheduledTimeouts = new Map, this._nextCallbackTimeoutID = 1;
+    let o = (t, e) => {
+      this.mem.setUint32(t + 0, e, true), this.mem.setUint32(t + 4, Math.floor(e / 4294967296), true);
+    }, n = (t) => {
+      let e = this.mem.getUint32(t + 0, true), s = this.mem.getInt32(t + 4, true);
+      return e + s * 4294967296;
+    }, r = (t) => {
+      let e = this.mem.getFloat64(t, true);
+      if (e === 0)
+        return;
+      if (!isNaN(e))
+        return e;
+      let s = this.mem.getUint32(t, true);
+      return this._values[s];
+    }, l = (t, e) => {
+      if (typeof e == "number" && e !== 0) {
+        if (isNaN(e)) {
+          this.mem.setUint32(t + 4, 2146959360, true), this.mem.setUint32(t, 0, true);
+          return;
+        }
+        this.mem.setFloat64(t, e, true);
+        return;
+      }
+      if (e === undefined) {
+        this.mem.setFloat64(t, 0, true);
+        return;
+      }
+      let i = this._ids.get(e);
+      i === undefined && (i = this._idPool.pop(), i === undefined && (i = this._values.length), this._values[i] = e, this._goRefCounts[i] = 0, this._ids.set(e, i)), this._goRefCounts[i]++;
+      let a = 0;
+      switch (typeof e) {
+        case "object":
+          e !== null && (a = 1);
+          break;
+        case "string":
+          a = 2;
+          break;
+        case "symbol":
+          a = 3;
+          break;
+        case "function":
+          a = 4;
+          break;
+      }
+      this.mem.setUint32(t + 4, 2146959360 | a, true), this.mem.setUint32(t, i, true);
+    }, c = (t) => {
+      let e = n(t + 0), s = n(t + 8);
+      return new Uint8Array(this._inst.exports.mem.buffer, e, s);
+    }, f = (t) => {
+      let e = n(t + 0), s = n(t + 8), i = new Array(s);
+      for (let a = 0;a < s; a++)
+        i[a] = r(e + a * 8);
+      return i;
+    }, u = (t) => {
+      let e = n(t + 0), s = n(t + 8);
+      return w.decode(new DataView(this._inst.exports.mem.buffer, e, s));
+    }, h = Date.now() - performance.now();
+    this.importObject = { gojs: { "runtime.wasmExit": (t) => {
+      t >>>= 0;
+      let e = this.mem.getInt32(t + 8, true);
+      this.exited = true, delete this._inst, delete this._values, delete this._goRefCounts, delete this._ids, delete this._idPool, this.exit(e);
+    }, "runtime.wasmWrite": (t) => {
+      t >>>= 0;
+      let e = n(t + 8), s = n(t + 16), i = this.mem.getInt32(t + 24, true);
+      _.writeSync(e, new Uint8Array(this._inst.exports.mem.buffer, s, i));
+    }, "runtime.resetMemoryDataView": (t) => {
+      t >>>= 0, this.mem = new DataView(this._inst.exports.mem.buffer);
+    }, "runtime.nanotime1": (t) => {
+      t >>>= 0, o(t + 8, (h + performance.now()) * 1e6);
+    }, "runtime.walltime": (t) => {
+      t >>>= 0;
+      let e = new Date().getTime();
+      o(t + 8, e / 1000), this.mem.setInt32(t + 16, e % 1000 * 1e6, true);
+    }, "runtime.scheduleTimeoutEvent": (t) => {
+      t >>>= 0;
+      let e = this._nextCallbackTimeoutID;
+      this._nextCallbackTimeoutID++, this._scheduledTimeouts.set(e, setTimeout(() => {
+        for (this._resume();this._scheduledTimeouts.has(e); )
+          console.warn("scheduleTimeoutEvent: missed timeout event"), this._resume();
+      }, n(t + 8) + 1)), this.mem.setInt32(t + 16, e, true);
+    }, "runtime.clearTimeoutEvent": (t) => {
+      t >>>= 0;
+      let e = this.mem.getInt32(t + 8, true);
+      clearTimeout(this._scheduledTimeouts.get(e)), this._scheduledTimeouts.delete(e);
+    }, "runtime.getRandomData": (t) => {
+      t >>>= 0, globalThis.crypto.getRandomValues(c(t + 8));
+    }, "syscall/js.finalizeRef": (t) => {
+      t >>>= 0;
+      let e = this.mem.getUint32(t + 8, true);
+      if (this._goRefCounts[e]--, this._goRefCounts[e] === 0) {
+        let s = this._values[e];
+        this._values[e] = null, this._ids.delete(s), this._idPool.push(e);
+      }
+    }, "syscall/js.stringVal": (t) => {
+      t >>>= 0, l(t + 24, u(t + 8));
+    }, "syscall/js.valueGet": (t) => {
+      t >>>= 0;
+      let e = Reflect.get(r(t + 8), u(t + 16));
+      t = this._inst.exports.getsp() >>> 0, l(t + 32, e);
+    }, "syscall/js.valueSet": (t) => {
+      t >>>= 0, Reflect.set(r(t + 8), u(t + 16), r(t + 32));
+    }, "syscall/js.valueDelete": (t) => {
+      t >>>= 0, Reflect.deleteProperty(r(t + 8), u(t + 16));
+    }, "syscall/js.valueIndex": (t) => {
+      t >>>= 0, l(t + 24, Reflect.get(r(t + 8), n(t + 16)));
+    }, "syscall/js.valueSetIndex": (t) => {
+      t >>>= 0, Reflect.set(r(t + 8), n(t + 16), r(t + 24));
+    }, "syscall/js.valueCall": (t) => {
+      t >>>= 0;
+      try {
+        let e = r(t + 8), s = Reflect.get(e, u(t + 16)), i = f(t + 32), a = Reflect.apply(s, e, i);
+        t = this._inst.exports.getsp() >>> 0, l(t + 56, a), this.mem.setUint8(t + 64, 1);
+      } catch (e) {
+        t = this._inst.exports.getsp() >>> 0, l(t + 56, e), this.mem.setUint8(t + 64, 0);
+      }
+    }, "syscall/js.valueInvoke": (t) => {
+      t >>>= 0;
+      try {
+        let e = r(t + 8), s = f(t + 16), i = Reflect.apply(e, undefined, s);
+        t = this._inst.exports.getsp() >>> 0, l(t + 40, i), this.mem.setUint8(t + 48, 1);
+      } catch (e) {
+        t = this._inst.exports.getsp() >>> 0, l(t + 40, e), this.mem.setUint8(t + 48, 0);
+      }
+    }, "syscall/js.valueNew": (t) => {
+      t >>>= 0;
+      try {
+        let e = r(t + 8), s = f(t + 16), i = Reflect.construct(e, s);
+        t = this._inst.exports.getsp() >>> 0, l(t + 40, i), this.mem.setUint8(t + 48, 1);
+      } catch (e) {
+        t = this._inst.exports.getsp() >>> 0, l(t + 40, e), this.mem.setUint8(t + 48, 0);
+      }
+    }, "syscall/js.valueLength": (t) => {
+      t >>>= 0, o(t + 16, Number.parseInt(r(t + 8).length));
+    }, "syscall/js.valuePrepareString": (t) => {
+      t >>>= 0;
+      let e = y.encode(String(r(t + 8)));
+      l(t + 16, e), o(t + 24, e.length);
+    }, "syscall/js.valueLoadString": (t) => {
+      t >>>= 0;
+      let e = r(t + 8);
+      c(t + 16).set(e);
+    }, "syscall/js.valueInstanceOf": (t) => {
+      t >>>= 0, this.mem.setUint8(t + 24, r(t + 8) instanceof r(t + 16) ? 1 : 0);
+    }, "syscall/js.copyBytesToGo": (t) => {
+      t >>>= 0;
+      let e = c(t + 8), s = r(t + 32);
+      if (!(s instanceof Uint8Array || s instanceof Uint8ClampedArray)) {
+        this.mem.setUint8(t + 48, 0);
+        return;
+      }
+      let i = s.subarray(0, e.length);
+      e.set(i), o(t + 40, i.length), this.mem.setUint8(t + 48, 1);
+    }, "syscall/js.copyBytesToJS": (t) => {
+      t >>>= 0;
+      let e = r(t + 8), s = c(t + 16);
+      if (!(e instanceof Uint8Array || e instanceof Uint8ClampedArray)) {
+        this.mem.setUint8(t + 48, 0);
+        return;
+      }
+      let i = s.subarray(0, e.length);
+      e.set(i), o(t + 40, i.length), this.mem.setUint8(t + 48, 1);
+    }, debug: (t) => {
+      console.log(t);
+    } } };
+  }
+  async run(o) {
+    if (!(o instanceof WebAssembly.Instance))
+      throw new Error("Go.run: WebAssembly.Instance expected");
+    this._inst = o, this.mem = new DataView(this._inst.exports.mem.buffer), this._values = [Number.NaN, 0, null, true, false, globalThis, this], this._goRefCounts = new Array(this._values.length).fill(Number.POSITIVE_INFINITY), this._ids = new Map([[0, 1], [null, 2], [true, 3], [false, 4], [globalThis, 5], [this, 6]]), this._idPool = [], this.exited = false;
+    let n = 4096, r = (h) => {
+      let t = n, e = y.encode(`${h}\x00`);
+      return new Uint8Array(this.mem.buffer, n, e.length).set(e), n += e.length, n % 8 !== 0 && (n += 8 - n % 8), t;
+    }, l = this.argv.length, c = [];
+    this.argv.forEach((h) => {
+      c.push(r(h));
+    }), c.push(0), Object.keys(this.env).sort().forEach((h) => {
+      c.push(r(`${h}=${this.env[h]}`));
+    }), c.push(0);
+    let u = n;
+    c.forEach((h) => {
+      this.mem.setUint32(n, h, true), this.mem.setUint32(n + 4, 0, true), n += 8;
+    }), this._inst.exports.run(l, u), this.exited && this._resolveExitPromise(), await this._exitPromise;
+  }
+  _resume() {
+    if (this.exited)
+      throw new Error("Go program has already exited");
+    this._inst.exports.resume(), this.exited && this._resolveExitPromise();
+  }
+  _makeFuncWrapper(o) {
+    let n = this;
+    return function() {
+      let r = { id: o, this: this, args: arguments };
+      return n._pendingEvent = r, n._resume(), r.result;
+    };
+  }
+};
+var init_chunk_W5DTLHV4 = __esm(() => {
+  globalThis.fs || Object.defineProperty(globalThis, "fs", { value: _ });
+  globalThis.process || Object.defineProperties(globalThis, "process", { value: process });
+  globalThis.crypto || Object.defineProperty(globalThis, "crypto", { value: g.webcrypto ? g.webcrypto : { getRandomValues(m) {
+    return g.randomFillSync(m);
+  } } });
+  globalThis.performance || Object.defineProperty(globalThis, "performance", { value: { now() {
+    let [m, o] = process.hrtime();
+    return m * 1000 + o / 1e6;
+  } } });
+  y = new v("utf-8");
+  w = new b("utf-8");
+});
+
+// ../../node_modules/@astrojs/compiler/dist/node/index.js
+import { promises as m } from "fs";
+import { fileURLToPath as f } from "url";
+var w2 = async (t, s) => i().then((r) => r.transform(t, s)), n, i = () => (n || (n = d2().catch((t) => {
+  throw n = undefined, t;
+})), n), y2 = async (t, s) => {
+  let r;
+  return r = await (async () => {
+    let o = await m.readFile(t).then((e) => e.buffer);
+    return WebAssembly.instantiate(new Uint8Array(o), s);
+  })(), r;
+}, d2 = async () => {
+  let t = new d, s = await y2(f(new URL("../astro.wasm", import.meta.url)), t.importObject);
+  t.run(s.instance);
+  let r = globalThis["@astrojs/compiler"];
+  return { transform: (a, o) => new Promise((e) => {
+    try {
+      e(r.transform(a, o || {}));
+    } catch (p) {
+      throw n = undefined, p;
+    }
+  }), parse: (a, o) => new Promise((e) => e(r.parse(a, o || {}))).catch((e) => {
+    throw n = undefined, e;
+  }).then((e) => ({ ...e, ast: JSON.parse(e.ast) })), convertToTSX: (a, o) => new Promise((e) => e(r.convertToTSX(a, o || {}))).catch((e) => {
+    throw n = undefined, e;
+  }).then((e) => ({ ...e, map: JSON.parse(e.map) })) };
+};
+var init_node = __esm(() => {
+  init_chunk_W5DTLHV4();
+});
+
+// ../../node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
+function decodeInteger(reader, relative) {
+  let value = 0;
+  let shift = 0;
+  let integer = 0;
+  do {
+    const c = reader.next();
+    integer = charToInt[c];
+    value |= (integer & 31) << shift;
+    shift += 5;
+  } while (integer & 32);
+  const shouldNegate = value & 1;
+  value >>>= 1;
+  if (shouldNegate) {
+    value = -2147483648 | -value;
+  }
+  return relative + value;
+}
+function hasMoreVlq(reader, max) {
+  if (reader.pos >= max)
+    return false;
+  return reader.peek() !== comma;
+}
+function decode(mappings) {
+  const { length } = mappings;
+  const reader = new StringReader(mappings);
+  const decoded = [];
+  let genColumn = 0;
+  let sourcesIndex = 0;
+  let sourceLine = 0;
+  let sourceColumn = 0;
+  let namesIndex = 0;
+  do {
+    const semi = reader.indexOf(";");
+    const line = [];
+    let sorted = true;
+    let lastCol = 0;
+    genColumn = 0;
+    while (reader.pos < semi) {
+      let seg;
+      genColumn = decodeInteger(reader, genColumn);
+      if (genColumn < lastCol)
+        sorted = false;
+      lastCol = genColumn;
+      if (hasMoreVlq(reader, semi)) {
+        sourcesIndex = decodeInteger(reader, sourcesIndex);
+        sourceLine = decodeInteger(reader, sourceLine);
+        sourceColumn = decodeInteger(reader, sourceColumn);
+        if (hasMoreVlq(reader, semi)) {
+          namesIndex = decodeInteger(reader, namesIndex);
+          seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
+        } else {
+          seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
+        }
+      } else {
+        seg = [genColumn];
+      }
+      line.push(seg);
+      reader.pos++;
+    }
+    if (!sorted)
+      sort(line);
+    decoded.push(line);
+    reader.pos = semi + 1;
+  } while (reader.pos <= length);
+  return decoded;
+}
+function sort(line) {
+  line.sort(sortComparator);
+}
+function sortComparator(a, b2) {
+  return a[0] - b2[0];
+}
+var comma = 44, chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", intToChar, charToInt, bufLength, StringReader = class {
+  constructor(buffer) {
+    this.pos = 0;
+    this.buffer = buffer;
+  }
+  next() {
+    return this.buffer.charCodeAt(this.pos++);
+  }
+  peek() {
+    return this.buffer.charCodeAt(this.pos);
+  }
+  indexOf(char) {
+    const { buffer, pos } = this;
+    const idx = buffer.indexOf(char, pos);
+    return idx === -1 ? buffer.length : idx;
+  }
+};
+var init_sourcemap_codec = __esm(() => {
+  intToChar = new Uint8Array(64);
+  charToInt = new Uint8Array(128);
+  for (let i2 = 0;i2 < chars.length; i2++) {
+    const c = chars.charCodeAt(i2);
+    intToChar[i2] = c;
+    charToInt[c] = i2;
+  }
+  bufLength = 1024 * 16;
+});
+
+// ../../node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs
+function isAbsoluteUrl(input) {
+  return schemeRegex.test(input);
+}
+function isSchemeRelativeUrl(input) {
+  return input.startsWith("//");
+}
+function isAbsolutePath(input) {
+  return input.startsWith("/");
+}
+function isFileUrl(input) {
+  return input.startsWith("file:");
+}
+function isRelative(input) {
+  return /^[.?#]/.test(input);
+}
+function parseAbsoluteUrl(input) {
+  const match = urlRegex.exec(input);
+  return makeUrl(match[1], match[2] || "", match[3], match[4] || "", match[5] || "/", match[6] || "", match[7] || "");
+}
+function parseFileUrl(input) {
+  const match = fileRegex.exec(input);
+  const path4 = match[2];
+  return makeUrl("file:", "", match[1] || "", "", isAbsolutePath(path4) ? path4 : "/" + path4, match[3] || "", match[4] || "");
+}
+function makeUrl(scheme, user, host, port, path4, query, hash) {
+  return {
+    scheme,
+    user,
+    host,
+    port,
+    path: path4,
+    query,
+    hash,
+    type: 7
+  };
+}
+function parseUrl(input) {
+  if (isSchemeRelativeUrl(input)) {
+    const url2 = parseAbsoluteUrl("http:" + input);
+    url2.scheme = "";
+    url2.type = 6;
+    return url2;
+  }
+  if (isAbsolutePath(input)) {
+    const url2 = parseAbsoluteUrl("http://foo.com" + input);
+    url2.scheme = "";
+    url2.host = "";
+    url2.type = 5;
+    return url2;
+  }
+  if (isFileUrl(input))
+    return parseFileUrl(input);
+  if (isAbsoluteUrl(input))
+    return parseAbsoluteUrl(input);
+  const url = parseAbsoluteUrl("http://foo.com/" + input);
+  url.scheme = "";
+  url.host = "";
+  url.type = input ? input.startsWith("?") ? 3 : input.startsWith("#") ? 2 : 4 : 1;
+  return url;
+}
+function stripPathFilename(path4) {
+  if (path4.endsWith("/.."))
+    return path4;
+  const index = path4.lastIndexOf("/");
+  return path4.slice(0, index + 1);
+}
+function mergePaths(url, base) {
+  normalizePath(base, base.type);
+  if (url.path === "/") {
+    url.path = base.path;
+  } else {
+    url.path = stripPathFilename(base.path) + url.path;
+  }
+}
+function normalizePath(url, type) {
+  const rel = type <= 4;
+  const pieces = url.path.split("/");
+  let pointer = 1;
+  let positive = 0;
+  let addTrailingSlash = false;
+  for (let i2 = 1;i2 < pieces.length; i2++) {
+    const piece = pieces[i2];
+    if (!piece) {
+      addTrailingSlash = true;
+      continue;
+    }
+    addTrailingSlash = false;
+    if (piece === ".")
+      continue;
+    if (piece === "..") {
+      if (positive) {
+        addTrailingSlash = true;
+        positive--;
+        pointer--;
+      } else if (rel) {
+        pieces[pointer++] = piece;
+      }
+      continue;
+    }
+    pieces[pointer++] = piece;
+    positive++;
+  }
+  let path4 = "";
+  for (let i2 = 1;i2 < pointer; i2++) {
+    path4 += "/" + pieces[i2];
+  }
+  if (!path4 || addTrailingSlash && !path4.endsWith("/..")) {
+    path4 += "/";
+  }
+  url.path = path4;
+}
+function resolve(input, base) {
+  if (!input && !base)
+    return "";
+  const url = parseUrl(input);
+  let inputType = url.type;
+  if (base && inputType !== 7) {
+    const baseUrl = parseUrl(base);
+    const baseType = baseUrl.type;
+    switch (inputType) {
+      case 1:
+        url.hash = baseUrl.hash;
+      case 2:
+        url.query = baseUrl.query;
+      case 3:
+      case 4:
+        mergePaths(url, baseUrl);
+      case 5:
+        url.user = baseUrl.user;
+        url.host = baseUrl.host;
+        url.port = baseUrl.port;
+      case 6:
+        url.scheme = baseUrl.scheme;
+    }
+    if (baseType > inputType)
+      inputType = baseType;
+  }
+  normalizePath(url, inputType);
+  const queryHash = url.query + url.hash;
+  switch (inputType) {
+    case 2:
+    case 3:
+      return queryHash;
+    case 4: {
+      const path4 = url.path.slice(1);
+      if (!path4)
+        return queryHash || ".";
+      if (isRelative(base || input) && !isRelative(path4)) {
+        return "./" + path4 + queryHash;
+      }
+      return path4 + queryHash;
+    }
+    case 5:
+      return url.path + queryHash;
+    default:
+      return url.scheme + "//" + url.user + url.host + url.port + url.path + queryHash;
+  }
+}
+var schemeRegex, urlRegex, fileRegex;
+var init_resolve_uri = __esm(() => {
+  schemeRegex = /^[\w+.-]+:\/\//;
+  urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+  fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+});
+
+// ../../node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs
+function stripFilename(path4) {
+  if (!path4)
+    return "";
+  const index = path4.lastIndexOf("/");
+  return path4.slice(0, index + 1);
+}
+function resolver(mapUrl, sourceRoot) {
+  const from = stripFilename(mapUrl);
+  const prefix = sourceRoot ? sourceRoot + "/" : "";
+  return (source) => resolve(prefix + (source || ""), from);
+}
+function maybeSort(mappings, owned) {
+  const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+  if (unsortedIndex === mappings.length)
+    return mappings;
+  if (!owned)
+    mappings = mappings.slice();
+  for (let i2 = unsortedIndex;i2 < mappings.length; i2 = nextUnsortedSegmentLine(mappings, i2 + 1)) {
+    mappings[i2] = sortSegments(mappings[i2], owned);
+  }
+  return mappings;
+}
+function nextUnsortedSegmentLine(mappings, start) {
+  for (let i2 = start;i2 < mappings.length; i2++) {
+    if (!isSorted(mappings[i2]))
+      return i2;
+  }
+  return mappings.length;
+}
+function isSorted(line) {
+  for (let j = 1;j < line.length; j++) {
+    if (line[j][COLUMN] < line[j - 1][COLUMN]) {
+      return false;
+    }
+  }
+  return true;
+}
+function sortSegments(line, owned) {
+  if (!owned)
+    line = line.slice();
+  return line.sort(sortComparator2);
+}
+function sortComparator2(a, b2) {
+  return a[COLUMN] - b2[COLUMN];
+}
+function binarySearch(haystack, needle, low, high) {
+  while (low <= high) {
+    const mid = low + (high - low >> 1);
+    const cmp = haystack[mid][COLUMN] - needle;
+    if (cmp === 0) {
+      found = true;
+      return mid;
+    }
+    if (cmp < 0) {
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+  found = false;
+  return low - 1;
+}
+function upperBound(haystack, needle, index) {
+  for (let i2 = index + 1;i2 < haystack.length; index = i2++) {
+    if (haystack[i2][COLUMN] !== needle)
+      break;
+  }
+  return index;
+}
+function lowerBound(haystack, needle, index) {
+  for (let i2 = index - 1;i2 >= 0; index = i2--) {
+    if (haystack[i2][COLUMN] !== needle)
+      break;
+  }
+  return index;
+}
+function memoizedState() {
+  return {
+    lastKey: -1,
+    lastNeedle: -1,
+    lastIndex: -1
+  };
+}
+function memoizedBinarySearch(haystack, needle, state, key) {
+  const { lastKey, lastNeedle, lastIndex } = state;
+  let low = 0;
+  let high = haystack.length - 1;
+  if (key === lastKey) {
+    if (needle === lastNeedle) {
+      found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
+      return lastIndex;
+    }
+    if (needle >= lastNeedle) {
+      low = lastIndex === -1 ? 0 : lastIndex;
+    } else {
+      high = lastIndex;
+    }
+  }
+  state.lastKey = key;
+  state.lastNeedle = needle;
+  return state.lastIndex = binarySearch(haystack, needle, low, high);
+}
+function parse2(map) {
+  return typeof map === "string" ? JSON.parse(map) : map;
+}
+function cast(map) {
+  return map;
+}
+function decodedMappings(map) {
+  var _a;
+  return (_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded));
+}
+function originalPositionFor(map, needle) {
+  let { line, column, bias } = needle;
+  line--;
+  if (line < 0)
+    throw new Error(LINE_GTR_ZERO);
+  if (column < 0)
+    throw new Error(COL_GTR_EQ_ZERO);
+  const decoded = decodedMappings(map);
+  if (line >= decoded.length)
+    return OMapping(null, null, null, null);
+  const segments = decoded[line];
+  const index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
+  if (index === -1)
+    return OMapping(null, null, null, null);
+  const segment = segments[index];
+  if (segment.length === 1)
+    return OMapping(null, null, null, null);
+  const { names, resolvedSources } = map;
+  return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
+}
+function OMapping(source, line, column, name) {
+  return { source, line, column, name };
+}
+function traceSegmentInternal(segments, memo, line, column, bias) {
+  let index = memoizedBinarySearch(segments, column, memo, line);
+  if (found) {
+    index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
+  } else if (bias === LEAST_UPPER_BOUND)
+    index++;
+  if (index === -1 || index === segments.length)
+    return -1;
+  return index;
+}
+var COLUMN = 0, SOURCES_INDEX = 1, SOURCE_LINE = 2, SOURCE_COLUMN = 3, NAMES_INDEX = 4, found = false, LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)", COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)", LEAST_UPPER_BOUND = -1, GREATEST_LOWER_BOUND = 1, TraceMap = class {
+  constructor(map, mapUrl) {
+    const isString = typeof map === "string";
+    if (!isString && map._decodedMemo)
+      return map;
+    const parsed = parse2(map);
+    const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+    this.version = version;
+    this.file = file;
+    this.names = names || [];
+    this.sourceRoot = sourceRoot;
+    this.sources = sources;
+    this.sourcesContent = sourcesContent;
+    this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || undefined;
+    const resolve2 = resolver(mapUrl, sourceRoot);
+    this.resolvedSources = sources.map(resolve2);
+    const { mappings } = parsed;
+    if (typeof mappings === "string") {
+      this._encoded = mappings;
+      this._decoded = undefined;
+    } else if (Array.isArray(mappings)) {
+      this._encoded = undefined;
+      this._decoded = maybeSort(mappings, isString);
+    } else if (parsed.sections) {
+      throw new Error(`TraceMap passed sectioned source map, please use FlattenMap export instead`);
+    } else {
+      throw new Error(`invalid source map: ${JSON.stringify(parsed)}`);
+    }
+    this._decodedMemo = memoizedState();
+    this._bySources = undefined;
+    this._bySourceMemos = undefined;
+  }
+};
+var init_trace_mapping = __esm(() => {
+  init_sourcemap_codec();
+  init_resolve_uri();
+});
+
+// src/check-code.ts
+var {Glob } = globalThis.Bun;
+import path4 from "path";
+function buildPosition(error) {
+  if (typeof error !== "object" || error === null || !("position" in error))
+    return null;
+  const position = error.position;
+  return typeof position === "object" && position !== null ? position : null;
+}
+function messageOf(error) {
+  const message = typeof error === "object" && error !== null && "message" in error ? error.message : undefined;
+  return String(typeof message === "string" ? message : error).split(`
+`)[0];
+}
+function toSource(map, position) {
+  if (!map || position?.line === undefined)
+    return {};
+  try {
+    const traced = originalPositionFor(new TraceMap(JSON.parse(map)), {
+      line: position.line,
+      column: position.column ?? 0
+    });
+    if (traced.line === null)
+      return {};
+    return { line: traced.line, column: traced.column + 1 };
+  } catch {
+    return {};
+  }
+}
+async function checkAstroFile(absolute, relative, source) {
+  let emitted;
+  try {
+    emitted = await w2(source, { filename: absolute, sourcemap: "both" });
+  } catch (error) {
+    return { severity: "error", code: "code/astro-parse", file: relative, message: messageOf(error) };
+  }
+  try {
+    new Bun.Transpiler({ loader: "ts" }).transformSync(emitted.code);
+    return null;
+  } catch (error) {
+    const position = buildPosition(error);
+    return {
+      severity: "error",
+      code: "code/syntax",
+      file: relative,
+      ...toSource(emitted.map, position),
+      message: messageOf(error)
+    };
+  }
+}
+function checkScriptFile(relative, source, loader) {
+  try {
+    new Bun.Transpiler({ loader }).transformSync(source);
+    return null;
+  } catch (error) {
+    const position = buildPosition(error);
+    return {
+      severity: "error",
+      code: "code/syntax",
+      file: relative,
+      line: position?.line,
+      column: position?.column === undefined ? undefined : position.column + 1,
+      message: messageOf(error)
+    };
+  }
+}
+async function checkCode(root) {
+  const findings = [];
+  let files = 0;
+  const paths = [];
+  for await (const relative of new Glob("**/*.{astro,ts,tsx,mts,cts}").scan({ cwd: root })) {
+    if (!isIgnored(relative))
+      paths.push(relative);
+  }
+  paths.sort();
+  for (const relative of paths) {
+    files++;
+    const absolute = path4.join(root, relative);
+    const source = await Bun.file(absolute).text();
+    const finding = relative.endsWith(".astro") ? await checkAstroFile(absolute, relative, source) : checkScriptFile(relative, source, relative.endsWith(".tsx") ? "tsx" : "ts");
+    if (finding)
+      findings.push(finding);
+  }
+  return { findings, files };
+}
+var IGNORED, isIgnored = (relative) => /\.d\.[mc]?ts$/.test(relative) || relative.split(path4.sep).some((segment) => IGNORED.includes(segment));
+var init_check_code = __esm(() => {
+  init_node();
+  init_trace_mapping();
+  IGNORED = ["node_modules", "dist", ".astro", ".git", ".output", ".vercel", ".netlify"];
+});
+
 // src/check.ts
 var exports_check = {};
 __export(exports_check, {
-  check: () => check
+  check: () => check,
+  astroRoots: () => astroRoots
 });
+import { existsSync, readdirSync } from "fs";
+import path5 from "path";
+function astroRoots(cwd) {
+  if (hasAstroConfig(cwd))
+    return ["."];
+  const packagesDir = path5.join(cwd, "packages");
+  if (!existsSync(packagesDir))
+    return [];
+  return readdirSync(packagesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort().filter((name) => hasAstroConfig(path5.join(packagesDir, name))).map((name) => path5.join("packages", name));
+}
+function prefixed(report, root) {
+  if (root === ".")
+    return report;
+  return {
+    ...report,
+    findings: report.findings.map((finding) => ({ ...finding, file: path5.join(root, finding.file) }))
+  };
+}
 async function check(options) {
-  const report = await checkContent(createNodeFs(options.cwd));
+  const roots = astroRoots(options.cwd);
+  if (roots.length === 0) {
+    console.error(`No astro.config.* found in ${options.cwd} or its packages/*. Run this in an Astro project.`);
+    return 1;
+  }
+  const reports = await Promise.all(roots.map(async (root) => {
+    const absolute = path5.join(options.cwd, root);
+    const content = prefixed(await checkContent(createNodeFs(absolute)), root);
+    if (options.contentOnly)
+      return { ...content, files: 0 };
+    const code = await checkCode(absolute);
+    return {
+      ...content,
+      findings: [...content.findings, ...code.findings.map((finding) => ({ ...finding, file: path5.join(root, finding.file) }))],
+      files: code.files
+    };
+  }));
+  const report = {
+    findings: reports.flatMap((one) => one.findings),
+    collections: reports.reduce((total, one) => total + one.collections, 0),
+    entries: reports.reduce((total, one) => total + one.entries, 0)
+  };
+  const sourceFiles = reports.reduce((total, one) => total + one.files, 0);
+  const errors = report.findings.filter((finding) => finding.severity === "error").length;
+  const warnings = report.findings.length - errors;
   if (options.json) {
-    console.log(JSON.stringify(report, null, 2));
+    console.log(JSON.stringify({ ...report, roots }, null, 2));
   } else {
     const formatted = formatCheckReport(report);
     if (formatted)
       console.log(formatted + `
 `);
-  }
-  const errors = report.findings.filter((finding) => finding.severity === "error").length;
-  const warnings = report.findings.length - errors;
-  if (!options.json) {
-    const counts = `${report.collections} collection(s), ${report.entries} entries`;
+    const where = roots.length === 1 && roots[0] === "." ? "" : ` in ${roots.join(", ")}`;
+    const code = options.contentOnly ? "" : `, ${sourceFiles} source file(s)`;
+    const counts = `${report.collections} collection(s), ${report.entries} entries${code}${where}`;
     console.log(errors === 0 && warnings === 0 ? `${counts} \u2014 no problems found` : `${counts} \u2014 ${errors} error(s), ${warnings} warning(s)`);
   }
   return errors > 0 || options.strict && warnings > 0 ? 1 : 0;
 }
+var ASTRO_CONFIG_NAMES, hasAstroConfig = (dir) => ASTRO_CONFIG_NAMES.some((name) => existsSync(path5.join(dir, name)));
 var init_check2 = __esm(() => {
   init_src2();
+  init_check_code();
+  ASTRO_CONFIG_NAMES = ["astro.config.ts", "astro.config.mts", "astro.config.mjs", "astro.config.js"];
 });
 
 // src/utils.ts
-import { existsSync } from "fs";
+import { existsSync as existsSync2 } from "fs";
 import { join } from "path";
 function findAstroConfig(cwd = process.cwd()) {
   for (const name of CONFIG_NAMES) {
     const p = join(cwd, name);
-    if (existsSync(p))
+    if (existsSync2(p))
       return p;
   }
   return null;
@@ -23869,11 +24708,11 @@ function findMatchingClose(text, start) {
   const close = open === "{" ? "}" : open === "[" ? "]" : ")";
   let depth = 0;
   let inString = false;
-  for (let i = start;i < text.length; i++) {
-    const ch = text[i];
+  for (let i2 = start;i2 < text.length; i2++) {
+    const ch = text[i2];
     if (inString) {
       if (ch === "\\") {
-        i++;
+        i2++;
         continue;
       }
       if (ch === inString)
@@ -23889,7 +24728,7 @@ function findMatchingClose(text, start) {
     if (ch === close) {
       depth--;
       if (depth === 0)
-        return i;
+        return i2;
     }
   }
   return -1;
@@ -23911,20 +24750,20 @@ function removeProperty(body, propName) {
     return body;
   const propLineStart = match.index + 1;
   const afterMatch = match.index + match[0].length;
-  let i = afterMatch;
-  while (i < body.length && (body[i] === " " || body[i] === "\t"))
-    i++;
+  let i2 = afterMatch;
+  while (i2 < body.length && (body[i2] === " " || body[i2] === "\t"))
+    i2++;
   let valueEnd;
-  if (body[i] === "{" || body[i] === "[") {
-    valueEnd = findMatchingClose(body, i);
+  if (body[i2] === "{" || body[i2] === "[") {
+    valueEnd = findMatchingClose(body, i2);
     if (valueEnd === -1)
       return body;
     valueEnd++;
   } else {
-    while (i < body.length && body[i] !== "," && body[i] !== `
+    while (i2 < body.length && body[i2] !== "," && body[i2] !== `
 `)
-      i++;
-    valueEnd = i;
+      i2++;
+    valueEnd = i2;
   }
   let end = valueEnd;
   while (end < body.length && (body[end] === " " || body[end] === "\t"))
@@ -23976,7 +24815,7 @@ __export(exports_init, {
   detectNuaManagedImports: () => detectNuaManagedImports,
   cleanEmptyStructures: () => cleanEmptyStructures
 });
-import { existsSync as existsSync2, readFileSync, writeFileSync } from "fs";
+import { existsSync as existsSync3, readFileSync, writeFileSync } from "fs";
 import { basename, join as join2 } from "path";
 function detectNuaManagedImports(content) {
   const managed = new Map;
@@ -24101,7 +24940,7 @@ function transformPackageJson(pkg, nuaVersion) {
   if (!result.dependencies["@nuasite/nua"]) {
     result.dependencies["@nuasite/nua"] = nuaVersion;
   }
-  result.dependencies = Object.fromEntries(Object.entries(result.dependencies).sort(([a], [b]) => a.localeCompare(b)));
+  result.dependencies = Object.fromEntries(Object.entries(result.dependencies).sort(([a], [b2]) => a.localeCompare(b2)));
   return result;
 }
 async function init({ cwd = process.cwd(), dryRun = false, yes = false } = {}) {
@@ -24120,7 +24959,7 @@ async function init({ cwd = process.cwd(), dryRun = false, yes = false } = {}) {
     process.exit(1);
   }
   const pkgPath = join2(cwd, "package.json");
-  if (!existsSync2(pkgPath)) {
+  if (!existsSync3(pkgPath)) {
     console.error("No package.json found.");
     process.exit(1);
   }
@@ -24198,7 +25037,7 @@ __export(exports_clean, {
   detectDisabledFeatures: () => detectDisabledFeatures,
   clean: () => clean
 });
-import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 import { basename as basename2, join as join3 } from "path";
 function detectDisabledFeatures(content) {
   const disabled = new Set;
@@ -24211,9 +25050,9 @@ function detectDisabledFeatures(content) {
 }
 function prependToArrayProperty(lines, property, items) {
   const pattern = new RegExp(`\\b${property}\\s*:\\s*\\[`);
-  for (let i = 0;i < lines.length; i++) {
-    if (pattern.test(lines[i])) {
-      lines[i] = lines[i].replace(new RegExp(`(\\b${property}\\s*:\\s*\\[)`), `$1${items}, `);
+  for (let i2 = 0;i2 < lines.length; i2++) {
+    if (pattern.test(lines[i2])) {
+      lines[i2] = lines[i2].replace(new RegExp(`(\\b${property}\\s*:\\s*\\[)`), `$1${items}, `);
       return true;
     }
   }
@@ -24302,16 +25141,16 @@ function transformPackageJson2(pkg, disabled, usedRuntimePackages = []) {
       result.dependencies[name] = nuaVersion ?? "^0.16.0";
     }
   }
-  result.dependencies = Object.fromEntries(Object.entries(result.dependencies).sort(([a], [b]) => a.localeCompare(b)));
+  result.dependencies = Object.fromEntries(Object.entries(result.dependencies).sort(([a], [b2]) => a.localeCompare(b2)));
   return result;
 }
 function scanForNuasiteUsage(cwd) {
   const srcDir = join3(cwd, "src");
-  if (!existsSync3(srcDir))
+  if (!existsSync4(srcDir))
     return [];
   const results = [];
   try {
-    const files = readdirSync(srcDir, { recursive: true });
+    const files = readdirSync2(srcDir, { recursive: true });
     for (const entry of files) {
       const fileName = String(entry);
       if (!/\.(astro|ts|tsx|js|jsx)$/.test(fileName))
@@ -24342,7 +25181,7 @@ async function clean({ cwd = process.cwd(), dryRun = false, yes = false } = {})
     return;
   }
   const pkgPath = join3(cwd, "package.json");
-  if (!existsSync3(pkgPath)) {
+  if (!existsSync4(pkgPath)) {
     console.error("No package.json found.");
     process.exit(1);
   }
@@ -24450,7 +25289,7 @@ var init_config = () => {};
 
 // ../cms/src/component-registry.ts
 import fs2 from "fs/promises";
-import path4 from "path";
+import path6 from "path";
 
 class ComponentRegistry {
   components = new Map;
@@ -24460,7 +25299,7 @@ class ComponentRegistry {
   }
   async scan() {
     for (const dir of this.componentDirs) {
-      const fullPath = path4.join(getProjectRoot(), dir);
+      const fullPath = path6.join(getProjectRoot(), dir);
       try {
         await this.scanDirectory(fullPath, dir);
       } catch {}
@@ -24475,8 +25314,8 @@ class ComponentRegistry {
   async scanDirectory(dir, relativePath) {
     const entries = await fs2.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path4.join(dir, entry.name);
-      const relPath = path4.join(relativePath, entry.name);
+      const fullPath = path6.join(dir, entry.name);
+      const relPath = path6.join(relativePath, entry.name);
       if (entry.isDirectory()) {
         await this.scanDirectory(fullPath, relPath);
       } else if (entry.isFile() && entry.name.endsWith(".astro")) {
@@ -24487,7 +25326,7 @@ class ComponentRegistry {
   async parseComponent(filePath, relativePath) {
     try {
       const content = await fs2.readFile(filePath, "utf-8");
-      const componentName = path4.basename(filePath, ".astro");
+      const componentName = path6.basename(filePath, ".astro");
       const props = await this.extractProps(content);
       const slots = this.extractSlots(content);
       const description = this.extractDescription(content);
@@ -24633,18 +25472,18 @@ ${propsContent}
       return null;
     const startIndex = match.index + match[0].length;
     let depth = 1;
-    let i = startIndex;
-    while (i < text.length && depth > 0) {
-      if (text[i] === "{") {
+    let i2 = startIndex;
+    while (i2 < text.length && depth > 0) {
+      if (text[i2] === "{") {
         depth++;
-      } else if (text[i] === "}") {
+      } else if (text[i2] === "}") {
         depth--;
       }
-      i++;
+      i2++;
     }
     if (depth !== 0)
       return null;
-    return text.substring(startIndex, i - 1);
+    return text.substring(startIndex, i2 - 1);
   }
   async extractProps(content) {
     const props = [];
@@ -24742,7 +25581,7 @@ function slugify2(text) {
 
 // ../cms/src/utils.ts
 import { createHash } from "crypto";
-import path5 from "path";
+import path7 from "path";
 function normalizePagePath(url) {
   let pathname;
   try {
@@ -24781,7 +25620,7 @@ function generateSourceFileHashes(entries) {
   }
   const hashes = {};
   for (const [filePath, fileEntries] of Object.entries(entriesByFile)) {
-    const sorted = fileEntries.sort((a, b) => (a.sourceLine || 0) - (b.sourceLine || 0));
+    const sorted = fileEntries.sort((a, b2) => (a.sourceLine || 0) - (b2.sourceLine || 0));
     const content = sorted.map((e) => `${e.sourceLine || 0}|${e.text}|${e.sourceSnippet || ""}`).join(`
 `);
     hashes[filePath] = sha256(content);
@@ -24795,27 +25634,27 @@ function escapeReplacement(str) {
   return str.replace(/\$/g, "$$$$");
 }
 function resolveSourcePath(sourcePath) {
-  return path5.isAbsolute(sourcePath) ? sourcePath : path5.join(getProjectRoot(), sourcePath);
+  return path7.isAbsolute(sourcePath) ? sourcePath : path7.join(getProjectRoot(), sourcePath);
 }
 function resolveAndValidatePath(filePath) {
   const projectRoot = getProjectRoot();
-  const resolvedRoot = path5.resolve(projectRoot);
+  const resolvedRoot = path7.resolve(projectRoot);
   const isAbsoluteFs = filePath.startsWith(resolvedRoot);
   const normalizedPath = !isAbsoluteFs && filePath.startsWith("/") ? filePath.slice(1) : filePath;
-  const fullPath = path5.isAbsolute(normalizedPath) ? path5.resolve(normalizedPath) : path5.resolve(projectRoot, normalizedPath);
-  if (!fullPath.startsWith(resolvedRoot + path5.sep) && fullPath !== resolvedRoot) {
+  const fullPath = path7.isAbsolute(normalizedPath) ? path7.resolve(normalizedPath) : path7.resolve(projectRoot, normalizedPath);
+  if (!fullPath.startsWith(resolvedRoot + path7.sep) && fullPath !== resolvedRoot) {
     throw new Error(`Path traversal detected: ${filePath}`);
   }
   return fullPath;
 }
 async function acquireFileLock(filePath) {
-  const key = path5.resolve(filePath);
+  const key = path7.resolve(filePath);
   while (fileLocks.has(key)) {
     await fileLocks.get(key);
   }
   let release;
-  const lockPromise = new Promise((resolve) => {
-    release = resolve;
+  const lockPromise = new Promise((resolve2) => {
+    release = resolve2;
   });
   fileLocks.set(key, lockPromise);
   return () => {
@@ -24827,8 +25666,8 @@ function escapeHtml2(text) {
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
 function relativeImportPath2(fromFile, toFile) {
-  const fromDir = path5.dirname(fromFile);
-  let rel = path5.relative(fromDir, toFile).split(path5.sep).join("/");
+  const fromDir = path7.dirname(fromFile);
+  let rel = path7.relative(fromDir, toFile).split(path7.sep).join("/");
   if (!rel.startsWith("."))
     rel = `./${rel}`;
   return rel;
@@ -24841,7 +25680,7 @@ var init_utils2 = __esm(() => {
 
 // ../cms/src/handlers/component-ops.ts
 import fs3 from "fs/promises";
-import path6 from "path";
+import path8 from "path";
 async function handleInsertComponent(request, manifestWriter) {
   const { position, referenceComponentId, componentName, props, meta } = request;
   if (!meta?.url) {
@@ -24982,12 +25821,12 @@ async function handleRemoveComponent(request, manifestWriter) {
 function findComponentBounds(lines, startLineIndex, componentName) {
   const startLine = startLineIndex;
   let tagClosed = false;
-  for (let i = startLineIndex;i < lines.length; i++) {
-    const currentLine = lines[i];
+  for (let i2 = startLineIndex;i2 < lines.length; i2++) {
+    const currentLine = lines[i2];
     const selfCloseIdx = currentLine.indexOf("/>");
     const openEndIdx = currentLine.indexOf(">");
     if (selfCloseIdx >= 0 && (openEndIdx < 0 || selfCloseIdx <= openEndIdx)) {
-      return { startLine, endLine: i };
+      return { startLine, endLine: i2 };
     }
     if (openEndIdx >= 0) {
       tagClosed = true;
@@ -25001,8 +25840,8 @@ function findComponentBounds(lines, startLineIndex, componentName) {
   const closingTag = `</${componentName}>`;
   let depth = 1;
   let endLine = startLineIndex;
-  for (let i = startLineIndex + 1;i < lines.length; i++) {
-    const currentLine = lines[i];
+  for (let i2 = startLineIndex + 1;i2 < lines.length; i2++) {
+    const currentLine = lines[i2];
     const openingMatches = currentLine.match(new RegExp(`<${escapedName}(?:\\s|>)`, "g"));
     if (openingMatches) {
       for (const match of openingMatches) {
@@ -25018,7 +25857,7 @@ function findComponentBounds(lines, startLineIndex, componentName) {
       depth -= closingMatches.length;
     }
     if (depth <= 0) {
-      endLine = i;
+      endLine = i2;
       break;
     }
   }
@@ -25059,7 +25898,7 @@ function getComponentOccurrenceIndex(manifest, referenceComponent) {
 async function findComponentInvocationFile(projectRoot, pageUrl, manifest, referenceComponent) {
   if (referenceComponent.invocationSourcePath) {
     const filePath = normalizeFilePath(referenceComponent.invocationSourcePath);
-    const fullPath = path6.resolve(projectRoot, filePath);
+    const fullPath = path8.resolve(projectRoot, filePath);
     try {
       const content = await fs3.readFile(fullPath, "utf-8");
       const lines = content.split(`
@@ -25073,7 +25912,7 @@ async function findComponentInvocationFile(projectRoot, pageUrl, manifest, refer
   const candidates = getPageFileCandidates(pageUrl);
   const occurrenceIndex = getComponentOccurrenceIndex(manifest, referenceComponent);
   for (const candidate of candidates) {
-    const fullPath = path6.resolve(projectRoot, candidate);
+    const fullPath = path8.resolve(projectRoot, candidate);
     try {
       const content = await fs3.readFile(fullPath, "utf-8");
       const lines = content.split(`
@@ -25089,22 +25928,22 @@ async function findComponentInvocationFile(projectRoot, pageUrl, manifest, refer
 function findComponentInvocationLine(lines, componentName, occurrenceIndex) {
   const pattern = new RegExp(`<${escapeRegex(componentName)}(?:\\s|>|/>|$)`);
   const startLine = findFrontmatterEnd(lines);
-  let found = 0;
-  for (let i = startLine;i < lines.length; i++) {
-    if (pattern.test(lines[i])) {
-      if (found === occurrenceIndex)
-        return i;
-      found++;
+  let found2 = 0;
+  for (let i2 = startLine;i2 < lines.length; i2++) {
+    if (pattern.test(lines[i2])) {
+      if (found2 === occurrenceIndex)
+        return i2;
+      found2++;
     }
   }
-  return found > 0 ? findComponentInvocationLine(lines, componentName, 0) : -1;
+  return found2 > 0 ? findComponentInvocationLine(lines, componentName, 0) : -1;
 }
 function findFrontmatterEnd(lines) {
   if (lines.length === 0 || lines[0].trim() !== "---")
     return 0;
-  for (let i = 1;i < lines.length; i++) {
-    if (lines[i].trim() === "---")
-      return i + 1;
+  for (let i2 = 1;i2 < lines.length; i2++) {
+    if (lines[i2].trim() === "---")
+      return i2 + 1;
   }
   return 0;
 }
@@ -25133,7 +25972,7 @@ function getIndentation(line) {
 function normalizeFilePath(p) {
   if (!p.startsWith("/"))
     return p;
-  const projectRoot = path6.resolve(getProjectRoot());
+  const projectRoot = path8.resolve(getProjectRoot());
   if (p.startsWith(projectRoot))
     return p;
   return p.slice(1);
@@ -25141,17 +25980,17 @@ function normalizeFilePath(p) {
 function ensureComponentImport(lines, componentName, componentFile, targetFile) {
   const importPattern = new RegExp(`import\\s+${escapeRegex(componentName)}\\s+from\\s+['"]`);
   const frontmatterEnd = findFrontmatterEnd(lines);
-  for (let i = 0;i < frontmatterEnd; i++) {
-    if (importPattern.test(lines[i])) {
+  for (let i2 = 0;i2 < frontmatterEnd; i2++) {
+    if (importPattern.test(lines[i2])) {
       return;
     }
   }
   const importStatement = `import ${componentName} from '${relativeImportPath2(targetFile, componentFile)}'`;
   if (frontmatterEnd > 0) {
     let insertAt = 1;
-    for (let i = 1;i < frontmatterEnd - 1; i++) {
-      if (/^\s*import\s/.test(lines[i])) {
-        insertAt = i + 1;
+    for (let i2 = 1;i2 < frontmatterEnd - 1; i2++) {
+      if (/^\s*import\s/.test(lines[i2])) {
+        insertAt = i2 + 1;
       }
     }
     lines.splice(insertAt, 0, importStatement);
@@ -25188,11 +26027,11 @@ function buildMapPattern(varName) {
 }
 function detectArrayPattern(lines, invocationLineIndex) {
   const searchStart = Math.max(0, invocationLineIndex - 5);
-  for (let i = invocationLineIndex;i >= searchStart; i--) {
-    const line = lines[i];
+  for (let i2 = invocationLineIndex;i2 >= searchStart; i2--) {
+    const line = lines[i2];
     const match = line.match(new RegExp(buildMapPattern()));
     if (match) {
-      return { arrayVarName: match[1], mapLineIndex: i };
+      return { arrayVarName: match[1], mapLineIndex: i2 };
     }
   }
   return null;
@@ -25254,10 +26093,10 @@ async function resolveArrayContext(component, manifest, pageUrl) {
     let mapLineIndex = -1;
     let occurrencesSeen = 0;
     const mapPattern = new RegExp(buildMapPattern(arrayVarName));
-    for (let i = fmEnd2;i < lines2.length; i++) {
-      if (mapPattern.test(lines2[i])) {
+    for (let i2 = fmEnd2;i2 < lines2.length; i2++) {
+      if (mapPattern.test(lines2[i2])) {
         if (occurrencesSeen === mapOccurrence) {
-          mapLineIndex = i;
+          mapLineIndex = i2;
           break;
         }
         occurrencesSeen++;
@@ -25271,7 +26110,7 @@ async function resolveArrayContext(component, manifest, pageUrl) {
     const elementBounds2 = findArrayDeclaration(frontmatterContent2, frontmatterStartLine2, arrayVarName);
     if (!elementBounds2 || elementBounds2.length === 0)
       return null;
-    const sameSourceComponents2 = Object.values(manifest.components).filter((c) => c.componentName === component.componentName && c.invocationSourcePath === component.invocationSourcePath).sort((a, b) => (a.invocationIndex ?? 0) - (b.invocationIndex ?? 0));
+    const sameSourceComponents2 = Object.values(manifest.components).filter((c) => c.componentName === component.componentName && c.invocationSourcePath === component.invocationSourcePath).sort((a, b2) => (a.invocationIndex ?? 0) - (b2.invocationIndex ?? 0));
     const arrayIndex2 = sameSourceComponents2.findIndex((c) => c.id === component.id);
     if (arrayIndex2 < 0 || arrayIndex2 >= elementBounds2.length)
       return null;
@@ -25318,7 +26157,7 @@ async function resolveArrayContext(component, manifest, pageUrl) {
     return null;
   }
   const occurrenceIndex = getComponentOccurrenceIndex(manifest, component);
-  const sameSourceComponents = Object.values(manifest.components).filter((c) => c.componentName === component.componentName && c.invocationSourcePath === component.invocationSourcePath).sort((a, b) => (a.invocationIndex ?? 0) - (b.invocationIndex ?? 0));
+  const sameSourceComponents = Object.values(manifest.components).filter((c) => c.componentName === component.componentName && c.invocationSourcePath === component.invocationSourcePath).sort((a, b2) => (a.invocationIndex ?? 0) - (b2.invocationIndex ?? 0));
   const arrayIndex = sameSourceComponents.findIndex((c) => c.id === component.id);
   if (arrayIndex < 0 || arrayIndex >= elementBounds.length) {
     return null;
@@ -25450,8 +26289,8 @@ async function handleAddArrayItem(request, manifestWriter) {
       const newElement = generateObjectLiteral(props);
       const indentation = getIndentation(freshLines[refBounds.startLine]);
       const indentedLines = newElement.split(`
-`).map((line, i) => {
-        if (i === 0)
+`).map((line, i2) => {
+        if (i2 === 0)
           return indentation + line;
         if (line.trim())
           return indentation + line;
@@ -25475,11 +26314,11 @@ async function handleAddArrayItem(request, manifestWriter) {
       const addedLineCount = indentedLines.split(`
 `).length;
       const closingSearchStart = lastEl.endLine + addedLineCount + 1;
-      for (let i = closingSearchStart;i < closingSearchStart + 5 && i < freshLines.length; i++) {
-        if (freshLines[i].trim().startsWith("]")) {
-          const prev = freshLines[i - 1];
+      for (let i2 = closingSearchStart;i2 < closingSearchStart + 5 && i2 < freshLines.length; i2++) {
+        if (freshLines[i2].trim().startsWith("]")) {
+          const prev = freshLines[i2 - 1];
           if (prev?.trimEnd().endsWith(",")) {
-            freshLines[i - 1] = prev.replace(/,(\s*)$/, "$1");
+            freshLines[i2 - 1] = prev.replace(/,(\s*)$/, "$1");
           }
           break;
         }
@@ -25541,45 +26380,45 @@ var init_array_ops = __esm(() => {
 // ../cms/src/astro-image-paths.ts
 import { createHash as createHash2 } from "crypto";
 import fs5 from "fs/promises";
-import path7 from "path";
+import path9 from "path";
 function isHugoStyleEntry(entryAbsPath) {
-  return HUGO_INDEX_RE.test(path7.basename(entryAbsPath));
+  return HUGO_INDEX_RE.test(path9.basename(entryAbsPath));
 }
 function shortContentHash(buf) {
   return createHash2("sha256").update(buf).digest("hex").slice(0, 8);
 }
 async function pickAstroImageTarget(args) {
-  const entryDir = path7.dirname(args.entryAbsPath);
+  const entryDir = path9.dirname(args.entryAbsPath);
   const isHugoStyle = isHugoStyleEntry(args.entryAbsPath);
-  const safeFilename = path7.basename(args.originalFilename);
+  const safeFilename = path9.basename(args.originalFilename);
   if (!safeFilename || safeFilename === "." || safeFilename === "..") {
     throw new Error(`Invalid filename: ${args.originalFilename}`);
   }
   const baseName = isHugoStyle ? safeFilename : `${args.slug}-${safeFilename}`;
-  const baseAbs = path7.join(entryDir, baseName);
+  const baseAbs = path9.join(entryDir, baseName);
   if (await isFreeOrMatching(baseAbs, args.compareBuffer)) {
     return { absPath: baseAbs, relPath: `./${baseName}` };
   }
   const candidateAbs = await pickHashedSibling(entryDir, baseName, args.compareBuffer);
-  return { absPath: candidateAbs, relPath: `./${path7.basename(candidateAbs)}` };
+  return { absPath: candidateAbs, relPath: `./${path9.basename(candidateAbs)}` };
 }
 async function pickSiblingTarget(dir, filename, buf) {
-  const safe = path7.basename(filename);
+  const safe = path9.basename(filename);
   if (!safe || safe === "." || safe === "..") {
     throw new Error(`Invalid filename: ${filename}`);
   }
-  const baseAbs = path7.join(dir, safe);
+  const baseAbs = path9.join(dir, safe);
   if (await isFreeOrMatching(baseAbs, buf))
     return baseAbs;
   return pickHashedSibling(dir, safe, buf);
 }
 async function pickHashedSibling(dir, baseName, buf) {
   const hash = shortContentHash(buf);
-  const ext = path7.extname(baseName);
-  const stem = path7.basename(baseName, ext);
+  const ext = path9.extname(baseName);
+  const stem = path9.basename(baseName, ext);
   for (let attempt = 0;attempt < 5; attempt++) {
     const suffix = attempt === 0 ? hash : `${hash}-${attempt}`;
-    const candidateAbs = path7.join(dir, `${stem}-${suffix}${ext}`);
+    const candidateAbs = path9.join(dir, `${stem}-${suffix}${ext}`);
     if (await isFreeOrMatching(candidateAbs, buf))
       return candidateAbs;
   }
@@ -25603,7 +26442,7 @@ var init_astro_image_paths = __esm(() => {
 
 // ../cms/src/handlers/astro-image-upload.ts
 import fs6 from "fs/promises";
-import path8 from "path";
+import path10 from "path";
 async function tryAstroImageUpload(args) {
   const { collection, entry, field } = args.context;
   if (!collection || !entry || !field)
@@ -25612,7 +26451,7 @@ async function tryAstroImageUpload(args) {
   const def = definitions[collection];
   if (!def)
     return null;
-  const fieldDef = def.fields.find((f) => f.name === field);
+  const fieldDef = def.fields.find((f2) => f2.name === field);
   if (!fieldDef?.astroImage)
     return null;
   const entryInfo = def.entries?.find((e) => e.slug === entry);
@@ -25625,12 +26464,12 @@ async function tryAstroImageUpload(args) {
     originalFilename: args.originalFilename,
     compareBuffer: args.fileBuffer
   });
-  await fs6.mkdir(path8.dirname(target.absPath), { recursive: true });
+  await fs6.mkdir(path10.dirname(target.absPath), { recursive: true });
   await fs6.writeFile(target.absPath, args.fileBuffer);
   return {
     success: true,
     url: target.relPath,
-    filename: path8.basename(target.absPath)
+    filename: path10.basename(target.absPath)
   };
 }
 var init_astro_image_upload = __esm(() => {
@@ -25644,8 +26483,8 @@ async function handleCheckSlugExists(slug) {
   const normalizedSlug = slugify2(slug);
   if (!normalizedSlug)
     return { exists: false };
-  const found = await findPageFile(`/${normalizedSlug}`);
-  return found ? { exists: true, filePath: found } : { exists: false };
+  const found2 = await findPageFile(`/${normalizedSlug}`);
+  return found2 ? { exists: true, filePath: found2 } : { exists: false };
 }
 async function fileExists(fullPath) {
   try {
@@ -25677,7 +26516,7 @@ var init_page_ops2 = __esm(() => {
 
 // ../cms/src/handlers/request-utils.ts
 function readBody(req, maxSize = MAX_BODY_SIZE) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const chunks = [];
     let totalSize = 0;
     req.on("data", (chunk) => {
@@ -25689,7 +26528,7 @@ function readBody(req, maxSize = MAX_BODY_SIZE) {
       }
       chunks.push(chunk);
     });
-    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("end", () => resolve2(Buffer.concat(chunks)));
     req.on("error", reject);
   });
 }
@@ -25877,8 +26716,8 @@ var require_he = __commonJS((exports, module) => {
     var parseError = function(message) {
       throw Error("Parse error: " + message);
     };
-    var encode = function(string, options) {
-      options = merge(options, encode.options);
+    var encode2 = function(string, options) {
+      options = merge(options, encode2.options);
       var strict = options.strict;
       if (strict && regexInvalidRawCodePoint.test(string)) {
         parseError("forbidden code point");
@@ -25925,15 +26764,15 @@ var require_he = __commonJS((exports, module) => {
         return escapeCodePoint(codePoint);
       }).replace(regexBmpWhitelist, escapeBmpSymbol);
     };
-    encode.options = {
+    encode2.options = {
       allowUnsafeSymbols: false,
       encodeEverything: false,
       strict: false,
       useNamedReferences: false,
       decimal: false
     };
-    var decode = function(html, options) {
-      options = merge(options, decode.options);
+    var decode2 = function(html, options) {
+      options = merge(options, decode2.options);
       var strict = options.strict;
       if (strict && regexInvalidEntity.test(html)) {
         parseError("malformed character reference");
@@ -25988,7 +26827,7 @@ var require_he = __commonJS((exports, module) => {
         return $0;
       });
     };
-    decode.options = {
+    decode2.options = {
       isAttributeValue: false,
       strict: false
     };
@@ -25999,10 +26838,10 @@ var require_he = __commonJS((exports, module) => {
     };
     var he = {
       version: "1.2.0",
-      encode,
-      decode,
+      encode: encode2,
+      decode: decode2,
       escape,
-      unescape: decode
+      unescape: decode2
     };
     if (typeof define == "function" && typeof define.amd == "object" && define.amd) {
       define(function() {
@@ -26136,30 +26975,30 @@ var require_lib2 = __commonJS((exports) => {
 // ../../node_modules/domhandler/lib/node.js
 var require_node2 = __commonJS((exports) => {
   var __extends = exports && exports.__extends || function() {
-    var extendStatics = function(d, b) {
-      extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
-        d2.__proto__ = b2;
-      } || function(d2, b2) {
-        for (var p in b2)
-          if (Object.prototype.hasOwnProperty.call(b2, p))
-            d2[p] = b2[p];
+    var extendStatics = function(d3, b2) {
+      extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d4, b3) {
+        d4.__proto__ = b3;
+      } || function(d4, b3) {
+        for (var p in b3)
+          if (Object.prototype.hasOwnProperty.call(b3, p))
+            d4[p] = b3[p];
       };
-      return extendStatics(d, b);
+      return extendStatics(d3, b2);
     };
-    return function(d, b) {
-      if (typeof b !== "function" && b !== null)
-        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-      extendStatics(d, b);
+    return function(d3, b2) {
+      if (typeof b2 !== "function" && b2 !== null)
+        throw new TypeError("Class extends value " + String(b2) + " is not a constructor or null");
+      extendStatics(d3, b2);
       function __() {
-        this.constructor = d;
+        this.constructor = d3;
       }
-      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __);
+      d3.prototype = b2 === null ? Object.create(b2) : (__.prototype = b2.prototype, new __);
     };
   }();
   var __assign = exports && exports.__assign || function() {
     __assign = Object.assign || function(t) {
-      for (var s, i = 1, n = arguments.length;i < n; i++) {
-        s = arguments[i];
+      for (var s, i2 = 1, n2 = arguments.length;i2 < n2; i2++) {
+        s = arguments[i2];
         for (var p in s)
           if (Object.prototype.hasOwnProperty.call(s, p))
             t[p] = s[p];
@@ -26503,9 +27342,9 @@ var require_node2 = __commonJS((exports) => {
     var children = childs.map(function(child) {
       return cloneNode(child, true);
     });
-    for (var i = 1;i < children.length; i++) {
-      children[i].prev = children[i - 1];
-      children[i - 1].next = children[i];
+    for (var i2 = 1;i2 < children.length; i2++) {
+      children[i2].prev = children[i2 - 1];
+      children[i2 - 1].next = children[i2];
     }
     return children;
   }
@@ -26513,25 +27352,25 @@ var require_node2 = __commonJS((exports) => {
 
 // ../../node_modules/domhandler/lib/index.js
 var require_lib3 = __commonJS((exports) => {
-  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m2, k, k2) {
     if (k2 === undefined)
       k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+    var desc = Object.getOwnPropertyDescriptor(m2, k);
+    if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
       desc = { enumerable: true, get: function() {
-        return m[k];
+        return m2[k];
       } };
     }
     Object.defineProperty(o, k2, desc);
-  } : function(o, m, k, k2) {
+  } : function(o, m2, k, k2) {
     if (k2 === undefined)
       k2 = k;
-    o[k2] = m[k];
+    o[k2] = m2[k];
   });
-  var __exportStar = exports && exports.__exportStar || function(m, exports2) {
-    for (var p in m)
+  var __exportStar = exports && exports.__exportStar || function(m2, exports2) {
+    for (var p in m2)
       if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
-        __createBinding(exports2, m, p);
+        __createBinding(exports2, m2, p);
   };
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.DomHandler = undefined;
@@ -26745,25 +27584,25 @@ var require_decode_codepoint = __commonJS((exports) => {
 
 // ../../node_modules/dom-serializer/node_modules/entities/lib/decode.js
 var require_decode = __commonJS((exports) => {
-  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m2, k, k2) {
     if (k2 === undefined)
       k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+    var desc = Object.getOwnPropertyDescriptor(m2, k);
+    if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
       desc = { enumerable: true, get: function() {
-        return m[k];
+        return m2[k];
       } };
     }
     Object.defineProperty(o, k2, desc);
-  } : function(o, m, k, k2) {
+  } : function(o, m2, k, k2) {
     if (k2 === undefined)
       k2 = k;
-    o[k2] = m[k];
+    o[k2] = m2[k];
   });
-  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-  } : function(o, v) {
-    o["default"] = v;
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v2) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v2 });
+  } : function(o, v2) {
+    o["default"] = v2;
   });
   var __importStar = exports && exports.__importStar || function(mod) {
     if (mod && mod.__esModule)
@@ -27097,8 +27936,8 @@ var require_decode = __commonJS((exports) => {
 var require_encode_html = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   function restoreDiff(arr) {
-    for (var i = 1;i < arr.length; i++) {
-      arr[i][0] += arr[i - 1][0] + 1;
+    for (var i2 = 1;i2 < arr.length; i2++) {
+      arr[i2][0] += arr[i2 - 1][0] + 1;
     }
     return arr;
   }
@@ -27127,14 +27966,14 @@ var require_escape = __commonJS((exports) => {
     var lastIdx = 0;
     var match;
     while ((match = exports.xmlReplacer.exec(str)) !== null) {
-      var i = match.index;
-      var char = str.charCodeAt(i);
+      var i2 = match.index;
+      var char = str.charCodeAt(i2);
       var next = xmlCodeMap.get(char);
       if (next !== undefined) {
-        ret += str.substring(lastIdx, i) + next;
-        lastIdx = i + 1;
+        ret += str.substring(lastIdx, i2) + next;
+        lastIdx = i2 + 1;
       } else {
-        ret += "".concat(str.substring(lastIdx, i), "&#x").concat((0, exports.getCodePoint)(str, i).toString(16), ";");
+        ret += "".concat(str.substring(lastIdx, i2), "&#x").concat((0, exports.getCodePoint)(str, i2).toString(16), ";");
         lastIdx = exports.xmlReplacer.lastIndex += Number((char & 64512) === 55296);
       }
     }
@@ -27194,13 +28033,13 @@ var require_encode = __commonJS((exports) => {
     var lastIdx = 0;
     var match;
     while ((match = regExp.exec(str)) !== null) {
-      var i = match.index;
-      ret += str.substring(lastIdx, i);
-      var char = str.charCodeAt(i);
+      var i2 = match.index;
+      ret += str.substring(lastIdx, i2);
+      var char = str.charCodeAt(i2);
       var next = encode_html_js_1.default.get(char);
       if (typeof next === "object") {
-        if (i + 1 < str.length) {
-          var nextChar = str.charCodeAt(i + 1);
+        if (i2 + 1 < str.length) {
+          var nextChar = str.charCodeAt(i2 + 1);
           var value = typeof next.n === "number" ? next.n === nextChar ? next.o : undefined : next.n.get(nextChar);
           if (value !== undefined) {
             ret += value;
@@ -27212,9 +28051,9 @@ var require_encode = __commonJS((exports) => {
       }
       if (next !== undefined) {
         ret += next;
-        lastIdx = i + 1;
+        lastIdx = i2 + 1;
       } else {
-        var cp = (0, escape_js_1.getCodePoint)(str, i);
+        var cp = (0, escape_js_1.getCodePoint)(str, i2);
         ret += "&#x".concat(cp.toString(16), ";");
         lastIdx = regExp.lastIndex += Number(cp !== char);
       }
@@ -27243,7 +28082,7 @@ var require_lib4 = __commonJS((exports) => {
     EncodingMode2[EncodingMode2["Attribute"] = 3] = "Attribute";
     EncodingMode2[EncodingMode2["Text"] = 4] = "Text";
   })(EncodingMode = exports.EncodingMode || (exports.EncodingMode = {}));
-  function decode(data, options) {
+  function decode2(data, options) {
     if (options === undefined) {
       options = EntityLevel.XML;
     }
@@ -27254,7 +28093,7 @@ var require_lib4 = __commonJS((exports) => {
     }
     return (0, decode_js_1.decodeXML)(data);
   }
-  exports.decode = decode;
+  exports.decode = decode2;
   function decodeStrict(data, options) {
     var _a;
     if (options === undefined) {
@@ -27262,10 +28101,10 @@ var require_lib4 = __commonJS((exports) => {
     }
     var opts = typeof options === "number" ? { level: options } : options;
     (_a = opts.mode) !== null && _a !== undefined || (opts.mode = decode_js_1.DecodingMode.Strict);
-    return decode(data, opts);
+    return decode2(data, opts);
   }
   exports.decodeStrict = decodeStrict;
-  function encode(data, options) {
+  function encode2(data, options) {
     if (options === undefined) {
       options = EntityLevel.XML;
     }
@@ -27284,7 +28123,7 @@ var require_lib4 = __commonJS((exports) => {
     }
     return (0, escape_js_1.encodeXML)(data);
   }
-  exports.encode = encode;
+  exports.encode = encode2;
   var escape_js_2 = require_escape();
   Object.defineProperty(exports, "encodeXML", { enumerable: true, get: function() {
     return escape_js_2.encodeXML;
@@ -27464,8 +28303,8 @@ var require_foreignNames = __commonJS((exports) => {
 var require_lib5 = __commonJS((exports) => {
   var __assign = exports && exports.__assign || function() {
     __assign = Object.assign || function(t) {
-      for (var s, i = 1, n = arguments.length;i < n; i++) {
-        s = arguments[i];
+      for (var s, i2 = 1, n2 = arguments.length;i2 < n2; i2++) {
+        s = arguments[i2];
         for (var p in s)
           if (Object.prototype.hasOwnProperty.call(s, p))
             t[p] = s[p];
@@ -27474,25 +28313,25 @@ var require_lib5 = __commonJS((exports) => {
     };
     return __assign.apply(this, arguments);
   };
-  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m2, k, k2) {
     if (k2 === undefined)
       k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+    var desc = Object.getOwnPropertyDescriptor(m2, k);
+    if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
       desc = { enumerable: true, get: function() {
-        return m[k];
+        return m2[k];
       } };
     }
     Object.defineProperty(o, k2, desc);
-  } : function(o, m, k, k2) {
+  } : function(o, m2, k, k2) {
     if (k2 === undefined)
       k2 = k;
-    o[k2] = m[k];
+    o[k2] = m2[k];
   });
-  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-  } : function(o, v) {
-    o["default"] = v;
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v2) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v2 });
+  } : function(o, v2) {
+    o["default"] = v2;
   });
   var __importStar = exports && exports.__importStar || function(mod) {
     if (mod && mod.__esModule)
@@ -27528,7 +28367,7 @@ var require_lib5 = __commonJS((exports) => {
     var _a;
     if (!attributes)
       return;
-    var encode = ((_a = opts.encodeEntities) !== null && _a !== undefined ? _a : opts.decodeEntities) === false ? replaceQuotes : opts.xmlMode || opts.encodeEntities !== "utf8" ? entities_1.encodeXML : entities_1.escapeAttribute;
+    var encode2 = ((_a = opts.encodeEntities) !== null && _a !== undefined ? _a : opts.decodeEntities) === false ? replaceQuotes : opts.xmlMode || opts.encodeEntities !== "utf8" ? entities_1.encodeXML : entities_1.escapeAttribute;
     return Object.keys(attributes).map(function(key) {
       var _a2, _b;
       var value = (_a2 = attributes[key]) !== null && _a2 !== undefined ? _a2 : "";
@@ -27538,7 +28377,7 @@ var require_lib5 = __commonJS((exports) => {
       if (!opts.emptyAttrs && !opts.xmlMode && value === "") {
         return key;
       }
-      return "".concat(key, '="').concat(encode(value), '"');
+      return "".concat(key, '="').concat(encode2(value), '"');
     }).join(" ");
   }
   var singleTag = new Set([
@@ -27568,8 +28407,8 @@ var require_lib5 = __commonJS((exports) => {
     }
     var nodes = "length" in node ? node : [node];
     var output = "";
-    for (var i = 0;i < nodes.length; i++) {
-      output += renderNode(nodes[i], options);
+    for (var i2 = 0;i2 < nodes.length; i2++) {
+      output += renderNode(nodes[i2], options);
     }
     return output;
   }
@@ -27925,15 +28764,15 @@ var require_querying = __commonJS((exports) => {
       recurse = true;
     }
     var searchedNodes = Array.isArray(nodes) ? nodes : [nodes];
-    for (var i = 0;i < searchedNodes.length; i++) {
-      var node = searchedNodes[i];
+    for (var i2 = 0;i2 < searchedNodes.length; i2++) {
+      var node = searchedNodes[i2];
       if ((0, domhandler_1.isTag)(node) && test(node)) {
         return node;
       }
       if (recurse && (0, domhandler_1.hasChildren)(node) && node.children.length > 0) {
-        var found = findOne(test, node.children, true);
-        if (found)
-          return found;
+        var found2 = findOne(test, node.children, true);
+        if (found2)
+          return found2;
       }
     }
     return null;
@@ -28022,9 +28861,9 @@ var require_legacy = __commonJS((exports) => {
       return (0, domhandler_1.isTag)(elem) && elem.attribs[attrib] === value;
     };
   }
-  function combineFuncs(a, b) {
+  function combineFuncs(a, b2) {
     return function(elem) {
-      return a(elem) || b(elem);
+      return a(elem) || b2(elem);
     };
   }
   function compileTest(options) {
@@ -28155,11 +28994,11 @@ var require_helpers = __commonJS((exports) => {
     return DocumentPosition.PRECEDING;
   }
   function uniqueSort(nodes) {
-    nodes = nodes.filter(function(node, i, arr) {
-      return !arr.includes(node, i + 1);
+    nodes = nodes.filter(function(node, i2, arr) {
+      return !arr.includes(node, i2 + 1);
     });
-    nodes.sort(function(a, b) {
-      var relative = compareDocumentPosition(a, b);
+    nodes.sort(function(a, b2) {
+      var relative = compareDocumentPosition(a, b2);
       if (relative & DocumentPosition.PRECEDING) {
         return -1;
       } else if (relative & DocumentPosition.FOLLOWING) {
@@ -28310,25 +29149,25 @@ var require_feeds = __commonJS((exports) => {
 
 // ../../node_modules/domutils/lib/index.js
 var require_lib6 = __commonJS((exports) => {
-  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m2, k, k2) {
     if (k2 === undefined)
       k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+    var desc = Object.getOwnPropertyDescriptor(m2, k);
+    if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
       desc = { enumerable: true, get: function() {
-        return m[k];
+        return m2[k];
       } };
     }
     Object.defineProperty(o, k2, desc);
-  } : function(o, m, k, k2) {
+  } : function(o, m2, k, k2) {
     if (k2 === undefined)
       k2 = k;
-    o[k2] = m[k];
+    o[k2] = m2[k];
   });
-  var __exportStar = exports && exports.__exportStar || function(m, exports2) {
-    for (var p in m)
+  var __exportStar = exports && exports.__exportStar || function(m2, exports2) {
+    for (var p in m2)
       if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
-        __createBinding(exports2, m, p);
+        __createBinding(exports2, m2, p);
   };
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.hasChildren = exports.isDocument = exports.isComment = exports.isText = exports.isCDATA = exports.isTag = undefined;
@@ -28448,7 +29287,7 @@ var require_parse = __commonJS((exports) => {
   }
   exports.isTraversal = isTraversal;
   var stripQuotesFromPseudos = new Set(["contains", "icontains"]);
-  function funescape(_, escaped, escapedWhitespace) {
+  function funescape(_2, escaped, escapedWhitespace) {
     var high = parseInt(escaped, 16) - 65536;
     return high !== high || escapedWhitespace ? escaped : high < 0 ? String.fromCharCode(high + 65536) : String.fromCharCode(high >> 10 | 55296, high & 1023 | 56320);
   }
@@ -28461,7 +29300,7 @@ var require_parse = __commonJS((exports) => {
   function isWhitespace(c) {
     return c === 32 || c === 9 || c === 10 || c === 12 || c === 13;
   }
-  function parse2(selector) {
+  function parse3(selector) {
     var subselects = [];
     var endIndex = parseSelector(subselects, "".concat(selector), 0);
     if (endIndex < selector.length) {
@@ -28469,7 +29308,7 @@ var require_parse = __commonJS((exports) => {
     }
     return subselects;
   }
-  exports.parse = parse2;
+  exports.parse = parse3;
   function parseSelector(subselects, selector, selectorIndex) {
     var tokens = [];
     function getName(offset) {
@@ -28757,11 +29596,11 @@ var require_parse = __commonJS((exports) => {
 var require_stringify3 = __commonJS((exports) => {
   var __spreadArray = exports && exports.__spreadArray || function(to, from, pack) {
     if (pack || arguments.length === 2)
-      for (var i = 0, l = from.length, ar;i < l; i++) {
-        if (ar || !(i in from)) {
+      for (var i2 = 0, l = from.length, ar;i2 < l; i2++) {
+        if (ar || !(i2 in from)) {
           if (!ar)
-            ar = Array.prototype.slice.call(from, 0, i);
-          ar[i] = from[i];
+            ar = Array.prototype.slice.call(from, 0, i2);
+          ar[i2] = from[i2];
         }
       }
     return to.concat(ar || Array.prototype.slice.call(from));
@@ -28865,10 +29704,10 @@ var require_stringify3 = __commonJS((exports) => {
   function escapeName(str, charsToEscape) {
     var lastIdx = 0;
     var ret = "";
-    for (var i = 0;i < str.length; i++) {
-      if (charsToEscape.has(str.charCodeAt(i))) {
-        ret += "".concat(str.slice(lastIdx, i), "\\").concat(str.charAt(i));
-        lastIdx = i + 1;
+    for (var i2 = 0;i2 < str.length; i2++) {
+      if (charsToEscape.has(str.charCodeAt(i2))) {
+        ret += "".concat(str.slice(lastIdx, i2), "\\").concat(str.charAt(i2));
+        lastIdx = i2 + 1;
       }
     }
     return ret.length > 0 ? ret + str.slice(lastIdx) : str;
@@ -28877,25 +29716,25 @@ var require_stringify3 = __commonJS((exports) => {
 
 // ../../node_modules/css-what/lib/commonjs/index.js
 var require_commonjs = __commonJS((exports) => {
-  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m2, k, k2) {
     if (k2 === undefined)
       k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+    var desc = Object.getOwnPropertyDescriptor(m2, k);
+    if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
       desc = { enumerable: true, get: function() {
-        return m[k];
+        return m2[k];
       } };
     }
     Object.defineProperty(o, k2, desc);
-  } : function(o, m, k, k2) {
+  } : function(o, m2, k, k2) {
     if (k2 === undefined)
       k2 = k;
-    o[k2] = m[k];
+    o[k2] = m2[k];
   });
-  var __exportStar = exports && exports.__exportStar || function(m, exports2) {
-    for (var p in m)
+  var __exportStar = exports && exports.__exportStar || function(m2, exports2) {
+    for (var p in m2)
       if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
-        __createBinding(exports2, m, p);
+        __createBinding(exports2, m2, p);
   };
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.stringify = exports.parse = exports.isTraversal = undefined;
@@ -28938,11 +29777,11 @@ var require_sort = __commonJS((exports) => {
   ]);
   function sortByProcedure(arr) {
     var procs = arr.map(getProcedure);
-    for (var i = 1;i < arr.length; i++) {
-      var procNew = procs[i];
+    for (var i2 = 1;i2 < arr.length; i2++) {
+      var procNew = procs[i2];
       if (procNew < 0)
         continue;
-      for (var j = i - 1;j >= 0 && procNew < procs[j]; j--) {
+      for (var j = i2 - 1;j >= 0 && procNew < procs[j]; j--) {
         var token = arr[j + 1];
         arr[j + 1] = arr[j];
         arr[j] = token;
@@ -28969,8 +29808,8 @@ var require_sort = __commonJS((exports) => {
       } else if (token.name === "has" || token.name === "contains") {
         proc = 0;
       } else if (Array.isArray(token.data)) {
-        proc = Math.min.apply(Math, token.data.map(function(d) {
-          return Math.min.apply(Math, d.map(getProcedure));
+        proc = Math.min.apply(Math, token.data.map(function(d3) {
+          return Math.min.apply(Math, d3.map(getProcedure));
         }));
         if (proc < 0) {
           proc = 0;
@@ -29185,7 +30024,7 @@ var require_parse2 = __commonJS((exports) => {
   var whitespace = new Set([9, 10, 12, 13, 32]);
   var ZERO = 48;
   var NINE = 57;
-  function parse2(formula) {
+  function parse3(formula) {
     formula = formula.trim().toLowerCase();
     if (formula === "even") {
       return [2, 0];
@@ -29237,7 +30076,7 @@ var require_parse2 = __commonJS((exports) => {
       }
     }
   }
-  exports.parse = parse2;
+  exports.parse = parse3;
 });
 
 // ../../node_modules/nth-check/lib/compile.js
@@ -29250,53 +30089,53 @@ var require_compile = __commonJS((exports) => {
   var boolbase_1 = __importDefault(require_boolbase());
   function compile(parsed) {
     var a = parsed[0];
-    var b = parsed[1] - 1;
-    if (b < 0 && a <= 0)
+    var b2 = parsed[1] - 1;
+    if (b2 < 0 && a <= 0)
       return boolbase_1.default.falseFunc;
     if (a === -1)
       return function(index) {
-        return index <= b;
+        return index <= b2;
       };
     if (a === 0)
       return function(index) {
-        return index === b;
+        return index === b2;
       };
     if (a === 1)
-      return b < 0 ? boolbase_1.default.trueFunc : function(index) {
-        return index >= b;
+      return b2 < 0 ? boolbase_1.default.trueFunc : function(index) {
+        return index >= b2;
       };
     var absA = Math.abs(a);
-    var bMod = (b % absA + absA) % absA;
+    var bMod = (b2 % absA + absA) % absA;
     return a > 1 ? function(index) {
-      return index >= b && index % absA === bMod;
+      return index >= b2 && index % absA === bMod;
     } : function(index) {
-      return index <= b && index % absA === bMod;
+      return index <= b2 && index % absA === bMod;
     };
   }
   exports.compile = compile;
   function generate(parsed) {
     var a = parsed[0];
-    var b = parsed[1] - 1;
-    var n = 0;
+    var b2 = parsed[1] - 1;
+    var n2 = 0;
     if (a < 0) {
       var aPos_1 = -a;
-      var minValue_1 = (b % aPos_1 + aPos_1) % aPos_1;
+      var minValue_1 = (b2 % aPos_1 + aPos_1) % aPos_1;
       return function() {
-        var val = minValue_1 + aPos_1 * n++;
-        return val > b ? null : val;
+        var val = minValue_1 + aPos_1 * n2++;
+        return val > b2 ? null : val;
       };
     }
     if (a === 0)
-      return b < 0 ? function() {
+      return b2 < 0 ? function() {
         return null;
       } : function() {
-        return n++ === 0 ? b : null;
+        return n2++ === 0 ? b2 : null;
       };
-    if (b < 0) {
-      b += a * Math.ceil(-b / a);
+    if (b2 < 0) {
+      b2 += a * Math.ceil(-b2 / a);
     }
     return function() {
-      return a * n++ + b;
+      return a * n2++ + b2;
     };
   }
   exports.generate = generate;
@@ -29366,10 +30205,10 @@ var require_filters = __commonJS((exports) => {
       return function nthChild(elem) {
         var siblings = adapter.getSiblings(elem);
         var pos = 0;
-        for (var i = 0;i < siblings.length; i++) {
-          if (equals(elem, siblings[i]))
+        for (var i2 = 0;i2 < siblings.length; i2++) {
+          if (equals(elem, siblings[i2]))
             break;
-          if (adapter.isTag(siblings[i])) {
+          if (adapter.isTag(siblings[i2])) {
             pos++;
           }
         }
@@ -29386,10 +30225,10 @@ var require_filters = __commonJS((exports) => {
       return function nthLastChild(elem) {
         var siblings = adapter.getSiblings(elem);
         var pos = 0;
-        for (var i = siblings.length - 1;i >= 0; i--) {
-          if (equals(elem, siblings[i]))
+        for (var i2 = siblings.length - 1;i2 >= 0; i2--) {
+          if (equals(elem, siblings[i2]))
             break;
-          if (adapter.isTag(siblings[i])) {
+          if (adapter.isTag(siblings[i2])) {
             pos++;
           }
         }
@@ -29406,8 +30245,8 @@ var require_filters = __commonJS((exports) => {
       return function nthOfType(elem) {
         var siblings = adapter.getSiblings(elem);
         var pos = 0;
-        for (var i = 0;i < siblings.length; i++) {
-          var currentSibling = siblings[i];
+        for (var i2 = 0;i2 < siblings.length; i2++) {
+          var currentSibling = siblings[i2];
           if (equals(elem, currentSibling))
             break;
           if (adapter.isTag(currentSibling) && adapter.getName(currentSibling) === adapter.getName(elem)) {
@@ -29427,8 +30266,8 @@ var require_filters = __commonJS((exports) => {
       return function nthLastOfType(elem) {
         var siblings = adapter.getSiblings(elem);
         var pos = 0;
-        for (var i = siblings.length - 1;i >= 0; i--) {
-          var currentSibling = siblings[i];
+        for (var i2 = siblings.length - 1;i2 >= 0; i2--) {
+          var currentSibling = siblings[i2];
           if (equals(elem, currentSibling))
             break;
           if (adapter.isTag(currentSibling) && adapter.getName(currentSibling) === adapter.getName(elem)) {
@@ -29501,10 +30340,10 @@ var require_pseudos = __commonJS((exports) => {
     "last-child": function(elem, _a) {
       var { adapter, equals } = _a;
       var siblings = adapter.getSiblings(elem);
-      for (var i = siblings.length - 1;i >= 0; i--) {
-        if (equals(elem, siblings[i]))
+      for (var i2 = siblings.length - 1;i2 >= 0; i2--) {
+        if (equals(elem, siblings[i2]))
           return true;
-        if (adapter.isTag(siblings[i]))
+        if (adapter.isTag(siblings[i2]))
           break;
       }
       return false;
@@ -29513,8 +30352,8 @@ var require_pseudos = __commonJS((exports) => {
       var { adapter, equals } = _a;
       var siblings = adapter.getSiblings(elem);
       var elemName = adapter.getName(elem);
-      for (var i = 0;i < siblings.length; i++) {
-        var currentSibling = siblings[i];
+      for (var i2 = 0;i2 < siblings.length; i2++) {
+        var currentSibling = siblings[i2];
         if (equals(elem, currentSibling))
           return true;
         if (adapter.isTag(currentSibling) && adapter.getName(currentSibling) === elemName) {
@@ -29527,8 +30366,8 @@ var require_pseudos = __commonJS((exports) => {
       var { adapter, equals } = _a;
       var siblings = adapter.getSiblings(elem);
       var elemName = adapter.getName(elem);
-      for (var i = siblings.length - 1;i >= 0; i--) {
-        var currentSibling = siblings[i];
+      for (var i2 = siblings.length - 1;i2 >= 0; i2--) {
+        var currentSibling = siblings[i2];
         if (equals(elem, currentSibling))
           return true;
         if (adapter.isTag(currentSibling) && adapter.getName(currentSibling) === elemName) {
@@ -29599,11 +30438,11 @@ var require_aliases = __commonJS((exports) => {
 var require_subselects = __commonJS((exports) => {
   var __spreadArray = exports && exports.__spreadArray || function(to, from, pack) {
     if (pack || arguments.length === 2)
-      for (var i = 0, l = from.length, ar;i < l; i++) {
-        if (ar || !(i in from)) {
+      for (var i2 = 0, l = from.length, ar;i2 < l; i2++) {
+        if (ar || !(i2 in from)) {
           if (!ar)
-            ar = Array.prototype.slice.call(from, 0, i);
-          ar[i] = from[i];
+            ar = Array.prototype.slice.call(from, 0, i2);
+          ar[i2] = from[i2];
         }
       }
     return to.concat(ar || Array.prototype.slice.call(from));
@@ -29847,8 +30686,8 @@ var require_general = __commonJS((exports) => {
       case css_what_1.SelectorType.Sibling: {
         return function sibling(elem) {
           var siblings = adapter.getSiblings(elem);
-          for (var i = 0;i < siblings.length; i++) {
-            var currentSibling = siblings[i];
+          for (var i2 = 0;i2 < siblings.length; i2++) {
+            var currentSibling = siblings[i2];
             if (equals(elem, currentSibling))
               break;
             if (adapter.isTag(currentSibling) && next(currentSibling)) {
@@ -29868,8 +30707,8 @@ var require_general = __commonJS((exports) => {
         return function adjacent(elem) {
           var siblings = adapter.getSiblings(elem);
           var lastElement;
-          for (var i = 0;i < siblings.length; i++) {
-            var currentSibling = siblings[i];
+          for (var i2 = 0;i2 < siblings.length; i2++) {
+            var currentSibling = siblings[i2];
             if (equals(elem, currentSibling))
               break;
             if (adapter.isTag(currentSibling)) {
@@ -29892,25 +30731,25 @@ var require_general = __commonJS((exports) => {
 
 // ../../node_modules/css-select/lib/compile.js
 var require_compile2 = __commonJS((exports) => {
-  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m2, k, k2) {
     if (k2 === undefined)
       k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+    var desc = Object.getOwnPropertyDescriptor(m2, k);
+    if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
       desc = { enumerable: true, get: function() {
-        return m[k];
+        return m2[k];
       } };
     }
     Object.defineProperty(o, k2, desc);
-  } : function(o, m, k, k2) {
+  } : function(o, m2, k, k2) {
     if (k2 === undefined)
       k2 = k;
-    o[k2] = m[k];
+    o[k2] = m2[k];
   });
-  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-  } : function(o, v) {
-    o["default"] = v;
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v2) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v2 });
+  } : function(o, v2) {
+    o["default"] = v2;
   });
   var __importStar = exports && exports.__importStar || function(mod) {
     if (mod && mod.__esModule)
@@ -30009,40 +30848,40 @@ var require_compile2 = __commonJS((exports) => {
       return previous === boolbase_1.default.falseFunc ? boolbase_1.default.falseFunc : (0, general_js_1.compileGeneralSelector)(previous, rule, options, context, compileToken);
     }, (_a = options.rootFunc) !== null && _a !== undefined ? _a : boolbase_1.default.trueFunc);
   }
-  function reduceRules(a, b) {
-    if (b === boolbase_1.default.falseFunc || a === boolbase_1.default.trueFunc) {
+  function reduceRules(a, b2) {
+    if (b2 === boolbase_1.default.falseFunc || a === boolbase_1.default.trueFunc) {
       return a;
     }
-    if (a === boolbase_1.default.falseFunc || b === boolbase_1.default.trueFunc) {
-      return b;
+    if (a === boolbase_1.default.falseFunc || b2 === boolbase_1.default.trueFunc) {
+      return b2;
     }
     return function combine(elem) {
-      return a(elem) || b(elem);
+      return a(elem) || b2(elem);
     };
   }
 });
 
 // ../../node_modules/css-select/lib/index.js
 var require_lib8 = __commonJS((exports) => {
-  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m2, k, k2) {
     if (k2 === undefined)
       k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+    var desc = Object.getOwnPropertyDescriptor(m2, k);
+    if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
       desc = { enumerable: true, get: function() {
-        return m[k];
+        return m2[k];
       } };
     }
     Object.defineProperty(o, k2, desc);
-  } : function(o, m, k, k2) {
+  } : function(o, m2, k, k2) {
     if (k2 === undefined)
       k2 = k;
-    o[k2] = m[k];
+    o[k2] = m2[k];
   });
-  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-  } : function(o, v) {
-    o["default"] = v;
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v2) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v2 });
+  } : function(o, v2) {
+    o["default"] = v2;
   });
   var __importStar = exports && exports.__importStar || function(mod) {
     if (mod && mod.__esModule)
@@ -30065,8 +30904,8 @@ var require_lib8 = __commonJS((exports) => {
   var boolbase_1 = __importDefault(require_boolbase());
   var compile_js_1 = require_compile2();
   var subselects_js_1 = require_subselects();
-  var defaultEquals = function(a, b) {
-    return a === b;
+  var defaultEquals = function(a, b2) {
+    return a === b2;
   };
   var defaultOptions = {
     adapter: DomUtils,
@@ -30111,8 +30950,8 @@ var require_lib8 = __commonJS((exports) => {
   function appendNextSiblings(elem, adapter) {
     var elems = Array.isArray(elem) ? elem.slice(0) : [elem];
     var elemsLength = elems.length;
-    for (var i = 0;i < elemsLength; i++) {
-      var nextSiblings = (0, subselects_js_1.getNextSiblings)(elems[i], adapter);
+    for (var i2 = 0;i2 < elemsLength; i2++) {
+      var nextSiblings = (0, subselects_js_1.getNextSiblings)(elems[i2], adapter);
       elems.push.apply(elems, nextSiblings);
     }
     return elems;
@@ -30212,8 +31051,8 @@ var require_matcher = __commonJS((exports) => {
   }
   function findOne(test, elems) {
     let elem = null;
-    for (let i = 0, l = elems === null || elems === undefined ? undefined : elems.length;i < l && !elem; i++) {
-      const el = elems[i];
+    for (let i2 = 0, l = elems === null || elems === undefined ? undefined : elems.length;i2 < l && !elem; i2++) {
+      const el = elems[i2];
       if (test(el)) {
         elem = el;
       } else {
@@ -30227,12 +31066,12 @@ var require_matcher = __commonJS((exports) => {
   }
   function findAll(test, nodes) {
     let result = [];
-    for (let i = 0, j = nodes.length;i < j; i++) {
-      if (!isTag(nodes[i]))
+    for (let i2 = 0, j = nodes.length;i2 < j; i2++) {
+      if (!isTag(nodes[i2]))
         continue;
-      if (test(nodes[i]))
-        result.push(nodes[i]);
-      const childs = getChildren(nodes[i]);
+      if (test(nodes[i2]))
+        result.push(nodes[i2]);
+      const childs = getChildren(nodes[i2]);
       if (childs)
         result = result.concat(findAll(test, childs));
     }
@@ -30336,23 +31175,23 @@ var require_text = __commonJS((exports) => {
   }
   exports.default = TextNode;
   function trimText(text) {
-    let i = 0;
+    let i2 = 0;
     let startPos;
     let endPos;
-    while (i >= 0 && i < text.length) {
-      if (/\S/.test(text[i])) {
+    while (i2 >= 0 && i2 < text.length) {
+      if (/\S/.test(text[i2])) {
         if (startPos === undefined) {
-          startPos = i;
-          i = text.length;
+          startPos = i2;
+          i2 = text.length;
         } else {
-          endPos = i;
-          i = undefined;
+          endPos = i2;
+          i2 = undefined;
         }
       }
       if (startPos === undefined)
-        i++;
+        i2++;
       else
-        i--;
+        i2--;
     }
     if (startPos === undefined)
       startPos = 0;
@@ -30380,7 +31219,7 @@ var require_html = __commonJS((exports) => {
   var node_1 = __importDefault(require_node());
   var text_1 = __importDefault(require_text());
   var type_1 = __importDefault(require_type());
-  function decode(val) {
+  function decode2(val) {
     return JSON.parse(JSON.stringify(he_1.default.decode(val)));
   }
   var Htags = ["h1", "h2", "h3", "h4", "h5", "h6", "header", "hgroup"];
@@ -30530,14 +31369,14 @@ var require_html = __commonJS((exports) => {
       }, "");
     }
     get textContent() {
-      return decode(this.rawText);
+      return decode2(this.rawText);
     }
     set textContent(val) {
       const content = [new text_1.default(val, this)];
       this.childNodes = content;
     }
     get text() {
-      return decode(this.rawText);
+      return decode2(this.rawText);
     }
     get structuredText() {
       let currentBlock = [];
@@ -30588,7 +31427,7 @@ var require_html = __commonJS((exports) => {
       }).join("");
     }
     set innerHTML(content) {
-      const r = parse2(content, this._parseOptions);
+      const r = parse3(content, this._parseOptions);
       const nodes = r.childNodes.length ? r.childNodes : [new text_1.default(content, this)];
       resetParent(nodes, this);
       resetParent(this.childNodes, null);
@@ -30599,7 +31438,7 @@ var require_html = __commonJS((exports) => {
         content = [content];
       } else if (typeof content == "string") {
         options = Object.assign(Object.assign({}, this._parseOptions), options);
-        const r = parse2(content, options);
+        const r = parse3(content, options);
         content = r.childNodes.length ? r.childNodes : [new text_1.default(r.innerHTML, this)];
       }
       resetParent(this.childNodes, null);
@@ -30613,7 +31452,7 @@ var require_html = __commonJS((exports) => {
         if (node instanceof node_1.default) {
           return [node];
         } else if (typeof node == "string") {
-          const r = parse2(node, this._parseOptions);
+          const r = parse3(node, this._parseOptions);
           return r.childNodes.length ? r.childNodes : [new text_1.default(node, this)];
         }
         return [];
@@ -30629,15 +31468,15 @@ var require_html = __commonJS((exports) => {
       return this.toString();
     }
     trimRight(pattern) {
-      for (let i = 0;i < this.childNodes.length; i++) {
-        const childNode = this.childNodes[i];
+      for (let i2 = 0;i2 < this.childNodes.length; i2++) {
+        const childNode = this.childNodes[i2];
         if (childNode.nodeType === type_1.default.ELEMENT_NODE) {
           childNode.trimRight(pattern);
         } else {
           const index = childNode.rawText.search(pattern);
           if (index > -1) {
             childNode.rawText = childNode.rawText.substr(0, index);
-            this.childNodes.length = i + 1;
+            this.childNodes.length = i2 + 1;
           }
         }
       }
@@ -30770,8 +31609,8 @@ var require_html = __commonJS((exports) => {
       let old = null;
       function findOne(test, elems) {
         let elem = null;
-        for (let i = 0, l = elems.length;i < l && !elem; i++) {
-          const el2 = elems[i];
+        for (let i2 = 0, l = elems.length;i2 < l && !elem; i2++) {
+          const el2 = elems[i2];
           if (test(el2)) {
             elem = el2;
           } else {
@@ -30825,7 +31664,7 @@ var require_html = __commonJS((exports) => {
       const attrs = this.rawAttributes;
       for (const key in attrs) {
         const val = attrs[key] || "";
-        this._attrs[key.toLowerCase()] = decode(val);
+        this._attrs[key.toLowerCase()] = decode2(val);
       }
       return this._attrs;
     }
@@ -30834,7 +31673,7 @@ var require_html = __commonJS((exports) => {
       const attrs = this.rawAttributes;
       for (const key in attrs) {
         const val = attrs[key] || "";
-        ret_attrs[key] = decode(val);
+        ret_attrs[key] = decode2(val);
       }
       return ret_attrs;
     }
@@ -30894,7 +31733,7 @@ var require_html = __commonJS((exports) => {
       }
       attrs[key] = String(value);
       if (this._attrs) {
-        this._attrs[k2] = decode(attrs[key]);
+        this._attrs[k2] = decode2(attrs[key]);
       }
       this.rawAttrs = Object.keys(attrs).map((name) => {
         const val = this.quoteAttribute(attrs[name]);
@@ -30929,7 +31768,7 @@ var require_html = __commonJS((exports) => {
       if (arguments.length < 2) {
         throw new Error("2 arguments required");
       }
-      const p = parse2(html, this._parseOptions);
+      const p = parse3(html, this._parseOptions);
       if (where === "afterend") {
         this.after(...p.childNodes);
       } else if (where === "afterbegin") {
@@ -30968,11 +31807,11 @@ var require_html = __commonJS((exports) => {
     get nextSibling() {
       if (this.parentNode) {
         const children = this.parentNode.childNodes;
-        let i = 0;
-        while (i < children.length) {
-          const child = children[i++];
+        let i2 = 0;
+        while (i2 < children.length) {
+          const child = children[i2++];
           if (this === child)
-            return children[i] || null;
+            return children[i2] || null;
         }
         return null;
       }
@@ -30980,10 +31819,10 @@ var require_html = __commonJS((exports) => {
     get nextElementSibling() {
       if (this.parentNode) {
         const children = this.parentNode.childNodes;
-        let i = 0;
+        let i2 = 0;
         let find = false;
-        while (i < children.length) {
-          const child = children[i++];
+        while (i2 < children.length) {
+          const child = children[i2++];
           if (find) {
             if (child instanceof HTMLElement) {
               return child || null;
@@ -30998,11 +31837,11 @@ var require_html = __commonJS((exports) => {
     get previousSibling() {
       if (this.parentNode) {
         const children = this.parentNode.childNodes;
-        let i = children.length;
-        while (i > 0) {
-          const child = children[--i];
+        let i2 = children.length;
+        while (i2 > 0) {
+          const child = children[--i2];
           if (this === child)
-            return children[i - 1] || null;
+            return children[i2 - 1] || null;
         }
         return null;
       }
@@ -31010,10 +31849,10 @@ var require_html = __commonJS((exports) => {
     get previousElementSibling() {
       if (this.parentNode) {
         const children = this.parentNode.childNodes;
-        let i = children.length;
+        let i2 = children.length;
         let find = false;
-        while (i > 0) {
-          const child = children[--i];
+        while (i2 > 0) {
+          const child = children[--i2];
           if (find) {
             if (child instanceof HTMLElement) {
               return child || null;
@@ -31053,7 +31892,7 @@ var require_html = __commonJS((exports) => {
       return this.classList.toString();
     }
     clone() {
-      return parse2(this.toString(), this._parseOptions).firstChild;
+      return parse3(this.toString(), this._parseOptions).firstChild;
     }
   }
   exports.default = HTMLElement;
@@ -31230,13 +32069,13 @@ var require_html = __commonJS((exports) => {
               }
             }
             if (options.closeAllByClosing === true) {
-              let i;
-              for (i = stack.length - 2;i >= 0; i--) {
-                if (stack[i].rawTagName === tagName)
+              let i2;
+              for (i2 = stack.length - 2;i2 >= 0; i2--) {
+                if (stack[i2].rawTagName === tagName)
                   break;
               }
-              if (i >= 0) {
-                while (stack.length > i) {
+              if (i2 >= 0) {
+                while (stack.length > i2) {
                   currentParent.range[1] = createRange(-1, Math.max(lastTextPos, tagEndPos))[1];
                   stack.pop();
                   currentParent = (0, back_1.default)(stack);
@@ -31252,7 +32091,7 @@ var require_html = __commonJS((exports) => {
     return stack;
   }
   exports.base_parse = base_parse;
-  function parse2(data, options = {}) {
+  function parse3(data, options = {}) {
     const stack = base_parse(data, options);
     const [root] = stack;
     while (stack.length > 1) {
@@ -31279,7 +32118,7 @@ var require_html = __commonJS((exports) => {
     }
     return root;
   }
-  exports.parse = parse2;
+  exports.parse = parse3;
   function resolveInsertable(insertable) {
     return insertable.map((val) => {
       if (typeof val === "string") {
@@ -31338,41 +32177,18 @@ var require_dist2 = __commonJS((exports) => {
   var parse_1 = __importDefault(require_parse3());
   var valid_1 = __importDefault(require_valid());
   exports.valid = valid_1.default;
-  function parse2(data, options = {}) {
+  function parse3(data, options = {}) {
     return (0, parse_1.default)(data, options);
   }
-  exports.default = parse2;
-  exports.parse = parse2;
-  parse2.parse = parse_1.default;
-  parse2.HTMLElement = html_1.default;
-  parse2.CommentNode = comment_1.default;
-  parse2.valid = valid_1.default;
-  parse2.Node = node_1.default;
-  parse2.TextNode = text_1.default;
-  parse2.NodeType = type_1.default;
-});
-// ../../node_modules/@astrojs/compiler/dist/chunk-W5DTLHV4.js
-import g from "crypto";
-import _ from "fs";
-import { TextDecoder as b, TextEncoder as v } from "util";
-var y, w;
-var init_chunk_W5DTLHV4 = __esm(() => {
-  globalThis.fs || Object.defineProperty(globalThis, "fs", { value: _ });
-  globalThis.process || Object.defineProperties(globalThis, "process", { value: process });
-  globalThis.crypto || Object.defineProperty(globalThis, "crypto", { value: g.webcrypto ? g.webcrypto : { getRandomValues(m) {
-    return g.randomFillSync(m);
-  } } });
-  globalThis.performance || Object.defineProperty(globalThis, "performance", { value: { now() {
-    let [m, o] = process.hrtime();
-    return m * 1000 + o / 1e6;
-  } } });
-  y = new v("utf-8");
-  w = new b("utf-8");
-});
-
-// ../../node_modules/@astrojs/compiler/dist/node/index.js
-var init_node = __esm(() => {
-  init_chunk_W5DTLHV4();
+  exports.default = parse3;
+  exports.parse = parse3;
+  parse3.parse = parse_1.default;
+  parse3.HTMLElement = html_1.default;
+  parse3.CommentNode = comment_1.default;
+  parse3.valid = valid_1.default;
+  parse3.Node = node_1.default;
+  parse3.TextNode = text_1.default;
+  parse3.NodeType = type_1.default;
 });
 // ../cms/src/source-finder/cache.ts
 var parsedFileCache, directoryCache, markdownFileCache, declaredUrlIndexCache, dirtyFiles;
@@ -31459,9 +32275,9 @@ function extractAstroImageOriginalUrl(src) {
         return href;
     }
     if (url.pathname.startsWith("/@image/")) {
-      const f = url.searchParams.get("f");
-      if (f)
-        return f;
+      const f2 = url.searchParams.get("f");
+      if (f2)
+        return f2;
     }
   } catch {}
   return;
@@ -31481,7 +32297,7 @@ var init_snippet_utils = __esm(() => {
 
 // ../cms/src/handlers/source-writer.ts
 import fs8 from "fs/promises";
-import path9 from "path";
+import path11 from "path";
 async function handleUpdate(request, manifestWriter) {
   const { changes, meta } = request;
   const errors = [];
@@ -31518,7 +32334,7 @@ async function handleUpdate(request, manifestWriter) {
         }
         if (appliedCount > 0 && newContent !== currentContent) {
           for (const op of fileOps) {
-            await fs8.mkdir(path9.dirname(op.target), { recursive: true });
+            await fs8.mkdir(path11.dirname(op.target), { recursive: true });
             await fs8.writeFile(op.target, op.bytes);
           }
           await fs8.writeFile(fullPath, newContent, "utf-8");
@@ -31752,28 +32568,28 @@ function findFrontmatterAssetImport(content, varName) {
     return null;
   const fmStart = fmMatch[0].indexOf(fmMatch[1]);
   const importRe = /^\s*import\s+(?!type\b)([\s\S]+?)\s+from\s+(['"])([^'"]+)\2/gm;
-  let m;
-  while ((m = importRe.exec(fmMatch[1])) !== null) {
-    const source = m[3];
+  let m2;
+  while ((m2 = importRe.exec(fmMatch[1])) !== null) {
+    const source = m2[3];
     if (!source.startsWith(".") || !ASSET_IMPORT_EXT_RE.test(source))
       continue;
-    const tokens = m[1].replace(/[{}]/g, ",").split(",").map((s) => s.trim()).filter((t) => t && !t.startsWith("type "));
+    const tokens = m2[1].replace(/[{}]/g, ",").split(",").map((s) => s.trim()).filter((t) => t && !t.startsWith("type "));
     const matches = tokens.some((tok) => {
       const aliasMatch = tok.match(/^\S+\s+as\s+(\S+)$/);
       return (aliasMatch ? aliasMatch[1] : tok) === varName;
     });
     if (!matches)
       continue;
-    const matchStart = fmStart + m.index;
-    const sourceStart = matchStart + m[0].indexOf(m[2]) + 1;
+    const matchStart = fmStart + m2.index;
+    const sourceStart = matchStart + m2[0].indexOf(m2[2]) + 1;
     return { localName: varName, source, sourceStart, sourceEnd: sourceStart + source.length };
   }
   return null;
 }
 function inlineJsxLiteralReplace(content, lines, regionStart, exprMatch, newSrc) {
   let regionStartOffset = 0;
-  for (let i = 0;i < regionStart; i++)
-    regionStartOffset += lines[i].length + 1;
+  for (let i2 = 0;i2 < regionStart; i2++)
+    regionStartOffset += lines[i2].length + 1;
   const absIndex = regionStartOffset + exprMatch.index;
   return {
     content: content.slice(0, absIndex) + `src="${escapeReplacement(newSrc)}"` + content.slice(absIndex + exprMatch.length),
@@ -31784,8 +32600,8 @@ async function tryRewriteAssetImport(content, importInfo, newSrc, absFilePath, o
   const resolved = await resolveNewSrcBytes(newSrc, originUrl);
   if (!resolved)
     return null;
-  const originalAssetAbs = path9.resolve(path9.dirname(absFilePath), importInfo.source);
-  const targetAbs = await pickSiblingTarget(path9.dirname(originalAssetAbs), resolved.filename, resolved.bytes);
+  const originalAssetAbs = path11.resolve(path11.dirname(absFilePath), importInfo.source);
+  const targetAbs = await pickSiblingTarget(path11.dirname(originalAssetAbs), resolved.filename, resolved.bytes);
   const newRelImport = relativeImportPath2(absFilePath, targetAbs);
   const newContent = content.slice(0, importInfo.sourceStart) + newRelImport + content.slice(importInfo.sourceEnd);
   return {
@@ -31795,8 +32611,8 @@ async function tryRewriteAssetImport(content, importInfo, newSrc, absFilePath, o
   };
 }
 async function resolveNewSrcBytes(newSrc, originUrl) {
-  const filenameFromPath = (p) => path9.basename(p.split("?")[0] ?? p);
-  const diskPath = newSrc.startsWith("/src/") ? path9.join(getProjectRoot(), newSrc.slice(1)) : newSrc.startsWith("/") && !newSrc.startsWith("//") ? path9.join(getProjectRoot(), "public", newSrc.replace(/^\/+/, "")) : null;
+  const filenameFromPath = (p) => path11.basename(p.split("?")[0] ?? p);
+  const diskPath = newSrc.startsWith("/src/") ? path11.join(getProjectRoot(), newSrc.slice(1)) : newSrc.startsWith("/") && !newSrc.startsWith("//") ? path11.join(getProjectRoot(), "public", newSrc.replace(/^\/+/, "")) : null;
   if (diskPath) {
     try {
       return { bytes: await fs8.readFile(diskPath), filename: filenameFromPath(newSrc) };
@@ -31886,10 +32702,10 @@ function replaceClassInAttribute(content, oldClass, newClass, sourceLine) {
   }
   const lines = content.split(`
 `);
-  for (let i = 0;i < lines.length; i++) {
-    const result = replaceOnLine(lines[i]);
+  for (let i2 = 0;i2 < lines.length; i2++) {
+    const result = replaceOnLine(lines[i2]);
     if (result !== null) {
-      lines[i] = result;
+      lines[i2] = result;
       return { success: true, content: lines.join(`
 `) };
     }
@@ -31929,10 +32745,10 @@ function appendClassToAttribute(content, newClass, sourceLine) {
   }
   const lines = content.split(`
 `);
-  for (let i = 0;i < lines.length; i++) {
-    const result = doAppendOnLine(lines[i]);
+  for (let i2 = 0;i2 < lines.length; i2++) {
+    const result = doAppendOnLine(lines[i2]);
     if (result !== null) {
-      lines[i] = result;
+      lines[i2] = result;
       return { success: true, content: lines.join(`
 `) };
     }
@@ -32091,9 +32907,9 @@ function applyTextChangeWithPlaceholders(content, sourceSnippet, originalValue,
   }
   let updatedSnippet = sourceSnippet;
   let anyChange = false;
-  for (let i = 0;i < originalParts.length; i++) {
-    const oldPart = originalParts[i];
-    let newPart = newParts[i];
+  for (let i2 = 0;i2 < originalParts.length; i2++) {
+    const oldPart = originalParts[i2];
+    let newPart = newParts[i2];
     if (oldPart === newPart || oldPart.length === 0) {
       continue;
     }
@@ -32140,8 +32956,8 @@ function findTextInSnippet(snippet, decodedText) {
   const match = snippet.match(regex);
   if (match)
     return match[0];
-  const chars = [...decodedText].map((ch) => escapeRegex(ch));
-  const brAwarePattern = chars.join("(?:<br\\b[^>]*\\/?>)*");
+  const chars2 = [...decodedText].map((ch) => escapeRegex(ch));
+  const brAwarePattern = chars2.join("(?:<br\\b[^>]*\\/?>)*");
   const brRegex = new RegExp(brAwarePattern);
   const brMatch = snippet.match(brRegex);
   return brMatch && brMatch[0] !== decodedText ? brMatch[0] : null;
@@ -32185,19 +33001,19 @@ function findExpressionAttribute(text, attr) {
     return null;
   const braceStart = match.index + match[0].length - 1;
   let depth = 1;
-  let i = braceStart + 1;
-  while (i < text.length && depth > 0) {
-    if (text[i] === "{")
+  let i2 = braceStart + 1;
+  while (i2 < text.length && depth > 0) {
+    if (text[i2] === "{")
       depth++;
-    else if (text[i] === "}")
+    else if (text[i2] === "}")
       depth--;
-    i++;
+    i2++;
   }
   if (depth !== 0)
     return null;
   return {
     index: match.index,
-    length: i - match.index
+    length: i2 - match.index
   };
 }
 function findExpressionSrcAttribute(text) {
@@ -32293,16 +33109,16 @@ function tryBrNormalizedChange(sourceSnippet, resolvedOriginal, resolvedNewText)
   if (originalSegments.length !== newSegments.length)
     return null;
   const root = import_node_html_parser.parse(sourceSnippet, { blockTextElements: {} });
-  const outerElement = root.childNodes.find((n) => n.nodeType === import_node_html_parser.NodeType.ELEMENT_NODE);
+  const outerElement = root.childNodes.find((n2) => n2.nodeType === import_node_html_parser.NodeType.ELEMENT_NODE);
   if (!outerElement)
     return null;
   const groups = [[]];
-  for (let i = 0;i < outerElement.childNodes.length; i++) {
-    const child = outerElement.childNodes[i];
+  for (let i2 = 0;i2 < outerElement.childNodes.length; i2++) {
+    const child = outerElement.childNodes[i2];
     if (child.nodeType === import_node_html_parser.NodeType.ELEMENT_NODE && child.rawTagName === "br") {
       groups.push([]);
     } else if (child.nodeType === import_node_html_parser.NodeType.TEXT_NODE) {
-      groups[groups.length - 1].push({ node: child, index: i });
+      groups[groups.length - 1].push({ node: child, index: i2 });
     }
   }
   if (groups.length !== originalSegments.length)
@@ -32344,7 +33160,7 @@ var init_source_writer = __esm(() => {
 });
 
 // ../cms/src/handlers/api-routes.ts
-import path10 from "path";
+import path12 from "path";
 function requireMedia(ctx) {
   if (!ctx.mediaAdapter) {
     sendError(ctx.res, "Media storage not configured", 501);
@@ -32507,7 +33323,7 @@ var init_api_routes = __esm(() => {
         sendJson(res, { success: false, error: `Invalid content path: ${body.filePath}` }, 400);
         return;
       }
-      const fullPath = path10.resolve(getProjectRoot(), body.filePath.replace(/^\//, ""));
+      const fullPath = path12.resolve(getProjectRoot(), body.filePath.replace(/^\//, ""));
       expectedDeletions.add(fullPath);
       const result = await core.deleteEntry(entry.collection, entry.slug);
       if (result.success) {
@@ -32614,7 +33430,7 @@ var init_api_routes = __esm(() => {
       const body = await parseJsonBody(req);
       const result = await core.deletePage(body);
       if (result.success && result.filePath) {
-        expectedDeletions.add(path10.resolve(getProjectRoot(), result.filePath));
+        expectedDeletions.add(path12.resolve(getProjectRoot(), result.filePath));
       }
       if (result.success && body.createRedirect && body.redirectTo) {
         await core.addRedirect({ source: body.pagePath, destination: body.redirectTo, statusCode: 307 });
@@ -32719,7 +33535,7 @@ var init_color_patterns = __esm(() => {
 
 // ../cms/src/tailwind-colors.ts
 import fs9 from "fs/promises";
-import path11 from "path";
+import path13 from "path";
 async function parseTailwindConfig(projectRoot = getProjectRoot()) {
   const cssFiles = [
     "src/styles/global.css",
@@ -32733,7 +33549,7 @@ async function parseTailwindConfig(projectRoot = getProjectRoot()) {
   ];
   let customColors = [];
   for (const cssFile of cssFiles) {
-    const fullPath = path11.join(projectRoot, cssFile);
+    const fullPath = path13.join(projectRoot, cssFile);
     try {
       const content = await fs9.readFile(fullPath, "utf-8");
       customColors = extractColorsFromCss(content);
@@ -32806,7 +33622,7 @@ async function parseTextStyles(projectRoot = getProjectRoot()) {
   ];
   let customTextStyles = {};
   for (const cssFile of cssFiles) {
-    const fullPath = path11.join(projectRoot, cssFile);
+    const fullPath = path13.join(projectRoot, cssFile);
     try {
       const content = await fs9.readFile(fullPath, "utf-8");
       customTextStyles = extractTextStylesFromCss(content);
@@ -33274,7 +34090,7 @@ var init_local_admin = __esm(() => {
 
 // ../cms/src/manifest-writer.ts
 import fs10 from "fs/promises";
-import path12 from "path";
+import path14 from "path";
 
 class ManifestWriter {
   globalManifest;
@@ -33345,10 +34161,10 @@ class ManifestWriter {
   }
   getPageManifestPath(pagePath) {
     if (pagePath === "/" || pagePath === "") {
-      return path12.join(this.outDir, "index.json");
+      return path14.join(this.outDir, "index.json");
     }
     const cleanPath = pagePath.replace(/^\//, "");
-    return path12.join(this.outDir, `${cleanPath}.json`);
+    return path14.join(this.outDir, `${cleanPath}.json`);
   }
   addPage(pagePath, entries, components, collection, seo) {
     this.pageManifests.set(pagePath, { entries, components, collection, seo });
@@ -33374,7 +34190,7 @@ class ManifestWriter {
   }
   async writePageManifest(pagePath, entries, components, collection, seo) {
     const manifestPath = this.getPageManifestPath(pagePath);
-    const manifestDir = path12.dirname(manifestPath);
+    const manifestDir = path14.dirname(manifestPath);
     await fs10.mkdir(manifestDir, { recursive: true });
     const metadata = {
       version: MANIFEST_VERSION,
@@ -33430,7 +34246,7 @@ class ManifestWriter {
       }
     }
     if (this.outDir) {
-      const globalManifestPath = path12.join(this.outDir, this.manifestFile);
+      const globalManifestPath = path14.join(this.outDir, this.manifestFile);
       const globalSettings = {
         componentDefinitions: this.componentDefinitions,
         pages
@@ -33540,8 +34356,8 @@ function $constructor(name, initializer, params) {
     initializer(inst, def);
     const proto = _2.prototype;
     const keys = Object.keys(proto);
-    for (let i = 0;i < keys.length; i++) {
-      const k = keys[i];
+    for (let i2 = 0;i2 < keys.length; i2++) {
+      const k = keys[i2];
       if (!(k in inst)) {
         inst[k] = proto[k].bind(inst);
       }
@@ -33692,10 +34508,10 @@ function formatError(error, mapper = (issue) => issue.message) {
         fieldErrors._errors.push(mapper(issue));
       } else {
         let curr = fieldErrors;
-        let i = 0;
-        while (i < issue.path.length) {
-          const el = issue.path[i];
-          const terminal = i === issue.path.length - 1;
+        let i2 = 0;
+        while (i2 < issue.path.length) {
+          const el = issue.path[i2];
+          const terminal = i2 === issue.path.length - 1;
           if (!terminal) {
             curr[el] = curr[el] || { _errors: [] };
           } else {
@@ -33703,7 +34519,7 @@ function formatError(error, mapper = (issue) => issue.message) {
             curr[el]._errors.push(mapper(issue));
           }
           curr = curr[el];
-          i++;
+          i2++;
         }
       }
     }
@@ -33897,8 +34713,8 @@ class $ZodRegistry {
     if (p) {
       const pm = { ...this.get(p) ?? {} };
       delete pm.id;
-      const f = { ...pm, ...this._map.get(schema) };
-      return Object.keys(f).length ? f : undefined;
+      const f2 = { ...pm, ...this._map.get(schema) };
+      return Object.keys(f2).length ? f2 : undefined;
     }
     return this._map.get(schema);
   }
@@ -34042,7 +34858,7 @@ var init_field_types = __esm(() => {
 
 // ../cms/src/migrate-astro-image.ts
 import fs11 from "fs/promises";
-import path13 from "path";
+import path15 from "path";
 async function migrateAstroImages(options = {}) {
   const projectRoot = options.projectRoot ?? getProjectRoot();
   const dryRun = options.dryRun ?? false;
@@ -34050,11 +34866,11 @@ async function migrateAstroImages(options = {}) {
   const migrations = [];
   const skipped = [];
   for (const def of Object.values(collections)) {
-    const astroFields = def.fields.filter((f) => f.astroImage);
+    const astroFields = def.fields.filter((f2) => f2.astroImage);
     if (astroFields.length === 0 || !def.entries)
       continue;
     for (const entry of def.entries) {
-      const entryAbs = path13.isAbsolute(entry.sourcePath) ? entry.sourcePath : path13.join(projectRoot, entry.sourcePath);
+      const entryAbs = path15.isAbsolute(entry.sourcePath) ? entry.sourcePath : path15.join(projectRoot, entry.sourcePath);
       let raw;
       try {
         raw = await fs11.readFile(entryAbs, "utf-8");
@@ -34079,7 +34895,7 @@ async function migrateAstroImages(options = {}) {
         }
         if (!current.startsWith("/") || current.startsWith("//"))
           continue;
-        const sourceAbs = path13.join(projectRoot, "public", current.replace(/^\/+/, ""));
+        const sourceAbs = path15.join(projectRoot, "public", current.replace(/^\/+/, ""));
         let sourceBuf;
         try {
           sourceBuf = await fs11.readFile(sourceAbs);
@@ -34090,11 +34906,11 @@ async function migrateAstroImages(options = {}) {
         const target = await pickAstroImageTarget({
           entryAbsPath: entryAbs,
           slug: entry.slug,
-          originalFilename: path13.basename(current),
+          originalFilename: path15.basename(current),
           compareBuffer: sourceBuf
         });
         if (!dryRun) {
-          await fs11.mkdir(path13.dirname(target.absPath), { recursive: true });
+          await fs11.mkdir(path15.dirname(target.absPath), { recursive: true });
           await fs11.writeFile(target.absPath, sourceBuf);
         }
         doc2.set(field.name, target.relPath);
@@ -34157,7 +34973,7 @@ var exports_migrate = {};
 __export(exports_migrate, {
   migrate: () => migrate
 });
-import path14 from "path";
+import path16 from "path";
 async function migrate(args) {
   if (args.target !== "astro-image") {
     console.error(`Unknown migrate target: ${args.target}`);
@@ -34173,10 +34989,10 @@ async function migrate(args) {
   } else {
     console.log(`${result.migrations.length} field(s) to migrate:
 `);
-    for (const m of result.migrations) {
-      console.log(`  ${m.entrySourcePath}`);
-      console.log(`    ${m.fieldName}: ${m.originalValue} \u2192 ${m.newValue}`);
-      console.log(`      copy: ${path14.relative(process.cwd(), m.copiedFrom)} \u2192 ${path14.relative(process.cwd(), m.copiedTo)}`);
+    for (const m2 of result.migrations) {
+      console.log(`  ${m2.entrySourcePath}`);
+      console.log(`    ${m2.fieldName}: ${m2.originalValue} \u2192 ${m2.newValue}`);
+      console.log(`      copy: ${path16.relative(process.cwd(), m2.copiedFrom)} \u2192 ${path16.relative(process.cwd(), m2.copiedTo)}`);
     }
   }
   if (result.skipped.length > 0) {
@@ -34218,7 +35034,7 @@ Commands:`);
   console.log("  build              Run astro build with the Nua defaults");
   console.log("  dev                Run astro dev with the Nua defaults");
   console.log("  preview            Run astro preview with the Nua defaults");
-  console.log("  check              Validate the content collections (no build). --json, --strict");
+  console.log("  check              Validate collections and parse the source (no build). --json, --strict, --content-only");
   console.log("  init               Convert a standard Astro project to use Nua");
   console.log("  clean              Eject to a standard Astro project (remove @nuasite/* deps)");
   console.log("  migrate <target>   Run a content migration. Targets: astro-image");
@@ -34236,7 +35052,8 @@ if (command && ["build", "dev", "preview"].includes(command)) {
       process.exit(await check2({
         cwd: process.cwd(),
         json: args.includes("--json"),
-        strict: args.includes("--strict")
+        strict: args.includes("--strict"),
+        contentOnly: args.includes("--content-only")
       }));
       break;
     }