@vxrn/mdx 1.2.54 → 1.2.55

package/dist/index.js

@@ -2794,38 +2794,38 @@ var require_queue = __commonJS({
       var queue = fastqueue(context, asyncWrapper, _concurrency), pushCb = queue.push, unshiftCb = queue.unshift;
       return queue.push = push, queue.unshift = unshift, queue.drained = drained, queue;
       function push(value) {
-        var p2 = new Promise(function(resolve, reject) {
+        var p2 = new Promise(function(resolve2, reject) {
           pushCb(value, function(err, result) {
             if (err) {
               reject(err);
               return;
             }
-            resolve(result);
+            resolve2(result);
           });
         });
         return p2.catch(noop), p2;
       }
       function unshift(value) {
-        var p2 = new Promise(function(resolve, reject) {
+        var p2 = new Promise(function(resolve2, reject) {
           unshiftCb(value, function(err, result) {
             if (err) {
               reject(err);
               return;
             }
-            resolve(result);
+            resolve2(result);
           });
         });
         return p2.catch(noop), p2;
       }
       function drained() {
-        var p2 = new Promise(function(resolve) {
+        var p2 = new Promise(function(resolve2) {
           process.nextTick(function() {
             if (queue.idle())
-              resolve();
+              resolve2();
             else {
               var previousDrain = queue.drain;
               queue.drain = function() {
-                typeof previousDrain == "function" && previousDrain(), resolve(), queue.drain = previousDrain;
+                typeof previousDrain == "function" && previousDrain(), resolve2(), queue.drain = previousDrain;
               };
             }
           });
@@ -3180,8 +3180,8 @@ var require_stream3 = __commonJS({
         });
       }
       _getStat(filepath) {
-        return new Promise((resolve, reject) => {
-          this._stat(filepath, this._fsStatSettings, (error, stats) => error === null ? resolve(stats) : reject(error));
+        return new Promise((resolve2, reject) => {
+          this._stat(filepath, this._fsStatSettings, (error, stats) => error === null ? resolve2(stats) : reject(error));
         });
       }
     };
@@ -3199,16 +3199,16 @@ var require_async5 = __commonJS({
         super(...arguments), this._walkAsync = fsWalk.walk, this._readerStream = new stream_1.default(this._settings);
       }
       dynamic(root3, options2) {
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           this._walkAsync(root3, options2, (error, entries) => {
-            error === null ? resolve(entries) : reject(error);
+            error === null ? resolve2(entries) : reject(error);
           });
         });
       }
       async static(patterns, options2) {
         let entries = [], stream = this._readerStream.static(patterns, options2);
-        return new Promise((resolve, reject) => {
-          stream.once("error", reject), stream.on("data", (entry) => entries.push(entry)), stream.once("end", () => resolve(entries));
+        return new Promise((resolve2, reject) => {
+          stream.once("error", reject), stream.on("data", (entry) => entries.push(entry)), stream.once("end", () => resolve2(entries));
         });
       }
     };
@@ -5821,6 +5821,4138 @@ var require_extend = __commonJS({
   }
 });
 
+// ../../node_modules/sharp/lib/is.js
+var require_is = __commonJS({
+  "../../node_modules/sharp/lib/is.js"(exports2, module2) {
+    "use strict";
+    var defined = function(val) {
+      return typeof val < "u" && val !== null;
+    }, object = function(val) {
+      return typeof val == "object";
+    }, plainObject = function(val) {
+      return Object.prototype.toString.call(val) === "[object Object]";
+    }, fn = function(val) {
+      return typeof val == "function";
+    }, bool = function(val) {
+      return typeof val == "boolean";
+    }, buffer2 = function(val) {
+      return val instanceof Buffer;
+    }, typedArray = function(val) {
+      if (defined(val))
+        switch (val.constructor) {
+          case Uint8Array:
+          case Uint8ClampedArray:
+          case Int8Array:
+          case Uint16Array:
+          case Int16Array:
+          case Uint32Array:
+          case Int32Array:
+          case Float32Array:
+          case Float64Array:
+            return !0;
+        }
+      return !1;
+    }, arrayBuffer = function(val) {
+      return val instanceof ArrayBuffer;
+    }, string = function(val) {
+      return typeof val == "string" && val.length > 0;
+    }, number2 = function(val) {
+      return typeof val == "number" && !Number.isNaN(val);
+    }, integer = function(val) {
+      return Number.isInteger(val);
+    }, inRange = function(val, min, max) {
+      return val >= min && val <= max;
+    }, inArray = function(val, list2) {
+      return list2.includes(val);
+    }, invalidParameterError = function(name, expected, actual) {
+      return new Error(
+        `Expected ${expected} for ${name} but received ${actual} of type ${typeof actual}`
+      );
+    }, nativeError = function(native, context) {
+      return context.message = native.message, context;
+    };
+    module2.exports = {
+      defined,
+      object,
+      plainObject,
+      fn,
+      bool,
+      buffer: buffer2,
+      typedArray,
+      arrayBuffer,
+      string,
+      number: number2,
+      integer,
+      inRange,
+      inArray,
+      invalidParameterError,
+      nativeError
+    };
+  }
+});
+
+// ../../node_modules/detect-libc/lib/process.js
+var require_process = __commonJS({
+  "../../node_modules/detect-libc/lib/process.js"(exports2, module2) {
+    "use strict";
+    var isLinux = () => process.platform === "linux", report = null, getReport = () => {
+      if (!report)
+        if (isLinux() && process.report) {
+          let orig = process.report.excludeNetwork;
+          process.report.excludeNetwork = !0, report = process.report.getReport(), process.report.excludeNetwork = orig;
+        } else
+          report = {};
+      return report;
+    };
+    module2.exports = { isLinux, getReport };
+  }
+});
+
+// ../../node_modules/detect-libc/lib/filesystem.js
+var require_filesystem = __commonJS({
+  "../../node_modules/detect-libc/lib/filesystem.js"(exports2, module2) {
+    "use strict";
+    var fs4 = require("fs"), LDD_PATH = "/usr/bin/ldd", readFileSync = (path5) => fs4.readFileSync(path5, "utf-8"), readFile = (path5) => new Promise((resolve2, reject) => {
+      fs4.readFile(path5, "utf-8", (err, data) => {
+        err ? reject(err) : resolve2(data);
+      });
+    });
+    module2.exports = {
+      LDD_PATH,
+      readFileSync,
+      readFile
+    };
+  }
+});
+
+// ../../node_modules/detect-libc/lib/detect-libc.js
+var require_detect_libc = __commonJS({
+  "../../node_modules/detect-libc/lib/detect-libc.js"(exports2, module2) {
+    "use strict";
+    var childProcess = require("child_process"), { isLinux, getReport } = require_process(), { LDD_PATH, readFile, readFileSync } = require_filesystem(), cachedFamilyFilesystem, cachedVersionFilesystem, command = "getconf GNU_LIBC_VERSION 2>&1 || true; ldd --version 2>&1 || true", commandOut = "", safeCommand = () => commandOut || new Promise((resolve2) => {
+      childProcess.exec(command, (err, out) => {
+        commandOut = err ? " " : out, resolve2(commandOut);
+      });
+    }), safeCommandSync = () => {
+      if (!commandOut)
+        try {
+          commandOut = childProcess.execSync(command, { encoding: "utf8" });
+        } catch {
+          commandOut = " ";
+        }
+      return commandOut;
+    }, GLIBC = "glibc", RE_GLIBC_VERSION = /LIBC[a-z0-9 \-).]*?(\d+\.\d+)/i, MUSL = "musl", isFileMusl = (f) => f.includes("libc.musl-") || f.includes("ld-musl-"), familyFromReport = () => {
+      let report = getReport();
+      return report.header && report.header.glibcVersionRuntime ? GLIBC : Array.isArray(report.sharedObjects) && report.sharedObjects.some(isFileMusl) ? MUSL : null;
+    }, familyFromCommand = (out) => {
+      let [getconf, ldd1] = out.split(/[\r\n]+/);
+      return getconf && getconf.includes(GLIBC) ? GLIBC : ldd1 && ldd1.includes(MUSL) ? MUSL : null;
+    }, getFamilyFromLddContent = (content) => content.includes("musl") ? MUSL : content.includes("GNU C Library") ? GLIBC : null, familyFromFilesystem = async () => {
+      if (cachedFamilyFilesystem !== void 0)
+        return cachedFamilyFilesystem;
+      cachedFamilyFilesystem = null;
+      try {
+        let lddContent = await readFile(LDD_PATH);
+        cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
+      } catch {
+      }
+      return cachedFamilyFilesystem;
+    }, familyFromFilesystemSync = () => {
+      if (cachedFamilyFilesystem !== void 0)
+        return cachedFamilyFilesystem;
+      cachedFamilyFilesystem = null;
+      try {
+        let lddContent = readFileSync(LDD_PATH);
+        cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
+      } catch {
+      }
+      return cachedFamilyFilesystem;
+    }, family = async () => {
+      let family2 = null;
+      if (isLinux() && (family2 = await familyFromFilesystem(), family2 || (family2 = familyFromReport()), !family2)) {
+        let out = await safeCommand();
+        family2 = familyFromCommand(out);
+      }
+      return family2;
+    }, familySync = () => {
+      let family2 = null;
+      if (isLinux() && (family2 = familyFromFilesystemSync(), family2 || (family2 = familyFromReport()), !family2)) {
+        let out = safeCommandSync();
+        family2 = familyFromCommand(out);
+      }
+      return family2;
+    }, isNonGlibcLinux = async () => isLinux() && await family() !== GLIBC, isNonGlibcLinuxSync = () => isLinux() && familySync() !== GLIBC, versionFromFilesystem = async () => {
+      if (cachedVersionFilesystem !== void 0)
+        return cachedVersionFilesystem;
+      cachedVersionFilesystem = null;
+      try {
+        let versionMatch = (await readFile(LDD_PATH)).match(RE_GLIBC_VERSION);
+        versionMatch && (cachedVersionFilesystem = versionMatch[1]);
+      } catch {
+      }
+      return cachedVersionFilesystem;
+    }, versionFromFilesystemSync = () => {
+      if (cachedVersionFilesystem !== void 0)
+        return cachedVersionFilesystem;
+      cachedVersionFilesystem = null;
+      try {
+        let versionMatch = readFileSync(LDD_PATH).match(RE_GLIBC_VERSION);
+        versionMatch && (cachedVersionFilesystem = versionMatch[1]);
+      } catch {
+      }
+      return cachedVersionFilesystem;
+    }, versionFromReport = () => {
+      let report = getReport();
+      return report.header && report.header.glibcVersionRuntime ? report.header.glibcVersionRuntime : null;
+    }, versionSuffix = (s2) => s2.trim().split(/\s+/)[1], versionFromCommand = (out) => {
+      let [getconf, ldd1, ldd2] = out.split(/[\r\n]+/);
+      return getconf && getconf.includes(GLIBC) ? versionSuffix(getconf) : ldd1 && ldd2 && ldd1.includes(MUSL) ? versionSuffix(ldd2) : null;
+    }, version = async () => {
+      let version2 = null;
+      if (isLinux() && (version2 = await versionFromFilesystem(), version2 || (version2 = versionFromReport()), !version2)) {
+        let out = await safeCommand();
+        version2 = versionFromCommand(out);
+      }
+      return version2;
+    }, versionSync = () => {
+      let version2 = null;
+      if (isLinux() && (version2 = versionFromFilesystemSync(), version2 || (version2 = versionFromReport()), !version2)) {
+        let out = safeCommandSync();
+        version2 = versionFromCommand(out);
+      }
+      return version2;
+    };
+    module2.exports = {
+      GLIBC,
+      MUSL,
+      family,
+      familySync,
+      isNonGlibcLinux,
+      isNonGlibcLinuxSync,
+      version,
+      versionSync
+    };
+  }
+});
+
+// ../../node_modules/semver/internal/debug.js
+var require_debug = __commonJS({
+  "../../node_modules/semver/internal/debug.js"(exports2, module2) {
+    "use strict";
+    var debug = typeof process == "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
+    };
+    module2.exports = debug;
+  }
+});
+
+// ../../node_modules/semver/internal/constants.js
+var require_constants4 = __commonJS({
+  "../../node_modules/semver/internal/constants.js"(exports2, module2) {
+    "use strict";
+    var SEMVER_SPEC_VERSION = "2.0.0", MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
+    9007199254740991, MAX_SAFE_COMPONENT_LENGTH = 16, MAX_SAFE_BUILD_LENGTH = 250, RELEASE_TYPES = [
+      "major",
+      "premajor",
+      "minor",
+      "preminor",
+      "patch",
+      "prepatch",
+      "prerelease"
+    ];
+    module2.exports = {
+      MAX_LENGTH: 256,
+      MAX_SAFE_COMPONENT_LENGTH,
+      MAX_SAFE_BUILD_LENGTH,
+      MAX_SAFE_INTEGER,
+      RELEASE_TYPES,
+      SEMVER_SPEC_VERSION,
+      FLAG_INCLUDE_PRERELEASE: 1,
+      FLAG_LOOSE: 2
+    };
+  }
+});
+
+// ../../node_modules/semver/internal/re.js
+var require_re = __commonJS({
+  "../../node_modules/semver/internal/re.js"(exports2, module2) {
+    "use strict";
+    var {
+      MAX_SAFE_COMPONENT_LENGTH,
+      MAX_SAFE_BUILD_LENGTH,
+      MAX_LENGTH
+    } = require_constants4(), debug = require_debug();
+    exports2 = module2.exports = {};
+    var re2 = exports2.re = [], safeRe = exports2.safeRe = [], src = exports2.src = [], safeSrc = exports2.safeSrc = [], t = exports2.t = {}, R = 0, LETTERDASHNUMBER = "[a-zA-Z0-9-]", safeRegexReplacements = [
+      ["\\s", 1],
+      ["\\d", MAX_LENGTH],
+      [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
+    ], makeSafeRegex = (value) => {
+      for (let [token, max] of safeRegexReplacements)
+        value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
+      return value;
+    }, createToken = (name, value, isGlobal) => {
+      let safe = makeSafeRegex(value), index2 = R++;
+      debug(name, index2, value), t[name] = index2, src[index2] = value, safeSrc[index2] = safe, re2[index2] = new RegExp(value, isGlobal ? "g" : void 0), safeRe[index2] = new RegExp(safe, isGlobal ? "g" : void 0);
+    };
+    createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
+    createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
+    createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
+    createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`);
+    createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`);
+    createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIER]})`);
+    createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIERLOOSE]})`);
+    createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
+    createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
+    createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
+    createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
+    createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
+    createToken("FULL", `^${src[t.FULLPLAIN]}$`);
+    createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
+    createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
+    createToken("GTLT", "((?:<|>)?=?)");
+    createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+    createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
+    createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`);
+    createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`);
+    createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
+    createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
+    createToken("COERCEPLAIN", `(^|[^\\d])(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
+    createToken("COERCE", `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
+    createToken("COERCEFULL", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?(?:${src[t.BUILD]})?(?:$|[^\\d])`);
+    createToken("COERCERTL", src[t.COERCE], !0);
+    createToken("COERCERTLFULL", src[t.COERCEFULL], !0);
+    createToken("LONETILDE", "(?:~>?)");
+    createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, !0);
+    exports2.tildeTrimReplace = "$1~";
+    createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
+    createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
+    createToken("LONECARET", "(?:\\^)");
+    createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, !0);
+    exports2.caretTrimReplace = "$1^";
+    createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
+    createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
+    createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
+    createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
+    createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, !0);
+    exports2.comparatorTrimReplace = "$1$2$3";
+    createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`);
+    createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`);
+    createToken("STAR", "(<|>)?=?\\s*\\*");
+    createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
+    createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+  }
+});
+
+// ../../node_modules/semver/internal/parse-options.js
+var require_parse_options = __commonJS({
+  "../../node_modules/semver/internal/parse-options.js"(exports2, module2) {
+    "use strict";
+    var looseOption = Object.freeze({ loose: !0 }), emptyOpts = Object.freeze({}), parseOptions = (options2) => options2 ? typeof options2 != "object" ? looseOption : options2 : emptyOpts;
+    module2.exports = parseOptions;
+  }
+});
+
+// ../../node_modules/semver/internal/identifiers.js
+var require_identifiers = __commonJS({
+  "../../node_modules/semver/internal/identifiers.js"(exports2, module2) {
+    "use strict";
+    var numeric = /^[0-9]+$/, compareIdentifiers = (a, b) => {
+      let anum = numeric.test(a), bnum = numeric.test(b);
+      return anum && bnum && (a = +a, b = +b), a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
+    }, rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
+    module2.exports = {
+      compareIdentifiers,
+      rcompareIdentifiers
+    };
+  }
+});
+
+// ../../node_modules/semver/classes/semver.js
+var require_semver = __commonJS({
+  "../../node_modules/semver/classes/semver.js"(exports2, module2) {
+    "use strict";
+    var debug = require_debug(), { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants4(), { safeRe: re2, t } = require_re(), parseOptions = require_parse_options(), { compareIdentifiers } = require_identifiers(), SemVer = class _SemVer {
+      constructor(version, options2) {
+        if (options2 = parseOptions(options2), version instanceof _SemVer) {
+          if (version.loose === !!options2.loose && version.includePrerelease === !!options2.includePrerelease)
+            return version;
+          version = version.version;
+        } else if (typeof version != "string")
+          throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`);
+        if (version.length > MAX_LENGTH)
+          throw new TypeError(
+            `version is longer than ${MAX_LENGTH} characters`
+          );
+        debug("SemVer", version, options2), this.options = options2, this.loose = !!options2.loose, this.includePrerelease = !!options2.includePrerelease;
+        let m = version.trim().match(options2.loose ? re2[t.LOOSE] : re2[t.FULL]);
+        if (!m)
+          throw new TypeError(`Invalid Version: ${version}`);
+        if (this.raw = version, this.major = +m[1], this.minor = +m[2], this.patch = +m[3], this.major > MAX_SAFE_INTEGER || this.major < 0)
+          throw new TypeError("Invalid major version");
+        if (this.minor > MAX_SAFE_INTEGER || this.minor < 0)
+          throw new TypeError("Invalid minor version");
+        if (this.patch > MAX_SAFE_INTEGER || this.patch < 0)
+          throw new TypeError("Invalid patch version");
+        m[4] ? this.prerelease = m[4].split(".").map((id) => {
+          if (/^[0-9]+$/.test(id)) {
+            let num = +id;
+            if (num >= 0 && num < MAX_SAFE_INTEGER)
+              return num;
+          }
+          return id;
+        }) : this.prerelease = [], this.build = m[5] ? m[5].split(".") : [], this.format();
+      }
+      format() {
+        return this.version = `${this.major}.${this.minor}.${this.patch}`, this.prerelease.length && (this.version += `-${this.prerelease.join(".")}`), this.version;
+      }
+      toString() {
+        return this.version;
+      }
+      compare(other) {
+        if (debug("SemVer.compare", this.version, this.options, other), !(other instanceof _SemVer)) {
+          if (typeof other == "string" && other === this.version)
+            return 0;
+          other = new _SemVer(other, this.options);
+        }
+        return other.version === this.version ? 0 : this.compareMain(other) || this.comparePre(other);
+      }
+      compareMain(other) {
+        return other instanceof _SemVer || (other = new _SemVer(other, this.options)), compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
+      }
+      comparePre(other) {
+        if (other instanceof _SemVer || (other = new _SemVer(other, this.options)), this.prerelease.length && !other.prerelease.length)
+          return -1;
+        if (!this.prerelease.length && other.prerelease.length)
+          return 1;
+        if (!this.prerelease.length && !other.prerelease.length)
+          return 0;
+        let i = 0;
+        do {
+          let a = this.prerelease[i], b = other.prerelease[i];
+          if (debug("prerelease compare", i, a, b), a === void 0 && b === void 0)
+            return 0;
+          if (b === void 0)
+            return 1;
+          if (a === void 0)
+            return -1;
+          if (a === b)
+            continue;
+          return compareIdentifiers(a, b);
+        } while (++i);
+      }
+      compareBuild(other) {
+        other instanceof _SemVer || (other = new _SemVer(other, this.options));
+        let i = 0;
+        do {
+          let a = this.build[i], b = other.build[i];
+          if (debug("build compare", i, a, b), a === void 0 && b === void 0)
+            return 0;
+          if (b === void 0)
+            return 1;
+          if (a === void 0)
+            return -1;
+          if (a === b)
+            continue;
+          return compareIdentifiers(a, b);
+        } while (++i);
+      }
+      // preminor will bump the version up to the next minor release, and immediately
+      // down to pre-release. premajor and prepatch work the same way.
+      inc(release, identifier, identifierBase) {
+        if (release.startsWith("pre")) {
+          if (!identifier && identifierBase === !1)
+            throw new Error("invalid increment argument: identifier is empty");
+          if (identifier) {
+            let match = `-${identifier}`.match(this.options.loose ? re2[t.PRERELEASELOOSE] : re2[t.PRERELEASE]);
+            if (!match || match[1] !== identifier)
+              throw new Error(`invalid identifier: ${identifier}`);
+          }
+        }
+        switch (release) {
+          case "premajor":
+            this.prerelease.length = 0, this.patch = 0, this.minor = 0, this.major++, this.inc("pre", identifier, identifierBase);
+            break;
+          case "preminor":
+            this.prerelease.length = 0, this.patch = 0, this.minor++, this.inc("pre", identifier, identifierBase);
+            break;
+          case "prepatch":
+            this.prerelease.length = 0, this.inc("patch", identifier, identifierBase), this.inc("pre", identifier, identifierBase);
+            break;
+          // If the input is a non-prerelease version, this acts the same as
+          // prepatch.
+          case "prerelease":
+            this.prerelease.length === 0 && this.inc("patch", identifier, identifierBase), this.inc("pre", identifier, identifierBase);
+            break;
+          case "release":
+            if (this.prerelease.length === 0)
+              throw new Error(`version ${this.raw} is not a prerelease`);
+            this.prerelease.length = 0;
+            break;
+          case "major":
+            (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) && this.major++, this.minor = 0, this.patch = 0, this.prerelease = [];
+            break;
+          case "minor":
+            (this.patch !== 0 || this.prerelease.length === 0) && this.minor++, this.patch = 0, this.prerelease = [];
+            break;
+          case "patch":
+            this.prerelease.length === 0 && this.patch++, this.prerelease = [];
+            break;
+          // This probably shouldn't be used publicly.
+          // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
+          case "pre": {
+            let base3 = Number(identifierBase) ? 1 : 0;
+            if (this.prerelease.length === 0)
+              this.prerelease = [base3];
+            else {
+              let i = this.prerelease.length;
+              for (; --i >= 0; )
+                typeof this.prerelease[i] == "number" && (this.prerelease[i]++, i = -2);
+              if (i === -1) {
+                if (identifier === this.prerelease.join(".") && identifierBase === !1)
+                  throw new Error("invalid increment argument: identifier already exists");
+                this.prerelease.push(base3);
+              }
+            }
+            if (identifier) {
+              let prerelease = [identifier, base3];
+              identifierBase === !1 && (prerelease = [identifier]), compareIdentifiers(this.prerelease[0], identifier) === 0 ? isNaN(this.prerelease[1]) && (this.prerelease = prerelease) : this.prerelease = prerelease;
+            }
+            break;
+          }
+          default:
+            throw new Error(`invalid increment argument: ${release}`);
+        }
+        return this.raw = this.format(), this.build.length && (this.raw += `+${this.build.join(".")}`), this;
+      }
+    };
+    module2.exports = SemVer;
+  }
+});
+
+// ../../node_modules/semver/functions/parse.js
+var require_parse4 = __commonJS({
+  "../../node_modules/semver/functions/parse.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver(), parse4 = (version, options2, throwErrors = !1) => {
+      if (version instanceof SemVer)
+        return version;
+      try {
+        return new SemVer(version, options2);
+      } catch (er) {
+        if (!throwErrors)
+          return null;
+        throw er;
+      }
+    };
+    module2.exports = parse4;
+  }
+});
+
+// ../../node_modules/semver/functions/coerce.js
+var require_coerce = __commonJS({
+  "../../node_modules/semver/functions/coerce.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver(), parse4 = require_parse4(), { safeRe: re2, t } = require_re(), coerce = (version, options2) => {
+      if (version instanceof SemVer)
+        return version;
+      if (typeof version == "number" && (version = String(version)), typeof version != "string")
+        return null;
+      options2 = options2 || {};
+      let match = null;
+      if (!options2.rtl)
+        match = version.match(options2.includePrerelease ? re2[t.COERCEFULL] : re2[t.COERCE]);
+      else {
+        let coerceRtlRegex = options2.includePrerelease ? re2[t.COERCERTLFULL] : re2[t.COERCERTL], next;
+        for (; (next = coerceRtlRegex.exec(version)) && (!match || match.index + match[0].length !== version.length); )
+          (!match || next.index + next[0].length !== match.index + match[0].length) && (match = next), coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
+        coerceRtlRegex.lastIndex = -1;
+      }
+      if (match === null)
+        return null;
+      let major = match[2], minor = match[3] || "0", patch2 = match[4] || "0", prerelease = options2.includePrerelease && match[5] ? `-${match[5]}` : "", build = options2.includePrerelease && match[6] ? `+${match[6]}` : "";
+      return parse4(`${major}.${minor}.${patch2}${prerelease}${build}`, options2);
+    };
+    module2.exports = coerce;
+  }
+});
+
+// ../../node_modules/semver/functions/compare.js
+var require_compare = __commonJS({
+  "../../node_modules/semver/functions/compare.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver(), compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
+    module2.exports = compare;
+  }
+});
+
+// ../../node_modules/semver/functions/gte.js
+var require_gte = __commonJS({
+  "../../node_modules/semver/functions/gte.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare(), gte = (a, b, loose) => compare(a, b, loose) >= 0;
+    module2.exports = gte;
+  }
+});
+
+// ../../node_modules/semver/internal/lrucache.js
+var require_lrucache = __commonJS({
+  "../../node_modules/semver/internal/lrucache.js"(exports2, module2) {
+    "use strict";
+    var LRUCache = class {
+      constructor() {
+        this.max = 1e3, this.map = /* @__PURE__ */ new Map();
+      }
+      get(key2) {
+        let value = this.map.get(key2);
+        if (value !== void 0)
+          return this.map.delete(key2), this.map.set(key2, value), value;
+      }
+      delete(key2) {
+        return this.map.delete(key2);
+      }
+      set(key2, value) {
+        if (!this.delete(key2) && value !== void 0) {
+          if (this.map.size >= this.max) {
+            let firstKey = this.map.keys().next().value;
+            this.delete(firstKey);
+          }
+          this.map.set(key2, value);
+        }
+        return this;
+      }
+    };
+    module2.exports = LRUCache;
+  }
+});
+
+// ../../node_modules/semver/functions/eq.js
+var require_eq = __commonJS({
+  "../../node_modules/semver/functions/eq.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare(), eq = (a, b, loose) => compare(a, b, loose) === 0;
+    module2.exports = eq;
+  }
+});
+
+// ../../node_modules/semver/functions/neq.js
+var require_neq = __commonJS({
+  "../../node_modules/semver/functions/neq.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare(), neq = (a, b, loose) => compare(a, b, loose) !== 0;
+    module2.exports = neq;
+  }
+});
+
+// ../../node_modules/semver/functions/gt.js
+var require_gt = __commonJS({
+  "../../node_modules/semver/functions/gt.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare(), gt = (a, b, loose) => compare(a, b, loose) > 0;
+    module2.exports = gt;
+  }
+});
+
+// ../../node_modules/semver/functions/lt.js
+var require_lt = __commonJS({
+  "../../node_modules/semver/functions/lt.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare(), lt = (a, b, loose) => compare(a, b, loose) < 0;
+    module2.exports = lt;
+  }
+});
+
+// ../../node_modules/semver/functions/lte.js
+var require_lte = __commonJS({
+  "../../node_modules/semver/functions/lte.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare(), lte = (a, b, loose) => compare(a, b, loose) <= 0;
+    module2.exports = lte;
+  }
+});
+
+// ../../node_modules/semver/functions/cmp.js
+var require_cmp = __commonJS({
+  "../../node_modules/semver/functions/cmp.js"(exports2, module2) {
+    "use strict";
+    var eq = require_eq(), neq = require_neq(), gt = require_gt(), gte = require_gte(), lt = require_lt(), lte = require_lte(), cmp = (a, op, b, loose) => {
+      switch (op) {
+        case "===":
+          return typeof a == "object" && (a = a.version), typeof b == "object" && (b = b.version), a === b;
+        case "!==":
+          return typeof a == "object" && (a = a.version), typeof b == "object" && (b = b.version), a !== b;
+        case "":
+        case "=":
+        case "==":
+          return eq(a, b, loose);
+        case "!=":
+          return neq(a, b, loose);
+        case ">":
+          return gt(a, b, loose);
+        case ">=":
+          return gte(a, b, loose);
+        case "<":
+          return lt(a, b, loose);
+        case "<=":
+          return lte(a, b, loose);
+        default:
+          throw new TypeError(`Invalid operator: ${op}`);
+      }
+    };
+    module2.exports = cmp;
+  }
+});
+
+// ../../node_modules/semver/classes/comparator.js
+var require_comparator = __commonJS({
+  "../../node_modules/semver/classes/comparator.js"(exports2, module2) {
+    "use strict";
+    var ANY = Symbol("SemVer ANY"), Comparator = class _Comparator {
+      static get ANY() {
+        return ANY;
+      }
+      constructor(comp, options2) {
+        if (options2 = parseOptions(options2), comp instanceof _Comparator) {
+          if (comp.loose === !!options2.loose)
+            return comp;
+          comp = comp.value;
+        }
+        comp = comp.trim().split(/\s+/).join(" "), debug("comparator", comp, options2), this.options = options2, this.loose = !!options2.loose, this.parse(comp), this.semver === ANY ? this.value = "" : this.value = this.operator + this.semver.version, debug("comp", this);
+      }
+      parse(comp) {
+        let r2 = this.options.loose ? re2[t.COMPARATORLOOSE] : re2[t.COMPARATOR], m = comp.match(r2);
+        if (!m)
+          throw new TypeError(`Invalid comparator: ${comp}`);
+        this.operator = m[1] !== void 0 ? m[1] : "", this.operator === "=" && (this.operator = ""), m[2] ? this.semver = new SemVer(m[2], this.options.loose) : this.semver = ANY;
+      }
+      toString() {
+        return this.value;
+      }
+      test(version) {
+        if (debug("Comparator.test", version, this.options.loose), this.semver === ANY || version === ANY)
+          return !0;
+        if (typeof version == "string")
+          try {
+            version = new SemVer(version, this.options);
+          } catch {
+            return !1;
+          }
+        return cmp(version, this.operator, this.semver, this.options);
+      }
+      intersects(comp, options2) {
+        if (!(comp instanceof _Comparator))
+          throw new TypeError("a Comparator is required");
+        return this.operator === "" ? this.value === "" ? !0 : new Range(comp.value, options2).test(this.value) : comp.operator === "" ? comp.value === "" ? !0 : new Range(this.value, options2).test(comp.semver) : (options2 = parseOptions(options2), options2.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0") || !options2.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0")) ? !1 : !!(this.operator.startsWith(">") && comp.operator.startsWith(">") || this.operator.startsWith("<") && comp.operator.startsWith("<") || this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=") || cmp(this.semver, "<", comp.semver, options2) && this.operator.startsWith(">") && comp.operator.startsWith("<") || cmp(this.semver, ">", comp.semver, options2) && this.operator.startsWith("<") && comp.operator.startsWith(">")));
+      }
+    };
+    module2.exports = Comparator;
+    var parseOptions = require_parse_options(), { safeRe: re2, t } = require_re(), cmp = require_cmp(), debug = require_debug(), SemVer = require_semver(), Range = require_range();
+  }
+});
+
+// ../../node_modules/semver/classes/range.js
+var require_range = __commonJS({
+  "../../node_modules/semver/classes/range.js"(exports2, module2) {
+    "use strict";
+    var SPACE_CHARACTERS = /\s+/g, Range = class _Range {
+      constructor(range, options2) {
+        if (options2 = parseOptions(options2), range instanceof _Range)
+          return range.loose === !!options2.loose && range.includePrerelease === !!options2.includePrerelease ? range : new _Range(range.raw, options2);
+        if (range instanceof Comparator)
+          return this.raw = range.value, this.set = [[range]], this.formatted = void 0, this;
+        if (this.options = options2, this.loose = !!options2.loose, this.includePrerelease = !!options2.includePrerelease, this.raw = range.trim().replace(SPACE_CHARACTERS, " "), this.set = this.raw.split("||").map((r2) => this.parseRange(r2.trim())).filter((c2) => c2.length), !this.set.length)
+          throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
+        if (this.set.length > 1) {
+          let first = this.set[0];
+          if (this.set = this.set.filter((c2) => !isNullSet(c2[0])), this.set.length === 0)
+            this.set = [first];
+          else if (this.set.length > 1) {
+            for (let c2 of this.set)
+              if (c2.length === 1 && isAny(c2[0])) {
+                this.set = [c2];
+                break;
+              }
+          }
+        }
+        this.formatted = void 0;
+      }
+      get range() {
+        if (this.formatted === void 0) {
+          this.formatted = "";
+          for (let i = 0; i < this.set.length; i++) {
+            i > 0 && (this.formatted += "||");
+            let comps = this.set[i];
+            for (let k = 0; k < comps.length; k++)
+              k > 0 && (this.formatted += " "), this.formatted += comps[k].toString().trim();
+          }
+        }
+        return this.formatted;
+      }
+      format() {
+        return this.range;
+      }
+      toString() {
+        return this.range;
+      }
+      parseRange(range) {
+        let memoKey = ((this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE)) + ":" + range, cached = cache.get(memoKey);
+        if (cached)
+          return cached;
+        let loose = this.options.loose, hr = loose ? re2[t.HYPHENRANGELOOSE] : re2[t.HYPHENRANGE];
+        range = range.replace(hr, hyphenReplace(this.options.includePrerelease)), debug("hyphen replace", range), range = range.replace(re2[t.COMPARATORTRIM], comparatorTrimReplace), debug("comparator trim", range), range = range.replace(re2[t.TILDETRIM], tildeTrimReplace), debug("tilde trim", range), range = range.replace(re2[t.CARETTRIM], caretTrimReplace), debug("caret trim", range);
+        let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
+        loose && (rangeList = rangeList.filter((comp) => (debug("loose invalid filter", comp, this.options), !!comp.match(re2[t.COMPARATORLOOSE])))), debug("range list", rangeList);
+        let rangeMap = /* @__PURE__ */ new Map(), comparators = rangeList.map((comp) => new Comparator(comp, this.options));
+        for (let comp of comparators) {
+          if (isNullSet(comp))
+            return [comp];
+          rangeMap.set(comp.value, comp);
+        }
+        rangeMap.size > 1 && rangeMap.has("") && rangeMap.delete("");
+        let result = [...rangeMap.values()];
+        return cache.set(memoKey, result), result;
+      }
+      intersects(range, options2) {
+        if (!(range instanceof _Range))
+          throw new TypeError("a Range is required");
+        return this.set.some((thisComparators) => isSatisfiable(thisComparators, options2) && range.set.some((rangeComparators) => isSatisfiable(rangeComparators, options2) && thisComparators.every((thisComparator) => rangeComparators.every((rangeComparator) => thisComparator.intersects(rangeComparator, options2)))));
+      }
+      // if ANY of the sets match ALL of its comparators, then pass
+      test(version) {
+        if (!version)
+          return !1;
+        if (typeof version == "string")
+          try {
+            version = new SemVer(version, this.options);
+          } catch {
+            return !1;
+          }
+        for (let i = 0; i < this.set.length; i++)
+          if (testSet(this.set[i], version, this.options))
+            return !0;
+        return !1;
+      }
+    };
+    module2.exports = Range;
+    var LRU = require_lrucache(), cache = new LRU(), parseOptions = require_parse_options(), Comparator = require_comparator(), debug = require_debug(), SemVer = require_semver(), {
+      safeRe: re2,
+      t,
+      comparatorTrimReplace,
+      tildeTrimReplace,
+      caretTrimReplace
+    } = require_re(), { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants4(), isNullSet = (c2) => c2.value === "<0.0.0-0", isAny = (c2) => c2.value === "", isSatisfiable = (comparators, options2) => {
+      let result = !0, remainingComparators = comparators.slice(), testComparator = remainingComparators.pop();
+      for (; result && remainingComparators.length; )
+        result = remainingComparators.every((otherComparator) => testComparator.intersects(otherComparator, options2)), testComparator = remainingComparators.pop();
+      return result;
+    }, parseComparator = (comp, options2) => (debug("comp", comp, options2), comp = replaceCarets(comp, options2), debug("caret", comp), comp = replaceTildes(comp, options2), debug("tildes", comp), comp = replaceXRanges(comp, options2), debug("xrange", comp), comp = replaceStars(comp, options2), debug("stars", comp), comp), isX = (id) => !id || id.toLowerCase() === "x" || id === "*", replaceTildes = (comp, options2) => comp.trim().split(/\s+/).map((c2) => replaceTilde(c2, options2)).join(" "), replaceTilde = (comp, options2) => {
+      let r2 = options2.loose ? re2[t.TILDELOOSE] : re2[t.TILDE];
+      return comp.replace(r2, (_2, M, m, p2, pr) => {
+        debug("tilde", comp, _2, M, m, p2, pr);
+        let ret;
+        return isX(M) ? ret = "" : isX(m) ? ret = `>=${M}.0.0 <${+M + 1}.0.0-0` : isX(p2) ? ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0` : pr ? (debug("replaceTilde pr", pr), ret = `>=${M}.${m}.${p2}-${pr} <${M}.${+m + 1}.0-0`) : ret = `>=${M}.${m}.${p2} <${M}.${+m + 1}.0-0`, debug("tilde return", ret), ret;
+      });
+    }, replaceCarets = (comp, options2) => comp.trim().split(/\s+/).map((c2) => replaceCaret(c2, options2)).join(" "), replaceCaret = (comp, options2) => {
+      debug("caret", comp, options2);
+      let r2 = options2.loose ? re2[t.CARETLOOSE] : re2[t.CARET], z = options2.includePrerelease ? "-0" : "";
+      return comp.replace(r2, (_2, M, m, p2, pr) => {
+        debug("caret", comp, _2, M, m, p2, pr);
+        let ret;
+        return isX(M) ? ret = "" : isX(m) ? ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0` : isX(p2) ? M === "0" ? ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0` : ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0` : pr ? (debug("replaceCaret pr", pr), M === "0" ? m === "0" ? ret = `>=${M}.${m}.${p2}-${pr} <${M}.${m}.${+p2 + 1}-0` : ret = `>=${M}.${m}.${p2}-${pr} <${M}.${+m + 1}.0-0` : ret = `>=${M}.${m}.${p2}-${pr} <${+M + 1}.0.0-0`) : (debug("no pr"), M === "0" ? m === "0" ? ret = `>=${M}.${m}.${p2}${z} <${M}.${m}.${+p2 + 1}-0` : ret = `>=${M}.${m}.${p2}${z} <${M}.${+m + 1}.0-0` : ret = `>=${M}.${m}.${p2} <${+M + 1}.0.0-0`), debug("caret return", ret), ret;
+      });
+    }, replaceXRanges = (comp, options2) => (debug("replaceXRanges", comp, options2), comp.split(/\s+/).map((c2) => replaceXRange(c2, options2)).join(" ")), replaceXRange = (comp, options2) => {
+      comp = comp.trim();
+      let r2 = options2.loose ? re2[t.XRANGELOOSE] : re2[t.XRANGE];
+      return comp.replace(r2, (ret, gtlt, M, m, p2, pr) => {
+        debug("xRange", comp, ret, gtlt, M, m, p2, pr);
+        let xM = isX(M), xm = xM || isX(m), xp = xm || isX(p2), anyX = xp;
+        return gtlt === "=" && anyX && (gtlt = ""), pr = options2.includePrerelease ? "-0" : "", xM ? gtlt === ">" || gtlt === "<" ? ret = "<0.0.0-0" : ret = "*" : gtlt && anyX ? (xm && (m = 0), p2 = 0, gtlt === ">" ? (gtlt = ">=", xm ? (M = +M + 1, m = 0, p2 = 0) : (m = +m + 1, p2 = 0)) : gtlt === "<=" && (gtlt = "<", xm ? M = +M + 1 : m = +m + 1), gtlt === "<" && (pr = "-0"), ret = `${gtlt + M}.${m}.${p2}${pr}`) : xm ? ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0` : xp && (ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`), debug("xRange return", ret), ret;
+      });
+    }, replaceStars = (comp, options2) => (debug("replaceStars", comp, options2), comp.trim().replace(re2[t.STAR], "")), replaceGTE0 = (comp, options2) => (debug("replaceGTE0", comp, options2), comp.trim().replace(re2[options2.includePrerelease ? t.GTE0PRE : t.GTE0], "")), hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => (isX(fM) ? from = "" : isX(fm) ? from = `>=${fM}.0.0${incPr ? "-0" : ""}` : isX(fp) ? from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}` : fpr ? from = `>=${from}` : from = `>=${from}${incPr ? "-0" : ""}`, isX(tM) ? to = "" : isX(tm) ? to = `<${+tM + 1}.0.0-0` : isX(tp) ? to = `<${tM}.${+tm + 1}.0-0` : tpr ? to = `<=${tM}.${tm}.${tp}-${tpr}` : incPr ? to = `<${tM}.${tm}.${+tp + 1}-0` : to = `<=${to}`, `${from} ${to}`.trim()), testSet = (set, version, options2) => {
+      for (let i = 0; i < set.length; i++)
+        if (!set[i].test(version))
+          return !1;
+      if (version.prerelease.length && !options2.includePrerelease) {
+        for (let i = 0; i < set.length; i++)
+          if (debug(set[i].semver), set[i].semver !== Comparator.ANY && set[i].semver.prerelease.length > 0) {
+            let allowed = set[i].semver;
+            if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch)
+              return !0;
+          }
+        return !1;
+      }
+      return !0;
+    };
+  }
+});
+
+// ../../node_modules/semver/functions/satisfies.js
+var require_satisfies = __commonJS({
+  "../../node_modules/semver/functions/satisfies.js"(exports2, module2) {
+    "use strict";
+    var Range = require_range(), satisfies = (version, range, options2) => {
+      try {
+        range = new Range(range, options2);
+      } catch {
+        return !1;
+      }
+      return range.test(version);
+    };
+    module2.exports = satisfies;
+  }
+});
+
+// ../../node_modules/sharp/package.json
+var require_package = __commonJS({
+  "../../node_modules/sharp/package.json"(exports2, module2) {
+    module2.exports = {
+      name: "sharp",
+      description: "High performance Node.js image processing, the fastest module to resize JPEG, PNG, WebP, GIF, AVIF and TIFF images",
+      version: "0.33.5",
+      author: "Lovell Fuller <npm@lovell.info>",
+      homepage: "https://sharp.pixelplumbing.com",
+      contributors: [
+        "Pierre Inglebert <pierre.inglebert@gmail.com>",
+        "Jonathan Ong <jonathanrichardong@gmail.com>",
+        "Chanon Sajjamanochai <chanon.s@gmail.com>",
+        "Juliano Julio <julianojulio@gmail.com>",
+        "Daniel Gasienica <daniel@gasienica.ch>",
+        "Julian Walker <julian@fiftythree.com>",
+        "Amit Pitaru <pitaru.amit@gmail.com>",
+        "Brandon Aaron <hello.brandon@aaron.sh>",
+        "Andreas Lind <andreas@one.com>",
+        "Maurus Cuelenaere <mcuelenaere@gmail.com>",
+        "Linus Unneb\xE4ck <linus@folkdatorn.se>",
+        "Victor Mateevitsi <mvictoras@gmail.com>",
+        "Alaric Holloway <alaric.holloway@gmail.com>",
+        "Bernhard K. Weisshuhn <bkw@codingforce.com>",
+        "Chris Riley <criley@primedia.com>",
+        "David Carley <dacarley@gmail.com>",
+        "John Tobin <john@limelightmobileinc.com>",
+        "Kenton Gray <kentongray@gmail.com>",
+        "Felix B\xFCnemann <Felix.Buenemann@gmail.com>",
+        "Samy Al Zahrani <samyalzahrany@gmail.com>",
+        "Chintan Thakkar <lemnisk8@gmail.com>",
+        "F. Orlando Galashan <frulo@gmx.de>",
+        "Kleis Auke Wolthuizen <info@kleisauke.nl>",
+        "Matt Hirsch <mhirsch@media.mit.edu>",
+        "Matthias Thoemmes <thoemmes@gmail.com>",
+        "Patrick Paskaris <patrick@paskaris.gr>",
+        "J\xE9r\xE9my Lal <kapouer@melix.org>",
+        "Rahul Nanwani <r.nanwani@gmail.com>",
+        "Alice Monday <alice0meta@gmail.com>",
+        "Kristo Jorgenson <kristo.jorgenson@gmail.com>",
+        "YvesBos <yves_bos@outlook.com>",
+        "Guy Maliar <guy@tailorbrands.com>",
+        "Nicolas Coden <nicolas@ncoden.fr>",
+        "Matt Parrish <matt.r.parrish@gmail.com>",
+        "Marcel Bretschneider <marcel.bretschneider@gmail.com>",
+        "Matthew McEachen <matthew+github@mceachen.org>",
+        "Jarda Kot\u011B\u0161ovec <jarda.kotesovec@gmail.com>",
+        "Kenric D'Souza <kenric.dsouza@gmail.com>",
+        "Oleh Aleinyk <oleg.aleynik@gmail.com>",
+        "Marcel Bretschneider <marcel.bretschneider@gmail.com>",
+        "Andrea Bianco <andrea.bianco@unibas.ch>",
+        "Rik Heywood <rik@rik.org>",
+        "Thomas Parisot <hi@oncletom.io>",
+        "Nathan Graves <nathanrgraves+github@gmail.com>",
+        "Tom Lokhorst <tom@lokhorst.eu>",
+        "Espen Hovlandsdal <espen@hovlandsdal.com>",
+        "Sylvain Dumont <sylvain.dumont35@gmail.com>",
+        "Alun Davies <alun.owain.davies@googlemail.com>",
+        "Aidan Hoolachan <ajhoolachan21@gmail.com>",
+        "Axel Eirola <axel.eirola@iki.fi>",
+        "Freezy <freezy@xbmc.org>",
+        "Daiz <taneli.vatanen@gmail.com>",
+        "Julian Aubourg <j@ubourg.net>",
+        "Keith Belovay <keith@picthrive.com>",
+        "Michael B. Klein <mbklein@gmail.com>",
+        "Jordan Prudhomme <jordan@raboland.fr>",
+        "Ilya Ovdin <iovdin@gmail.com>",
+        "Andargor <andargor@yahoo.com>",
+        "Paul Neave <paul.neave@gmail.com>",
+        "Brendan Kennedy <brenwken@gmail.com>",
+        "Brychan Bennett-Odlum <git@brychan.io>",
+        "Edward Silverton <e.silverton@gmail.com>",
+        "Roman Malieiev <aromaleev@gmail.com>",
+        "Tomas Szabo <tomas.szabo@deftomat.com>",
+        "Robert O'Rourke <robert@o-rourke.org>",
+        "Guillermo Alfonso Varela Chouci\xF1o <guillevch@gmail.com>",
+        "Christian Flintrup <chr@gigahost.dk>",
+        "Manan Jadhav <manan@motionden.com>",
+        "Leon Radley <leon@radley.se>",
+        "alza54 <alza54@thiocod.in>",
+        "Jacob Smith <jacob@frende.me>",
+        "Michael Nutt <michael@nutt.im>",
+        "Brad Parham <baparham@gmail.com>",
+        "Taneli Vatanen <taneli.vatanen@gmail.com>",
+        "Joris Dugu\xE9 <zaruike10@gmail.com>",
+        "Chris Banks <christopher.bradley.banks@gmail.com>",
+        "Ompal Singh <ompal.hitm09@gmail.com>",
+        "Brodan <christopher.hranj@gmail.com>",
+        "Ankur Parihar <ankur.github@gmail.com>",
+        "Brahim Ait elhaj <brahima@gmail.com>",
+        "Mart Jansink <m.jansink@gmail.com>",
+        "Lachlan Newman <lachnewman007@gmail.com>",
+        "Dennis Beatty <dennis@dcbeatty.com>",
+        "Ingvar Stepanyan <me@rreverser.com>",
+        "Don Denton <don@happycollision.com>"
+      ],
+      scripts: {
+        install: "node install/check",
+        clean: "rm -rf src/build/ .nyc_output/ coverage/ test/fixtures/output.*",
+        test: "npm run test-lint && npm run test-unit && npm run test-licensing && npm run test-types",
+        "test-lint": "semistandard && cpplint",
+        "test-unit": "nyc --reporter=lcov --reporter=text --check-coverage --branches=100 mocha",
+        "test-licensing": 'license-checker --production --summary --onlyAllow="Apache-2.0;BSD;ISC;LGPL-3.0-or-later;MIT"',
+        "test-leak": "./test/leak/leak.sh",
+        "test-types": "tsd",
+        "package-from-local-build": "node npm/from-local-build",
+        "package-from-github-release": "node npm/from-github-release",
+        "docs-build": "node docs/build && node docs/search-index/build",
+        "docs-serve": "cd docs && npx serve",
+        "docs-publish": "cd docs && npx firebase-tools deploy --project pixelplumbing --only hosting:pixelplumbing-sharp"
+      },
+      type: "commonjs",
+      main: "lib/index.js",
+      types: "lib/index.d.ts",
+      files: [
+        "install",
+        "lib",
+        "src/*.{cc,h,gyp}"
+      ],
+      repository: {
+        type: "git",
+        url: "git://github.com/lovell/sharp.git"
+      },
+      keywords: [
+        "jpeg",
+        "png",
+        "webp",
+        "avif",
+        "tiff",
+        "gif",
+        "svg",
+        "jp2",
+        "dzi",
+        "image",
+        "resize",
+        "thumbnail",
+        "crop",
+        "embed",
+        "libvips",
+        "vips"
+      ],
+      dependencies: {
+        color: "^4.2.3",
+        "detect-libc": "^2.0.3",
+        semver: "^7.6.3"
+      },
+      optionalDependencies: {
+        "@img/sharp-darwin-arm64": "0.33.5",
+        "@img/sharp-darwin-x64": "0.33.5",
+        "@img/sharp-libvips-darwin-arm64": "1.0.4",
+        "@img/sharp-libvips-darwin-x64": "1.0.4",
+        "@img/sharp-libvips-linux-arm": "1.0.5",
+        "@img/sharp-libvips-linux-arm64": "1.0.4",
+        "@img/sharp-libvips-linux-s390x": "1.0.4",
+        "@img/sharp-libvips-linux-x64": "1.0.4",
+        "@img/sharp-libvips-linuxmusl-arm64": "1.0.4",
+        "@img/sharp-libvips-linuxmusl-x64": "1.0.4",
+        "@img/sharp-linux-arm": "0.33.5",
+        "@img/sharp-linux-arm64": "0.33.5",
+        "@img/sharp-linux-s390x": "0.33.5",
+        "@img/sharp-linux-x64": "0.33.5",
+        "@img/sharp-linuxmusl-arm64": "0.33.5",
+        "@img/sharp-linuxmusl-x64": "0.33.5",
+        "@img/sharp-wasm32": "0.33.5",
+        "@img/sharp-win32-ia32": "0.33.5",
+        "@img/sharp-win32-x64": "0.33.5"
+      },
+      devDependencies: {
+        "@emnapi/runtime": "^1.2.0",
+        "@img/sharp-libvips-dev": "1.0.4",
+        "@img/sharp-libvips-dev-wasm32": "1.0.5",
+        "@img/sharp-libvips-win32-ia32": "1.0.4",
+        "@img/sharp-libvips-win32-x64": "1.0.4",
+        "@types/node": "*",
+        async: "^3.2.5",
+        cc: "^3.0.1",
+        emnapi: "^1.2.0",
+        "exif-reader": "^2.0.1",
+        "extract-zip": "^2.0.1",
+        icc: "^3.0.0",
+        "jsdoc-to-markdown": "^8.0.3",
+        "license-checker": "^25.0.1",
+        mocha: "^10.7.3",
+        "node-addon-api": "^8.1.0",
+        nyc: "^17.0.0",
+        prebuild: "^13.0.1",
+        semistandard: "^17.0.0",
+        "tar-fs": "^3.0.6",
+        tsd: "^0.31.1"
+      },
+      license: "Apache-2.0",
+      engines: {
+        node: "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      config: {
+        libvips: ">=8.15.3"
+      },
+      funding: {
+        url: "https://opencollective.com/libvips"
+      },
+      binary: {
+        napi_versions: [
+          9
+        ]
+      },
+      semistandard: {
+        env: [
+          "mocha"
+        ]
+      },
+      cc: {
+        linelength: "120",
+        filter: [
+          "build/include"
+        ]
+      },
+      nyc: {
+        include: [
+          "lib"
+        ]
+      },
+      tsd: {
+        directory: "test/types/"
+      }
+    };
+  }
+});
+
+// ../../node_modules/sharp/lib/libvips.js
+var require_libvips = __commonJS({
+  "../../node_modules/sharp/lib/libvips.js"(exports2, module2) {
+    "use strict";
+    var { spawnSync } = require("node:child_process"), { createHash } = require("node:crypto"), semverCoerce = require_coerce(), semverGreaterThanOrEqualTo = require_gte(), semverSatisfies = require_satisfies(), detectLibc = require_detect_libc(), { config, engines: engines2, optionalDependencies } = require_package(), minimumLibvipsVersionLabelled = process.env.npm_package_config_libvips || /* istanbul ignore next */
+    config.libvips, minimumLibvipsVersion = semverCoerce(minimumLibvipsVersionLabelled).version, prebuiltPlatforms = [
+      "darwin-arm64",
+      "darwin-x64",
+      "linux-arm",
+      "linux-arm64",
+      "linux-s390x",
+      "linux-x64",
+      "linuxmusl-arm64",
+      "linuxmusl-x64",
+      "win32-ia32",
+      "win32-x64"
+    ], spawnSyncOptions = {
+      encoding: "utf8",
+      shell: !0
+    }, log = (item) => {
+      item instanceof Error ? console.error(`sharp: Installation error: ${item.message}`) : console.log(`sharp: ${item}`);
+    }, runtimeLibc = () => detectLibc.isNonGlibcLinuxSync() ? detectLibc.familySync() : "", runtimePlatformArch = () => `${process.platform}${runtimeLibc()}-${process.arch}`, buildPlatformArch = () => {
+      if (isEmscripten())
+        return "wasm32";
+      let { npm_config_arch, npm_config_platform, npm_config_libc } = process.env, libc = typeof npm_config_libc == "string" ? npm_config_libc : runtimeLibc();
+      return `${npm_config_platform || process.platform}${libc}-${npm_config_arch || process.arch}`;
+    }, buildSharpLibvipsIncludeDir = () => {
+      try {
+        return require(`@img/sharp-libvips-dev-${buildPlatformArch()}/include`);
+      } catch {
+        try {
+          return require("@img/sharp-libvips-dev/include");
+        } catch {
+        }
+      }
+      return "";
+    }, buildSharpLibvipsCPlusPlusDir = () => {
+      try {
+        return require("@img/sharp-libvips-dev/cplusplus");
+      } catch {
+      }
+      return "";
+    }, buildSharpLibvipsLibDir = () => {
+      try {
+        return require(`@img/sharp-libvips-dev-${buildPlatformArch()}/lib`);
+      } catch {
+        try {
+          return require(`@img/sharp-libvips-${buildPlatformArch()}/lib`);
+        } catch {
+        }
+      }
+      return "";
+    }, isUnsupportedNodeRuntime = () => {
+      if (process.release?.name === "node" && process.versions && !semverSatisfies(process.versions.node, engines2.node))
+        return { found: process.versions.node, expected: engines2.node };
+    }, isEmscripten = () => {
+      let { CC } = process.env;
+      return !!(CC && CC.endsWith("/emcc"));
+    }, isRosetta = () => process.platform === "darwin" && process.arch === "x64" ? (spawnSync("sysctl sysctl.proc_translated", spawnSyncOptions).stdout || "").trim() === "sysctl.proc_translated: 1" : !1, sha512 = (s2) => createHash("sha512").update(s2).digest("hex"), yarnLocator = () => {
+      try {
+        let identHash = sha512(`imgsharp-libvips-${buildPlatformArch()}`), npmVersion = semverCoerce(optionalDependencies[`@img/sharp-libvips-${buildPlatformArch()}`]).version;
+        return sha512(`${identHash}npm:${npmVersion}`).slice(0, 10);
+      } catch {
+      }
+      return "";
+    }, spawnRebuild = () => spawnSync(`node-gyp rebuild --directory=src ${isEmscripten() ? "--nodedir=emscripten" : ""}`, {
+      ...spawnSyncOptions,
+      stdio: "inherit"
+    }).status, globalLibvipsVersion = () => process.platform !== "win32" ? (spawnSync("pkg-config --modversion vips-cpp", {
+      ...spawnSyncOptions,
+      env: {
+        ...process.env,
+        PKG_CONFIG_PATH: pkgConfigPath()
+      }
+    }).stdout || "").trim() : "", pkgConfigPath = () => process.platform !== "win32" ? [
+      (spawnSync(
+        'which brew >/dev/null 2>&1 && brew environment --plain | grep PKG_CONFIG_LIBDIR | cut -d" " -f2',
+        spawnSyncOptions
+      ).stdout || "").trim(),
+      process.env.PKG_CONFIG_PATH,
+      "/usr/local/lib/pkgconfig",
+      "/usr/lib/pkgconfig",
+      "/usr/local/libdata/pkgconfig",
+      "/usr/libdata/pkgconfig"
+    ].filter(Boolean).join(":") : "", skipSearch = (status, reason, logger) => (logger && logger(`Detected ${reason}, skipping search for globally-installed libvips`), status), useGlobalLibvips = (logger) => {
+      if (process.env.SHARP_IGNORE_GLOBAL_LIBVIPS)
+        return skipSearch(!1, "SHARP_IGNORE_GLOBAL_LIBVIPS", logger);
+      if (process.env.SHARP_FORCE_GLOBAL_LIBVIPS)
+        return skipSearch(!0, "SHARP_FORCE_GLOBAL_LIBVIPS", logger);
+      if (isRosetta())
+        return skipSearch(!1, "Rosetta", logger);
+      let globalVipsVersion = globalLibvipsVersion();
+      return !!globalVipsVersion && /* istanbul ignore next */
+      semverGreaterThanOrEqualTo(globalVipsVersion, minimumLibvipsVersion);
+    };
+    module2.exports = {
+      minimumLibvipsVersion,
+      prebuiltPlatforms,
+      buildPlatformArch,
+      buildSharpLibvipsIncludeDir,
+      buildSharpLibvipsCPlusPlusDir,
+      buildSharpLibvipsLibDir,
+      isUnsupportedNodeRuntime,
+      runtimePlatformArch,
+      log,
+      yarnLocator,
+      spawnRebuild,
+      globalLibvipsVersion,
+      pkgConfigPath,
+      useGlobalLibvips
+    };
+  }
+});
+
+// ../../node_modules/sharp/lib/sharp.js
+var require_sharp = __commonJS({
+  "../../node_modules/sharp/lib/sharp.js"(exports2, module2) {
+    "use strict";
+    var { familySync, versionSync } = require_detect_libc(), { runtimePlatformArch, isUnsupportedNodeRuntime, prebuiltPlatforms, minimumLibvipsVersion } = require_libvips(), runtimePlatform = runtimePlatformArch(), paths = [
+      `../src/build/Release/sharp-${runtimePlatform}.node`,
+      "../src/build/Release/sharp-wasm32.node",
+      `@img/sharp-${runtimePlatform}/sharp.node`,
+      "@img/sharp-wasm32/sharp.node"
+    ], sharp, errors2 = [];
+    for (let path5 of paths)
+      try {
+        sharp = require(path5);
+        break;
+      } catch (err) {
+        errors2.push(err);
+      }
+    if (sharp)
+      module2.exports = sharp;
+    else {
+      let [isLinux, isMacOs, isWindows] = ["linux", "darwin", "win32"].map((os) => runtimePlatform.startsWith(os)), help = [`Could not load the "sharp" module using the ${runtimePlatform} runtime`];
+      errors2.forEach((err) => {
+        err.code !== "MODULE_NOT_FOUND" && help.push(`${err.code}: ${err.message}`);
+      });
+      let messages2 = errors2.map((err) => err.message).join(" ");
+      if (help.push("Possible solutions:"), isUnsupportedNodeRuntime()) {
+        let { found, expected } = isUnsupportedNodeRuntime();
+        help.push(
+          "- Please upgrade Node.js:",
+          `    Found ${found}`,
+          `    Requires ${expected}`
+        );
+      } else if (prebuiltPlatforms.includes(runtimePlatform)) {
+        let [os, cpu] = runtimePlatform.split("-"), libc = os.endsWith("musl") ? " --libc=musl" : "";
+        help.push(
+          "- Ensure optional dependencies can be installed:",
+          "    npm install --include=optional sharp",
+          "- Ensure your package manager supports multi-platform installation:",
+          "    See https://sharp.pixelplumbing.com/install#cross-platform",
+          "- Add platform-specific dependencies:",
+          `    npm install --os=${os.replace("musl", "")}${libc} --cpu=${cpu} sharp`
+        );
+      } else
+        help.push(
+          `- Manually install libvips >= ${minimumLibvipsVersion}`,
+          "- Add experimental WebAssembly-based dependencies:",
+          "    npm install --cpu=wasm32 sharp",
+          "    npm install @img/sharp-wasm32"
+        );
+      if (isLinux && /(symbol not found|CXXABI_)/i.test(messages2))
+        try {
+          let { config } = require(`@img/sharp-libvips-${runtimePlatform}/package`), libcFound = `${familySync()} ${versionSync()}`, libcRequires = `${config.musl ? "musl" : "glibc"} ${config.musl || config.glibc}`;
+          help.push(
+            "- Update your OS:",
+            `    Found ${libcFound}`,
+            `    Requires ${libcRequires}`
+          );
+        } catch {
+        }
+      throw isLinux && /\/snap\/core[0-9]{2}/.test(messages2) && help.push(
+        "- Remove the Node.js Snap, which does not support native modules",
+        "    snap remove node"
+      ), isMacOs && /Incompatible library version/.test(messages2) && help.push(
+        "- Update Homebrew:",
+        "    brew update && brew upgrade vips"
+      ), errors2.some((err) => err.code === "ERR_DLOPEN_DISABLED") && help.push("- Run Node.js without using the --no-addons flag"), isWindows && /The specified procedure could not be found/.test(messages2) && help.push(
+        "- Using the canvas package on Windows?",
+        "    See https://sharp.pixelplumbing.com/install#canvas-and-windows",
+        "- Check for outdated versions of sharp in the dependency tree:",
+        "    npm ls sharp"
+      ), help.push(
+        "- Consult the installation documentation:",
+        "    See https://sharp.pixelplumbing.com/install"
+      ), new Error(help.join(`
+`));
+    }
+  }
+});
+
+// ../../node_modules/sharp/lib/constructor.js
+var require_constructor = __commonJS({
+  "../../node_modules/sharp/lib/constructor.js"(exports2, module2) {
+    "use strict";
+    var util = require("node:util"), stream = require("node:stream"), is4 = require_is();
+    require_sharp();
+    var debuglog = util.debuglog("sharp"), Sharp = function(input, options2) {
+      if (arguments.length === 1 && !is4.defined(input))
+        throw new Error("Invalid input");
+      return this instanceof Sharp ? (stream.Duplex.call(this), this.options = {
+        // resize options
+        topOffsetPre: -1,
+        leftOffsetPre: -1,
+        widthPre: -1,
+        heightPre: -1,
+        topOffsetPost: -1,
+        leftOffsetPost: -1,
+        widthPost: -1,
+        heightPost: -1,
+        width: -1,
+        height: -1,
+        canvas: "crop",
+        position: 0,
+        resizeBackground: [0, 0, 0, 255],
+        useExifOrientation: !1,
+        angle: 0,
+        rotationAngle: 0,
+        rotationBackground: [0, 0, 0, 255],
+        rotateBeforePreExtract: !1,
+        flip: !1,
+        flop: !1,
+        extendTop: 0,
+        extendBottom: 0,
+        extendLeft: 0,
+        extendRight: 0,
+        extendBackground: [0, 0, 0, 255],
+        extendWith: "background",
+        withoutEnlargement: !1,
+        withoutReduction: !1,
+        affineMatrix: [],
+        affineBackground: [0, 0, 0, 255],
+        affineIdx: 0,
+        affineIdy: 0,
+        affineOdx: 0,
+        affineOdy: 0,
+        affineInterpolator: this.constructor.interpolators.bilinear,
+        kernel: "lanczos3",
+        fastShrinkOnLoad: !0,
+        // operations
+        tint: [-1, 0, 0, 0],
+        flatten: !1,
+        flattenBackground: [0, 0, 0],
+        unflatten: !1,
+        negate: !1,
+        negateAlpha: !0,
+        medianSize: 0,
+        blurSigma: 0,
+        precision: "integer",
+        minAmpl: 0.2,
+        sharpenSigma: 0,
+        sharpenM1: 1,
+        sharpenM2: 2,
+        sharpenX1: 2,
+        sharpenY2: 10,
+        sharpenY3: 20,
+        threshold: 0,
+        thresholdGrayscale: !0,
+        trimBackground: [],
+        trimThreshold: -1,
+        trimLineArt: !1,
+        gamma: 0,
+        gammaOut: 0,
+        greyscale: !1,
+        normalise: !1,
+        normaliseLower: 1,
+        normaliseUpper: 99,
+        claheWidth: 0,
+        claheHeight: 0,
+        claheMaxSlope: 3,
+        brightness: 1,
+        saturation: 1,
+        hue: 0,
+        lightness: 0,
+        booleanBufferIn: null,
+        booleanFileIn: "",
+        joinChannelIn: [],
+        extractChannel: -1,
+        removeAlpha: !1,
+        ensureAlpha: -1,
+        colourspace: "srgb",
+        colourspacePipeline: "last",
+        composite: [],
+        // output
+        fileOut: "",
+        formatOut: "input",
+        streamOut: !1,
+        keepMetadata: 0,
+        withMetadataOrientation: -1,
+        withMetadataDensity: 0,
+        withIccProfile: "",
+        withExif: {},
+        withExifMerge: !0,
+        resolveWithObject: !1,
+        // output format
+        jpegQuality: 80,
+        jpegProgressive: !1,
+        jpegChromaSubsampling: "4:2:0",
+        jpegTrellisQuantisation: !1,
+        jpegOvershootDeringing: !1,
+        jpegOptimiseScans: !1,
+        jpegOptimiseCoding: !0,
+        jpegQuantisationTable: 0,
+        pngProgressive: !1,
+        pngCompressionLevel: 6,
+        pngAdaptiveFiltering: !1,
+        pngPalette: !1,
+        pngQuality: 100,
+        pngEffort: 7,
+        pngBitdepth: 8,
+        pngDither: 1,
+        jp2Quality: 80,
+        jp2TileHeight: 512,
+        jp2TileWidth: 512,
+        jp2Lossless: !1,
+        jp2ChromaSubsampling: "4:4:4",
+        webpQuality: 80,
+        webpAlphaQuality: 100,
+        webpLossless: !1,
+        webpNearLossless: !1,
+        webpSmartSubsample: !1,
+        webpPreset: "default",
+        webpEffort: 4,
+        webpMinSize: !1,
+        webpMixed: !1,
+        gifBitdepth: 8,
+        gifEffort: 7,
+        gifDither: 1,
+        gifInterFrameMaxError: 0,
+        gifInterPaletteMaxError: 3,
+        gifReuse: !0,
+        gifProgressive: !1,
+        tiffQuality: 80,
+        tiffCompression: "jpeg",
+        tiffPredictor: "horizontal",
+        tiffPyramid: !1,
+        tiffMiniswhite: !1,
+        tiffBitdepth: 8,
+        tiffTile: !1,
+        tiffTileHeight: 256,
+        tiffTileWidth: 256,
+        tiffXres: 1,
+        tiffYres: 1,
+        tiffResolutionUnit: "inch",
+        heifQuality: 50,
+        heifLossless: !1,
+        heifCompression: "av1",
+        heifEffort: 4,
+        heifChromaSubsampling: "4:4:4",
+        heifBitdepth: 8,
+        jxlDistance: 1,
+        jxlDecodingTier: 0,
+        jxlEffort: 7,
+        jxlLossless: !1,
+        rawDepth: "uchar",
+        tileSize: 256,
+        tileOverlap: 0,
+        tileContainer: "fs",
+        tileLayout: "dz",
+        tileFormat: "last",
+        tileDepth: "last",
+        tileAngle: 0,
+        tileSkipBlanks: -1,
+        tileBackground: [255, 255, 255, 255],
+        tileCentre: !1,
+        tileId: "https://example.com/iiif",
+        tileBasename: "",
+        timeoutSeconds: 0,
+        linearA: [],
+        linearB: [],
+        // Function to notify of libvips warnings
+        debuglog: (warning) => {
+          this.emit("warning", warning), debuglog(warning);
+        },
+        // Function to notify of queue length changes
+        queueListener: function(queueLength) {
+          Sharp.queue.emit("change", queueLength);
+        }
+      }, this.options.input = this._createInputDescriptor(input, options2, { allowStream: !0 }), this) : new Sharp(input, options2);
+    };
+    Object.setPrototypeOf(Sharp.prototype, stream.Duplex.prototype);
+    Object.setPrototypeOf(Sharp, stream.Duplex);
+    function clone() {
+      let clone2 = this.constructor.call(), { debuglog: debuglog2, queueListener, ...options2 } = this.options;
+      return clone2.options = structuredClone(options2), clone2.options.debuglog = debuglog2, clone2.options.queueListener = queueListener, this._isStreamInput() && this.on("finish", () => {
+        this._flattenBufferIn(), clone2.options.input.buffer = this.options.input.buffer, clone2.emit("finish");
+      }), clone2;
+    }
+    Object.assign(Sharp.prototype, { clone });
+    module2.exports = Sharp;
+  }
+});
+
+// ../../node_modules/color-name/index.js
+var require_color_name = __commonJS({
+  "../../node_modules/color-name/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = {
+      aliceblue: [240, 248, 255],
+      antiquewhite: [250, 235, 215],
+      aqua: [0, 255, 255],
+      aquamarine: [127, 255, 212],
+      azure: [240, 255, 255],
+      beige: [245, 245, 220],
+      bisque: [255, 228, 196],
+      black: [0, 0, 0],
+      blanchedalmond: [255, 235, 205],
+      blue: [0, 0, 255],
+      blueviolet: [138, 43, 226],
+      brown: [165, 42, 42],
+      burlywood: [222, 184, 135],
+      cadetblue: [95, 158, 160],
+      chartreuse: [127, 255, 0],
+      chocolate: [210, 105, 30],
+      coral: [255, 127, 80],
+      cornflowerblue: [100, 149, 237],
+      cornsilk: [255, 248, 220],
+      crimson: [220, 20, 60],
+      cyan: [0, 255, 255],
+      darkblue: [0, 0, 139],
+      darkcyan: [0, 139, 139],
+      darkgoldenrod: [184, 134, 11],
+      darkgray: [169, 169, 169],
+      darkgreen: [0, 100, 0],
+      darkgrey: [169, 169, 169],
+      darkkhaki: [189, 183, 107],
+      darkmagenta: [139, 0, 139],
+      darkolivegreen: [85, 107, 47],
+      darkorange: [255, 140, 0],
+      darkorchid: [153, 50, 204],
+      darkred: [139, 0, 0],
+      darksalmon: [233, 150, 122],
+      darkseagreen: [143, 188, 143],
+      darkslateblue: [72, 61, 139],
+      darkslategray: [47, 79, 79],
+      darkslategrey: [47, 79, 79],
+      darkturquoise: [0, 206, 209],
+      darkviolet: [148, 0, 211],
+      deeppink: [255, 20, 147],
+      deepskyblue: [0, 191, 255],
+      dimgray: [105, 105, 105],
+      dimgrey: [105, 105, 105],
+      dodgerblue: [30, 144, 255],
+      firebrick: [178, 34, 34],
+      floralwhite: [255, 250, 240],
+      forestgreen: [34, 139, 34],
+      fuchsia: [255, 0, 255],
+      gainsboro: [220, 220, 220],
+      ghostwhite: [248, 248, 255],
+      gold: [255, 215, 0],
+      goldenrod: [218, 165, 32],
+      gray: [128, 128, 128],
+      green: [0, 128, 0],
+      greenyellow: [173, 255, 47],
+      grey: [128, 128, 128],
+      honeydew: [240, 255, 240],
+      hotpink: [255, 105, 180],
+      indianred: [205, 92, 92],
+      indigo: [75, 0, 130],
+      ivory: [255, 255, 240],
+      khaki: [240, 230, 140],
+      lavender: [230, 230, 250],
+      lavenderblush: [255, 240, 245],
+      lawngreen: [124, 252, 0],
+      lemonchiffon: [255, 250, 205],
+      lightblue: [173, 216, 230],
+      lightcoral: [240, 128, 128],
+      lightcyan: [224, 255, 255],
+      lightgoldenrodyellow: [250, 250, 210],
+      lightgray: [211, 211, 211],
+      lightgreen: [144, 238, 144],
+      lightgrey: [211, 211, 211],
+      lightpink: [255, 182, 193],
+      lightsalmon: [255, 160, 122],
+      lightseagreen: [32, 178, 170],
+      lightskyblue: [135, 206, 250],
+      lightslategray: [119, 136, 153],
+      lightslategrey: [119, 136, 153],
+      lightsteelblue: [176, 196, 222],
+      lightyellow: [255, 255, 224],
+      lime: [0, 255, 0],
+      limegreen: [50, 205, 50],
+      linen: [250, 240, 230],
+      magenta: [255, 0, 255],
+      maroon: [128, 0, 0],
+      mediumaquamarine: [102, 205, 170],
+      mediumblue: [0, 0, 205],
+      mediumorchid: [186, 85, 211],
+      mediumpurple: [147, 112, 219],
+      mediumseagreen: [60, 179, 113],
+      mediumslateblue: [123, 104, 238],
+      mediumspringgreen: [0, 250, 154],
+      mediumturquoise: [72, 209, 204],
+      mediumvioletred: [199, 21, 133],
+      midnightblue: [25, 25, 112],
+      mintcream: [245, 255, 250],
+      mistyrose: [255, 228, 225],
+      moccasin: [255, 228, 181],
+      navajowhite: [255, 222, 173],
+      navy: [0, 0, 128],
+      oldlace: [253, 245, 230],
+      olive: [128, 128, 0],
+      olivedrab: [107, 142, 35],
+      orange: [255, 165, 0],
+      orangered: [255, 69, 0],
+      orchid: [218, 112, 214],
+      palegoldenrod: [238, 232, 170],
+      palegreen: [152, 251, 152],
+      paleturquoise: [175, 238, 238],
+      palevioletred: [219, 112, 147],
+      papayawhip: [255, 239, 213],
+      peachpuff: [255, 218, 185],
+      peru: [205, 133, 63],
+      pink: [255, 192, 203],
+      plum: [221, 160, 221],
+      powderblue: [176, 224, 230],
+      purple: [128, 0, 128],
+      rebeccapurple: [102, 51, 153],
+      red: [255, 0, 0],
+      rosybrown: [188, 143, 143],
+      royalblue: [65, 105, 225],
+      saddlebrown: [139, 69, 19],
+      salmon: [250, 128, 114],
+      sandybrown: [244, 164, 96],
+      seagreen: [46, 139, 87],
+      seashell: [255, 245, 238],
+      sienna: [160, 82, 45],
+      silver: [192, 192, 192],
+      skyblue: [135, 206, 235],
+      slateblue: [106, 90, 205],
+      slategray: [112, 128, 144],
+      slategrey: [112, 128, 144],
+      snow: [255, 250, 250],
+      springgreen: [0, 255, 127],
+      steelblue: [70, 130, 180],
+      tan: [210, 180, 140],
+      teal: [0, 128, 128],
+      thistle: [216, 191, 216],
+      tomato: [255, 99, 71],
+      turquoise: [64, 224, 208],
+      violet: [238, 130, 238],
+      wheat: [245, 222, 179],
+      white: [255, 255, 255],
+      whitesmoke: [245, 245, 245],
+      yellow: [255, 255, 0],
+      yellowgreen: [154, 205, 50]
+    };
+  }
+});
+
+// ../../node_modules/simple-swizzle/node_modules/is-arrayish/index.js
+var require_is_arrayish = __commonJS({
+  "../../node_modules/simple-swizzle/node_modules/is-arrayish/index.js"(exports2, module2) {
+    module2.exports = function(obj) {
+      return !obj || typeof obj == "string" ? !1 : obj instanceof Array || Array.isArray(obj) || obj.length >= 0 && (obj.splice instanceof Function || Object.getOwnPropertyDescriptor(obj, obj.length - 1) && obj.constructor.name !== "String");
+    };
+  }
+});
+
+// ../../node_modules/simple-swizzle/index.js
+var require_simple_swizzle = __commonJS({
+  "../../node_modules/simple-swizzle/index.js"(exports2, module2) {
+    "use strict";
+    var isArrayish = require_is_arrayish(), concat = Array.prototype.concat, slice = Array.prototype.slice, swizzle = module2.exports = function(args) {
+      for (var results = [], i = 0, len = args.length; i < len; i++) {
+        var arg = args[i];
+        isArrayish(arg) ? results = concat.call(results, slice.call(arg)) : results.push(arg);
+      }
+      return results;
+    };
+    swizzle.wrap = function(fn) {
+      return function() {
+        return fn(swizzle(arguments));
+      };
+    };
+  }
+});
+
+// ../../node_modules/color-string/index.js
+var require_color_string = __commonJS({
+  "../../node_modules/color-string/index.js"(exports2, module2) {
+    var colorNames = require_color_name(), swizzle = require_simple_swizzle(), hasOwnProperty2 = Object.hasOwnProperty, reverseNames = /* @__PURE__ */ Object.create(null);
+    for (name in colorNames)
+      hasOwnProperty2.call(colorNames, name) && (reverseNames[colorNames[name]] = name);
+    var name, cs = module2.exports = {
+      to: {},
+      get: {}
+    };
+    cs.get = function(string) {
+      var prefix = string.substring(0, 3).toLowerCase(), val, model;
+      switch (prefix) {
+        case "hsl":
+          val = cs.get.hsl(string), model = "hsl";
+          break;
+        case "hwb":
+          val = cs.get.hwb(string), model = "hwb";
+          break;
+        default:
+          val = cs.get.rgb(string), model = "rgb";
+          break;
+      }
+      return val ? { model, value: val } : null;
+    };
+    cs.get.rgb = function(string) {
+      if (!string)
+        return null;
+      var abbr = /^#([a-f0-9]{3,4})$/i, hex = /^#([a-f0-9]{6})([a-f0-9]{2})?$/i, rgba = /^rgba?\(\s*([+-]?\d+)(?=[\s,])\s*(?:,\s*)?([+-]?\d+)(?=[\s,])\s*(?:,\s*)?([+-]?\d+)\s*(?:[,|\/]\s*([+-]?[\d\.]+)(%?)\s*)?\)$/, per = /^rgba?\(\s*([+-]?[\d\.]+)\%\s*,?\s*([+-]?[\d\.]+)\%\s*,?\s*([+-]?[\d\.]+)\%\s*(?:[,|\/]\s*([+-]?[\d\.]+)(%?)\s*)?\)$/, keyword = /^(\w+)$/, rgb = [0, 0, 0, 1], match, i, hexAlpha;
+      if (match = string.match(hex)) {
+        for (hexAlpha = match[2], match = match[1], i = 0; i < 3; i++) {
+          var i2 = i * 2;
+          rgb[i] = parseInt(match.slice(i2, i2 + 2), 16);
+        }
+        hexAlpha && (rgb[3] = parseInt(hexAlpha, 16) / 255);
+      } else if (match = string.match(abbr)) {
+        for (match = match[1], hexAlpha = match[3], i = 0; i < 3; i++)
+          rgb[i] = parseInt(match[i] + match[i], 16);
+        hexAlpha && (rgb[3] = parseInt(hexAlpha + hexAlpha, 16) / 255);
+      } else if (match = string.match(rgba)) {
+        for (i = 0; i < 3; i++)
+          rgb[i] = parseInt(match[i + 1], 0);
+        match[4] && (match[5] ? rgb[3] = parseFloat(match[4]) * 0.01 : rgb[3] = parseFloat(match[4]));
+      } else if (match = string.match(per)) {
+        for (i = 0; i < 3; i++)
+          rgb[i] = Math.round(parseFloat(match[i + 1]) * 2.55);
+        match[4] && (match[5] ? rgb[3] = parseFloat(match[4]) * 0.01 : rgb[3] = parseFloat(match[4]));
+      } else return (match = string.match(keyword)) ? match[1] === "transparent" ? [0, 0, 0, 0] : hasOwnProperty2.call(colorNames, match[1]) ? (rgb = colorNames[match[1]], rgb[3] = 1, rgb) : null : null;
+      for (i = 0; i < 3; i++)
+        rgb[i] = clamp(rgb[i], 0, 255);
+      return rgb[3] = clamp(rgb[3], 0, 1), rgb;
+    };
+    cs.get.hsl = function(string) {
+      if (!string)
+        return null;
+      var hsl = /^hsla?\(\s*([+-]?(?:\d{0,3}\.)?\d+)(?:deg)?\s*,?\s*([+-]?[\d\.]+)%\s*,?\s*([+-]?[\d\.]+)%\s*(?:[,|\/]\s*([+-]?(?=\.\d|\d)(?:0|[1-9]\d*)?(?:\.\d*)?(?:[eE][+-]?\d+)?)\s*)?\)$/, match = string.match(hsl);
+      if (match) {
+        var alpha = parseFloat(match[4]), h2 = (parseFloat(match[1]) % 360 + 360) % 360, s2 = clamp(parseFloat(match[2]), 0, 100), l = clamp(parseFloat(match[3]), 0, 100), a = clamp(isNaN(alpha) ? 1 : alpha, 0, 1);
+        return [h2, s2, l, a];
+      }
+      return null;
+    };
+    cs.get.hwb = function(string) {
+      if (!string)
+        return null;
+      var hwb = /^hwb\(\s*([+-]?\d{0,3}(?:\.\d+)?)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?(?=\.\d|\d)(?:0|[1-9]\d*)?(?:\.\d*)?(?:[eE][+-]?\d+)?)\s*)?\)$/, match = string.match(hwb);
+      if (match) {
+        var alpha = parseFloat(match[4]), h2 = (parseFloat(match[1]) % 360 + 360) % 360, w = clamp(parseFloat(match[2]), 0, 100), b = clamp(parseFloat(match[3]), 0, 100), a = clamp(isNaN(alpha) ? 1 : alpha, 0, 1);
+        return [h2, w, b, a];
+      }
+      return null;
+    };
+    cs.to.hex = function() {
+      var rgba = swizzle(arguments);
+      return "#" + hexDouble(rgba[0]) + hexDouble(rgba[1]) + hexDouble(rgba[2]) + (rgba[3] < 1 ? hexDouble(Math.round(rgba[3] * 255)) : "");
+    };
+    cs.to.rgb = function() {
+      var rgba = swizzle(arguments);
+      return rgba.length < 4 || rgba[3] === 1 ? "rgb(" + Math.round(rgba[0]) + ", " + Math.round(rgba[1]) + ", " + Math.round(rgba[2]) + ")" : "rgba(" + Math.round(rgba[0]) + ", " + Math.round(rgba[1]) + ", " + Math.round(rgba[2]) + ", " + rgba[3] + ")";
+    };
+    cs.to.rgb.percent = function() {
+      var rgba = swizzle(arguments), r2 = Math.round(rgba[0] / 255 * 100), g = Math.round(rgba[1] / 255 * 100), b = Math.round(rgba[2] / 255 * 100);
+      return rgba.length < 4 || rgba[3] === 1 ? "rgb(" + r2 + "%, " + g + "%, " + b + "%)" : "rgba(" + r2 + "%, " + g + "%, " + b + "%, " + rgba[3] + ")";
+    };
+    cs.to.hsl = function() {
+      var hsla = swizzle(arguments);
+      return hsla.length < 4 || hsla[3] === 1 ? "hsl(" + hsla[0] + ", " + hsla[1] + "%, " + hsla[2] + "%)" : "hsla(" + hsla[0] + ", " + hsla[1] + "%, " + hsla[2] + "%, " + hsla[3] + ")";
+    };
+    cs.to.hwb = function() {
+      var hwba = swizzle(arguments), a = "";
+      return hwba.length >= 4 && hwba[3] !== 1 && (a = ", " + hwba[3]), "hwb(" + hwba[0] + ", " + hwba[1] + "%, " + hwba[2] + "%" + a + ")";
+    };
+    cs.to.keyword = function(rgb) {
+      return reverseNames[rgb.slice(0, 3)];
+    };
+    function clamp(num, min, max) {
+      return Math.min(Math.max(min, num), max);
+    }
+    function hexDouble(num) {
+      var str2 = Math.round(num).toString(16).toUpperCase();
+      return str2.length < 2 ? "0" + str2 : str2;
+    }
+  }
+});
+
+// ../../node_modules/color-convert/conversions.js
+var require_conversions = __commonJS({
+  "../../node_modules/color-convert/conversions.js"(exports2, module2) {
+    var cssKeywords = require_color_name(), reverseKeywords = {};
+    for (let key2 of Object.keys(cssKeywords))
+      reverseKeywords[cssKeywords[key2]] = key2;
+    var convert4 = {
+      rgb: { channels: 3, labels: "rgb" },
+      hsl: { channels: 3, labels: "hsl" },
+      hsv: { channels: 3, labels: "hsv" },
+      hwb: { channels: 3, labels: "hwb" },
+      cmyk: { channels: 4, labels: "cmyk" },
+      xyz: { channels: 3, labels: "xyz" },
+      lab: { channels: 3, labels: "lab" },
+      lch: { channels: 3, labels: "lch" },
+      hex: { channels: 1, labels: ["hex"] },
+      keyword: { channels: 1, labels: ["keyword"] },
+      ansi16: { channels: 1, labels: ["ansi16"] },
+      ansi256: { channels: 1, labels: ["ansi256"] },
+      hcg: { channels: 3, labels: ["h", "c", "g"] },
+      apple: { channels: 3, labels: ["r16", "g16", "b16"] },
+      gray: { channels: 1, labels: ["gray"] }
+    };
+    module2.exports = convert4;
+    for (let model of Object.keys(convert4)) {
+      if (!("channels" in convert4[model]))
+        throw new Error("missing channels property: " + model);
+      if (!("labels" in convert4[model]))
+        throw new Error("missing channel labels property: " + model);
+      if (convert4[model].labels.length !== convert4[model].channels)
+        throw new Error("channel and label counts mismatch: " + model);
+      let { channels, labels } = convert4[model];
+      delete convert4[model].channels, delete convert4[model].labels, Object.defineProperty(convert4[model], "channels", { value: channels }), Object.defineProperty(convert4[model], "labels", { value: labels });
+    }
+    convert4.rgb.hsl = function(rgb) {
+      let r2 = rgb[0] / 255, g = rgb[1] / 255, b = rgb[2] / 255, min = Math.min(r2, g, b), max = Math.max(r2, g, b), delta = max - min, h2, s2;
+      max === min ? h2 = 0 : r2 === max ? h2 = (g - b) / delta : g === max ? h2 = 2 + (b - r2) / delta : b === max && (h2 = 4 + (r2 - g) / delta), h2 = Math.min(h2 * 60, 360), h2 < 0 && (h2 += 360);
+      let l = (min + max) / 2;
+      return max === min ? s2 = 0 : l <= 0.5 ? s2 = delta / (max + min) : s2 = delta / (2 - max - min), [h2, s2 * 100, l * 100];
+    };
+    convert4.rgb.hsv = function(rgb) {
+      let rdif, gdif, bdif, h2, s2, r2 = rgb[0] / 255, g = rgb[1] / 255, b = rgb[2] / 255, v = Math.max(r2, g, b), diff2 = v - Math.min(r2, g, b), diffc = function(c2) {
+        return (v - c2) / 6 / diff2 + 1 / 2;
+      };
+      return diff2 === 0 ? (h2 = 0, s2 = 0) : (s2 = diff2 / v, rdif = diffc(r2), gdif = diffc(g), bdif = diffc(b), r2 === v ? h2 = bdif - gdif : g === v ? h2 = 1 / 3 + rdif - bdif : b === v && (h2 = 2 / 3 + gdif - rdif), h2 < 0 ? h2 += 1 : h2 > 1 && (h2 -= 1)), [
+        h2 * 360,
+        s2 * 100,
+        v * 100
+      ];
+    };
+    convert4.rgb.hwb = function(rgb) {
+      let r2 = rgb[0], g = rgb[1], b = rgb[2], h2 = convert4.rgb.hsl(rgb)[0], w = 1 / 255 * Math.min(r2, Math.min(g, b));
+      return b = 1 - 1 / 255 * Math.max(r2, Math.max(g, b)), [h2, w * 100, b * 100];
+    };
+    convert4.rgb.cmyk = function(rgb) {
+      let r2 = rgb[0] / 255, g = rgb[1] / 255, b = rgb[2] / 255, k = Math.min(1 - r2, 1 - g, 1 - b), c2 = (1 - r2 - k) / (1 - k) || 0, m = (1 - g - k) / (1 - k) || 0, y = (1 - b - k) / (1 - k) || 0;
+      return [c2 * 100, m * 100, y * 100, k * 100];
+    };
+    function comparativeDistance(x, y) {
+      return (x[0] - y[0]) ** 2 + (x[1] - y[1]) ** 2 + (x[2] - y[2]) ** 2;
+    }
+    convert4.rgb.keyword = function(rgb) {
+      let reversed = reverseKeywords[rgb];
+      if (reversed)
+        return reversed;
+      let currentClosestDistance = 1 / 0, currentClosestKeyword;
+      for (let keyword of Object.keys(cssKeywords)) {
+        let value = cssKeywords[keyword], distance = comparativeDistance(rgb, value);
+        distance < currentClosestDistance && (currentClosestDistance = distance, currentClosestKeyword = keyword);
+      }
+      return currentClosestKeyword;
+    };
+    convert4.keyword.rgb = function(keyword) {
+      return cssKeywords[keyword];
+    };
+    convert4.rgb.xyz = function(rgb) {
+      let r2 = rgb[0] / 255, g = rgb[1] / 255, b = rgb[2] / 255;
+      r2 = r2 > 0.04045 ? ((r2 + 0.055) / 1.055) ** 2.4 : r2 / 12.92, g = g > 0.04045 ? ((g + 0.055) / 1.055) ** 2.4 : g / 12.92, b = b > 0.04045 ? ((b + 0.055) / 1.055) ** 2.4 : b / 12.92;
+      let x = r2 * 0.4124 + g * 0.3576 + b * 0.1805, y = r2 * 0.2126 + g * 0.7152 + b * 0.0722, z = r2 * 0.0193 + g * 0.1192 + b * 0.9505;
+      return [x * 100, y * 100, z * 100];
+    };
+    convert4.rgb.lab = function(rgb) {
+      let xyz = convert4.rgb.xyz(rgb), x = xyz[0], y = xyz[1], z = xyz[2];
+      x /= 95.047, y /= 100, z /= 108.883, x = x > 8856e-6 ? x ** (1 / 3) : 7.787 * x + 16 / 116, y = y > 8856e-6 ? y ** (1 / 3) : 7.787 * y + 16 / 116, z = z > 8856e-6 ? z ** (1 / 3) : 7.787 * z + 16 / 116;
+      let l = 116 * y - 16, a = 500 * (x - y), b = 200 * (y - z);
+      return [l, a, b];
+    };
+    convert4.hsl.rgb = function(hsl) {
+      let h2 = hsl[0] / 360, s2 = hsl[1] / 100, l = hsl[2] / 100, t2, t3, val;
+      if (s2 === 0)
+        return val = l * 255, [val, val, val];
+      l < 0.5 ? t2 = l * (1 + s2) : t2 = l + s2 - l * s2;
+      let t1 = 2 * l - t2, rgb = [0, 0, 0];
+      for (let i = 0; i < 3; i++)
+        t3 = h2 + 1 / 3 * -(i - 1), t3 < 0 && t3++, t3 > 1 && t3--, 6 * t3 < 1 ? val = t1 + (t2 - t1) * 6 * t3 : 2 * t3 < 1 ? val = t2 : 3 * t3 < 2 ? val = t1 + (t2 - t1) * (2 / 3 - t3) * 6 : val = t1, rgb[i] = val * 255;
+      return rgb;
+    };
+    convert4.hsl.hsv = function(hsl) {
+      let h2 = hsl[0], s2 = hsl[1] / 100, l = hsl[2] / 100, smin = s2, lmin = Math.max(l, 0.01);
+      l *= 2, s2 *= l <= 1 ? l : 2 - l, smin *= lmin <= 1 ? lmin : 2 - lmin;
+      let v = (l + s2) / 2, sv = l === 0 ? 2 * smin / (lmin + smin) : 2 * s2 / (l + s2);
+      return [h2, sv * 100, v * 100];
+    };
+    convert4.hsv.rgb = function(hsv) {
+      let h2 = hsv[0] / 60, s2 = hsv[1] / 100, v = hsv[2] / 100, hi = Math.floor(h2) % 6, f = h2 - Math.floor(h2), p2 = 255 * v * (1 - s2), q = 255 * v * (1 - s2 * f), t = 255 * v * (1 - s2 * (1 - f));
+      switch (v *= 255, hi) {
+        case 0:
+          return [v, t, p2];
+        case 1:
+          return [q, v, p2];
+        case 2:
+          return [p2, v, t];
+        case 3:
+          return [p2, q, v];
+        case 4:
+          return [t, p2, v];
+        case 5:
+          return [v, p2, q];
+      }
+    };
+    convert4.hsv.hsl = function(hsv) {
+      let h2 = hsv[0], s2 = hsv[1] / 100, v = hsv[2] / 100, vmin = Math.max(v, 0.01), sl, l;
+      l = (2 - s2) * v;
+      let lmin = (2 - s2) * vmin;
+      return sl = s2 * vmin, sl /= lmin <= 1 ? lmin : 2 - lmin, sl = sl || 0, l /= 2, [h2, sl * 100, l * 100];
+    };
+    convert4.hwb.rgb = function(hwb) {
+      let h2 = hwb[0] / 360, wh = hwb[1] / 100, bl = hwb[2] / 100, ratio = wh + bl, f;
+      ratio > 1 && (wh /= ratio, bl /= ratio);
+      let i = Math.floor(6 * h2), v = 1 - bl;
+      f = 6 * h2 - i, (i & 1) !== 0 && (f = 1 - f);
+      let n = wh + f * (v - wh), r2, g, b;
+      switch (i) {
+        default:
+        case 6:
+        case 0:
+          r2 = v, g = n, b = wh;
+          break;
+        case 1:
+          r2 = n, g = v, b = wh;
+          break;
+        case 2:
+          r2 = wh, g = v, b = n;
+          break;
+        case 3:
+          r2 = wh, g = n, b = v;
+          break;
+        case 4:
+          r2 = n, g = wh, b = v;
+          break;
+        case 5:
+          r2 = v, g = wh, b = n;
+          break;
+      }
+      return [r2 * 255, g * 255, b * 255];
+    };
+    convert4.cmyk.rgb = function(cmyk) {
+      let c2 = cmyk[0] / 100, m = cmyk[1] / 100, y = cmyk[2] / 100, k = cmyk[3] / 100, r2 = 1 - Math.min(1, c2 * (1 - k) + k), g = 1 - Math.min(1, m * (1 - k) + k), b = 1 - Math.min(1, y * (1 - k) + k);
+      return [r2 * 255, g * 255, b * 255];
+    };
+    convert4.xyz.rgb = function(xyz) {
+      let x = xyz[0] / 100, y = xyz[1] / 100, z = xyz[2] / 100, r2, g, b;
+      return r2 = x * 3.2406 + y * -1.5372 + z * -0.4986, g = x * -0.9689 + y * 1.8758 + z * 0.0415, b = x * 0.0557 + y * -0.204 + z * 1.057, r2 = r2 > 31308e-7 ? 1.055 * r2 ** (1 / 2.4) - 0.055 : r2 * 12.92, g = g > 31308e-7 ? 1.055 * g ** (1 / 2.4) - 0.055 : g * 12.92, b = b > 31308e-7 ? 1.055 * b ** (1 / 2.4) - 0.055 : b * 12.92, r2 = Math.min(Math.max(0, r2), 1), g = Math.min(Math.max(0, g), 1), b = Math.min(Math.max(0, b), 1), [r2 * 255, g * 255, b * 255];
+    };
+    convert4.xyz.lab = function(xyz) {
+      let x = xyz[0], y = xyz[1], z = xyz[2];
+      x /= 95.047, y /= 100, z /= 108.883, x = x > 8856e-6 ? x ** (1 / 3) : 7.787 * x + 16 / 116, y = y > 8856e-6 ? y ** (1 / 3) : 7.787 * y + 16 / 116, z = z > 8856e-6 ? z ** (1 / 3) : 7.787 * z + 16 / 116;
+      let l = 116 * y - 16, a = 500 * (x - y), b = 200 * (y - z);
+      return [l, a, b];
+    };
+    convert4.lab.xyz = function(lab) {
+      let l = lab[0], a = lab[1], b = lab[2], x, y, z;
+      y = (l + 16) / 116, x = a / 500 + y, z = y - b / 200;
+      let y2 = y ** 3, x2 = x ** 3, z2 = z ** 3;
+      return y = y2 > 8856e-6 ? y2 : (y - 16 / 116) / 7.787, x = x2 > 8856e-6 ? x2 : (x - 16 / 116) / 7.787, z = z2 > 8856e-6 ? z2 : (z - 16 / 116) / 7.787, x *= 95.047, y *= 100, z *= 108.883, [x, y, z];
+    };
+    convert4.lab.lch = function(lab) {
+      let l = lab[0], a = lab[1], b = lab[2], h2;
+      h2 = Math.atan2(b, a) * 360 / 2 / Math.PI, h2 < 0 && (h2 += 360);
+      let c2 = Math.sqrt(a * a + b * b);
+      return [l, c2, h2];
+    };
+    convert4.lch.lab = function(lch) {
+      let l = lch[0], c2 = lch[1], hr = lch[2] / 360 * 2 * Math.PI, a = c2 * Math.cos(hr), b = c2 * Math.sin(hr);
+      return [l, a, b];
+    };
+    convert4.rgb.ansi16 = function(args, saturation = null) {
+      let [r2, g, b] = args, value = saturation === null ? convert4.rgb.hsv(args)[2] : saturation;
+      if (value = Math.round(value / 50), value === 0)
+        return 30;
+      let ansi = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r2 / 255));
+      return value === 2 && (ansi += 60), ansi;
+    };
+    convert4.hsv.ansi16 = function(args) {
+      return convert4.rgb.ansi16(convert4.hsv.rgb(args), args[2]);
+    };
+    convert4.rgb.ansi256 = function(args) {
+      let r2 = args[0], g = args[1], b = args[2];
+      return r2 === g && g === b ? r2 < 8 ? 16 : r2 > 248 ? 231 : Math.round((r2 - 8) / 247 * 24) + 232 : 16 + 36 * Math.round(r2 / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5);
+    };
+    convert4.ansi16.rgb = function(args) {
+      let color4 = args % 10;
+      if (color4 === 0 || color4 === 7)
+        return args > 50 && (color4 += 3.5), color4 = color4 / 10.5 * 255, [color4, color4, color4];
+      let mult = (~~(args > 50) + 1) * 0.5, r2 = (color4 & 1) * mult * 255, g = (color4 >> 1 & 1) * mult * 255, b = (color4 >> 2 & 1) * mult * 255;
+      return [r2, g, b];
+    };
+    convert4.ansi256.rgb = function(args) {
+      if (args >= 232) {
+        let c2 = (args - 232) * 10 + 8;
+        return [c2, c2, c2];
+      }
+      args -= 16;
+      let rem, r2 = Math.floor(args / 36) / 5 * 255, g = Math.floor((rem = args % 36) / 6) / 5 * 255, b = rem % 6 / 5 * 255;
+      return [r2, g, b];
+    };
+    convert4.rgb.hex = function(args) {
+      let string = (((Math.round(args[0]) & 255) << 16) + ((Math.round(args[1]) & 255) << 8) + (Math.round(args[2]) & 255)).toString(16).toUpperCase();
+      return "000000".substring(string.length) + string;
+    };
+    convert4.hex.rgb = function(args) {
+      let match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
+      if (!match)
+        return [0, 0, 0];
+      let colorString = match[0];
+      match[0].length === 3 && (colorString = colorString.split("").map((char) => char + char).join(""));
+      let integer = parseInt(colorString, 16), r2 = integer >> 16 & 255, g = integer >> 8 & 255, b = integer & 255;
+      return [r2, g, b];
+    };
+    convert4.rgb.hcg = function(rgb) {
+      let r2 = rgb[0] / 255, g = rgb[1] / 255, b = rgb[2] / 255, max = Math.max(Math.max(r2, g), b), min = Math.min(Math.min(r2, g), b), chroma = max - min, grayscale, hue;
+      return chroma < 1 ? grayscale = min / (1 - chroma) : grayscale = 0, chroma <= 0 ? hue = 0 : max === r2 ? hue = (g - b) / chroma % 6 : max === g ? hue = 2 + (b - r2) / chroma : hue = 4 + (r2 - g) / chroma, hue /= 6, hue %= 1, [hue * 360, chroma * 100, grayscale * 100];
+    };
+    convert4.hsl.hcg = function(hsl) {
+      let s2 = hsl[1] / 100, l = hsl[2] / 100, c2 = l < 0.5 ? 2 * s2 * l : 2 * s2 * (1 - l), f = 0;
+      return c2 < 1 && (f = (l - 0.5 * c2) / (1 - c2)), [hsl[0], c2 * 100, f * 100];
+    };
+    convert4.hsv.hcg = function(hsv) {
+      let s2 = hsv[1] / 100, v = hsv[2] / 100, c2 = s2 * v, f = 0;
+      return c2 < 1 && (f = (v - c2) / (1 - c2)), [hsv[0], c2 * 100, f * 100];
+    };
+    convert4.hcg.rgb = function(hcg) {
+      let h2 = hcg[0] / 360, c2 = hcg[1] / 100, g = hcg[2] / 100;
+      if (c2 === 0)
+        return [g * 255, g * 255, g * 255];
+      let pure = [0, 0, 0], hi = h2 % 1 * 6, v = hi % 1, w = 1 - v, mg = 0;
+      switch (Math.floor(hi)) {
+        case 0:
+          pure[0] = 1, pure[1] = v, pure[2] = 0;
+          break;
+        case 1:
+          pure[0] = w, pure[1] = 1, pure[2] = 0;
+          break;
+        case 2:
+          pure[0] = 0, pure[1] = 1, pure[2] = v;
+          break;
+        case 3:
+          pure[0] = 0, pure[1] = w, pure[2] = 1;
+          break;
+        case 4:
+          pure[0] = v, pure[1] = 0, pure[2] = 1;
+          break;
+        default:
+          pure[0] = 1, pure[1] = 0, pure[2] = w;
+      }
+      return mg = (1 - c2) * g, [
+        (c2 * pure[0] + mg) * 255,
+        (c2 * pure[1] + mg) * 255,
+        (c2 * pure[2] + mg) * 255
+      ];
+    };
+    convert4.hcg.hsv = function(hcg) {
+      let c2 = hcg[1] / 100, g = hcg[2] / 100, v = c2 + g * (1 - c2), f = 0;
+      return v > 0 && (f = c2 / v), [hcg[0], f * 100, v * 100];
+    };
+    convert4.hcg.hsl = function(hcg) {
+      let c2 = hcg[1] / 100, l = hcg[2] / 100 * (1 - c2) + 0.5 * c2, s2 = 0;
+      return l > 0 && l < 0.5 ? s2 = c2 / (2 * l) : l >= 0.5 && l < 1 && (s2 = c2 / (2 * (1 - l))), [hcg[0], s2 * 100, l * 100];
+    };
+    convert4.hcg.hwb = function(hcg) {
+      let c2 = hcg[1] / 100, g = hcg[2] / 100, v = c2 + g * (1 - c2);
+      return [hcg[0], (v - c2) * 100, (1 - v) * 100];
+    };
+    convert4.hwb.hcg = function(hwb) {
+      let w = hwb[1] / 100, v = 1 - hwb[2] / 100, c2 = v - w, g = 0;
+      return c2 < 1 && (g = (v - c2) / (1 - c2)), [hwb[0], c2 * 100, g * 100];
+    };
+    convert4.apple.rgb = function(apple) {
+      return [apple[0] / 65535 * 255, apple[1] / 65535 * 255, apple[2] / 65535 * 255];
+    };
+    convert4.rgb.apple = function(rgb) {
+      return [rgb[0] / 255 * 65535, rgb[1] / 255 * 65535, rgb[2] / 255 * 65535];
+    };
+    convert4.gray.rgb = function(args) {
+      return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
+    };
+    convert4.gray.hsl = function(args) {
+      return [0, 0, args[0]];
+    };
+    convert4.gray.hsv = convert4.gray.hsl;
+    convert4.gray.hwb = function(gray) {
+      return [0, 100, gray[0]];
+    };
+    convert4.gray.cmyk = function(gray) {
+      return [0, 0, 0, gray[0]];
+    };
+    convert4.gray.lab = function(gray) {
+      return [gray[0], 0, 0];
+    };
+    convert4.gray.hex = function(gray) {
+      let val = Math.round(gray[0] / 100 * 255) & 255, string = ((val << 16) + (val << 8) + val).toString(16).toUpperCase();
+      return "000000".substring(string.length) + string;
+    };
+    convert4.rgb.gray = function(rgb) {
+      return [(rgb[0] + rgb[1] + rgb[2]) / 3 / 255 * 100];
+    };
+  }
+});
+
+// ../../node_modules/color-convert/route.js
+var require_route = __commonJS({
+  "../../node_modules/color-convert/route.js"(exports2, module2) {
+    var conversions = require_conversions();
+    function buildGraph() {
+      let graph = {}, models = Object.keys(conversions);
+      for (let len = models.length, i = 0; i < len; i++)
+        graph[models[i]] = {
+          // http://jsperf.com/1-vs-infinity
+          // micro-opt, but this is simple.
+          distance: -1,
+          parent: null
+        };
+      return graph;
+    }
+    function deriveBFS(fromModel) {
+      let graph = buildGraph(), queue = [fromModel];
+      for (graph[fromModel].distance = 0; queue.length; ) {
+        let current = queue.pop(), adjacents = Object.keys(conversions[current]);
+        for (let len = adjacents.length, i = 0; i < len; i++) {
+          let adjacent = adjacents[i], node2 = graph[adjacent];
+          node2.distance === -1 && (node2.distance = graph[current].distance + 1, node2.parent = current, queue.unshift(adjacent));
+        }
+      }
+      return graph;
+    }
+    function link2(from, to) {
+      return function(args) {
+        return to(from(args));
+      };
+    }
+    function wrapConversion(toModel, graph) {
+      let path5 = [graph[toModel].parent, toModel], fn = conversions[graph[toModel].parent][toModel], cur = graph[toModel].parent;
+      for (; graph[cur].parent; )
+        path5.unshift(graph[cur].parent), fn = link2(conversions[graph[cur].parent][cur], fn), cur = graph[cur].parent;
+      return fn.conversion = path5, fn;
+    }
+    module2.exports = function(fromModel) {
+      let graph = deriveBFS(fromModel), conversion = {}, models = Object.keys(graph);
+      for (let len = models.length, i = 0; i < len; i++) {
+        let toModel = models[i];
+        graph[toModel].parent !== null && (conversion[toModel] = wrapConversion(toModel, graph));
+      }
+      return conversion;
+    };
+  }
+});
+
+// ../../node_modules/color-convert/index.js
+var require_color_convert = __commonJS({
+  "../../node_modules/color-convert/index.js"(exports2, module2) {
+    var conversions = require_conversions(), route = require_route(), convert4 = {}, models = Object.keys(conversions);
+    function wrapRaw(fn) {
+      let wrappedFn = function(...args) {
+        let arg0 = args[0];
+        return arg0 == null ? arg0 : (arg0.length > 1 && (args = arg0), fn(args));
+      };
+      return "conversion" in fn && (wrappedFn.conversion = fn.conversion), wrappedFn;
+    }
+    function wrapRounded(fn) {
+      let wrappedFn = function(...args) {
+        let arg0 = args[0];
+        if (arg0 == null)
+          return arg0;
+        arg0.length > 1 && (args = arg0);
+        let result = fn(args);
+        if (typeof result == "object")
+          for (let len = result.length, i = 0; i < len; i++)
+            result[i] = Math.round(result[i]);
+        return result;
+      };
+      return "conversion" in fn && (wrappedFn.conversion = fn.conversion), wrappedFn;
+    }
+    models.forEach((fromModel) => {
+      convert4[fromModel] = {}, Object.defineProperty(convert4[fromModel], "channels", { value: conversions[fromModel].channels }), Object.defineProperty(convert4[fromModel], "labels", { value: conversions[fromModel].labels });
+      let routes = route(fromModel);
+      Object.keys(routes).forEach((toModel) => {
+        let fn = routes[toModel];
+        convert4[fromModel][toModel] = wrapRounded(fn), convert4[fromModel][toModel].raw = wrapRaw(fn);
+      });
+    });
+    module2.exports = convert4;
+  }
+});
+
+// ../../node_modules/color/index.js
+var require_color = __commonJS({
+  "../../node_modules/color/index.js"(exports2, module2) {
+    var colorString = require_color_string(), convert4 = require_color_convert(), skippedModels = [
+      // To be honest, I don't really feel like keyword belongs in color convert, but eh.
+      "keyword",
+      // Gray conflicts with some method names, and has its own method defined.
+      "gray",
+      // Shouldn't really be in color-convert either...
+      "hex"
+    ], hashedModelKeys = {};
+    for (let model of Object.keys(convert4))
+      hashedModelKeys[[...convert4[model].labels].sort().join("")] = model;
+    var limiters = {};
+    function Color(object, model) {
+      if (!(this instanceof Color))
+        return new Color(object, model);
+      if (model && model in skippedModels && (model = null), model && !(model in convert4))
+        throw new Error("Unknown model: " + model);
+      let i, channels;
+      if (object == null)
+        this.model = "rgb", this.color = [0, 0, 0], this.valpha = 1;
+      else if (object instanceof Color)
+        this.model = object.model, this.color = [...object.color], this.valpha = object.valpha;
+      else if (typeof object == "string") {
+        let result = colorString.get(object);
+        if (result === null)
+          throw new Error("Unable to parse color from string: " + object);
+        this.model = result.model, channels = convert4[this.model].channels, this.color = result.value.slice(0, channels), this.valpha = typeof result.value[channels] == "number" ? result.value[channels] : 1;
+      } else if (object.length > 0) {
+        this.model = model || "rgb", channels = convert4[this.model].channels;
+        let newArray = Array.prototype.slice.call(object, 0, channels);
+        this.color = zeroArray(newArray, channels), this.valpha = typeof object[channels] == "number" ? object[channels] : 1;
+      } else if (typeof object == "number")
+        this.model = "rgb", this.color = [
+          object >> 16 & 255,
+          object >> 8 & 255,
+          object & 255
+        ], this.valpha = 1;
+      else {
+        this.valpha = 1;
+        let keys2 = Object.keys(object);
+        "alpha" in object && (keys2.splice(keys2.indexOf("alpha"), 1), this.valpha = typeof object.alpha == "number" ? object.alpha : 0);
+        let hashedKeys = keys2.sort().join("");
+        if (!(hashedKeys in hashedModelKeys))
+          throw new Error("Unable to parse color from object: " + JSON.stringify(object));
+        this.model = hashedModelKeys[hashedKeys];
+        let { labels } = convert4[this.model], color4 = [];
+        for (i = 0; i < labels.length; i++)
+          color4.push(object[labels[i]]);
+        this.color = zeroArray(color4);
+      }
+      if (limiters[this.model])
+        for (channels = convert4[this.model].channels, i = 0; i < channels; i++) {
+          let limit = limiters[this.model][i];
+          limit && (this.color[i] = limit(this.color[i]));
+        }
+      this.valpha = Math.max(0, Math.min(1, this.valpha)), Object.freeze && Object.freeze(this);
+    }
+    Color.prototype = {
+      toString() {
+        return this.string();
+      },
+      toJSON() {
+        return this[this.model]();
+      },
+      string(places) {
+        let self = this.model in colorString.to ? this : this.rgb();
+        self = self.round(typeof places == "number" ? places : 1);
+        let args = self.valpha === 1 ? self.color : [...self.color, this.valpha];
+        return colorString.to[self.model](args);
+      },
+      percentString(places) {
+        let self = this.rgb().round(typeof places == "number" ? places : 1), args = self.valpha === 1 ? self.color : [...self.color, this.valpha];
+        return colorString.to.rgb.percent(args);
+      },
+      array() {
+        return this.valpha === 1 ? [...this.color] : [...this.color, this.valpha];
+      },
+      object() {
+        let result = {}, { channels } = convert4[this.model], { labels } = convert4[this.model];
+        for (let i = 0; i < channels; i++)
+          result[labels[i]] = this.color[i];
+        return this.valpha !== 1 && (result.alpha = this.valpha), result;
+      },
+      unitArray() {
+        let rgb = this.rgb().color;
+        return rgb[0] /= 255, rgb[1] /= 255, rgb[2] /= 255, this.valpha !== 1 && rgb.push(this.valpha), rgb;
+      },
+      unitObject() {
+        let rgb = this.rgb().object();
+        return rgb.r /= 255, rgb.g /= 255, rgb.b /= 255, this.valpha !== 1 && (rgb.alpha = this.valpha), rgb;
+      },
+      round(places) {
+        return places = Math.max(places || 0, 0), new Color([...this.color.map(roundToPlace(places)), this.valpha], this.model);
+      },
+      alpha(value) {
+        return value !== void 0 ? new Color([...this.color, Math.max(0, Math.min(1, value))], this.model) : this.valpha;
+      },
+      // Rgb
+      red: getset("rgb", 0, maxfn(255)),
+      green: getset("rgb", 1, maxfn(255)),
+      blue: getset("rgb", 2, maxfn(255)),
+      hue: getset(["hsl", "hsv", "hsl", "hwb", "hcg"], 0, (value) => (value % 360 + 360) % 360),
+      saturationl: getset("hsl", 1, maxfn(100)),
+      lightness: getset("hsl", 2, maxfn(100)),
+      saturationv: getset("hsv", 1, maxfn(100)),
+      value: getset("hsv", 2, maxfn(100)),
+      chroma: getset("hcg", 1, maxfn(100)),
+      gray: getset("hcg", 2, maxfn(100)),
+      white: getset("hwb", 1, maxfn(100)),
+      wblack: getset("hwb", 2, maxfn(100)),
+      cyan: getset("cmyk", 0, maxfn(100)),
+      magenta: getset("cmyk", 1, maxfn(100)),
+      yellow: getset("cmyk", 2, maxfn(100)),
+      black: getset("cmyk", 3, maxfn(100)),
+      x: getset("xyz", 0, maxfn(95.047)),
+      y: getset("xyz", 1, maxfn(100)),
+      z: getset("xyz", 2, maxfn(108.833)),
+      l: getset("lab", 0, maxfn(100)),
+      a: getset("lab", 1),
+      b: getset("lab", 2),
+      keyword(value) {
+        return value !== void 0 ? new Color(value) : convert4[this.model].keyword(this.color);
+      },
+      hex(value) {
+        return value !== void 0 ? new Color(value) : colorString.to.hex(this.rgb().round().color);
+      },
+      hexa(value) {
+        if (value !== void 0)
+          return new Color(value);
+        let rgbArray = this.rgb().round().color, alphaHex = Math.round(this.valpha * 255).toString(16).toUpperCase();
+        return alphaHex.length === 1 && (alphaHex = "0" + alphaHex), colorString.to.hex(rgbArray) + alphaHex;
+      },
+      rgbNumber() {
+        let rgb = this.rgb().color;
+        return (rgb[0] & 255) << 16 | (rgb[1] & 255) << 8 | rgb[2] & 255;
+      },
+      luminosity() {
+        let rgb = this.rgb().color, lum = [];
+        for (let [i, element4] of rgb.entries()) {
+          let chan = element4 / 255;
+          lum[i] = chan <= 0.04045 ? chan / 12.92 : ((chan + 0.055) / 1.055) ** 2.4;
+        }
+        return 0.2126 * lum[0] + 0.7152 * lum[1] + 0.0722 * lum[2];
+      },
+      contrast(color22) {
+        let lum1 = this.luminosity(), lum2 = color22.luminosity();
+        return lum1 > lum2 ? (lum1 + 0.05) / (lum2 + 0.05) : (lum2 + 0.05) / (lum1 + 0.05);
+      },
+      level(color22) {
+        let contrastRatio = this.contrast(color22);
+        return contrastRatio >= 7 ? "AAA" : contrastRatio >= 4.5 ? "AA" : "";
+      },
+      isDark() {
+        let rgb = this.rgb().color;
+        return (rgb[0] * 2126 + rgb[1] * 7152 + rgb[2] * 722) / 1e4 < 128;
+      },
+      isLight() {
+        return !this.isDark();
+      },
+      negate() {
+        let rgb = this.rgb();
+        for (let i = 0; i < 3; i++)
+          rgb.color[i] = 255 - rgb.color[i];
+        return rgb;
+      },
+      lighten(ratio) {
+        let hsl = this.hsl();
+        return hsl.color[2] += hsl.color[2] * ratio, hsl;
+      },
+      darken(ratio) {
+        let hsl = this.hsl();
+        return hsl.color[2] -= hsl.color[2] * ratio, hsl;
+      },
+      saturate(ratio) {
+        let hsl = this.hsl();
+        return hsl.color[1] += hsl.color[1] * ratio, hsl;
+      },
+      desaturate(ratio) {
+        let hsl = this.hsl();
+        return hsl.color[1] -= hsl.color[1] * ratio, hsl;
+      },
+      whiten(ratio) {
+        let hwb = this.hwb();
+        return hwb.color[1] += hwb.color[1] * ratio, hwb;
+      },
+      blacken(ratio) {
+        let hwb = this.hwb();
+        return hwb.color[2] += hwb.color[2] * ratio, hwb;
+      },
+      grayscale() {
+        let rgb = this.rgb().color, value = rgb[0] * 0.3 + rgb[1] * 0.59 + rgb[2] * 0.11;
+        return Color.rgb(value, value, value);
+      },
+      fade(ratio) {
+        return this.alpha(this.valpha - this.valpha * ratio);
+      },
+      opaquer(ratio) {
+        return this.alpha(this.valpha + this.valpha * ratio);
+      },
+      rotate(degrees) {
+        let hsl = this.hsl(), hue = hsl.color[0];
+        return hue = (hue + degrees) % 360, hue = hue < 0 ? 360 + hue : hue, hsl.color[0] = hue, hsl;
+      },
+      mix(mixinColor, weight) {
+        if (!mixinColor || !mixinColor.rgb)
+          throw new Error('Argument to "mix" was not a Color instance, but rather an instance of ' + typeof mixinColor);
+        let color1 = mixinColor.rgb(), color22 = this.rgb(), p2 = weight === void 0 ? 0.5 : weight, w = 2 * p2 - 1, a = color1.alpha() - color22.alpha(), w1 = ((w * a === -1 ? w : (w + a) / (1 + w * a)) + 1) / 2, w2 = 1 - w1;
+        return Color.rgb(
+          w1 * color1.red() + w2 * color22.red(),
+          w1 * color1.green() + w2 * color22.green(),
+          w1 * color1.blue() + w2 * color22.blue(),
+          color1.alpha() * p2 + color22.alpha() * (1 - p2)
+        );
+      }
+    };
+    for (let model of Object.keys(convert4)) {
+      if (skippedModels.includes(model))
+        continue;
+      let { channels } = convert4[model];
+      Color.prototype[model] = function(...args) {
+        return this.model === model ? new Color(this) : args.length > 0 ? new Color(args, model) : new Color([...assertArray(convert4[this.model][model].raw(this.color)), this.valpha], model);
+      }, Color[model] = function(...args) {
+        let color4 = args[0];
+        return typeof color4 == "number" && (color4 = zeroArray(args, channels)), new Color(color4, model);
+      };
+    }
+    function roundTo(number2, places) {
+      return Number(number2.toFixed(places));
+    }
+    function roundToPlace(places) {
+      return function(number2) {
+        return roundTo(number2, places);
+      };
+    }
+    function getset(model, channel, modifier) {
+      model = Array.isArray(model) ? model : [model];
+      for (let m of model)
+        (limiters[m] || (limiters[m] = []))[channel] = modifier;
+      return model = model[0], function(value) {
+        let result;
+        return value !== void 0 ? (modifier && (value = modifier(value)), result = this[model](), result.color[channel] = value, result) : (result = this[model]().color[channel], modifier && (result = modifier(result)), result);
+      };
+    }
+    function maxfn(max) {
+      return function(v) {
+        return Math.max(0, Math.min(max, v));
+      };
+    }
+    function assertArray(value) {
+      return Array.isArray(value) ? value : [value];
+    }
+    function zeroArray(array, length) {
+      for (let i = 0; i < length; i++)
+        typeof array[i] != "number" && (array[i] = 0);
+      return array;
+    }
+    module2.exports = Color;
+  }
+});
+
+// ../../node_modules/sharp/lib/input.js
+var require_input = __commonJS({
+  "../../node_modules/sharp/lib/input.js"(exports2, module2) {
+    "use strict";
+    var color4 = require_color(), is4 = require_is(), sharp = require_sharp(), align = {
+      left: "low",
+      center: "centre",
+      centre: "centre",
+      right: "high"
+    };
+    function _inputOptionsFromObject(obj) {
+      let { raw: raw2, density, limitInputPixels, ignoreIcc, unlimited, sequentialRead, failOn, failOnError, animated, page, pages, subifd } = obj;
+      return [raw2, density, limitInputPixels, ignoreIcc, unlimited, sequentialRead, failOn, failOnError, animated, page, pages, subifd].some(is4.defined) ? { raw: raw2, density, limitInputPixels, ignoreIcc, unlimited, sequentialRead, failOn, failOnError, animated, page, pages, subifd } : void 0;
+    }
+    function _createInputDescriptor(input, inputOptions, containerOptions) {
+      let inputDescriptor = {
+        failOn: "warning",
+        limitInputPixels: Math.pow(16383, 2),
+        ignoreIcc: !1,
+        unlimited: !1,
+        sequentialRead: !0
+      };
+      if (is4.string(input))
+        inputDescriptor.file = input;
+      else if (is4.buffer(input)) {
+        if (input.length === 0)
+          throw Error("Input Buffer is empty");
+        inputDescriptor.buffer = input;
+      } else if (is4.arrayBuffer(input)) {
+        if (input.byteLength === 0)
+          throw Error("Input bit Array is empty");
+        inputDescriptor.buffer = Buffer.from(input, 0, input.byteLength);
+      } else if (is4.typedArray(input)) {
+        if (input.length === 0)
+          throw Error("Input Bit Array is empty");
+        inputDescriptor.buffer = Buffer.from(input.buffer, input.byteOffset, input.byteLength);
+      } else if (is4.plainObject(input) && !is4.defined(inputOptions))
+        inputOptions = input, _inputOptionsFromObject(inputOptions) && (inputDescriptor.buffer = []);
+      else if (!is4.defined(input) && !is4.defined(inputOptions) && is4.object(containerOptions) && containerOptions.allowStream)
+        inputDescriptor.buffer = [];
+      else
+        throw new Error(`Unsupported input '${input}' of type ${typeof input}${is4.defined(inputOptions) ? ` when also providing options of type ${typeof inputOptions}` : ""}`);
+      if (is4.object(inputOptions)) {
+        if (is4.defined(inputOptions.failOnError))
+          if (is4.bool(inputOptions.failOnError))
+            inputDescriptor.failOn = inputOptions.failOnError ? "warning" : "none";
+          else
+            throw is4.invalidParameterError("failOnError", "boolean", inputOptions.failOnError);
+        if (is4.defined(inputOptions.failOn))
+          if (is4.string(inputOptions.failOn) && is4.inArray(inputOptions.failOn, ["none", "truncated", "error", "warning"]))
+            inputDescriptor.failOn = inputOptions.failOn;
+          else
+            throw is4.invalidParameterError("failOn", "one of: none, truncated, error, warning", inputOptions.failOn);
+        if (is4.defined(inputOptions.density))
+          if (is4.inRange(inputOptions.density, 1, 1e5))
+            inputDescriptor.density = inputOptions.density;
+          else
+            throw is4.invalidParameterError("density", "number between 1 and 100000", inputOptions.density);
+        if (is4.defined(inputOptions.ignoreIcc))
+          if (is4.bool(inputOptions.ignoreIcc))
+            inputDescriptor.ignoreIcc = inputOptions.ignoreIcc;
+          else
+            throw is4.invalidParameterError("ignoreIcc", "boolean", inputOptions.ignoreIcc);
+        if (is4.defined(inputOptions.limitInputPixels))
+          if (is4.bool(inputOptions.limitInputPixels))
+            inputDescriptor.limitInputPixels = inputOptions.limitInputPixels ? Math.pow(16383, 2) : 0;
+          else if (is4.integer(inputOptions.limitInputPixels) && is4.inRange(inputOptions.limitInputPixels, 0, Number.MAX_SAFE_INTEGER))
+            inputDescriptor.limitInputPixels = inputOptions.limitInputPixels;
+          else
+            throw is4.invalidParameterError("limitInputPixels", "positive integer", inputOptions.limitInputPixels);
+        if (is4.defined(inputOptions.unlimited))
+          if (is4.bool(inputOptions.unlimited))
+            inputDescriptor.unlimited = inputOptions.unlimited;
+          else
+            throw is4.invalidParameterError("unlimited", "boolean", inputOptions.unlimited);
+        if (is4.defined(inputOptions.sequentialRead))
+          if (is4.bool(inputOptions.sequentialRead))
+            inputDescriptor.sequentialRead = inputOptions.sequentialRead;
+          else
+            throw is4.invalidParameterError("sequentialRead", "boolean", inputOptions.sequentialRead);
+        if (is4.defined(inputOptions.raw))
+          if (is4.object(inputOptions.raw) && is4.integer(inputOptions.raw.width) && inputOptions.raw.width > 0 && is4.integer(inputOptions.raw.height) && inputOptions.raw.height > 0 && is4.integer(inputOptions.raw.channels) && is4.inRange(inputOptions.raw.channels, 1, 4))
+            switch (inputDescriptor.rawWidth = inputOptions.raw.width, inputDescriptor.rawHeight = inputOptions.raw.height, inputDescriptor.rawChannels = inputOptions.raw.channels, inputDescriptor.rawPremultiplied = !!inputOptions.raw.premultiplied, input.constructor) {
+              case Uint8Array:
+              case Uint8ClampedArray:
+                inputDescriptor.rawDepth = "uchar";
+                break;
+              case Int8Array:
+                inputDescriptor.rawDepth = "char";
+                break;
+              case Uint16Array:
+                inputDescriptor.rawDepth = "ushort";
+                break;
+              case Int16Array:
+                inputDescriptor.rawDepth = "short";
+                break;
+              case Uint32Array:
+                inputDescriptor.rawDepth = "uint";
+                break;
+              case Int32Array:
+                inputDescriptor.rawDepth = "int";
+                break;
+              case Float32Array:
+                inputDescriptor.rawDepth = "float";
+                break;
+              case Float64Array:
+                inputDescriptor.rawDepth = "double";
+                break;
+              default:
+                inputDescriptor.rawDepth = "uchar";
+                break;
+            }
+          else
+            throw new Error("Expected width, height and channels for raw pixel input");
+        if (is4.defined(inputOptions.animated))
+          if (is4.bool(inputOptions.animated))
+            inputDescriptor.pages = inputOptions.animated ? -1 : 1;
+          else
+            throw is4.invalidParameterError("animated", "boolean", inputOptions.animated);
+        if (is4.defined(inputOptions.pages))
+          if (is4.integer(inputOptions.pages) && is4.inRange(inputOptions.pages, -1, 1e5))
+            inputDescriptor.pages = inputOptions.pages;
+          else
+            throw is4.invalidParameterError("pages", "integer between -1 and 100000", inputOptions.pages);
+        if (is4.defined(inputOptions.page))
+          if (is4.integer(inputOptions.page) && is4.inRange(inputOptions.page, 0, 1e5))
+            inputDescriptor.page = inputOptions.page;
+          else
+            throw is4.invalidParameterError("page", "integer between 0 and 100000", inputOptions.page);
+        if (is4.defined(inputOptions.level))
+          if (is4.integer(inputOptions.level) && is4.inRange(inputOptions.level, 0, 256))
+            inputDescriptor.level = inputOptions.level;
+          else
+            throw is4.invalidParameterError("level", "integer between 0 and 256", inputOptions.level);
+        if (is4.defined(inputOptions.subifd))
+          if (is4.integer(inputOptions.subifd) && is4.inRange(inputOptions.subifd, -1, 1e5))
+            inputDescriptor.subifd = inputOptions.subifd;
+          else
+            throw is4.invalidParameterError("subifd", "integer between -1 and 100000", inputOptions.subifd);
+        if (is4.defined(inputOptions.create))
+          if (is4.object(inputOptions.create) && is4.integer(inputOptions.create.width) && inputOptions.create.width > 0 && is4.integer(inputOptions.create.height) && inputOptions.create.height > 0 && is4.integer(inputOptions.create.channels)) {
+            if (inputDescriptor.createWidth = inputOptions.create.width, inputDescriptor.createHeight = inputOptions.create.height, inputDescriptor.createChannels = inputOptions.create.channels, is4.defined(inputOptions.create.noise)) {
+              if (!is4.object(inputOptions.create.noise))
+                throw new Error("Expected noise to be an object");
+              if (!is4.inArray(inputOptions.create.noise.type, ["gaussian"]))
+                throw new Error("Only gaussian noise is supported at the moment");
+              if (!is4.inRange(inputOptions.create.channels, 1, 4))
+                throw is4.invalidParameterError("create.channels", "number between 1 and 4", inputOptions.create.channels);
+              if (inputDescriptor.createNoiseType = inputOptions.create.noise.type, is4.number(inputOptions.create.noise.mean) && is4.inRange(inputOptions.create.noise.mean, 0, 1e4))
+                inputDescriptor.createNoiseMean = inputOptions.create.noise.mean;
+              else
+                throw is4.invalidParameterError("create.noise.mean", "number between 0 and 10000", inputOptions.create.noise.mean);
+              if (is4.number(inputOptions.create.noise.sigma) && is4.inRange(inputOptions.create.noise.sigma, 0, 1e4))
+                inputDescriptor.createNoiseSigma = inputOptions.create.noise.sigma;
+              else
+                throw is4.invalidParameterError("create.noise.sigma", "number between 0 and 10000", inputOptions.create.noise.sigma);
+            } else if (is4.defined(inputOptions.create.background)) {
+              if (!is4.inRange(inputOptions.create.channels, 3, 4))
+                throw is4.invalidParameterError("create.channels", "number between 3 and 4", inputOptions.create.channels);
+              let background = color4(inputOptions.create.background);
+              inputDescriptor.createBackground = [
+                background.red(),
+                background.green(),
+                background.blue(),
+                Math.round(background.alpha() * 255)
+              ];
+            } else
+              throw new Error("Expected valid noise or background to create a new input image");
+            delete inputDescriptor.buffer;
+          } else
+            throw new Error("Expected valid width, height and channels to create a new input image");
+        if (is4.defined(inputOptions.text))
+          if (is4.object(inputOptions.text) && is4.string(inputOptions.text.text)) {
+            if (inputDescriptor.textValue = inputOptions.text.text, is4.defined(inputOptions.text.height) && is4.defined(inputOptions.text.dpi))
+              throw new Error("Expected only one of dpi or height");
+            if (is4.defined(inputOptions.text.font))
+              if (is4.string(inputOptions.text.font))
+                inputDescriptor.textFont = inputOptions.text.font;
+              else
+                throw is4.invalidParameterError("text.font", "string", inputOptions.text.font);
+            if (is4.defined(inputOptions.text.fontfile))
+              if (is4.string(inputOptions.text.fontfile))
+                inputDescriptor.textFontfile = inputOptions.text.fontfile;
+              else
+                throw is4.invalidParameterError("text.fontfile", "string", inputOptions.text.fontfile);
+            if (is4.defined(inputOptions.text.width))
+              if (is4.integer(inputOptions.text.width) && inputOptions.text.width > 0)
+                inputDescriptor.textWidth = inputOptions.text.width;
+              else
+                throw is4.invalidParameterError("text.width", "positive integer", inputOptions.text.width);
+            if (is4.defined(inputOptions.text.height))
+              if (is4.integer(inputOptions.text.height) && inputOptions.text.height > 0)
+                inputDescriptor.textHeight = inputOptions.text.height;
+              else
+                throw is4.invalidParameterError("text.height", "positive integer", inputOptions.text.height);
+            if (is4.defined(inputOptions.text.align))
+              if (is4.string(inputOptions.text.align) && is4.string(this.constructor.align[inputOptions.text.align]))
+                inputDescriptor.textAlign = this.constructor.align[inputOptions.text.align];
+              else
+                throw is4.invalidParameterError("text.align", "valid alignment", inputOptions.text.align);
+            if (is4.defined(inputOptions.text.justify))
+              if (is4.bool(inputOptions.text.justify))
+                inputDescriptor.textJustify = inputOptions.text.justify;
+              else
+                throw is4.invalidParameterError("text.justify", "boolean", inputOptions.text.justify);
+            if (is4.defined(inputOptions.text.dpi))
+              if (is4.integer(inputOptions.text.dpi) && is4.inRange(inputOptions.text.dpi, 1, 1e6))
+                inputDescriptor.textDpi = inputOptions.text.dpi;
+              else
+                throw is4.invalidParameterError("text.dpi", "integer between 1 and 1000000", inputOptions.text.dpi);
+            if (is4.defined(inputOptions.text.rgba))
+              if (is4.bool(inputOptions.text.rgba))
+                inputDescriptor.textRgba = inputOptions.text.rgba;
+              else
+                throw is4.invalidParameterError("text.rgba", "bool", inputOptions.text.rgba);
+            if (is4.defined(inputOptions.text.spacing))
+              if (is4.integer(inputOptions.text.spacing) && is4.inRange(inputOptions.text.spacing, -1e6, 1e6))
+                inputDescriptor.textSpacing = inputOptions.text.spacing;
+              else
+                throw is4.invalidParameterError("text.spacing", "integer between -1000000 and 1000000", inputOptions.text.spacing);
+            if (is4.defined(inputOptions.text.wrap))
+              if (is4.string(inputOptions.text.wrap) && is4.inArray(inputOptions.text.wrap, ["word", "char", "word-char", "none"]))
+                inputDescriptor.textWrap = inputOptions.text.wrap;
+              else
+                throw is4.invalidParameterError("text.wrap", "one of: word, char, word-char, none", inputOptions.text.wrap);
+            delete inputDescriptor.buffer;
+          } else
+            throw new Error("Expected a valid string to create an image with text.");
+      } else if (is4.defined(inputOptions))
+        throw new Error("Invalid input options " + inputOptions);
+      return inputDescriptor;
+    }
+    function _write(chunk, encoding, callback) {
+      Array.isArray(this.options.input.buffer) ? is4.buffer(chunk) ? (this.options.input.buffer.length === 0 && this.on("finish", () => {
+        this.streamInFinished = !0;
+      }), this.options.input.buffer.push(chunk), callback()) : callback(new Error("Non-Buffer data on Writable Stream")) : callback(new Error("Unexpected data on Writable Stream"));
+    }
+    function _flattenBufferIn() {
+      this._isStreamInput() && (this.options.input.buffer = Buffer.concat(this.options.input.buffer));
+    }
+    function _isStreamInput() {
+      return Array.isArray(this.options.input.buffer);
+    }
+    function metadata(callback) {
+      let stack = Error();
+      return is4.fn(callback) ? (this._isStreamInput() ? this.on("finish", () => {
+        this._flattenBufferIn(), sharp.metadata(this.options, (err, metadata2) => {
+          err ? callback(is4.nativeError(err, stack)) : callback(null, metadata2);
+        });
+      }) : sharp.metadata(this.options, (err, metadata2) => {
+        err ? callback(is4.nativeError(err, stack)) : callback(null, metadata2);
+      }), this) : this._isStreamInput() ? new Promise((resolve2, reject) => {
+        let finished = () => {
+          this._flattenBufferIn(), sharp.metadata(this.options, (err, metadata2) => {
+            err ? reject(is4.nativeError(err, stack)) : resolve2(metadata2);
+          });
+        };
+        this.writableFinished ? finished() : this.once("finish", finished);
+      }) : new Promise((resolve2, reject) => {
+        sharp.metadata(this.options, (err, metadata2) => {
+          err ? reject(is4.nativeError(err, stack)) : resolve2(metadata2);
+        });
+      });
+    }
+    function stats(callback) {
+      let stack = Error();
+      return is4.fn(callback) ? (this._isStreamInput() ? this.on("finish", () => {
+        this._flattenBufferIn(), sharp.stats(this.options, (err, stats2) => {
+          err ? callback(is4.nativeError(err, stack)) : callback(null, stats2);
+        });
+      }) : sharp.stats(this.options, (err, stats2) => {
+        err ? callback(is4.nativeError(err, stack)) : callback(null, stats2);
+      }), this) : this._isStreamInput() ? new Promise((resolve2, reject) => {
+        this.on("finish", function() {
+          this._flattenBufferIn(), sharp.stats(this.options, (err, stats2) => {
+            err ? reject(is4.nativeError(err, stack)) : resolve2(stats2);
+          });
+        });
+      }) : new Promise((resolve2, reject) => {
+        sharp.stats(this.options, (err, stats2) => {
+          err ? reject(is4.nativeError(err, stack)) : resolve2(stats2);
+        });
+      });
+    }
+    module2.exports = function(Sharp) {
+      Object.assign(Sharp.prototype, {
+        // Private
+        _inputOptionsFromObject,
+        _createInputDescriptor,
+        _write,
+        _flattenBufferIn,
+        _isStreamInput,
+        // Public
+        metadata,
+        stats
+      }), Sharp.align = align;
+    };
+  }
+});
+
+// ../../node_modules/sharp/lib/resize.js
+var require_resize = __commonJS({
+  "../../node_modules/sharp/lib/resize.js"(exports2, module2) {
+    "use strict";
+    var is4 = require_is(), gravity = {
+      center: 0,
+      centre: 0,
+      north: 1,
+      east: 2,
+      south: 3,
+      west: 4,
+      northeast: 5,
+      southeast: 6,
+      southwest: 7,
+      northwest: 8
+    }, position3 = {
+      top: 1,
+      right: 2,
+      bottom: 3,
+      left: 4,
+      "right top": 5,
+      "right bottom": 6,
+      "left bottom": 7,
+      "left top": 8
+    }, extendWith = {
+      background: "background",
+      copy: "copy",
+      repeat: "repeat",
+      mirror: "mirror"
+    }, strategy = {
+      entropy: 16,
+      attention: 17
+    }, kernel = {
+      nearest: "nearest",
+      linear: "linear",
+      cubic: "cubic",
+      mitchell: "mitchell",
+      lanczos2: "lanczos2",
+      lanczos3: "lanczos3"
+    }, fit = {
+      contain: "contain",
+      cover: "cover",
+      fill: "fill",
+      inside: "inside",
+      outside: "outside"
+    }, mapFitToCanvas = {
+      contain: "embed",
+      cover: "crop",
+      fill: "ignore_aspect",
+      inside: "max",
+      outside: "min"
+    };
+    function isRotationExpected(options2) {
+      return options2.angle % 360 !== 0 || options2.useExifOrientation === !0 || options2.rotationAngle !== 0;
+    }
+    function isResizeExpected(options2) {
+      return options2.width !== -1 || options2.height !== -1;
+    }
+    function resize(widthOrOptions, height, options2) {
+      if (isResizeExpected(this.options) && this.options.debuglog("ignoring previous resize options"), this.options.widthPost !== -1 && this.options.debuglog("operation order will be: extract, resize, extract"), is4.defined(widthOrOptions))
+        if (is4.object(widthOrOptions) && !is4.defined(options2))
+          options2 = widthOrOptions;
+        else if (is4.integer(widthOrOptions) && widthOrOptions > 0)
+          this.options.width = widthOrOptions;
+        else
+          throw is4.invalidParameterError("width", "positive integer", widthOrOptions);
+      else
+        this.options.width = -1;
+      if (is4.defined(height))
+        if (is4.integer(height) && height > 0)
+          this.options.height = height;
+        else
+          throw is4.invalidParameterError("height", "positive integer", height);
+      else
+        this.options.height = -1;
+      if (is4.object(options2)) {
+        if (is4.defined(options2.width))
+          if (is4.integer(options2.width) && options2.width > 0)
+            this.options.width = options2.width;
+          else
+            throw is4.invalidParameterError("width", "positive integer", options2.width);
+        if (is4.defined(options2.height))
+          if (is4.integer(options2.height) && options2.height > 0)
+            this.options.height = options2.height;
+          else
+            throw is4.invalidParameterError("height", "positive integer", options2.height);
+        if (is4.defined(options2.fit)) {
+          let canvas = mapFitToCanvas[options2.fit];
+          if (is4.string(canvas))
+            this.options.canvas = canvas;
+          else
+            throw is4.invalidParameterError("fit", "valid fit", options2.fit);
+        }
+        if (is4.defined(options2.position)) {
+          let pos = is4.integer(options2.position) ? options2.position : strategy[options2.position] || position3[options2.position] || gravity[options2.position];
+          if (is4.integer(pos) && (is4.inRange(pos, 0, 8) || is4.inRange(pos, 16, 17)))
+            this.options.position = pos;
+          else
+            throw is4.invalidParameterError("position", "valid position/gravity/strategy", options2.position);
+        }
+        if (this._setBackgroundColourOption("resizeBackground", options2.background), is4.defined(options2.kernel))
+          if (is4.string(kernel[options2.kernel]))
+            this.options.kernel = kernel[options2.kernel];
+          else
+            throw is4.invalidParameterError("kernel", "valid kernel name", options2.kernel);
+        is4.defined(options2.withoutEnlargement) && this._setBooleanOption("withoutEnlargement", options2.withoutEnlargement), is4.defined(options2.withoutReduction) && this._setBooleanOption("withoutReduction", options2.withoutReduction), is4.defined(options2.fastShrinkOnLoad) && this._setBooleanOption("fastShrinkOnLoad", options2.fastShrinkOnLoad);
+      }
+      return isRotationExpected(this.options) && isResizeExpected(this.options) && (this.options.rotateBeforePreExtract = !0), this;
+    }
+    function extend3(extend4) {
+      if (is4.integer(extend4) && extend4 > 0)
+        this.options.extendTop = extend4, this.options.extendBottom = extend4, this.options.extendLeft = extend4, this.options.extendRight = extend4;
+      else if (is4.object(extend4)) {
+        if (is4.defined(extend4.top))
+          if (is4.integer(extend4.top) && extend4.top >= 0)
+            this.options.extendTop = extend4.top;
+          else
+            throw is4.invalidParameterError("top", "positive integer", extend4.top);
+        if (is4.defined(extend4.bottom))
+          if (is4.integer(extend4.bottom) && extend4.bottom >= 0)
+            this.options.extendBottom = extend4.bottom;
+          else
+            throw is4.invalidParameterError("bottom", "positive integer", extend4.bottom);
+        if (is4.defined(extend4.left))
+          if (is4.integer(extend4.left) && extend4.left >= 0)
+            this.options.extendLeft = extend4.left;
+          else
+            throw is4.invalidParameterError("left", "positive integer", extend4.left);
+        if (is4.defined(extend4.right))
+          if (is4.integer(extend4.right) && extend4.right >= 0)
+            this.options.extendRight = extend4.right;
+          else
+            throw is4.invalidParameterError("right", "positive integer", extend4.right);
+        if (this._setBackgroundColourOption("extendBackground", extend4.background), is4.defined(extend4.extendWith))
+          if (is4.string(extendWith[extend4.extendWith]))
+            this.options.extendWith = extendWith[extend4.extendWith];
+          else
+            throw is4.invalidParameterError("extendWith", "one of: background, copy, repeat, mirror", extend4.extendWith);
+      } else
+        throw is4.invalidParameterError("extend", "integer or object", extend4);
+      return this;
+    }
+    function extract(options2) {
+      let suffix = isResizeExpected(this.options) || this.options.widthPre !== -1 ? "Post" : "Pre";
+      return this.options[`width${suffix}`] !== -1 && this.options.debuglog("ignoring previous extract options"), ["left", "top", "width", "height"].forEach(function(name) {
+        let value = options2[name];
+        if (is4.integer(value) && value >= 0)
+          this.options[name + (name === "left" || name === "top" ? "Offset" : "") + suffix] = value;
+        else
+          throw is4.invalidParameterError(name, "integer", value);
+      }, this), isRotationExpected(this.options) && !isResizeExpected(this.options) && (this.options.widthPre === -1 || this.options.widthPost === -1) && (this.options.rotateBeforePreExtract = !0), this;
+    }
+    function trim(options2) {
+      if (this.options.trimThreshold = 10, is4.defined(options2))
+        if (is4.object(options2)) {
+          if (is4.defined(options2.background) && this._setBackgroundColourOption("trimBackground", options2.background), is4.defined(options2.threshold))
+            if (is4.number(options2.threshold) && options2.threshold >= 0)
+              this.options.trimThreshold = options2.threshold;
+            else
+              throw is4.invalidParameterError("threshold", "positive number", options2.threshold);
+          is4.defined(options2.lineArt) && this._setBooleanOption("trimLineArt", options2.lineArt);
+        } else
+          throw is4.invalidParameterError("trim", "object", options2);
+      return isRotationExpected(this.options) && (this.options.rotateBeforePreExtract = !0), this;
+    }
+    module2.exports = function(Sharp) {
+      Object.assign(Sharp.prototype, {
+        resize,
+        extend: extend3,
+        extract,
+        trim
+      }), Sharp.gravity = gravity, Sharp.strategy = strategy, Sharp.kernel = kernel, Sharp.fit = fit, Sharp.position = position3;
+    };
+  }
+});
+
+// ../../node_modules/sharp/lib/composite.js
+var require_composite = __commonJS({
+  "../../node_modules/sharp/lib/composite.js"(exports2, module2) {
+    "use strict";
+    var is4 = require_is(), blend = {
+      clear: "clear",
+      source: "source",
+      over: "over",
+      in: "in",
+      out: "out",
+      atop: "atop",
+      dest: "dest",
+      "dest-over": "dest-over",
+      "dest-in": "dest-in",
+      "dest-out": "dest-out",
+      "dest-atop": "dest-atop",
+      xor: "xor",
+      add: "add",
+      saturate: "saturate",
+      multiply: "multiply",
+      screen: "screen",
+      overlay: "overlay",
+      darken: "darken",
+      lighten: "lighten",
+      "colour-dodge": "colour-dodge",
+      "color-dodge": "colour-dodge",
+      "colour-burn": "colour-burn",
+      "color-burn": "colour-burn",
+      "hard-light": "hard-light",
+      "soft-light": "soft-light",
+      difference: "difference",
+      exclusion: "exclusion"
+    };
+    function composite(images) {
+      if (!Array.isArray(images))
+        throw is4.invalidParameterError("images to composite", "array", images);
+      return this.options.composite = images.map((image2) => {
+        if (!is4.object(image2))
+          throw is4.invalidParameterError("image to composite", "object", image2);
+        let inputOptions = this._inputOptionsFromObject(image2), composite2 = {
+          input: this._createInputDescriptor(image2.input, inputOptions, { allowStream: !1 }),
+          blend: "over",
+          tile: !1,
+          left: 0,
+          top: 0,
+          hasOffset: !1,
+          gravity: 0,
+          premultiplied: !1
+        };
+        if (is4.defined(image2.blend))
+          if (is4.string(blend[image2.blend]))
+            composite2.blend = blend[image2.blend];
+          else
+            throw is4.invalidParameterError("blend", "valid blend name", image2.blend);
+        if (is4.defined(image2.tile))
+          if (is4.bool(image2.tile))
+            composite2.tile = image2.tile;
+          else
+            throw is4.invalidParameterError("tile", "boolean", image2.tile);
+        if (is4.defined(image2.left))
+          if (is4.integer(image2.left))
+            composite2.left = image2.left;
+          else
+            throw is4.invalidParameterError("left", "integer", image2.left);
+        if (is4.defined(image2.top))
+          if (is4.integer(image2.top))
+            composite2.top = image2.top;
+          else
+            throw is4.invalidParameterError("top", "integer", image2.top);
+        if (is4.defined(image2.top) !== is4.defined(image2.left))
+          throw new Error("Expected both left and top to be set");
+        if (composite2.hasOffset = is4.integer(image2.top) && is4.integer(image2.left), is4.defined(image2.gravity))
+          if (is4.integer(image2.gravity) && is4.inRange(image2.gravity, 0, 8))
+            composite2.gravity = image2.gravity;
+          else if (is4.string(image2.gravity) && is4.integer(this.constructor.gravity[image2.gravity]))
+            composite2.gravity = this.constructor.gravity[image2.gravity];
+          else
+            throw is4.invalidParameterError("gravity", "valid gravity", image2.gravity);
+        if (is4.defined(image2.premultiplied))
+          if (is4.bool(image2.premultiplied))
+            composite2.premultiplied = image2.premultiplied;
+          else
+            throw is4.invalidParameterError("premultiplied", "boolean", image2.premultiplied);
+        return composite2;
+      }), this;
+    }
+    module2.exports = function(Sharp) {
+      Sharp.prototype.composite = composite, Sharp.blend = blend;
+    };
+  }
+});
+
+// ../../node_modules/sharp/lib/operation.js
+var require_operation = __commonJS({
+  "../../node_modules/sharp/lib/operation.js"(exports2, module2) {
+    "use strict";
+    var color4 = require_color(), is4 = require_is(), vipsPrecision = {
+      integer: "integer",
+      float: "float",
+      approximate: "approximate"
+    };
+    function rotate(angle, options2) {
+      if ((this.options.useExifOrientation || this.options.angle || this.options.rotationAngle) && this.options.debuglog("ignoring previous rotate options"), !is4.defined(angle))
+        this.options.useExifOrientation = !0;
+      else if (is4.integer(angle) && !(angle % 90))
+        this.options.angle = angle;
+      else if (is4.number(angle)) {
+        if (this.options.rotationAngle = angle, is4.object(options2) && options2.background) {
+          let backgroundColour = color4(options2.background);
+          this.options.rotationBackground = [
+            backgroundColour.red(),
+            backgroundColour.green(),
+            backgroundColour.blue(),
+            Math.round(backgroundColour.alpha() * 255)
+          ];
+        }
+      } else
+        throw is4.invalidParameterError("angle", "numeric", angle);
+      return this;
+    }
+    function flip(flip2) {
+      return this.options.flip = is4.bool(flip2) ? flip2 : !0, this;
+    }
+    function flop(flop2) {
+      return this.options.flop = is4.bool(flop2) ? flop2 : !0, this;
+    }
+    function affine(matrix, options2) {
+      let flatMatrix = [].concat(...matrix);
+      if (flatMatrix.length === 4 && flatMatrix.every(is4.number))
+        this.options.affineMatrix = flatMatrix;
+      else
+        throw is4.invalidParameterError("matrix", "1x4 or 2x2 array", matrix);
+      if (is4.defined(options2))
+        if (is4.object(options2)) {
+          if (this._setBackgroundColourOption("affineBackground", options2.background), is4.defined(options2.idx))
+            if (is4.number(options2.idx))
+              this.options.affineIdx = options2.idx;
+            else
+              throw is4.invalidParameterError("options.idx", "number", options2.idx);
+          if (is4.defined(options2.idy))
+            if (is4.number(options2.idy))
+              this.options.affineIdy = options2.idy;
+            else
+              throw is4.invalidParameterError("options.idy", "number", options2.idy);
+          if (is4.defined(options2.odx))
+            if (is4.number(options2.odx))
+              this.options.affineOdx = options2.odx;
+            else
+              throw is4.invalidParameterError("options.odx", "number", options2.odx);
+          if (is4.defined(options2.ody))
+            if (is4.number(options2.ody))
+              this.options.affineOdy = options2.ody;
+            else
+              throw is4.invalidParameterError("options.ody", "number", options2.ody);
+          if (is4.defined(options2.interpolator))
+            if (is4.inArray(options2.interpolator, Object.values(this.constructor.interpolators)))
+              this.options.affineInterpolator = options2.interpolator;
+            else
+              throw is4.invalidParameterError("options.interpolator", "valid interpolator name", options2.interpolator);
+        } else
+          throw is4.invalidParameterError("options", "object", options2);
+      return this;
+    }
+    function sharpen(options2, flat, jagged) {
+      if (!is4.defined(options2))
+        this.options.sharpenSigma = -1;
+      else if (is4.bool(options2))
+        this.options.sharpenSigma = options2 ? -1 : 0;
+      else if (is4.number(options2) && is4.inRange(options2, 0.01, 1e4)) {
+        if (this.options.sharpenSigma = options2, is4.defined(flat))
+          if (is4.number(flat) && is4.inRange(flat, 0, 1e4))
+            this.options.sharpenM1 = flat;
+          else
+            throw is4.invalidParameterError("flat", "number between 0 and 10000", flat);
+        if (is4.defined(jagged))
+          if (is4.number(jagged) && is4.inRange(jagged, 0, 1e4))
+            this.options.sharpenM2 = jagged;
+          else
+            throw is4.invalidParameterError("jagged", "number between 0 and 10000", jagged);
+      } else if (is4.plainObject(options2)) {
+        if (is4.number(options2.sigma) && is4.inRange(options2.sigma, 1e-6, 10))
+          this.options.sharpenSigma = options2.sigma;
+        else
+          throw is4.invalidParameterError("options.sigma", "number between 0.000001 and 10", options2.sigma);
+        if (is4.defined(options2.m1))
+          if (is4.number(options2.m1) && is4.inRange(options2.m1, 0, 1e6))
+            this.options.sharpenM1 = options2.m1;
+          else
+            throw is4.invalidParameterError("options.m1", "number between 0 and 1000000", options2.m1);
+        if (is4.defined(options2.m2))
+          if (is4.number(options2.m2) && is4.inRange(options2.m2, 0, 1e6))
+            this.options.sharpenM2 = options2.m2;
+          else
+            throw is4.invalidParameterError("options.m2", "number between 0 and 1000000", options2.m2);
+        if (is4.defined(options2.x1))
+          if (is4.number(options2.x1) && is4.inRange(options2.x1, 0, 1e6))
+            this.options.sharpenX1 = options2.x1;
+          else
+            throw is4.invalidParameterError("options.x1", "number between 0 and 1000000", options2.x1);
+        if (is4.defined(options2.y2))
+          if (is4.number(options2.y2) && is4.inRange(options2.y2, 0, 1e6))
+            this.options.sharpenY2 = options2.y2;
+          else
+            throw is4.invalidParameterError("options.y2", "number between 0 and 1000000", options2.y2);
+        if (is4.defined(options2.y3))
+          if (is4.number(options2.y3) && is4.inRange(options2.y3, 0, 1e6))
+            this.options.sharpenY3 = options2.y3;
+          else
+            throw is4.invalidParameterError("options.y3", "number between 0 and 1000000", options2.y3);
+      } else
+        throw is4.invalidParameterError("sigma", "number between 0.01 and 10000", options2);
+      return this;
+    }
+    function median(size) {
+      if (!is4.defined(size))
+        this.options.medianSize = 3;
+      else if (is4.integer(size) && is4.inRange(size, 1, 1e3))
+        this.options.medianSize = size;
+      else
+        throw is4.invalidParameterError("size", "integer between 1 and 1000", size);
+      return this;
+    }
+    function blur(options2) {
+      let sigma;
+      if (is4.number(options2))
+        sigma = options2;
+      else if (is4.plainObject(options2)) {
+        if (!is4.number(options2.sigma))
+          throw is4.invalidParameterError("options.sigma", "number between 0.3 and 1000", sigma);
+        if (sigma = options2.sigma, "precision" in options2)
+          if (is4.string(vipsPrecision[options2.precision]))
+            this.options.precision = vipsPrecision[options2.precision];
+          else
+            throw is4.invalidParameterError("precision", "one of: integer, float, approximate", options2.precision);
+        if ("minAmplitude" in options2)
+          if (is4.number(options2.minAmplitude) && is4.inRange(options2.minAmplitude, 1e-3, 1))
+            this.options.minAmpl = options2.minAmplitude;
+          else
+            throw is4.invalidParameterError("minAmplitude", "number between 0.001 and 1", options2.minAmplitude);
+      }
+      if (!is4.defined(options2))
+        this.options.blurSigma = -1;
+      else if (is4.bool(options2))
+        this.options.blurSigma = options2 ? -1 : 0;
+      else if (is4.number(sigma) && is4.inRange(sigma, 0.3, 1e3))
+        this.options.blurSigma = sigma;
+      else
+        throw is4.invalidParameterError("sigma", "number between 0.3 and 1000", sigma);
+      return this;
+    }
+    function flatten(options2) {
+      return this.options.flatten = is4.bool(options2) ? options2 : !0, is4.object(options2) && this._setBackgroundColourOption("flattenBackground", options2.background), this;
+    }
+    function unflatten() {
+      return this.options.unflatten = !0, this;
+    }
+    function gamma(gamma2, gammaOut) {
+      if (!is4.defined(gamma2))
+        this.options.gamma = 2.2;
+      else if (is4.number(gamma2) && is4.inRange(gamma2, 1, 3))
+        this.options.gamma = gamma2;
+      else
+        throw is4.invalidParameterError("gamma", "number between 1.0 and 3.0", gamma2);
+      if (!is4.defined(gammaOut))
+        this.options.gammaOut = this.options.gamma;
+      else if (is4.number(gammaOut) && is4.inRange(gammaOut, 1, 3))
+        this.options.gammaOut = gammaOut;
+      else
+        throw is4.invalidParameterError("gammaOut", "number between 1.0 and 3.0", gammaOut);
+      return this;
+    }
+    function negate(options2) {
+      if (this.options.negate = is4.bool(options2) ? options2 : !0, is4.plainObject(options2) && "alpha" in options2)
+        if (is4.bool(options2.alpha))
+          this.options.negateAlpha = options2.alpha;
+        else
+          throw is4.invalidParameterError("alpha", "should be boolean value", options2.alpha);
+      return this;
+    }
+    function normalise(options2) {
+      if (is4.plainObject(options2)) {
+        if (is4.defined(options2.lower))
+          if (is4.number(options2.lower) && is4.inRange(options2.lower, 0, 99))
+            this.options.normaliseLower = options2.lower;
+          else
+            throw is4.invalidParameterError("lower", "number between 0 and 99", options2.lower);
+        if (is4.defined(options2.upper))
+          if (is4.number(options2.upper) && is4.inRange(options2.upper, 1, 100))
+            this.options.normaliseUpper = options2.upper;
+          else
+            throw is4.invalidParameterError("upper", "number between 1 and 100", options2.upper);
+      }
+      if (this.options.normaliseLower >= this.options.normaliseUpper)
+        throw is4.invalidParameterError(
+          "range",
+          "lower to be less than upper",
+          `${this.options.normaliseLower} >= ${this.options.normaliseUpper}`
+        );
+      return this.options.normalise = !0, this;
+    }
+    function normalize2(options2) {
+      return this.normalise(options2);
+    }
+    function clahe(options2) {
+      if (is4.plainObject(options2)) {
+        if (is4.integer(options2.width) && options2.width > 0)
+          this.options.claheWidth = options2.width;
+        else
+          throw is4.invalidParameterError("width", "integer greater than zero", options2.width);
+        if (is4.integer(options2.height) && options2.height > 0)
+          this.options.claheHeight = options2.height;
+        else
+          throw is4.invalidParameterError("height", "integer greater than zero", options2.height);
+        if (is4.defined(options2.maxSlope))
+          if (is4.integer(options2.maxSlope) && is4.inRange(options2.maxSlope, 0, 100))
+            this.options.claheMaxSlope = options2.maxSlope;
+          else
+            throw is4.invalidParameterError("maxSlope", "integer between 0 and 100", options2.maxSlope);
+      } else
+        throw is4.invalidParameterError("options", "plain object", options2);
+      return this;
+    }
+    function convolve(kernel) {
+      if (!is4.object(kernel) || !Array.isArray(kernel.kernel) || !is4.integer(kernel.width) || !is4.integer(kernel.height) || !is4.inRange(kernel.width, 3, 1001) || !is4.inRange(kernel.height, 3, 1001) || kernel.height * kernel.width !== kernel.kernel.length)
+        throw new Error("Invalid convolution kernel");
+      return is4.integer(kernel.scale) || (kernel.scale = kernel.kernel.reduce(function(a, b) {
+        return a + b;
+      }, 0)), kernel.scale < 1 && (kernel.scale = 1), is4.integer(kernel.offset) || (kernel.offset = 0), this.options.convKernel = kernel, this;
+    }
+    function threshold(threshold2, options2) {
+      if (!is4.defined(threshold2))
+        this.options.threshold = 128;
+      else if (is4.bool(threshold2))
+        this.options.threshold = threshold2 ? 128 : 0;
+      else if (is4.integer(threshold2) && is4.inRange(threshold2, 0, 255))
+        this.options.threshold = threshold2;
+      else
+        throw is4.invalidParameterError("threshold", "integer between 0 and 255", threshold2);
+      return !is4.object(options2) || options2.greyscale === !0 || options2.grayscale === !0 ? this.options.thresholdGrayscale = !0 : this.options.thresholdGrayscale = !1, this;
+    }
+    function boolean2(operand, operator, options2) {
+      if (this.options.boolean = this._createInputDescriptor(operand, options2), is4.string(operator) && is4.inArray(operator, ["and", "or", "eor"]))
+        this.options.booleanOp = operator;
+      else
+        throw is4.invalidParameterError("operator", "one of: and, or, eor", operator);
+      return this;
+    }
+    function linear(a, b) {
+      if (!is4.defined(a) && is4.number(b) ? a = 1 : is4.number(a) && !is4.defined(b) && (b = 0), !is4.defined(a))
+        this.options.linearA = [];
+      else if (is4.number(a))
+        this.options.linearA = [a];
+      else if (Array.isArray(a) && a.length && a.every(is4.number))
+        this.options.linearA = a;
+      else
+        throw is4.invalidParameterError("a", "number or array of numbers", a);
+      if (!is4.defined(b))
+        this.options.linearB = [];
+      else if (is4.number(b))
+        this.options.linearB = [b];
+      else if (Array.isArray(b) && b.length && b.every(is4.number))
+        this.options.linearB = b;
+      else
+        throw is4.invalidParameterError("b", "number or array of numbers", b);
+      if (this.options.linearA.length !== this.options.linearB.length)
+        throw new Error("Expected a and b to be arrays of the same length");
+      return this;
+    }
+    function recomb(inputMatrix) {
+      if (!Array.isArray(inputMatrix))
+        throw is4.invalidParameterError("inputMatrix", "array", inputMatrix);
+      if (inputMatrix.length !== 3 && inputMatrix.length !== 4)
+        throw is4.invalidParameterError("inputMatrix", "3x3 or 4x4 array", inputMatrix.length);
+      let recombMatrix = inputMatrix.flat().map(Number);
+      if (recombMatrix.length !== 9 && recombMatrix.length !== 16)
+        throw is4.invalidParameterError("inputMatrix", "cardinality of 9 or 16", recombMatrix.length);
+      return this.options.recombMatrix = recombMatrix, this;
+    }
+    function modulate(options2) {
+      if (!is4.plainObject(options2))
+        throw is4.invalidParameterError("options", "plain object", options2);
+      if ("brightness" in options2)
+        if (is4.number(options2.brightness) && options2.brightness >= 0)
+          this.options.brightness = options2.brightness;
+        else
+          throw is4.invalidParameterError("brightness", "number above zero", options2.brightness);
+      if ("saturation" in options2)
+        if (is4.number(options2.saturation) && options2.saturation >= 0)
+          this.options.saturation = options2.saturation;
+        else
+          throw is4.invalidParameterError("saturation", "number above zero", options2.saturation);
+      if ("hue" in options2)
+        if (is4.integer(options2.hue))
+          this.options.hue = options2.hue % 360;
+        else
+          throw is4.invalidParameterError("hue", "number", options2.hue);
+      if ("lightness" in options2)
+        if (is4.number(options2.lightness))
+          this.options.lightness = options2.lightness;
+        else
+          throw is4.invalidParameterError("lightness", "number", options2.lightness);
+      return this;
+    }
+    module2.exports = function(Sharp) {
+      Object.assign(Sharp.prototype, {
+        rotate,
+        flip,
+        flop,
+        affine,
+        sharpen,
+        median,
+        blur,
+        flatten,
+        unflatten,
+        gamma,
+        negate,
+        normalise,
+        normalize: normalize2,
+        clahe,
+        convolve,
+        threshold,
+        boolean: boolean2,
+        linear,
+        recomb,
+        modulate
+      });
+    };
+  }
+});
+
+// ../../node_modules/sharp/lib/colour.js
+var require_colour = __commonJS({
+  "../../node_modules/sharp/lib/colour.js"(exports2, module2) {
+    "use strict";
+    var color4 = require_color(), is4 = require_is(), colourspace = {
+      multiband: "multiband",
+      "b-w": "b-w",
+      bw: "b-w",
+      cmyk: "cmyk",
+      srgb: "srgb"
+    };
+    function tint(tint2) {
+      return this._setBackgroundColourOption("tint", tint2), this;
+    }
+    function greyscale(greyscale2) {
+      return this.options.greyscale = is4.bool(greyscale2) ? greyscale2 : !0, this;
+    }
+    function grayscale(grayscale2) {
+      return this.greyscale(grayscale2);
+    }
+    function pipelineColourspace(colourspace2) {
+      if (!is4.string(colourspace2))
+        throw is4.invalidParameterError("colourspace", "string", colourspace2);
+      return this.options.colourspacePipeline = colourspace2, this;
+    }
+    function pipelineColorspace(colorspace) {
+      return this.pipelineColourspace(colorspace);
+    }
+    function toColourspace(colourspace2) {
+      if (!is4.string(colourspace2))
+        throw is4.invalidParameterError("colourspace", "string", colourspace2);
+      return this.options.colourspace = colourspace2, this;
+    }
+    function toColorspace(colorspace) {
+      return this.toColourspace(colorspace);
+    }
+    function _setBackgroundColourOption(key2, value) {
+      if (is4.defined(value))
+        if (is4.object(value) || is4.string(value)) {
+          let colour = color4(value);
+          this.options[key2] = [
+            colour.red(),
+            colour.green(),
+            colour.blue(),
+            Math.round(colour.alpha() * 255)
+          ];
+        } else
+          throw is4.invalidParameterError("background", "object or string", value);
+    }
+    module2.exports = function(Sharp) {
+      Object.assign(Sharp.prototype, {
+        // Public
+        tint,
+        greyscale,
+        grayscale,
+        pipelineColourspace,
+        pipelineColorspace,
+        toColourspace,
+        toColorspace,
+        // Private
+        _setBackgroundColourOption
+      }), Sharp.colourspace = colourspace, Sharp.colorspace = colourspace;
+    };
+  }
+});
+
+// ../../node_modules/sharp/lib/channel.js
+var require_channel = __commonJS({
+  "../../node_modules/sharp/lib/channel.js"(exports2, module2) {
+    "use strict";
+    var is4 = require_is(), bool = {
+      and: "and",
+      or: "or",
+      eor: "eor"
+    };
+    function removeAlpha() {
+      return this.options.removeAlpha = !0, this;
+    }
+    function ensureAlpha(alpha) {
+      if (is4.defined(alpha))
+        if (is4.number(alpha) && is4.inRange(alpha, 0, 1))
+          this.options.ensureAlpha = alpha;
+        else
+          throw is4.invalidParameterError("alpha", "number between 0 and 1", alpha);
+      else
+        this.options.ensureAlpha = 1;
+      return this;
+    }
+    function extractChannel(channel) {
+      let channelMap = { red: 0, green: 1, blue: 2, alpha: 3 };
+      if (Object.keys(channelMap).includes(channel) && (channel = channelMap[channel]), is4.integer(channel) && is4.inRange(channel, 0, 4))
+        this.options.extractChannel = channel;
+      else
+        throw is4.invalidParameterError("channel", "integer or one of: red, green, blue, alpha", channel);
+      return this;
+    }
+    function joinChannel(images, options2) {
+      return Array.isArray(images) ? images.forEach(function(image2) {
+        this.options.joinChannelIn.push(this._createInputDescriptor(image2, options2));
+      }, this) : this.options.joinChannelIn.push(this._createInputDescriptor(images, options2)), this;
+    }
+    function bandbool(boolOp) {
+      if (is4.string(boolOp) && is4.inArray(boolOp, ["and", "or", "eor"]))
+        this.options.bandBoolOp = boolOp;
+      else
+        throw is4.invalidParameterError("boolOp", "one of: and, or, eor", boolOp);
+      return this;
+    }
+    module2.exports = function(Sharp) {
+      Object.assign(Sharp.prototype, {
+        // Public instance functions
+        removeAlpha,
+        ensureAlpha,
+        extractChannel,
+        joinChannel,
+        bandbool
+      }), Sharp.bool = bool;
+    };
+  }
+});
+
+// ../../node_modules/sharp/lib/output.js
+var require_output = __commonJS({
+  "../../node_modules/sharp/lib/output.js"(exports2, module2) {
+    "use strict";
+    var path5 = require("node:path"), is4 = require_is(), sharp = require_sharp(), formats = /* @__PURE__ */ new Map([
+      ["heic", "heif"],
+      ["heif", "heif"],
+      ["avif", "avif"],
+      ["jpeg", "jpeg"],
+      ["jpg", "jpeg"],
+      ["jpe", "jpeg"],
+      ["tile", "tile"],
+      ["dz", "tile"],
+      ["png", "png"],
+      ["raw", "raw"],
+      ["tiff", "tiff"],
+      ["tif", "tiff"],
+      ["webp", "webp"],
+      ["gif", "gif"],
+      ["jp2", "jp2"],
+      ["jpx", "jp2"],
+      ["j2k", "jp2"],
+      ["j2c", "jp2"],
+      ["jxl", "jxl"]
+    ]), jp2Regex = /\.(jp[2x]|j2[kc])$/i, errJp2Save = () => new Error("JP2 output requires libvips with support for OpenJPEG"), bitdepthFromColourCount = (colours) => 1 << 31 - Math.clz32(Math.ceil(Math.log2(colours)));
+    function toFile(fileOut, callback) {
+      let err;
+      if (is4.string(fileOut) ? is4.string(this.options.input.file) && path5.resolve(this.options.input.file) === path5.resolve(fileOut) ? err = new Error("Cannot use same file for input and output") : jp2Regex.test(path5.extname(fileOut)) && !this.constructor.format.jp2k.output.file && (err = errJp2Save()) : err = new Error("Missing output file path"), err)
+        if (is4.fn(callback))
+          callback(err);
+        else
+          return Promise.reject(err);
+      else {
+        this.options.fileOut = fileOut;
+        let stack = Error();
+        return this._pipeline(callback, stack);
+      }
+      return this;
+    }
+    function toBuffer(options2, callback) {
+      is4.object(options2) ? this._setBooleanOption("resolveWithObject", options2.resolveWithObject) : this.options.resolveWithObject && (this.options.resolveWithObject = !1), this.options.fileOut = "";
+      let stack = Error();
+      return this._pipeline(is4.fn(options2) ? options2 : callback, stack);
+    }
+    function keepExif() {
+      return this.options.keepMetadata |= 1, this;
+    }
+    function withExif(exif) {
+      if (is4.object(exif))
+        for (let [ifd, entries] of Object.entries(exif))
+          if (is4.object(entries))
+            for (let [k, v] of Object.entries(entries))
+              if (is4.string(v))
+                this.options.withExif[`exif-${ifd.toLowerCase()}-${k}`] = v;
+              else
+                throw is4.invalidParameterError(`${ifd}.${k}`, "string", v);
+          else
+            throw is4.invalidParameterError(ifd, "object", entries);
+      else
+        throw is4.invalidParameterError("exif", "object", exif);
+      return this.options.withExifMerge = !1, this.keepExif();
+    }
+    function withExifMerge(exif) {
+      return this.withExif(exif), this.options.withExifMerge = !0, this;
+    }
+    function keepIccProfile() {
+      return this.options.keepMetadata |= 8, this;
+    }
+    function withIccProfile(icc, options2) {
+      if (is4.string(icc))
+        this.options.withIccProfile = icc;
+      else
+        throw is4.invalidParameterError("icc", "string", icc);
+      if (this.keepIccProfile(), is4.object(options2) && is4.defined(options2.attach))
+        if (is4.bool(options2.attach))
+          options2.attach || (this.options.keepMetadata &= -9);
+        else
+          throw is4.invalidParameterError("attach", "boolean", options2.attach);
+      return this;
+    }
+    function keepMetadata() {
+      return this.options.keepMetadata = 31, this;
+    }
+    function withMetadata(options2) {
+      if (this.keepMetadata(), this.withIccProfile("srgb"), is4.object(options2)) {
+        if (is4.defined(options2.orientation))
+          if (is4.integer(options2.orientation) && is4.inRange(options2.orientation, 1, 8))
+            this.options.withMetadataOrientation = options2.orientation;
+          else
+            throw is4.invalidParameterError("orientation", "integer between 1 and 8", options2.orientation);
+        if (is4.defined(options2.density))
+          if (is4.number(options2.density) && options2.density > 0)
+            this.options.withMetadataDensity = options2.density;
+          else
+            throw is4.invalidParameterError("density", "positive number", options2.density);
+        is4.defined(options2.icc) && this.withIccProfile(options2.icc), is4.defined(options2.exif) && this.withExifMerge(options2.exif);
+      }
+      return this;
+    }
+    function toFormat(format, options2) {
+      let actualFormat = formats.get((is4.object(format) && is4.string(format.id) ? format.id : format).toLowerCase());
+      if (!actualFormat)
+        throw is4.invalidParameterError("format", `one of: ${[...formats.keys()].join(", ")}`, format);
+      return this[actualFormat](options2);
+    }
+    function jpeg(options2) {
+      if (is4.object(options2)) {
+        if (is4.defined(options2.quality))
+          if (is4.integer(options2.quality) && is4.inRange(options2.quality, 1, 100))
+            this.options.jpegQuality = options2.quality;
+          else
+            throw is4.invalidParameterError("quality", "integer between 1 and 100", options2.quality);
+        if (is4.defined(options2.progressive) && this._setBooleanOption("jpegProgressive", options2.progressive), is4.defined(options2.chromaSubsampling))
+          if (is4.string(options2.chromaSubsampling) && is4.inArray(options2.chromaSubsampling, ["4:2:0", "4:4:4"]))
+            this.options.jpegChromaSubsampling = options2.chromaSubsampling;
+          else
+            throw is4.invalidParameterError("chromaSubsampling", "one of: 4:2:0, 4:4:4", options2.chromaSubsampling);
+        let optimiseCoding = is4.bool(options2.optimizeCoding) ? options2.optimizeCoding : options2.optimiseCoding;
+        if (is4.defined(optimiseCoding) && this._setBooleanOption("jpegOptimiseCoding", optimiseCoding), is4.defined(options2.mozjpeg))
+          if (is4.bool(options2.mozjpeg))
+            options2.mozjpeg && (this.options.jpegTrellisQuantisation = !0, this.options.jpegOvershootDeringing = !0, this.options.jpegOptimiseScans = !0, this.options.jpegProgressive = !0, this.options.jpegQuantisationTable = 3);
+          else
+            throw is4.invalidParameterError("mozjpeg", "boolean", options2.mozjpeg);
+        let trellisQuantisation = is4.bool(options2.trellisQuantization) ? options2.trellisQuantization : options2.trellisQuantisation;
+        is4.defined(trellisQuantisation) && this._setBooleanOption("jpegTrellisQuantisation", trellisQuantisation), is4.defined(options2.overshootDeringing) && this._setBooleanOption("jpegOvershootDeringing", options2.overshootDeringing);
+        let optimiseScans = is4.bool(options2.optimizeScans) ? options2.optimizeScans : options2.optimiseScans;
+        is4.defined(optimiseScans) && (this._setBooleanOption("jpegOptimiseScans", optimiseScans), optimiseScans && (this.options.jpegProgressive = !0));
+        let quantisationTable = is4.number(options2.quantizationTable) ? options2.quantizationTable : options2.quantisationTable;
+        if (is4.defined(quantisationTable))
+          if (is4.integer(quantisationTable) && is4.inRange(quantisationTable, 0, 8))
+            this.options.jpegQuantisationTable = quantisationTable;
+          else
+            throw is4.invalidParameterError("quantisationTable", "integer between 0 and 8", quantisationTable);
+      }
+      return this._updateFormatOut("jpeg", options2);
+    }
+    function png(options2) {
+      if (is4.object(options2)) {
+        if (is4.defined(options2.progressive) && this._setBooleanOption("pngProgressive", options2.progressive), is4.defined(options2.compressionLevel))
+          if (is4.integer(options2.compressionLevel) && is4.inRange(options2.compressionLevel, 0, 9))
+            this.options.pngCompressionLevel = options2.compressionLevel;
+          else
+            throw is4.invalidParameterError("compressionLevel", "integer between 0 and 9", options2.compressionLevel);
+        is4.defined(options2.adaptiveFiltering) && this._setBooleanOption("pngAdaptiveFiltering", options2.adaptiveFiltering);
+        let colours = options2.colours || options2.colors;
+        if (is4.defined(colours))
+          if (is4.integer(colours) && is4.inRange(colours, 2, 256))
+            this.options.pngBitdepth = bitdepthFromColourCount(colours);
+          else
+            throw is4.invalidParameterError("colours", "integer between 2 and 256", colours);
+        if (is4.defined(options2.palette) ? this._setBooleanOption("pngPalette", options2.palette) : [options2.quality, options2.effort, options2.colours, options2.colors, options2.dither].some(is4.defined) && this._setBooleanOption("pngPalette", !0), this.options.pngPalette) {
+          if (is4.defined(options2.quality))
+            if (is4.integer(options2.quality) && is4.inRange(options2.quality, 0, 100))
+              this.options.pngQuality = options2.quality;
+            else
+              throw is4.invalidParameterError("quality", "integer between 0 and 100", options2.quality);
+          if (is4.defined(options2.effort))
+            if (is4.integer(options2.effort) && is4.inRange(options2.effort, 1, 10))
+              this.options.pngEffort = options2.effort;
+            else
+              throw is4.invalidParameterError("effort", "integer between 1 and 10", options2.effort);
+          if (is4.defined(options2.dither))
+            if (is4.number(options2.dither) && is4.inRange(options2.dither, 0, 1))
+              this.options.pngDither = options2.dither;
+            else
+              throw is4.invalidParameterError("dither", "number between 0.0 and 1.0", options2.dither);
+        }
+      }
+      return this._updateFormatOut("png", options2);
+    }
+    function webp(options2) {
+      if (is4.object(options2)) {
+        if (is4.defined(options2.quality))
+          if (is4.integer(options2.quality) && is4.inRange(options2.quality, 1, 100))
+            this.options.webpQuality = options2.quality;
+          else
+            throw is4.invalidParameterError("quality", "integer between 1 and 100", options2.quality);
+        if (is4.defined(options2.alphaQuality))
+          if (is4.integer(options2.alphaQuality) && is4.inRange(options2.alphaQuality, 0, 100))
+            this.options.webpAlphaQuality = options2.alphaQuality;
+          else
+            throw is4.invalidParameterError("alphaQuality", "integer between 0 and 100", options2.alphaQuality);
+        if (is4.defined(options2.lossless) && this._setBooleanOption("webpLossless", options2.lossless), is4.defined(options2.nearLossless) && this._setBooleanOption("webpNearLossless", options2.nearLossless), is4.defined(options2.smartSubsample) && this._setBooleanOption("webpSmartSubsample", options2.smartSubsample), is4.defined(options2.preset))
+          if (is4.string(options2.preset) && is4.inArray(options2.preset, ["default", "photo", "picture", "drawing", "icon", "text"]))
+            this.options.webpPreset = options2.preset;
+          else
+            throw is4.invalidParameterError("preset", "one of: default, photo, picture, drawing, icon, text", options2.preset);
+        if (is4.defined(options2.effort))
+          if (is4.integer(options2.effort) && is4.inRange(options2.effort, 0, 6))
+            this.options.webpEffort = options2.effort;
+          else
+            throw is4.invalidParameterError("effort", "integer between 0 and 6", options2.effort);
+        is4.defined(options2.minSize) && this._setBooleanOption("webpMinSize", options2.minSize), is4.defined(options2.mixed) && this._setBooleanOption("webpMixed", options2.mixed);
+      }
+      return trySetAnimationOptions(options2, this.options), this._updateFormatOut("webp", options2);
+    }
+    function gif(options2) {
+      if (is4.object(options2)) {
+        is4.defined(options2.reuse) && this._setBooleanOption("gifReuse", options2.reuse), is4.defined(options2.progressive) && this._setBooleanOption("gifProgressive", options2.progressive);
+        let colours = options2.colours || options2.colors;
+        if (is4.defined(colours))
+          if (is4.integer(colours) && is4.inRange(colours, 2, 256))
+            this.options.gifBitdepth = bitdepthFromColourCount(colours);
+          else
+            throw is4.invalidParameterError("colours", "integer between 2 and 256", colours);
+        if (is4.defined(options2.effort))
+          if (is4.number(options2.effort) && is4.inRange(options2.effort, 1, 10))
+            this.options.gifEffort = options2.effort;
+          else
+            throw is4.invalidParameterError("effort", "integer between 1 and 10", options2.effort);
+        if (is4.defined(options2.dither))
+          if (is4.number(options2.dither) && is4.inRange(options2.dither, 0, 1))
+            this.options.gifDither = options2.dither;
+          else
+            throw is4.invalidParameterError("dither", "number between 0.0 and 1.0", options2.dither);
+        if (is4.defined(options2.interFrameMaxError))
+          if (is4.number(options2.interFrameMaxError) && is4.inRange(options2.interFrameMaxError, 0, 32))
+            this.options.gifInterFrameMaxError = options2.interFrameMaxError;
+          else
+            throw is4.invalidParameterError("interFrameMaxError", "number between 0.0 and 32.0", options2.interFrameMaxError);
+        if (is4.defined(options2.interPaletteMaxError))
+          if (is4.number(options2.interPaletteMaxError) && is4.inRange(options2.interPaletteMaxError, 0, 256))
+            this.options.gifInterPaletteMaxError = options2.interPaletteMaxError;
+          else
+            throw is4.invalidParameterError("interPaletteMaxError", "number between 0.0 and 256.0", options2.interPaletteMaxError);
+      }
+      return trySetAnimationOptions(options2, this.options), this._updateFormatOut("gif", options2);
+    }
+    function jp2(options2) {
+      if (!this.constructor.format.jp2k.output.buffer)
+        throw errJp2Save();
+      if (is4.object(options2)) {
+        if (is4.defined(options2.quality))
+          if (is4.integer(options2.quality) && is4.inRange(options2.quality, 1, 100))
+            this.options.jp2Quality = options2.quality;
+          else
+            throw is4.invalidParameterError("quality", "integer between 1 and 100", options2.quality);
+        if (is4.defined(options2.lossless))
+          if (is4.bool(options2.lossless))
+            this.options.jp2Lossless = options2.lossless;
+          else
+            throw is4.invalidParameterError("lossless", "boolean", options2.lossless);
+        if (is4.defined(options2.tileWidth))
+          if (is4.integer(options2.tileWidth) && is4.inRange(options2.tileWidth, 1, 32768))
+            this.options.jp2TileWidth = options2.tileWidth;
+          else
+            throw is4.invalidParameterError("tileWidth", "integer between 1 and 32768", options2.tileWidth);
+        if (is4.defined(options2.tileHeight))
+          if (is4.integer(options2.tileHeight) && is4.inRange(options2.tileHeight, 1, 32768))
+            this.options.jp2TileHeight = options2.tileHeight;
+          else
+            throw is4.invalidParameterError("tileHeight", "integer between 1 and 32768", options2.tileHeight);
+        if (is4.defined(options2.chromaSubsampling))
+          if (is4.string(options2.chromaSubsampling) && is4.inArray(options2.chromaSubsampling, ["4:2:0", "4:4:4"]))
+            this.options.jp2ChromaSubsampling = options2.chromaSubsampling;
+          else
+            throw is4.invalidParameterError("chromaSubsampling", "one of: 4:2:0, 4:4:4", options2.chromaSubsampling);
+      }
+      return this._updateFormatOut("jp2", options2);
+    }
+    function trySetAnimationOptions(source, target) {
+      if (is4.object(source) && is4.defined(source.loop))
+        if (is4.integer(source.loop) && is4.inRange(source.loop, 0, 65535))
+          target.loop = source.loop;
+        else
+          throw is4.invalidParameterError("loop", "integer between 0 and 65535", source.loop);
+      if (is4.object(source) && is4.defined(source.delay))
+        if (is4.integer(source.delay) && is4.inRange(source.delay, 0, 65535))
+          target.delay = [source.delay];
+        else if (Array.isArray(source.delay) && source.delay.every(is4.integer) && source.delay.every((v) => is4.inRange(v, 0, 65535)))
+          target.delay = source.delay;
+        else
+          throw is4.invalidParameterError("delay", "integer or an array of integers between 0 and 65535", source.delay);
+    }
+    function tiff(options2) {
+      if (is4.object(options2)) {
+        if (is4.defined(options2.quality))
+          if (is4.integer(options2.quality) && is4.inRange(options2.quality, 1, 100))
+            this.options.tiffQuality = options2.quality;
+          else
+            throw is4.invalidParameterError("quality", "integer between 1 and 100", options2.quality);
+        if (is4.defined(options2.bitdepth))
+          if (is4.integer(options2.bitdepth) && is4.inArray(options2.bitdepth, [1, 2, 4, 8]))
+            this.options.tiffBitdepth = options2.bitdepth;
+          else
+            throw is4.invalidParameterError("bitdepth", "1, 2, 4 or 8", options2.bitdepth);
+        if (is4.defined(options2.tile) && this._setBooleanOption("tiffTile", options2.tile), is4.defined(options2.tileWidth))
+          if (is4.integer(options2.tileWidth) && options2.tileWidth > 0)
+            this.options.tiffTileWidth = options2.tileWidth;
+          else
+            throw is4.invalidParameterError("tileWidth", "integer greater than zero", options2.tileWidth);
+        if (is4.defined(options2.tileHeight))
+          if (is4.integer(options2.tileHeight) && options2.tileHeight > 0)
+            this.options.tiffTileHeight = options2.tileHeight;
+          else
+            throw is4.invalidParameterError("tileHeight", "integer greater than zero", options2.tileHeight);
+        if (is4.defined(options2.miniswhite) && this._setBooleanOption("tiffMiniswhite", options2.miniswhite), is4.defined(options2.pyramid) && this._setBooleanOption("tiffPyramid", options2.pyramid), is4.defined(options2.xres))
+          if (is4.number(options2.xres) && options2.xres > 0)
+            this.options.tiffXres = options2.xres;
+          else
+            throw is4.invalidParameterError("xres", "number greater than zero", options2.xres);
+        if (is4.defined(options2.yres))
+          if (is4.number(options2.yres) && options2.yres > 0)
+            this.options.tiffYres = options2.yres;
+          else
+            throw is4.invalidParameterError("yres", "number greater than zero", options2.yres);
+        if (is4.defined(options2.compression))
+          if (is4.string(options2.compression) && is4.inArray(options2.compression, ["none", "jpeg", "deflate", "packbits", "ccittfax4", "lzw", "webp", "zstd", "jp2k"]))
+            this.options.tiffCompression = options2.compression;
+          else
+            throw is4.invalidParameterError("compression", "one of: none, jpeg, deflate, packbits, ccittfax4, lzw, webp, zstd, jp2k", options2.compression);
+        if (is4.defined(options2.predictor))
+          if (is4.string(options2.predictor) && is4.inArray(options2.predictor, ["none", "horizontal", "float"]))
+            this.options.tiffPredictor = options2.predictor;
+          else
+            throw is4.invalidParameterError("predictor", "one of: none, horizontal, float", options2.predictor);
+        if (is4.defined(options2.resolutionUnit))
+          if (is4.string(options2.resolutionUnit) && is4.inArray(options2.resolutionUnit, ["inch", "cm"]))
+            this.options.tiffResolutionUnit = options2.resolutionUnit;
+          else
+            throw is4.invalidParameterError("resolutionUnit", "one of: inch, cm", options2.resolutionUnit);
+      }
+      return this._updateFormatOut("tiff", options2);
+    }
+    function avif(options2) {
+      return this.heif({ ...options2, compression: "av1" });
+    }
+    function heif(options2) {
+      if (is4.object(options2)) {
+        if (is4.string(options2.compression) && is4.inArray(options2.compression, ["av1", "hevc"]))
+          this.options.heifCompression = options2.compression;
+        else
+          throw is4.invalidParameterError("compression", "one of: av1, hevc", options2.compression);
+        if (is4.defined(options2.quality))
+          if (is4.integer(options2.quality) && is4.inRange(options2.quality, 1, 100))
+            this.options.heifQuality = options2.quality;
+          else
+            throw is4.invalidParameterError("quality", "integer between 1 and 100", options2.quality);
+        if (is4.defined(options2.lossless))
+          if (is4.bool(options2.lossless))
+            this.options.heifLossless = options2.lossless;
+          else
+            throw is4.invalidParameterError("lossless", "boolean", options2.lossless);
+        if (is4.defined(options2.effort))
+          if (is4.integer(options2.effort) && is4.inRange(options2.effort, 0, 9))
+            this.options.heifEffort = options2.effort;
+          else
+            throw is4.invalidParameterError("effort", "integer between 0 and 9", options2.effort);
+        if (is4.defined(options2.chromaSubsampling))
+          if (is4.string(options2.chromaSubsampling) && is4.inArray(options2.chromaSubsampling, ["4:2:0", "4:4:4"]))
+            this.options.heifChromaSubsampling = options2.chromaSubsampling;
+          else
+            throw is4.invalidParameterError("chromaSubsampling", "one of: 4:2:0, 4:4:4", options2.chromaSubsampling);
+        if (is4.defined(options2.bitdepth))
+          if (is4.integer(options2.bitdepth) && is4.inArray(options2.bitdepth, [8, 10, 12])) {
+            if (options2.bitdepth !== 8 && this.constructor.versions.heif)
+              throw is4.invalidParameterError("bitdepth when using prebuilt binaries", 8, options2.bitdepth);
+            this.options.heifBitdepth = options2.bitdepth;
+          } else
+            throw is4.invalidParameterError("bitdepth", "8, 10 or 12", options2.bitdepth);
+      } else
+        throw is4.invalidParameterError("options", "Object", options2);
+      return this._updateFormatOut("heif", options2);
+    }
+    function jxl(options2) {
+      if (is4.object(options2)) {
+        if (is4.defined(options2.quality))
+          if (is4.integer(options2.quality) && is4.inRange(options2.quality, 1, 100))
+            this.options.jxlDistance = options2.quality >= 30 ? 0.1 + (100 - options2.quality) * 0.09 : 53 / 3e3 * options2.quality * options2.quality - 23 / 20 * options2.quality + 25;
+          else
+            throw is4.invalidParameterError("quality", "integer between 1 and 100", options2.quality);
+        else if (is4.defined(options2.distance))
+          if (is4.number(options2.distance) && is4.inRange(options2.distance, 0, 15))
+            this.options.jxlDistance = options2.distance;
+          else
+            throw is4.invalidParameterError("distance", "number between 0.0 and 15.0", options2.distance);
+        if (is4.defined(options2.decodingTier))
+          if (is4.integer(options2.decodingTier) && is4.inRange(options2.decodingTier, 0, 4))
+            this.options.jxlDecodingTier = options2.decodingTier;
+          else
+            throw is4.invalidParameterError("decodingTier", "integer between 0 and 4", options2.decodingTier);
+        if (is4.defined(options2.lossless))
+          if (is4.bool(options2.lossless))
+            this.options.jxlLossless = options2.lossless;
+          else
+            throw is4.invalidParameterError("lossless", "boolean", options2.lossless);
+        if (is4.defined(options2.effort))
+          if (is4.integer(options2.effort) && is4.inRange(options2.effort, 3, 9))
+            this.options.jxlEffort = options2.effort;
+          else
+            throw is4.invalidParameterError("effort", "integer between 3 and 9", options2.effort);
+      }
+      return this._updateFormatOut("jxl", options2);
+    }
+    function raw2(options2) {
+      if (is4.object(options2) && is4.defined(options2.depth))
+        if (is4.string(options2.depth) && is4.inArray(
+          options2.depth,
+          ["char", "uchar", "short", "ushort", "int", "uint", "float", "complex", "double", "dpcomplex"]
+        ))
+          this.options.rawDepth = options2.depth;
+        else
+          throw is4.invalidParameterError("depth", "one of: char, uchar, short, ushort, int, uint, float, complex, double, dpcomplex", options2.depth);
+      return this._updateFormatOut("raw");
+    }
+    function tile(options2) {
+      if (is4.object(options2)) {
+        if (is4.defined(options2.size))
+          if (is4.integer(options2.size) && is4.inRange(options2.size, 1, 8192))
+            this.options.tileSize = options2.size;
+          else
+            throw is4.invalidParameterError("size", "integer between 1 and 8192", options2.size);
+        if (is4.defined(options2.overlap))
+          if (is4.integer(options2.overlap) && is4.inRange(options2.overlap, 0, 8192)) {
+            if (options2.overlap > this.options.tileSize)
+              throw is4.invalidParameterError("overlap", `<= size (${this.options.tileSize})`, options2.overlap);
+            this.options.tileOverlap = options2.overlap;
+          } else
+            throw is4.invalidParameterError("overlap", "integer between 0 and 8192", options2.overlap);
+        if (is4.defined(options2.container))
+          if (is4.string(options2.container) && is4.inArray(options2.container, ["fs", "zip"]))
+            this.options.tileContainer = options2.container;
+          else
+            throw is4.invalidParameterError("container", "one of: fs, zip", options2.container);
+        if (is4.defined(options2.layout))
+          if (is4.string(options2.layout) && is4.inArray(options2.layout, ["dz", "google", "iiif", "iiif3", "zoomify"]))
+            this.options.tileLayout = options2.layout;
+          else
+            throw is4.invalidParameterError("layout", "one of: dz, google, iiif, iiif3, zoomify", options2.layout);
+        if (is4.defined(options2.angle))
+          if (is4.integer(options2.angle) && !(options2.angle % 90))
+            this.options.tileAngle = options2.angle;
+          else
+            throw is4.invalidParameterError("angle", "positive/negative multiple of 90", options2.angle);
+        if (this._setBackgroundColourOption("tileBackground", options2.background), is4.defined(options2.depth))
+          if (is4.string(options2.depth) && is4.inArray(options2.depth, ["onepixel", "onetile", "one"]))
+            this.options.tileDepth = options2.depth;
+          else
+            throw is4.invalidParameterError("depth", "one of: onepixel, onetile, one", options2.depth);
+        if (is4.defined(options2.skipBlanks))
+          if (is4.integer(options2.skipBlanks) && is4.inRange(options2.skipBlanks, -1, 65535))
+            this.options.tileSkipBlanks = options2.skipBlanks;
+          else
+            throw is4.invalidParameterError("skipBlanks", "integer between -1 and 255/65535", options2.skipBlanks);
+        else is4.defined(options2.layout) && options2.layout === "google" && (this.options.tileSkipBlanks = 5);
+        let centre = is4.bool(options2.center) ? options2.center : options2.centre;
+        if (is4.defined(centre) && this._setBooleanOption("tileCentre", centre), is4.defined(options2.id))
+          if (is4.string(options2.id))
+            this.options.tileId = options2.id;
+          else
+            throw is4.invalidParameterError("id", "string", options2.id);
+        if (is4.defined(options2.basename))
+          if (is4.string(options2.basename))
+            this.options.tileBasename = options2.basename;
+          else
+            throw is4.invalidParameterError("basename", "string", options2.basename);
+      }
+      if (is4.inArray(this.options.formatOut, ["jpeg", "png", "webp"]))
+        this.options.tileFormat = this.options.formatOut;
+      else if (this.options.formatOut !== "input")
+        throw is4.invalidParameterError("format", "one of: jpeg, png, webp", this.options.formatOut);
+      return this._updateFormatOut("dz");
+    }
+    function timeout(options2) {
+      if (!is4.plainObject(options2))
+        throw is4.invalidParameterError("options", "object", options2);
+      if (is4.integer(options2.seconds) && is4.inRange(options2.seconds, 0, 3600))
+        this.options.timeoutSeconds = options2.seconds;
+      else
+        throw is4.invalidParameterError("seconds", "integer between 0 and 3600", options2.seconds);
+      return this;
+    }
+    function _updateFormatOut(formatOut, options2) {
+      return is4.object(options2) && options2.force === !1 || (this.options.formatOut = formatOut), this;
+    }
+    function _setBooleanOption(key2, val) {
+      if (is4.bool(val))
+        this.options[key2] = val;
+      else
+        throw is4.invalidParameterError(key2, "boolean", val);
+    }
+    function _read() {
+      if (!this.options.streamOut) {
+        this.options.streamOut = !0;
+        let stack = Error();
+        this._pipeline(void 0, stack);
+      }
+    }
+    function _pipeline(callback, stack) {
+      return typeof callback == "function" ? (this._isStreamInput() ? this.on("finish", () => {
+        this._flattenBufferIn(), sharp.pipeline(this.options, (err, data, info) => {
+          err ? callback(is4.nativeError(err, stack)) : callback(null, data, info);
+        });
+      }) : sharp.pipeline(this.options, (err, data, info) => {
+        err ? callback(is4.nativeError(err, stack)) : callback(null, data, info);
+      }), this) : this.options.streamOut ? (this._isStreamInput() ? (this.once("finish", () => {
+        this._flattenBufferIn(), sharp.pipeline(this.options, (err, data, info) => {
+          err ? this.emit("error", is4.nativeError(err, stack)) : (this.emit("info", info), this.push(data)), this.push(null), this.on("end", () => this.emit("close"));
+        });
+      }), this.streamInFinished && this.emit("finish")) : sharp.pipeline(this.options, (err, data, info) => {
+        err ? this.emit("error", is4.nativeError(err, stack)) : (this.emit("info", info), this.push(data)), this.push(null), this.on("end", () => this.emit("close"));
+      }), this) : this._isStreamInput() ? new Promise((resolve2, reject) => {
+        this.once("finish", () => {
+          this._flattenBufferIn(), sharp.pipeline(this.options, (err, data, info) => {
+            err ? reject(is4.nativeError(err, stack)) : this.options.resolveWithObject ? resolve2({ data, info }) : resolve2(data);
+          });
+        });
+      }) : new Promise((resolve2, reject) => {
+        sharp.pipeline(this.options, (err, data, info) => {
+          err ? reject(is4.nativeError(err, stack)) : this.options.resolveWithObject ? resolve2({ data, info }) : resolve2(data);
+        });
+      });
+    }
+    module2.exports = function(Sharp) {
+      Object.assign(Sharp.prototype, {
+        // Public
+        toFile,
+        toBuffer,
+        keepExif,
+        withExif,
+        withExifMerge,
+        keepIccProfile,
+        withIccProfile,
+        keepMetadata,
+        withMetadata,
+        toFormat,
+        jpeg,
+        jp2,
+        png,
+        webp,
+        tiff,
+        avif,
+        heif,
+        jxl,
+        gif,
+        raw: raw2,
+        tile,
+        timeout,
+        // Private
+        _updateFormatOut,
+        _setBooleanOption,
+        _read,
+        _pipeline
+      });
+    };
+  }
+});
+
+// ../../node_modules/sharp/lib/utility.js
+var require_utility = __commonJS({
+  "../../node_modules/sharp/lib/utility.js"(exports2, module2) {
+    "use strict";
+    var events = require("node:events"), detectLibc = require_detect_libc(), is4 = require_is(), { runtimePlatformArch } = require_libvips(), sharp = require_sharp(), runtimePlatform = runtimePlatformArch(), libvipsVersion = sharp.libvipsVersion(), format = sharp.format();
+    format.heif.output.alias = ["avif", "heic"];
+    format.jpeg.output.alias = ["jpe", "jpg"];
+    format.tiff.output.alias = ["tif"];
+    format.jp2k.output.alias = ["j2c", "j2k", "jp2", "jpx"];
+    var interpolators = {
+      /** [Nearest neighbour interpolation](http://en.wikipedia.org/wiki/Nearest-neighbor_interpolation). Suitable for image enlargement only. */
+      nearest: "nearest",
+      /** [Bilinear interpolation](http://en.wikipedia.org/wiki/Bilinear_interpolation). Faster than bicubic but with less smooth results. */
+      bilinear: "bilinear",
+      /** [Bicubic interpolation](http://en.wikipedia.org/wiki/Bicubic_interpolation) (the default). */
+      bicubic: "bicubic",
+      /** [LBB interpolation](https://github.com/libvips/libvips/blob/master/libvips/resample/lbb.cpp#L100). Prevents some "[acutance](http://en.wikipedia.org/wiki/Acutance)" but typically reduces performance by a factor of 2. */
+      locallyBoundedBicubic: "lbb",
+      /** [Nohalo interpolation](http://eprints.soton.ac.uk/268086/). Prevents acutance but typically reduces performance by a factor of 3. */
+      nohalo: "nohalo",
+      /** [VSQBS interpolation](https://github.com/libvips/libvips/blob/master/libvips/resample/vsqbs.cpp#L48). Prevents "staircasing" when enlarging. */
+      vertexSplitQuadraticBasisSpline: "vsqbs"
+    }, versions = {
+      vips: libvipsVersion.semver
+    };
+    if (!libvipsVersion.isGlobal)
+      if (libvipsVersion.isWasm)
+        try {
+          versions = require("@img/sharp-wasm32/versions");
+        } catch {
+        }
+      else
+        try {
+          versions = require(`@img/sharp-${runtimePlatform}/versions`);
+        } catch {
+          try {
+            versions = require(`@img/sharp-libvips-${runtimePlatform}/versions`);
+          } catch {
+          }
+        }
+    versions.sharp = require_package().version;
+    versions.heif && format.heif && (format.heif.input.fileSuffix = [".avif"], format.heif.output.alias = ["avif"]);
+    function cache(options2) {
+      return is4.bool(options2) ? options2 ? sharp.cache(50, 20, 100) : sharp.cache(0, 0, 0) : is4.object(options2) ? sharp.cache(options2.memory, options2.files, options2.items) : sharp.cache();
+    }
+    cache(!0);
+    function concurrency(concurrency2) {
+      return sharp.concurrency(is4.integer(concurrency2) ? concurrency2 : null);
+    }
+    detectLibc.familySync() === detectLibc.GLIBC && !sharp._isUsingJemalloc() ? sharp.concurrency(1) : detectLibc.familySync() === detectLibc.MUSL && sharp.concurrency() === 1024 && sharp.concurrency(require("node:os").availableParallelism());
+    var queue = new events.EventEmitter();
+    function counters() {
+      return sharp.counters();
+    }
+    function simd(simd2) {
+      return sharp.simd(is4.bool(simd2) ? simd2 : null);
+    }
+    function block(options2) {
+      if (is4.object(options2))
+        if (Array.isArray(options2.operation) && options2.operation.every(is4.string))
+          sharp.block(options2.operation, !0);
+        else
+          throw is4.invalidParameterError("operation", "Array<string>", options2.operation);
+      else
+        throw is4.invalidParameterError("options", "object", options2);
+    }
+    function unblock(options2) {
+      if (is4.object(options2))
+        if (Array.isArray(options2.operation) && options2.operation.every(is4.string))
+          sharp.block(options2.operation, !1);
+        else
+          throw is4.invalidParameterError("operation", "Array<string>", options2.operation);
+      else
+        throw is4.invalidParameterError("options", "object", options2);
+    }
+    module2.exports = function(Sharp) {
+      Sharp.cache = cache, Sharp.concurrency = concurrency, Sharp.counters = counters, Sharp.simd = simd, Sharp.format = format, Sharp.interpolators = interpolators, Sharp.versions = versions, Sharp.queue = queue, Sharp.block = block, Sharp.unblock = unblock;
+    };
+  }
+});
+
+// ../../node_modules/sharp/lib/index.js
+var require_lib = __commonJS({
+  "../../node_modules/sharp/lib/index.js"(exports2, module2) {
+    "use strict";
+    var Sharp = require_constructor();
+    require_input()(Sharp);
+    require_resize()(Sharp);
+    require_composite()(Sharp);
+    require_operation()(Sharp);
+    require_colour()(Sharp);
+    require_channel()(Sharp);
+    require_output()(Sharp);
+    require_utility()(Sharp);
+    module2.exports = Sharp;
+  }
+});
+
 // ../../node_modules/parse-numeric-range/index.js
 var require_parse_numeric_range = __commonJS({
   "../../node_modules/parse-numeric-range/index.js"(exports2, module2) {
@@ -5894,7 +10026,7 @@ var require_convert = __commonJS({
 });
 
 // ../../node_modules/unist-util-visit/node_modules/unist-util-visit-parents/color.js
-var require_color = __commonJS({
+var require_color2 = __commonJS({
   "../../node_modules/unist-util-visit/node_modules/unist-util-visit-parents/color.js"(exports2, module2) {
     module2.exports = color4;
     function color4(d) {
@@ -5908,7 +10040,7 @@ var require_unist_util_visit_parents = __commonJS({
   "../../node_modules/unist-util-visit/node_modules/unist-util-visit-parents/index.js"(exports2, module2) {
     "use strict";
     module2.exports = visitParents4;
-    var convert4 = require_convert(), color4 = require_color(), CONTINUE4 = !0, SKIP4 = "skip", EXIT4 = !1;
+    var convert4 = require_convert(), color4 = require_color2(), CONTINUE4 = !0, SKIP4 = "skip", EXIT4 = !1;
     visitParents4.CONTINUE = CONTINUE4;
     visitParents4.SKIP = SKIP4;
     visitParents4.EXIT = EXIT4;
@@ -14084,8 +18216,8 @@ function previousUnbalanced(events) {
 function resolveAll(constructs2, events, context) {
   let called = [], index2 = -1;
   for (; ++index2 < constructs2.length; ) {
-    let resolve = constructs2[index2].resolveAll;
-    resolve && !called.includes(resolve) && (events = resolve(events, context), called.push(resolve));
+    let resolve2 = constructs2[index2].resolveAll;
+    resolve2 && !called.includes(resolve2) && (events = resolve2(events, context), called.push(resolve2));
   }
   return events;
 }
@@ -14651,6 +18783,31 @@ function remarkGfm(options2) {
   micromarkExtensions.push(gfm(settings)), fromMarkdownExtensions.push(gfmFromMarkdown()), toMarkdownExtensions.push(gfmToMarkdown(settings));
 }
 
+// src/processImageMeta.ts
+var import_node_fs2 = require("node:fs"), import_node_path2 = require("node:path");
+async function getSharp() {
+  try {
+    let sharpModule = await Promise.resolve().then(() => __toESM(require_lib()));
+    return sharpModule.default || sharpModule;
+  } catch {
+    return null;
+  }
+}
+async function processImageMeta(imagePath, opts) {
+  let publicDir = opts?.publicDir ?? "./public", filePath;
+  if (imagePath.startsWith("/") ? filePath = (0, import_node_path2.resolve)(publicDir, imagePath.slice(1)) : filePath = (0, import_node_path2.resolve)(imagePath), !(0, import_node_fs2.existsSync)(filePath))
+    return null;
+  let sharp = await getSharp();
+  if (!sharp)
+    return null;
+  try {
+    let image2 = sharp(filePath), metadata = await image2.metadata(), { width = 0, height = 0 } = metadata, blurDataURL = `data:image/jpeg;base64,${(await image2.resize(10).blur(1).jpeg({ quality: 40 }).toBuffer()).toString("base64")}`;
+    return { width, height, blurDataURL };
+  } catch {
+    return null;
+  }
+}
+
 // src/rehypeHighlightCode.tsx
 var import_parse_numeric_range = __toESM(require_parse_numeric_range());
 
@@ -22172,10 +26329,10 @@ function base2() {
     if (assertNode(node2), processor.freeze(), !callback && typeof doc == "function" && (callback = doc, doc = void 0), !callback)
       return new Promise(executor);
     executor(null, callback);
-    function executor(resolve, reject) {
+    function executor(resolve2, reject) {
       transformers.run(node2, vfile(doc), done);
       function done(error, tree, file) {
-        tree = tree || node2, error ? reject(error) : resolve ? resolve(tree) : callback(null, tree, file);
+        tree = tree || node2, error ? reject(error) : resolve2 ? resolve2(tree) : callback(null, tree, file);
       }
     }
   }
@@ -22190,7 +26347,7 @@ function base2() {
     if (processor.freeze(), assertParser("process", processor.Parser), assertCompiler("process", processor.Compiler), !callback)
       return new Promise(executor);
     executor(null, callback);
-    function executor(resolve, reject) {
+    function executor(resolve2, reject) {
       let file = vfile(doc);
       processor.run(processor.parse(file), file, (error, tree, file2) => {
         if (error || !tree || !file2)
@@ -22201,7 +26358,7 @@ function base2() {
         }
       });
       function done(error, file2) {
-        error || !file2 ? reject(error) : resolve ? resolve(file2) : callback(null, file2);
+        error || !file2 ? reject(error) : resolve2 ? resolve2(file2) : callback(null, file2);
       }
     }
   }
@@ -22374,13 +26531,13 @@ var import_unist_util_visit5 = __toESM(require_unist_util_visit()), re = /\b([-\
 };
 
 // src/getMDX.ts
-async function getMDX(source, extraPlugins) {
-  let { frontmatter, code: code3 } = await (0, import_mdx_bundler.bundleMDX)({
+async function getMDX(source, extraPluginsOrOptions) {
+  let opts = Array.isArray(extraPluginsOrOptions) ? { extraPlugins: extraPluginsOrOptions } : extraPluginsOrOptions ?? {}, { frontmatter, code: code3 } = await (0, import_mdx_bundler.bundleMDX)({
     source,
     mdxOptions(options2) {
       options2.remarkPlugins = [...options2.remarkPlugins ?? [], remarkGfm];
       let plugins = [
-        ...extraPlugins || [],
+        ...opts.extraPlugins || [],
         ...options2.rehypePlugins ?? [],
         rehypeMetaAttribute_default,
         rehypeHighlightCode,
@@ -22389,32 +26546,37 @@ async function getMDX(source, extraPlugins) {
       ];
       return options2.rehypePlugins = plugins, options2;
     }
-  });
+  }), imageMeta;
+  if (frontmatter.image && typeof frontmatter.image == "string") {
+    let meta = await processImageMeta(frontmatter.image, { publicDir: opts.publicDir });
+    meta && (imageMeta = meta);
+  }
   return {
     frontmatter: {
       ...frontmatter,
       headings: getHeadings(source),
-      readingTime: (0, import_reading_time2.default)(code3)
+      readingTime: (0, import_reading_time2.default)(code3),
+      imageMeta
     },
     code: code3
   };
 }
 
 // src/getMDXBySlug.tsx
-var import_node_fs2 = __toESM(require("node:fs")), import_node_path2 = __toESM(require("node:path")), import_compare_versions = __toESM(require_compare_versions());
+var import_node_fs3 = __toESM(require("node:fs")), import_node_path3 = __toESM(require("node:path")), import_compare_versions = __toESM(require_compare_versions());
 var getMDXBySlug = async (basePath, slug2, extraPlugins) => {
   let mdxPath = slug2;
   if (!slug2.includes(".") && basePath.includes("components")) {
-    let versions = getAllVersionsFromPath(import_node_path2.default.join(basePath, slug2));
+    let versions = getAllVersionsFromPath(import_node_path3.default.join(basePath, slug2));
     mdxPath += `/${versions[0]}`;
   }
-  let filePath = import_node_path2.default.join(basePath, `${mdxPath}.mdx`);
+  let filePath = import_node_path3.default.join(basePath, `${mdxPath}.mdx`);
   notifyFileRead(filePath);
-  let source = import_node_fs2.default.readFileSync(filePath, "utf8");
+  let source = import_node_fs3.default.readFileSync(filePath, "utf8");
   return await getMDX(source, extraPlugins);
 };
 function getAllVersionsFromPath(fromPath) {
-  return import_node_fs2.default.existsSync(fromPath) ? import_node_fs2.default.readdirSync(fromPath).map((fileName) => fileName.replace(".mdx", "")).sort(import_compare_versions.default).reverse() : [];
+  return import_node_fs3.default.existsSync(fromPath) ? import_node_fs3.default.readdirSync(fromPath).map((fileName) => fileName.replace(".mdx", "")).sort(import_compare_versions.default).reverse() : [];
 }
 
 // src/highlightCode.tsx
@@ -22428,13 +26590,13 @@ function createCodeHighlighter() {
 }
 
 // src/rehypeHeroTemplate.ts
-var import_node_module = require("node:module"), import_node_fs3 = __toESM(require("node:fs")), import_node_path3 = __toESM(require("node:path")), import_unist_util_visit6 = __toESM(require_unist_util_visit()), import_meta = {}, rehypeHeroTemplate = (options2 = {}) => {
+var import_node_module = require("node:module"), import_node_fs4 = __toESM(require("node:fs")), import_node_path4 = __toESM(require("node:path")), import_unist_util_visit6 = __toESM(require_unist_util_visit()), import_meta = {}, rehypeHeroTemplate = (options2 = {}) => {
   let demosRoot;
   if (options2.demosPath)
     demosRoot = options2.demosPath;
   else if (options2.demosPackage) {
     let resolved = (typeof require > "u" ? (0, import_node_module.createRequire)(import_meta.url) : require).resolve(options2.demosPackage);
-    demosRoot = import_node_path3.default.join(resolved, "..", "..", "..");
+    demosRoot = import_node_path4.default.join(resolved, "..", "..", "..");
   } else
     throw new Error("rehypeHeroTemplate requires either demosPackage or demosPath option");
   return (tree) => {
@@ -22442,9 +26604,9 @@ var import_node_module = require("node:module"), import_node_fs3 = __toESM(requi
       if (node2.tagName !== "code" || !node2.properties.template) return;
       let templateName = node2.properties.template;
       if (!templateName) return;
-      let templatePath = import_node_path3.default.join(demosRoot, "src", `${templateName}Demo.tsx`);
+      let templatePath = import_node_path4.default.join(demosRoot, "src", `${templateName}Demo.tsx`);
       try {
-        let source = import_node_fs3.default.readFileSync(templatePath, "utf8");
+        let source = import_node_fs4.default.readFileSync(templatePath, "utf8");
         node2.children[0].value = source;
       } catch (err) {
         console.warn("Error setting template", err.message);