@ecmaos/kernel 0.2.6 → 0.2.7

package/dist/{empty-BMkCc_7L.js → empty--zdtkf0T.js}

@@ -2525,6 +2525,1903 @@ function requirePathBrowserify() {
 }
 var pathBrowserifyExports = requirePathBrowserify();
 const path = /* @__PURE__ */ getDefaultExportFromCjs$2(pathBrowserifyExports);
+var re$2 = { exports: {} };
+var constants$4;
+var hasRequiredConstants;
+function requireConstants() {
+  if (hasRequiredConstants) return constants$4;
+  hasRequiredConstants = 1;
+  const SEMVER_SPEC_VERSION = "2.0.0";
+  const MAX_LENGTH = 256;
+  const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
+  9007199254740991;
+  const MAX_SAFE_COMPONENT_LENGTH = 16;
+  const MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
+  const RELEASE_TYPES = [
+    "major",
+    "premajor",
+    "minor",
+    "preminor",
+    "patch",
+    "prepatch",
+    "prerelease"
+  ];
+  constants$4 = {
+    MAX_LENGTH,
+    MAX_SAFE_COMPONENT_LENGTH,
+    MAX_SAFE_BUILD_LENGTH,
+    MAX_SAFE_INTEGER,
+    RELEASE_TYPES,
+    SEMVER_SPEC_VERSION,
+    FLAG_INCLUDE_PRERELEASE: 1,
+    FLAG_LOOSE: 2
+  };
+  return constants$4;
+}
+var debug_1;
+var hasRequiredDebug;
+function requireDebug() {
+  if (hasRequiredDebug) return debug_1;
+  hasRequiredDebug = 1;
+  const debug = typeof process$1$1 === "object" && process$1$1.env && process$1$1.env.NODE_DEBUG && /\bsemver\b/i.test(process$1$1.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
+  };
+  debug_1 = debug;
+  return debug_1;
+}
+var hasRequiredRe;
+function requireRe() {
+  if (hasRequiredRe) return re$2.exports;
+  hasRequiredRe = 1;
+  (function(module, exports) {
+    const {
+      MAX_SAFE_COMPONENT_LENGTH,
+      MAX_SAFE_BUILD_LENGTH,
+      MAX_LENGTH
+    } = requireConstants();
+    const debug = requireDebug();
+    exports = module.exports = {};
+    const re2 = exports.re = [];
+    const safeRe = exports.safeRe = [];
+    const src = exports.src = [];
+    const t2 = exports.t = {};
+    let R = 0;
+    const LETTERDASHNUMBER = "[a-zA-Z0-9-]";
+    const safeRegexReplacements = [
+      ["\\s", 1],
+      ["\\d", MAX_LENGTH],
+      [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
+    ];
+    const makeSafeRegex = (value) => {
+      for (const [token, max2] of safeRegexReplacements) {
+        value = value.split(`${token}*`).join(`${token}{0,${max2}}`).split(`${token}+`).join(`${token}{1,${max2}}`);
+      }
+      return value;
+    };
+    const createToken = (name, value, isGlobal) => {
+      const safe = makeSafeRegex(value);
+      const index = R++;
+      debug(name, index, value);
+      t2[name] = index;
+      src[index] = value;
+      re2[index] = new RegExp(value, isGlobal ? "g" : void 0);
+      safeRe[index] = 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[t2.NUMERICIDENTIFIER]})\\.(${src[t2.NUMERICIDENTIFIER]})\\.(${src[t2.NUMERICIDENTIFIER]})`);
+    createToken("MAINVERSIONLOOSE", `(${src[t2.NUMERICIDENTIFIERLOOSE]})\\.(${src[t2.NUMERICIDENTIFIERLOOSE]})\\.(${src[t2.NUMERICIDENTIFIERLOOSE]})`);
+    createToken("PRERELEASEIDENTIFIER", `(?:${src[t2.NUMERICIDENTIFIER]}|${src[t2.NONNUMERICIDENTIFIER]})`);
+    createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t2.NUMERICIDENTIFIERLOOSE]}|${src[t2.NONNUMERICIDENTIFIER]})`);
+    createToken("PRERELEASE", `(?:-(${src[t2.PRERELEASEIDENTIFIER]}(?:\\.${src[t2.PRERELEASEIDENTIFIER]})*))`);
+    createToken("PRERELEASELOOSE", `(?:-?(${src[t2.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t2.PRERELEASEIDENTIFIERLOOSE]})*))`);
+    createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
+    createToken("BUILD", `(?:\\+(${src[t2.BUILDIDENTIFIER]}(?:\\.${src[t2.BUILDIDENTIFIER]})*))`);
+    createToken("FULLPLAIN", `v?${src[t2.MAINVERSION]}${src[t2.PRERELEASE]}?${src[t2.BUILD]}?`);
+    createToken("FULL", `^${src[t2.FULLPLAIN]}$`);
+    createToken("LOOSEPLAIN", `[v=\\s]*${src[t2.MAINVERSIONLOOSE]}${src[t2.PRERELEASELOOSE]}?${src[t2.BUILD]}?`);
+    createToken("LOOSE", `^${src[t2.LOOSEPLAIN]}$`);
+    createToken("GTLT", "((?:<|>)?=?)");
+    createToken("XRANGEIDENTIFIERLOOSE", `${src[t2.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+    createToken("XRANGEIDENTIFIER", `${src[t2.NUMERICIDENTIFIER]}|x|X|\\*`);
+    createToken("XRANGEPLAIN", `[v=\\s]*(${src[t2.XRANGEIDENTIFIER]})(?:\\.(${src[t2.XRANGEIDENTIFIER]})(?:\\.(${src[t2.XRANGEIDENTIFIER]})(?:${src[t2.PRERELEASE]})?${src[t2.BUILD]}?)?)?`);
+    createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t2.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t2.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t2.XRANGEIDENTIFIERLOOSE]})(?:${src[t2.PRERELEASELOOSE]})?${src[t2.BUILD]}?)?)?`);
+    createToken("XRANGE", `^${src[t2.GTLT]}\\s*${src[t2.XRANGEPLAIN]}$`);
+    createToken("XRANGELOOSE", `^${src[t2.GTLT]}\\s*${src[t2.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[t2.COERCEPLAIN]}(?:$|[^\\d])`);
+    createToken("COERCEFULL", src[t2.COERCEPLAIN] + `(?:${src[t2.PRERELEASE]})?(?:${src[t2.BUILD]})?(?:$|[^\\d])`);
+    createToken("COERCERTL", src[t2.COERCE], true);
+    createToken("COERCERTLFULL", src[t2.COERCEFULL], true);
+    createToken("LONETILDE", "(?:~>?)");
+    createToken("TILDETRIM", `(\\s*)${src[t2.LONETILDE]}\\s+`, true);
+    exports.tildeTrimReplace = "$1~";
+    createToken("TILDE", `^${src[t2.LONETILDE]}${src[t2.XRANGEPLAIN]}$`);
+    createToken("TILDELOOSE", `^${src[t2.LONETILDE]}${src[t2.XRANGEPLAINLOOSE]}$`);
+    createToken("LONECARET", "(?:\\^)");
+    createToken("CARETTRIM", `(\\s*)${src[t2.LONECARET]}\\s+`, true);
+    exports.caretTrimReplace = "$1^";
+    createToken("CARET", `^${src[t2.LONECARET]}${src[t2.XRANGEPLAIN]}$`);
+    createToken("CARETLOOSE", `^${src[t2.LONECARET]}${src[t2.XRANGEPLAINLOOSE]}$`);
+    createToken("COMPARATORLOOSE", `^${src[t2.GTLT]}\\s*(${src[t2.LOOSEPLAIN]})$|^$`);
+    createToken("COMPARATOR", `^${src[t2.GTLT]}\\s*(${src[t2.FULLPLAIN]})$|^$`);
+    createToken("COMPARATORTRIM", `(\\s*)${src[t2.GTLT]}\\s*(${src[t2.LOOSEPLAIN]}|${src[t2.XRANGEPLAIN]})`, true);
+    exports.comparatorTrimReplace = "$1$2$3";
+    createToken("HYPHENRANGE", `^\\s*(${src[t2.XRANGEPLAIN]})\\s+-\\s+(${src[t2.XRANGEPLAIN]})\\s*$`);
+    createToken("HYPHENRANGELOOSE", `^\\s*(${src[t2.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t2.XRANGEPLAINLOOSE]})\\s*$`);
+    createToken("STAR", "(<|>)?=?\\s*\\*");
+    createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
+    createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+  })(re$2, re$2.exports);
+  return re$2.exports;
+}
+var parseOptions_1;
+var hasRequiredParseOptions;
+function requireParseOptions() {
+  if (hasRequiredParseOptions) return parseOptions_1;
+  hasRequiredParseOptions = 1;
+  const looseOption = Object.freeze({ loose: true });
+  const emptyOpts = Object.freeze({});
+  const parseOptions = (options) => {
+    if (!options) {
+      return emptyOpts;
+    }
+    if (typeof options !== "object") {
+      return looseOption;
+    }
+    return options;
+  };
+  parseOptions_1 = parseOptions;
+  return parseOptions_1;
+}
+var identifiers;
+var hasRequiredIdentifiers;
+function requireIdentifiers() {
+  if (hasRequiredIdentifiers) return identifiers;
+  hasRequiredIdentifiers = 1;
+  const numeric = /^[0-9]+$/;
+  const compareIdentifiers = (a, b) => {
+    const anum = numeric.test(a);
+    const bnum = numeric.test(b);
+    if (anum && bnum) {
+      a = +a;
+      b = +b;
+    }
+    return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
+  };
+  const rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
+  identifiers = {
+    compareIdentifiers,
+    rcompareIdentifiers
+  };
+  return identifiers;
+}
+var semver$2;
+var hasRequiredSemver$1;
+function requireSemver$1() {
+  if (hasRequiredSemver$1) return semver$2;
+  hasRequiredSemver$1 = 1;
+  const debug = requireDebug();
+  const { MAX_LENGTH, MAX_SAFE_INTEGER } = requireConstants();
+  const { safeRe: re2, t: t2 } = requireRe();
+  const parseOptions = requireParseOptions();
+  const { compareIdentifiers } = requireIdentifiers();
+  class SemVer {
+    constructor(version2, options) {
+      options = parseOptions(options);
+      if (version2 instanceof SemVer) {
+        if (version2.loose === !!options.loose && version2.includePrerelease === !!options.includePrerelease) {
+          return version2;
+        } else {
+          version2 = version2.version;
+        }
+      } else if (typeof version2 !== "string") {
+        throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version2}".`);
+      }
+      if (version2.length > MAX_LENGTH) {
+        throw new TypeError(
+          `version is longer than ${MAX_LENGTH} characters`
+        );
+      }
+      debug("SemVer", version2, options);
+      this.options = options;
+      this.loose = !!options.loose;
+      this.includePrerelease = !!options.includePrerelease;
+      const m = version2.trim().match(options.loose ? re2[t2.LOOSE] : re2[t2.FULL]);
+      if (!m) {
+        throw new TypeError(`Invalid Version: ${version2}`);
+      }
+      this.raw = version2;
+      this.major = +m[1];
+      this.minor = +m[2];
+      this.patch = +m[3];
+      if (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");
+      }
+      if (!m[4]) {
+        this.prerelease = [];
+      } else {
+        this.prerelease = m[4].split(".").map((id) => {
+          if (/^[0-9]+$/.test(id)) {
+            const num = +id;
+            if (num >= 0 && num < MAX_SAFE_INTEGER) {
+              return num;
+            }
+          }
+          return id;
+        });
+      }
+      this.build = m[5] ? m[5].split(".") : [];
+      this.format();
+    }
+    format() {
+      this.version = `${this.major}.${this.minor}.${this.patch}`;
+      if (this.prerelease.length) {
+        this.version += `-${this.prerelease.join(".")}`;
+      }
+      return this.version;
+    }
+    toString() {
+      return this.version;
+    }
+    compare(other) {
+      debug("SemVer.compare", this.version, this.options, other);
+      if (!(other instanceof SemVer)) {
+        if (typeof other === "string" && other === this.version) {
+          return 0;
+        }
+        other = new SemVer(other, this.options);
+      }
+      if (other.version === this.version) {
+        return 0;
+      }
+      return this.compareMain(other) || this.comparePre(other);
+    }
+    compareMain(other) {
+      if (!(other instanceof SemVer)) {
+        other = new SemVer(other, this.options);
+      }
+      return 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);
+      }
+      if (this.prerelease.length && !other.prerelease.length) {
+        return -1;
+      } else if (!this.prerelease.length && other.prerelease.length) {
+        return 1;
+      } else if (!this.prerelease.length && !other.prerelease.length) {
+        return 0;
+      }
+      let i = 0;
+      do {
+        const a = this.prerelease[i];
+        const b = other.prerelease[i];
+        debug("prerelease compare", i, a, b);
+        if (a === void 0 && b === void 0) {
+          return 0;
+        } else if (b === void 0) {
+          return 1;
+        } else if (a === void 0) {
+          return -1;
+        } else if (a === b) {
+          continue;
+        } else {
+          return compareIdentifiers(a, b);
+        }
+      } while (++i);
+    }
+    compareBuild(other) {
+      if (!(other instanceof SemVer)) {
+        other = new SemVer(other, this.options);
+      }
+      let i = 0;
+      do {
+        const a = this.build[i];
+        const b = other.build[i];
+        debug("build compare", i, a, b);
+        if (a === void 0 && b === void 0) {
+          return 0;
+        } else if (b === void 0) {
+          return 1;
+        } else if (a === void 0) {
+          return -1;
+        } else if (a === b) {
+          continue;
+        } else {
+          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) {
+      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":
+          if (this.prerelease.length === 0) {
+            this.inc("patch", identifier, identifierBase);
+          }
+          this.inc("pre", identifier, identifierBase);
+          break;
+        case "major":
+          if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
+            this.major++;
+          }
+          this.minor = 0;
+          this.patch = 0;
+          this.prerelease = [];
+          break;
+        case "minor":
+          if (this.patch !== 0 || this.prerelease.length === 0) {
+            this.minor++;
+          }
+          this.patch = 0;
+          this.prerelease = [];
+          break;
+        case "patch":
+          if (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": {
+          const base = Number(identifierBase) ? 1 : 0;
+          if (!identifier && identifierBase === false) {
+            throw new Error("invalid increment argument: identifier is empty");
+          }
+          if (this.prerelease.length === 0) {
+            this.prerelease = [base];
+          } else {
+            let i = this.prerelease.length;
+            while (--i >= 0) {
+              if (typeof this.prerelease[i] === "number") {
+                this.prerelease[i]++;
+                i = -2;
+              }
+            }
+            if (i === -1) {
+              if (identifier === this.prerelease.join(".") && identifierBase === false) {
+                throw new Error("invalid increment argument: identifier already exists");
+              }
+              this.prerelease.push(base);
+            }
+          }
+          if (identifier) {
+            let prerelease = [identifier, base];
+            if (identifierBase === false) {
+              prerelease = [identifier];
+            }
+            if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
+              if (isNaN(this.prerelease[1])) {
+                this.prerelease = prerelease;
+              }
+            } else {
+              this.prerelease = prerelease;
+            }
+          }
+          break;
+        }
+        default:
+          throw new Error(`invalid increment argument: ${release}`);
+      }
+      this.raw = this.format();
+      if (this.build.length) {
+        this.raw += `+${this.build.join(".")}`;
+      }
+      return this;
+    }
+  }
+  semver$2 = SemVer;
+  return semver$2;
+}
+var parse_1;
+var hasRequiredParse$1;
+function requireParse$1() {
+  if (hasRequiredParse$1) return parse_1;
+  hasRequiredParse$1 = 1;
+  const SemVer = requireSemver$1();
+  const parse2 = (version2, options, throwErrors = false) => {
+    if (version2 instanceof SemVer) {
+      return version2;
+    }
+    try {
+      return new SemVer(version2, options);
+    } catch (er) {
+      if (!throwErrors) {
+        return null;
+      }
+      throw er;
+    }
+  };
+  parse_1 = parse2;
+  return parse_1;
+}
+var valid_1;
+var hasRequiredValid$1;
+function requireValid$1() {
+  if (hasRequiredValid$1) return valid_1;
+  hasRequiredValid$1 = 1;
+  const parse2 = requireParse$1();
+  const valid2 = (version2, options) => {
+    const v = parse2(version2, options);
+    return v ? v.version : null;
+  };
+  valid_1 = valid2;
+  return valid_1;
+}
+var clean_1;
+var hasRequiredClean;
+function requireClean() {
+  if (hasRequiredClean) return clean_1;
+  hasRequiredClean = 1;
+  const parse2 = requireParse$1();
+  const clean = (version2, options) => {
+    const s = parse2(version2.trim().replace(/^[=v]+/, ""), options);
+    return s ? s.version : null;
+  };
+  clean_1 = clean;
+  return clean_1;
+}
+var inc_1;
+var hasRequiredInc;
+function requireInc() {
+  if (hasRequiredInc) return inc_1;
+  hasRequiredInc = 1;
+  const SemVer = requireSemver$1();
+  const inc = (version2, release, options, identifier, identifierBase) => {
+    if (typeof options === "string") {
+      identifierBase = identifier;
+      identifier = options;
+      options = void 0;
+    }
+    try {
+      return new SemVer(
+        version2 instanceof SemVer ? version2.version : version2,
+        options
+      ).inc(release, identifier, identifierBase).version;
+    } catch (er) {
+      return null;
+    }
+  };
+  inc_1 = inc;
+  return inc_1;
+}
+var diff_1;
+var hasRequiredDiff;
+function requireDiff() {
+  if (hasRequiredDiff) return diff_1;
+  hasRequiredDiff = 1;
+  const parse2 = requireParse$1();
+  const diff = (version1, version2) => {
+    const v1 = parse2(version1, null, true);
+    const v2 = parse2(version2, null, true);
+    const comparison = v1.compare(v2);
+    if (comparison === 0) {
+      return null;
+    }
+    const v1Higher = comparison > 0;
+    const highVersion = v1Higher ? v1 : v2;
+    const lowVersion = v1Higher ? v2 : v1;
+    const highHasPre = !!highVersion.prerelease.length;
+    const lowHasPre = !!lowVersion.prerelease.length;
+    if (lowHasPre && !highHasPre) {
+      if (!lowVersion.patch && !lowVersion.minor) {
+        return "major";
+      }
+      if (highVersion.patch) {
+        return "patch";
+      }
+      if (highVersion.minor) {
+        return "minor";
+      }
+      return "major";
+    }
+    const prefix = highHasPre ? "pre" : "";
+    if (v1.major !== v2.major) {
+      return prefix + "major";
+    }
+    if (v1.minor !== v2.minor) {
+      return prefix + "minor";
+    }
+    if (v1.patch !== v2.patch) {
+      return prefix + "patch";
+    }
+    return "prerelease";
+  };
+  diff_1 = diff;
+  return diff_1;
+}
+var major_1;
+var hasRequiredMajor;
+function requireMajor() {
+  if (hasRequiredMajor) return major_1;
+  hasRequiredMajor = 1;
+  const SemVer = requireSemver$1();
+  const major = (a, loose) => new SemVer(a, loose).major;
+  major_1 = major;
+  return major_1;
+}
+var minor_1;
+var hasRequiredMinor;
+function requireMinor() {
+  if (hasRequiredMinor) return minor_1;
+  hasRequiredMinor = 1;
+  const SemVer = requireSemver$1();
+  const minor = (a, loose) => new SemVer(a, loose).minor;
+  minor_1 = minor;
+  return minor_1;
+}
+var patch_1;
+var hasRequiredPatch;
+function requirePatch() {
+  if (hasRequiredPatch) return patch_1;
+  hasRequiredPatch = 1;
+  const SemVer = requireSemver$1();
+  const patch = (a, loose) => new SemVer(a, loose).patch;
+  patch_1 = patch;
+  return patch_1;
+}
+var prerelease_1;
+var hasRequiredPrerelease;
+function requirePrerelease() {
+  if (hasRequiredPrerelease) return prerelease_1;
+  hasRequiredPrerelease = 1;
+  const parse2 = requireParse$1();
+  const prerelease = (version2, options) => {
+    const parsed = parse2(version2, options);
+    return parsed && parsed.prerelease.length ? parsed.prerelease : null;
+  };
+  prerelease_1 = prerelease;
+  return prerelease_1;
+}
+var compare_1;
+var hasRequiredCompare;
+function requireCompare() {
+  if (hasRequiredCompare) return compare_1;
+  hasRequiredCompare = 1;
+  const SemVer = requireSemver$1();
+  const compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
+  compare_1 = compare;
+  return compare_1;
+}
+var rcompare_1;
+var hasRequiredRcompare;
+function requireRcompare() {
+  if (hasRequiredRcompare) return rcompare_1;
+  hasRequiredRcompare = 1;
+  const compare = requireCompare();
+  const rcompare = (a, b, loose) => compare(b, a, loose);
+  rcompare_1 = rcompare;
+  return rcompare_1;
+}
+var compareLoose_1;
+var hasRequiredCompareLoose;
+function requireCompareLoose() {
+  if (hasRequiredCompareLoose) return compareLoose_1;
+  hasRequiredCompareLoose = 1;
+  const compare = requireCompare();
+  const compareLoose = (a, b) => compare(a, b, true);
+  compareLoose_1 = compareLoose;
+  return compareLoose_1;
+}
+var compareBuild_1;
+var hasRequiredCompareBuild;
+function requireCompareBuild() {
+  if (hasRequiredCompareBuild) return compareBuild_1;
+  hasRequiredCompareBuild = 1;
+  const SemVer = requireSemver$1();
+  const compareBuild = (a, b, loose) => {
+    const versionA = new SemVer(a, loose);
+    const versionB = new SemVer(b, loose);
+    return versionA.compare(versionB) || versionA.compareBuild(versionB);
+  };
+  compareBuild_1 = compareBuild;
+  return compareBuild_1;
+}
+var sort_1;
+var hasRequiredSort;
+function requireSort() {
+  if (hasRequiredSort) return sort_1;
+  hasRequiredSort = 1;
+  const compareBuild = requireCompareBuild();
+  const sort = (list2, loose) => list2.sort((a, b) => compareBuild(a, b, loose));
+  sort_1 = sort;
+  return sort_1;
+}
+var rsort_1;
+var hasRequiredRsort;
+function requireRsort() {
+  if (hasRequiredRsort) return rsort_1;
+  hasRequiredRsort = 1;
+  const compareBuild = requireCompareBuild();
+  const rsort = (list2, loose) => list2.sort((a, b) => compareBuild(b, a, loose));
+  rsort_1 = rsort;
+  return rsort_1;
+}
+var gt_1;
+var hasRequiredGt;
+function requireGt() {
+  if (hasRequiredGt) return gt_1;
+  hasRequiredGt = 1;
+  const compare = requireCompare();
+  const gt = (a, b, loose) => compare(a, b, loose) > 0;
+  gt_1 = gt;
+  return gt_1;
+}
+var lt_1;
+var hasRequiredLt;
+function requireLt() {
+  if (hasRequiredLt) return lt_1;
+  hasRequiredLt = 1;
+  const compare = requireCompare();
+  const lt = (a, b, loose) => compare(a, b, loose) < 0;
+  lt_1 = lt;
+  return lt_1;
+}
+var eq_1;
+var hasRequiredEq;
+function requireEq() {
+  if (hasRequiredEq) return eq_1;
+  hasRequiredEq = 1;
+  const compare = requireCompare();
+  const eq = (a, b, loose) => compare(a, b, loose) === 0;
+  eq_1 = eq;
+  return eq_1;
+}
+var neq_1;
+var hasRequiredNeq;
+function requireNeq() {
+  if (hasRequiredNeq) return neq_1;
+  hasRequiredNeq = 1;
+  const compare = requireCompare();
+  const neq = (a, b, loose) => compare(a, b, loose) !== 0;
+  neq_1 = neq;
+  return neq_1;
+}
+var gte_1;
+var hasRequiredGte;
+function requireGte() {
+  if (hasRequiredGte) return gte_1;
+  hasRequiredGte = 1;
+  const compare = requireCompare();
+  const gte = (a, b, loose) => compare(a, b, loose) >= 0;
+  gte_1 = gte;
+  return gte_1;
+}
+var lte_1;
+var hasRequiredLte;
+function requireLte() {
+  if (hasRequiredLte) return lte_1;
+  hasRequiredLte = 1;
+  const compare = requireCompare();
+  const lte = (a, b, loose) => compare(a, b, loose) <= 0;
+  lte_1 = lte;
+  return lte_1;
+}
+var cmp_1;
+var hasRequiredCmp;
+function requireCmp() {
+  if (hasRequiredCmp) return cmp_1;
+  hasRequiredCmp = 1;
+  const eq = requireEq();
+  const neq = requireNeq();
+  const gt = requireGt();
+  const gte = requireGte();
+  const lt = requireLt();
+  const lte = requireLte();
+  const cmp = (a, op, b, loose) => {
+    switch (op) {
+      case "===":
+        if (typeof a === "object") {
+          a = a.version;
+        }
+        if (typeof b === "object") {
+          b = b.version;
+        }
+        return a === b;
+      case "!==":
+        if (typeof a === "object") {
+          a = a.version;
+        }
+        if (typeof b === "object") {
+          b = b.version;
+        }
+        return 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}`);
+    }
+  };
+  cmp_1 = cmp;
+  return cmp_1;
+}
+var coerce_1;
+var hasRequiredCoerce;
+function requireCoerce() {
+  if (hasRequiredCoerce) return coerce_1;
+  hasRequiredCoerce = 1;
+  const SemVer = requireSemver$1();
+  const parse2 = requireParse$1();
+  const { safeRe: re2, t: t2 } = requireRe();
+  const coerce2 = (version2, options) => {
+    if (version2 instanceof SemVer) {
+      return version2;
+    }
+    if (typeof version2 === "number") {
+      version2 = String(version2);
+    }
+    if (typeof version2 !== "string") {
+      return null;
+    }
+    options = options || {};
+    let match = null;
+    if (!options.rtl) {
+      match = version2.match(options.includePrerelease ? re2[t2.COERCEFULL] : re2[t2.COERCE]);
+    } else {
+      const coerceRtlRegex = options.includePrerelease ? re2[t2.COERCERTLFULL] : re2[t2.COERCERTL];
+      let next;
+      while ((next = coerceRtlRegex.exec(version2)) && (!match || match.index + match[0].length !== version2.length)) {
+        if (!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;
+    }
+    const major = match[2];
+    const minor = match[3] || "0";
+    const patch = match[4] || "0";
+    const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : "";
+    const build = options.includePrerelease && match[6] ? `+${match[6]}` : "";
+    return parse2(`${major}.${minor}.${patch}${prerelease}${build}`, options);
+  };
+  coerce_1 = coerce2;
+  return coerce_1;
+}
+var lrucache;
+var hasRequiredLrucache;
+function requireLrucache() {
+  if (hasRequiredLrucache) return lrucache;
+  hasRequiredLrucache = 1;
+  class LRUCache {
+    constructor() {
+      this.max = 1e3;
+      this.map = /* @__PURE__ */ new Map();
+    }
+    get(key) {
+      const value = this.map.get(key);
+      if (value === void 0) {
+        return void 0;
+      } else {
+        this.map.delete(key);
+        this.map.set(key, value);
+        return value;
+      }
+    }
+    delete(key) {
+      return this.map.delete(key);
+    }
+    set(key, value) {
+      const deleted = this.delete(key);
+      if (!deleted && value !== void 0) {
+        if (this.map.size >= this.max) {
+          const firstKey = this.map.keys().next().value;
+          this.delete(firstKey);
+        }
+        this.map.set(key, value);
+      }
+      return this;
+    }
+  }
+  lrucache = LRUCache;
+  return lrucache;
+}
+var range;
+var hasRequiredRange;
+function requireRange() {
+  if (hasRequiredRange) return range;
+  hasRequiredRange = 1;
+  const SPACE_CHARACTERS = /\s+/g;
+  class Range {
+    constructor(range2, options) {
+      options = parseOptions(options);
+      if (range2 instanceof Range) {
+        if (range2.loose === !!options.loose && range2.includePrerelease === !!options.includePrerelease) {
+          return range2;
+        } else {
+          return new Range(range2.raw, options);
+        }
+      }
+      if (range2 instanceof Comparator) {
+        this.raw = range2.value;
+        this.set = [[range2]];
+        this.formatted = void 0;
+        return this;
+      }
+      this.options = options;
+      this.loose = !!options.loose;
+      this.includePrerelease = !!options.includePrerelease;
+      this.raw = range2.trim().replace(SPACE_CHARACTERS, " ");
+      this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
+      if (!this.set.length) {
+        throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
+      }
+      if (this.set.length > 1) {
+        const first = this.set[0];
+        this.set = this.set.filter((c) => !isNullSet(c[0]));
+        if (this.set.length === 0) {
+          this.set = [first];
+        } else if (this.set.length > 1) {
+          for (const c of this.set) {
+            if (c.length === 1 && isAny(c[0])) {
+              this.set = [c];
+              break;
+            }
+          }
+        }
+      }
+      this.formatted = void 0;
+    }
+    get range() {
+      if (this.formatted === void 0) {
+        this.formatted = "";
+        for (let i = 0; i < this.set.length; i++) {
+          if (i > 0) {
+            this.formatted += "||";
+          }
+          const comps = this.set[i];
+          for (let k = 0; k < comps.length; k++) {
+            if (k > 0) {
+              this.formatted += " ";
+            }
+            this.formatted += comps[k].toString().trim();
+          }
+        }
+      }
+      return this.formatted;
+    }
+    format() {
+      return this.range;
+    }
+    toString() {
+      return this.range;
+    }
+    parseRange(range2) {
+      const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
+      const memoKey = memoOpts + ":" + range2;
+      const cached = cache.get(memoKey);
+      if (cached) {
+        return cached;
+      }
+      const loose = this.options.loose;
+      const hr = loose ? re2[t2.HYPHENRANGELOOSE] : re2[t2.HYPHENRANGE];
+      range2 = range2.replace(hr, hyphenReplace(this.options.includePrerelease));
+      debug("hyphen replace", range2);
+      range2 = range2.replace(re2[t2.COMPARATORTRIM], comparatorTrimReplace);
+      debug("comparator trim", range2);
+      range2 = range2.replace(re2[t2.TILDETRIM], tildeTrimReplace);
+      debug("tilde trim", range2);
+      range2 = range2.replace(re2[t2.CARETTRIM], caretTrimReplace);
+      debug("caret trim", range2);
+      let rangeList = range2.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
+      if (loose) {
+        rangeList = rangeList.filter((comp) => {
+          debug("loose invalid filter", comp, this.options);
+          return !!comp.match(re2[t2.COMPARATORLOOSE]);
+        });
+      }
+      debug("range list", rangeList);
+      const rangeMap = /* @__PURE__ */ new Map();
+      const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
+      for (const comp of comparators) {
+        if (isNullSet(comp)) {
+          return [comp];
+        }
+        rangeMap.set(comp.value, comp);
+      }
+      if (rangeMap.size > 1 && rangeMap.has("")) {
+        rangeMap.delete("");
+      }
+      const result = [...rangeMap.values()];
+      cache.set(memoKey, result);
+      return result;
+    }
+    intersects(range2, options) {
+      if (!(range2 instanceof Range)) {
+        throw new TypeError("a Range is required");
+      }
+      return this.set.some((thisComparators) => {
+        return isSatisfiable(thisComparators, options) && range2.set.some((rangeComparators) => {
+          return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
+            return rangeComparators.every((rangeComparator) => {
+              return thisComparator.intersects(rangeComparator, options);
+            });
+          });
+        });
+      });
+    }
+    // if ANY of the sets match ALL of its comparators, then pass
+    test(version2) {
+      if (!version2) {
+        return false;
+      }
+      if (typeof version2 === "string") {
+        try {
+          version2 = new SemVer(version2, this.options);
+        } catch (er) {
+          return false;
+        }
+      }
+      for (let i = 0; i < this.set.length; i++) {
+        if (testSet(this.set[i], version2, this.options)) {
+          return true;
+        }
+      }
+      return false;
+    }
+  }
+  range = Range;
+  const LRU = requireLrucache();
+  const cache = new LRU();
+  const parseOptions = requireParseOptions();
+  const Comparator = requireComparator();
+  const debug = requireDebug();
+  const SemVer = requireSemver$1();
+  const {
+    safeRe: re2,
+    t: t2,
+    comparatorTrimReplace,
+    tildeTrimReplace,
+    caretTrimReplace
+  } = requireRe();
+  const { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = requireConstants();
+  const isNullSet = (c) => c.value === "<0.0.0-0";
+  const isAny = (c) => c.value === "";
+  const isSatisfiable = (comparators, options) => {
+    let result = true;
+    const remainingComparators = comparators.slice();
+    let testComparator = remainingComparators.pop();
+    while (result && remainingComparators.length) {
+      result = remainingComparators.every((otherComparator) => {
+        return testComparator.intersects(otherComparator, options);
+      });
+      testComparator = remainingComparators.pop();
+    }
+    return result;
+  };
+  const parseComparator = (comp, options) => {
+    debug("comp", comp, options);
+    comp = replaceCarets(comp, options);
+    debug("caret", comp);
+    comp = replaceTildes(comp, options);
+    debug("tildes", comp);
+    comp = replaceXRanges(comp, options);
+    debug("xrange", comp);
+    comp = replaceStars(comp, options);
+    debug("stars", comp);
+    return comp;
+  };
+  const isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
+  const replaceTildes = (comp, options) => {
+    return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
+  };
+  const replaceTilde = (comp, options) => {
+    const r = options.loose ? re2[t2.TILDELOOSE] : re2[t2.TILDE];
+    return comp.replace(r, (_, M, m, p, pr) => {
+      debug("tilde", comp, _, M, m, p, pr);
+      let ret;
+      if (isX(M)) {
+        ret = "";
+      } else if (isX(m)) {
+        ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
+      } else if (isX(p)) {
+        ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
+      } else if (pr) {
+        debug("replaceTilde pr", pr);
+        ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+      } else {
+        ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
+      }
+      debug("tilde return", ret);
+      return ret;
+    });
+  };
+  const replaceCarets = (comp, options) => {
+    return comp.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" ");
+  };
+  const replaceCaret = (comp, options) => {
+    debug("caret", comp, options);
+    const r = options.loose ? re2[t2.CARETLOOSE] : re2[t2.CARET];
+    const z2 = options.includePrerelease ? "-0" : "";
+    return comp.replace(r, (_, M, m, p, pr) => {
+      debug("caret", comp, _, M, m, p, pr);
+      let ret;
+      if (isX(M)) {
+        ret = "";
+      } else if (isX(m)) {
+        ret = `>=${M}.0.0${z2} <${+M + 1}.0.0-0`;
+      } else if (isX(p)) {
+        if (M === "0") {
+          ret = `>=${M}.${m}.0${z2} <${M}.${+m + 1}.0-0`;
+        } else {
+          ret = `>=${M}.${m}.0${z2} <${+M + 1}.0.0-0`;
+        }
+      } else if (pr) {
+        debug("replaceCaret pr", pr);
+        if (M === "0") {
+          if (m === "0") {
+            ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
+          } else {
+            ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+          }
+        } else {
+          ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
+        }
+      } else {
+        debug("no pr");
+        if (M === "0") {
+          if (m === "0") {
+            ret = `>=${M}.${m}.${p}${z2} <${M}.${m}.${+p + 1}-0`;
+          } else {
+            ret = `>=${M}.${m}.${p}${z2} <${M}.${+m + 1}.0-0`;
+          }
+        } else {
+          ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
+        }
+      }
+      debug("caret return", ret);
+      return ret;
+    });
+  };
+  const replaceXRanges = (comp, options) => {
+    debug("replaceXRanges", comp, options);
+    return comp.split(/\s+/).map((c) => replaceXRange(c, options)).join(" ");
+  };
+  const replaceXRange = (comp, options) => {
+    comp = comp.trim();
+    const r = options.loose ? re2[t2.XRANGELOOSE] : re2[t2.XRANGE];
+    return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
+      debug("xRange", comp, ret, gtlt, M, m, p, pr);
+      const xM = isX(M);
+      const xm = xM || isX(m);
+      const xp = xm || isX(p);
+      const anyX = xp;
+      if (gtlt === "=" && anyX) {
+        gtlt = "";
+      }
+      pr = options.includePrerelease ? "-0" : "";
+      if (xM) {
+        if (gtlt === ">" || gtlt === "<") {
+          ret = "<0.0.0-0";
+        } else {
+          ret = "*";
+        }
+      } else if (gtlt && anyX) {
+        if (xm) {
+          m = 0;
+        }
+        p = 0;
+        if (gtlt === ">") {
+          gtlt = ">=";
+          if (xm) {
+            M = +M + 1;
+            m = 0;
+            p = 0;
+          } else {
+            m = +m + 1;
+            p = 0;
+          }
+        } else if (gtlt === "<=") {
+          gtlt = "<";
+          if (xm) {
+            M = +M + 1;
+          } else {
+            m = +m + 1;
+          }
+        }
+        if (gtlt === "<") {
+          pr = "-0";
+        }
+        ret = `${gtlt + M}.${m}.${p}${pr}`;
+      } else if (xm) {
+        ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
+      } else if (xp) {
+        ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
+      }
+      debug("xRange return", ret);
+      return ret;
+    });
+  };
+  const replaceStars = (comp, options) => {
+    debug("replaceStars", comp, options);
+    return comp.trim().replace(re2[t2.STAR], "");
+  };
+  const replaceGTE0 = (comp, options) => {
+    debug("replaceGTE0", comp, options);
+    return comp.trim().replace(re2[options.includePrerelease ? t2.GTE0PRE : t2.GTE0], "");
+  };
+  const hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
+    if (isX(fM)) {
+      from = "";
+    } else if (isX(fm)) {
+      from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
+    } else if (isX(fp)) {
+      from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
+    } else if (fpr) {
+      from = `>=${from}`;
+    } else {
+      from = `>=${from}${incPr ? "-0" : ""}`;
+    }
+    if (isX(tM)) {
+      to = "";
+    } else if (isX(tm)) {
+      to = `<${+tM + 1}.0.0-0`;
+    } else if (isX(tp)) {
+      to = `<${tM}.${+tm + 1}.0-0`;
+    } else if (tpr) {
+      to = `<=${tM}.${tm}.${tp}-${tpr}`;
+    } else if (incPr) {
+      to = `<${tM}.${tm}.${+tp + 1}-0`;
+    } else {
+      to = `<=${to}`;
+    }
+    return `${from} ${to}`.trim();
+  };
+  const testSet = (set, version2, options) => {
+    for (let i = 0; i < set.length; i++) {
+      if (!set[i].test(version2)) {
+        return false;
+      }
+    }
+    if (version2.prerelease.length && !options.includePrerelease) {
+      for (let i = 0; i < set.length; i++) {
+        debug(set[i].semver);
+        if (set[i].semver === Comparator.ANY) {
+          continue;
+        }
+        if (set[i].semver.prerelease.length > 0) {
+          const allowed = set[i].semver;
+          if (allowed.major === version2.major && allowed.minor === version2.minor && allowed.patch === version2.patch) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+    return true;
+  };
+  return range;
+}
+var comparator;
+var hasRequiredComparator;
+function requireComparator() {
+  if (hasRequiredComparator) return comparator;
+  hasRequiredComparator = 1;
+  const ANY = Symbol("SemVer ANY");
+  class Comparator {
+    static get ANY() {
+      return ANY;
+    }
+    constructor(comp, options) {
+      options = parseOptions(options);
+      if (comp instanceof Comparator) {
+        if (comp.loose === !!options.loose) {
+          return comp;
+        } else {
+          comp = comp.value;
+        }
+      }
+      comp = comp.trim().split(/\s+/).join(" ");
+      debug("comparator", comp, options);
+      this.options = options;
+      this.loose = !!options.loose;
+      this.parse(comp);
+      if (this.semver === ANY) {
+        this.value = "";
+      } else {
+        this.value = this.operator + this.semver.version;
+      }
+      debug("comp", this);
+    }
+    parse(comp) {
+      const r = this.options.loose ? re2[t2.COMPARATORLOOSE] : re2[t2.COMPARATOR];
+      const m = comp.match(r);
+      if (!m) {
+        throw new TypeError(`Invalid comparator: ${comp}`);
+      }
+      this.operator = m[1] !== void 0 ? m[1] : "";
+      if (this.operator === "=") {
+        this.operator = "";
+      }
+      if (!m[2]) {
+        this.semver = ANY;
+      } else {
+        this.semver = new SemVer(m[2], this.options.loose);
+      }
+    }
+    toString() {
+      return this.value;
+    }
+    test(version2) {
+      debug("Comparator.test", version2, this.options.loose);
+      if (this.semver === ANY || version2 === ANY) {
+        return true;
+      }
+      if (typeof version2 === "string") {
+        try {
+          version2 = new SemVer(version2, this.options);
+        } catch (er) {
+          return false;
+        }
+      }
+      return cmp(version2, this.operator, this.semver, this.options);
+    }
+    intersects(comp, options) {
+      if (!(comp instanceof Comparator)) {
+        throw new TypeError("a Comparator is required");
+      }
+      if (this.operator === "") {
+        if (this.value === "") {
+          return true;
+        }
+        return new Range(comp.value, options).test(this.value);
+      } else if (comp.operator === "") {
+        if (comp.value === "") {
+          return true;
+        }
+        return new Range(this.value, options).test(comp.semver);
+      }
+      options = parseOptions(options);
+      if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) {
+        return false;
+      }
+      if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) {
+        return false;
+      }
+      if (this.operator.startsWith(">") && comp.operator.startsWith(">")) {
+        return true;
+      }
+      if (this.operator.startsWith("<") && comp.operator.startsWith("<")) {
+        return true;
+      }
+      if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) {
+        return true;
+      }
+      if (cmp(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) {
+        return true;
+      }
+      if (cmp(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) {
+        return true;
+      }
+      return false;
+    }
+  }
+  comparator = Comparator;
+  const parseOptions = requireParseOptions();
+  const { safeRe: re2, t: t2 } = requireRe();
+  const cmp = requireCmp();
+  const debug = requireDebug();
+  const SemVer = requireSemver$1();
+  const Range = requireRange();
+  return comparator;
+}
+var satisfies_1;
+var hasRequiredSatisfies;
+function requireSatisfies() {
+  if (hasRequiredSatisfies) return satisfies_1;
+  hasRequiredSatisfies = 1;
+  const Range = requireRange();
+  const satisfies = (version2, range2, options) => {
+    try {
+      range2 = new Range(range2, options);
+    } catch (er) {
+      return false;
+    }
+    return range2.test(version2);
+  };
+  satisfies_1 = satisfies;
+  return satisfies_1;
+}
+var toComparators_1;
+var hasRequiredToComparators;
+function requireToComparators() {
+  if (hasRequiredToComparators) return toComparators_1;
+  hasRequiredToComparators = 1;
+  const Range = requireRange();
+  const toComparators = (range2, options) => new Range(range2, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
+  toComparators_1 = toComparators;
+  return toComparators_1;
+}
+var maxSatisfying_1;
+var hasRequiredMaxSatisfying;
+function requireMaxSatisfying() {
+  if (hasRequiredMaxSatisfying) return maxSatisfying_1;
+  hasRequiredMaxSatisfying = 1;
+  const SemVer = requireSemver$1();
+  const Range = requireRange();
+  const maxSatisfying = (versions, range2, options) => {
+    let max2 = null;
+    let maxSV = null;
+    let rangeObj = null;
+    try {
+      rangeObj = new Range(range2, options);
+    } catch (er) {
+      return null;
+    }
+    versions.forEach((v) => {
+      if (rangeObj.test(v)) {
+        if (!max2 || maxSV.compare(v) === -1) {
+          max2 = v;
+          maxSV = new SemVer(max2, options);
+        }
+      }
+    });
+    return max2;
+  };
+  maxSatisfying_1 = maxSatisfying;
+  return maxSatisfying_1;
+}
+var minSatisfying_1;
+var hasRequiredMinSatisfying;
+function requireMinSatisfying() {
+  if (hasRequiredMinSatisfying) return minSatisfying_1;
+  hasRequiredMinSatisfying = 1;
+  const SemVer = requireSemver$1();
+  const Range = requireRange();
+  const minSatisfying = (versions, range2, options) => {
+    let min = null;
+    let minSV = null;
+    let rangeObj = null;
+    try {
+      rangeObj = new Range(range2, options);
+    } catch (er) {
+      return null;
+    }
+    versions.forEach((v) => {
+      if (rangeObj.test(v)) {
+        if (!min || minSV.compare(v) === 1) {
+          min = v;
+          minSV = new SemVer(min, options);
+        }
+      }
+    });
+    return min;
+  };
+  minSatisfying_1 = minSatisfying;
+  return minSatisfying_1;
+}
+var minVersion_1;
+var hasRequiredMinVersion;
+function requireMinVersion() {
+  if (hasRequiredMinVersion) return minVersion_1;
+  hasRequiredMinVersion = 1;
+  const SemVer = requireSemver$1();
+  const Range = requireRange();
+  const gt = requireGt();
+  const minVersion = (range2, loose) => {
+    range2 = new Range(range2, loose);
+    let minver = new SemVer("0.0.0");
+    if (range2.test(minver)) {
+      return minver;
+    }
+    minver = new SemVer("0.0.0-0");
+    if (range2.test(minver)) {
+      return minver;
+    }
+    minver = null;
+    for (let i = 0; i < range2.set.length; ++i) {
+      const comparators = range2.set[i];
+      let setMin = null;
+      comparators.forEach((comparator2) => {
+        const compver = new SemVer(comparator2.semver.version);
+        switch (comparator2.operator) {
+          case ">":
+            if (compver.prerelease.length === 0) {
+              compver.patch++;
+            } else {
+              compver.prerelease.push(0);
+            }
+            compver.raw = compver.format();
+          /* fallthrough */
+          case "":
+          case ">=":
+            if (!setMin || gt(compver, setMin)) {
+              setMin = compver;
+            }
+            break;
+          case "<":
+          case "<=":
+            break;
+          /* istanbul ignore next */
+          default:
+            throw new Error(`Unexpected operation: ${comparator2.operator}`);
+        }
+      });
+      if (setMin && (!minver || gt(minver, setMin))) {
+        minver = setMin;
+      }
+    }
+    if (minver && range2.test(minver)) {
+      return minver;
+    }
+    return null;
+  };
+  minVersion_1 = minVersion;
+  return minVersion_1;
+}
+var valid;
+var hasRequiredValid;
+function requireValid() {
+  if (hasRequiredValid) return valid;
+  hasRequiredValid = 1;
+  const Range = requireRange();
+  const validRange = (range2, options) => {
+    try {
+      return new Range(range2, options).range || "*";
+    } catch (er) {
+      return null;
+    }
+  };
+  valid = validRange;
+  return valid;
+}
+var outside_1;
+var hasRequiredOutside;
+function requireOutside() {
+  if (hasRequiredOutside) return outside_1;
+  hasRequiredOutside = 1;
+  const SemVer = requireSemver$1();
+  const Comparator = requireComparator();
+  const { ANY } = Comparator;
+  const Range = requireRange();
+  const satisfies = requireSatisfies();
+  const gt = requireGt();
+  const lt = requireLt();
+  const lte = requireLte();
+  const gte = requireGte();
+  const outside = (version2, range2, hilo, options) => {
+    version2 = new SemVer(version2, options);
+    range2 = new Range(range2, options);
+    let gtfn, ltefn, ltfn, comp, ecomp;
+    switch (hilo) {
+      case ">":
+        gtfn = gt;
+        ltefn = lte;
+        ltfn = lt;
+        comp = ">";
+        ecomp = ">=";
+        break;
+      case "<":
+        gtfn = lt;
+        ltefn = gte;
+        ltfn = gt;
+        comp = "<";
+        ecomp = "<=";
+        break;
+      default:
+        throw new TypeError('Must provide a hilo val of "<" or ">"');
+    }
+    if (satisfies(version2, range2, options)) {
+      return false;
+    }
+    for (let i = 0; i < range2.set.length; ++i) {
+      const comparators = range2.set[i];
+      let high = null;
+      let low = null;
+      comparators.forEach((comparator2) => {
+        if (comparator2.semver === ANY) {
+          comparator2 = new Comparator(">=0.0.0");
+        }
+        high = high || comparator2;
+        low = low || comparator2;
+        if (gtfn(comparator2.semver, high.semver, options)) {
+          high = comparator2;
+        } else if (ltfn(comparator2.semver, low.semver, options)) {
+          low = comparator2;
+        }
+      });
+      if (high.operator === comp || high.operator === ecomp) {
+        return false;
+      }
+      if ((!low.operator || low.operator === comp) && ltefn(version2, low.semver)) {
+        return false;
+      } else if (low.operator === ecomp && ltfn(version2, low.semver)) {
+        return false;
+      }
+    }
+    return true;
+  };
+  outside_1 = outside;
+  return outside_1;
+}
+var gtr_1;
+var hasRequiredGtr;
+function requireGtr() {
+  if (hasRequiredGtr) return gtr_1;
+  hasRequiredGtr = 1;
+  const outside = requireOutside();
+  const gtr = (version2, range2, options) => outside(version2, range2, ">", options);
+  gtr_1 = gtr;
+  return gtr_1;
+}
+var ltr_1;
+var hasRequiredLtr;
+function requireLtr() {
+  if (hasRequiredLtr) return ltr_1;
+  hasRequiredLtr = 1;
+  const outside = requireOutside();
+  const ltr = (version2, range2, options) => outside(version2, range2, "<", options);
+  ltr_1 = ltr;
+  return ltr_1;
+}
+var intersects_1;
+var hasRequiredIntersects;
+function requireIntersects() {
+  if (hasRequiredIntersects) return intersects_1;
+  hasRequiredIntersects = 1;
+  const Range = requireRange();
+  const intersects = (r1, r2, options) => {
+    r1 = new Range(r1, options);
+    r2 = new Range(r2, options);
+    return r1.intersects(r2, options);
+  };
+  intersects_1 = intersects;
+  return intersects_1;
+}
+var simplify;
+var hasRequiredSimplify;
+function requireSimplify() {
+  if (hasRequiredSimplify) return simplify;
+  hasRequiredSimplify = 1;
+  const satisfies = requireSatisfies();
+  const compare = requireCompare();
+  simplify = (versions, range2, options) => {
+    const set = [];
+    let first = null;
+    let prev = null;
+    const v = versions.sort((a, b) => compare(a, b, options));
+    for (const version2 of v) {
+      const included = satisfies(version2, range2, options);
+      if (included) {
+        prev = version2;
+        if (!first) {
+          first = version2;
+        }
+      } else {
+        if (prev) {
+          set.push([first, prev]);
+        }
+        prev = null;
+        first = null;
+      }
+    }
+    if (first) {
+      set.push([first, null]);
+    }
+    const ranges = [];
+    for (const [min, max2] of set) {
+      if (min === max2) {
+        ranges.push(min);
+      } else if (!max2 && min === v[0]) {
+        ranges.push("*");
+      } else if (!max2) {
+        ranges.push(`>=${min}`);
+      } else if (min === v[0]) {
+        ranges.push(`<=${max2}`);
+      } else {
+        ranges.push(`${min} - ${max2}`);
+      }
+    }
+    const simplified = ranges.join(" || ");
+    const original = typeof range2.raw === "string" ? range2.raw : String(range2);
+    return simplified.length < original.length ? simplified : range2;
+  };
+  return simplify;
+}
+var subset_1;
+var hasRequiredSubset;
+function requireSubset() {
+  if (hasRequiredSubset) return subset_1;
+  hasRequiredSubset = 1;
+  const Range = requireRange();
+  const Comparator = requireComparator();
+  const { ANY } = Comparator;
+  const satisfies = requireSatisfies();
+  const compare = requireCompare();
+  const subset = (sub, dom, options = {}) => {
+    if (sub === dom) {
+      return true;
+    }
+    sub = new Range(sub, options);
+    dom = new Range(dom, options);
+    let sawNonNull = false;
+    OUTER: for (const simpleSub of sub.set) {
+      for (const simpleDom of dom.set) {
+        const isSub = simpleSubset(simpleSub, simpleDom, options);
+        sawNonNull = sawNonNull || isSub !== null;
+        if (isSub) {
+          continue OUTER;
+        }
+      }
+      if (sawNonNull) {
+        return false;
+      }
+    }
+    return true;
+  };
+  const minimumVersionWithPreRelease = [new Comparator(">=0.0.0-0")];
+  const minimumVersion = [new Comparator(">=0.0.0")];
+  const simpleSubset = (sub, dom, options) => {
+    if (sub === dom) {
+      return true;
+    }
+    if (sub.length === 1 && sub[0].semver === ANY) {
+      if (dom.length === 1 && dom[0].semver === ANY) {
+        return true;
+      } else if (options.includePrerelease) {
+        sub = minimumVersionWithPreRelease;
+      } else {
+        sub = minimumVersion;
+      }
+    }
+    if (dom.length === 1 && dom[0].semver === ANY) {
+      if (options.includePrerelease) {
+        return true;
+      } else {
+        dom = minimumVersion;
+      }
+    }
+    const eqSet = /* @__PURE__ */ new Set();
+    let gt, lt;
+    for (const c of sub) {
+      if (c.operator === ">" || c.operator === ">=") {
+        gt = higherGT(gt, c, options);
+      } else if (c.operator === "<" || c.operator === "<=") {
+        lt = lowerLT(lt, c, options);
+      } else {
+        eqSet.add(c.semver);
+      }
+    }
+    if (eqSet.size > 1) {
+      return null;
+    }
+    let gtltComp;
+    if (gt && lt) {
+      gtltComp = compare(gt.semver, lt.semver, options);
+      if (gtltComp > 0) {
+        return null;
+      } else if (gtltComp === 0 && (gt.operator !== ">=" || lt.operator !== "<=")) {
+        return null;
+      }
+    }
+    for (const eq of eqSet) {
+      if (gt && !satisfies(eq, String(gt), options)) {
+        return null;
+      }
+      if (lt && !satisfies(eq, String(lt), options)) {
+        return null;
+      }
+      for (const c of dom) {
+        if (!satisfies(eq, String(c), options)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    let higher, lower;
+    let hasDomLT, hasDomGT;
+    let needDomLTPre = lt && !options.includePrerelease && lt.semver.prerelease.length ? lt.semver : false;
+    let needDomGTPre = gt && !options.includePrerelease && gt.semver.prerelease.length ? gt.semver : false;
+    if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt.operator === "<" && needDomLTPre.prerelease[0] === 0) {
+      needDomLTPre = false;
+    }
+    for (const c of dom) {
+      hasDomGT = hasDomGT || c.operator === ">" || c.operator === ">=";
+      hasDomLT = hasDomLT || c.operator === "<" || c.operator === "<=";
+      if (gt) {
+        if (needDomGTPre) {
+          if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomGTPre.major && c.semver.minor === needDomGTPre.minor && c.semver.patch === needDomGTPre.patch) {
+            needDomGTPre = false;
+          }
+        }
+        if (c.operator === ">" || c.operator === ">=") {
+          higher = higherGT(gt, c, options);
+          if (higher === c && higher !== gt) {
+            return false;
+          }
+        } else if (gt.operator === ">=" && !satisfies(gt.semver, String(c), options)) {
+          return false;
+        }
+      }
+      if (lt) {
+        if (needDomLTPre) {
+          if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch) {
+            needDomLTPre = false;
+          }
+        }
+        if (c.operator === "<" || c.operator === "<=") {
+          lower = lowerLT(lt, c, options);
+          if (lower === c && lower !== lt) {
+            return false;
+          }
+        } else if (lt.operator === "<=" && !satisfies(lt.semver, String(c), options)) {
+          return false;
+        }
+      }
+      if (!c.operator && (lt || gt) && gtltComp !== 0) {
+        return false;
+      }
+    }
+    if (gt && hasDomLT && !lt && gtltComp !== 0) {
+      return false;
+    }
+    if (lt && hasDomGT && !gt && gtltComp !== 0) {
+      return false;
+    }
+    if (needDomGTPre || needDomLTPre) {
+      return false;
+    }
+    return true;
+  };
+  const higherGT = (a, b, options) => {
+    if (!a) {
+      return b;
+    }
+    const comp = compare(a.semver, b.semver, options);
+    return comp > 0 ? a : comp < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a;
+  };
+  const lowerLT = (a, b, options) => {
+    if (!a) {
+      return b;
+    }
+    const comp = compare(a.semver, b.semver, options);
+    return comp < 0 ? a : comp > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a;
+  };
+  subset_1 = subset;
+  return subset_1;
+}
+var semver$1;
+var hasRequiredSemver;
+function requireSemver() {
+  if (hasRequiredSemver) return semver$1;
+  hasRequiredSemver = 1;
+  const internalRe = requireRe();
+  const constants2 = requireConstants();
+  const SemVer = requireSemver$1();
+  const identifiers2 = requireIdentifiers();
+  const parse2 = requireParse$1();
+  const valid2 = requireValid$1();
+  const clean = requireClean();
+  const inc = requireInc();
+  const diff = requireDiff();
+  const major = requireMajor();
+  const minor = requireMinor();
+  const patch = requirePatch();
+  const prerelease = requirePrerelease();
+  const compare = requireCompare();
+  const rcompare = requireRcompare();
+  const compareLoose = requireCompareLoose();
+  const compareBuild = requireCompareBuild();
+  const sort = requireSort();
+  const rsort = requireRsort();
+  const gt = requireGt();
+  const lt = requireLt();
+  const eq = requireEq();
+  const neq = requireNeq();
+  const gte = requireGte();
+  const lte = requireLte();
+  const cmp = requireCmp();
+  const coerce2 = requireCoerce();
+  const Comparator = requireComparator();
+  const Range = requireRange();
+  const satisfies = requireSatisfies();
+  const toComparators = requireToComparators();
+  const maxSatisfying = requireMaxSatisfying();
+  const minSatisfying = requireMinSatisfying();
+  const minVersion = requireMinVersion();
+  const validRange = requireValid();
+  const outside = requireOutside();
+  const gtr = requireGtr();
+  const ltr = requireLtr();
+  const intersects = requireIntersects();
+  const simplifyRange = requireSimplify();
+  const subset = requireSubset();
+  semver$1 = {
+    parse: parse2,
+    valid: valid2,
+    clean,
+    inc,
+    diff,
+    major,
+    minor,
+    patch,
+    prerelease,
+    compare,
+    rcompare,
+    compareLoose,
+    compareBuild,
+    sort,
+    rsort,
+    gt,
+    lt,
+    eq,
+    neq,
+    gte,
+    lte,
+    cmp,
+    coerce: coerce2,
+    Comparator,
+    Range,
+    satisfies,
+    toComparators,
+    maxSatisfying,
+    minSatisfying,
+    minVersion,
+    validRange,
+    outside,
+    gtr,
+    ltr,
+    intersects,
+    simplifyRange,
+    subset,
+    SemVer,
+    re: internalRe.re,
+    src: internalRe.src,
+    tokens: internalRe.t,
+    SEMVER_SPEC_VERSION: constants2.SEMVER_SPEC_VERSION,
+    RELEASE_TYPES: constants2.RELEASE_TYPES,
+    compareIdentifiers: identifiers2.compareIdentifiers,
+    rcompareIdentifiers: identifiers2.rcompareIdentifiers
+  };
+  return semver$1;
+}
+var semverExports = requireSemver();
+const semver = /* @__PURE__ */ getDefaultExportFromCjs$2(semverExports);
 /*! *****************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -7835,7 +9732,7 @@ function requireBuffer() {
     );
     E(
       "ERR_OUT_OF_RANGE",
-      function(str, range, input) {
+      function(str, range2, input) {
         let msg = `The value of "${str}" is out of range.`;
         let received = input;
         if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {
@@ -7847,7 +9744,7 @@ function requireBuffer() {
           }
           received += "n";
         }
-        msg += ` It must be ${range}. Received ${received}`;
+        msg += ` It must be ${range2}. Received ${received}`;
         return msg;
       },
       RangeError
@@ -7870,15 +9767,15 @@ function requireBuffer() {
     function checkIntBI(value, min, max2, buf, offset, byteLength3) {
       if (value > max2 || value < min) {
         const n = typeof min === "bigint" ? "n" : "";
-        let range;
+        let range2;
         {
           if (min === 0 || min === BigInt(0)) {
-            range = `>= 0${n} and < 2${n} ** ${(byteLength3 + 1) * 8}${n}`;
+            range2 = `>= 0${n} and < 2${n} ** ${(byteLength3 + 1) * 8}${n}`;
           } else {
-            range = `>= -(2${n} ** ${(byteLength3 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength3 + 1) * 8 - 1}${n}`;
+            range2 = `>= -(2${n} ** ${(byteLength3 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength3 + 1) * 8 - 1}${n}`;
           }
         }
-        throw new errors2.ERR_OUT_OF_RANGE("value", range, value);
+        throw new errors2.ERR_OUT_OF_RANGE("value", range2, value);
       }
       checkBounds(buf, offset, byteLength3);
     }
@@ -9996,8 +11893,8 @@ function requireErrors() {
   );
   E(
     "ERR_OUT_OF_RANGE",
-    (str, range, input) => {
-      assert(range, 'Missing "range" argument');
+    (str, range2, input) => {
+      assert(range2, 'Missing "range" argument');
       let received;
       if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {
         received = addNumericalSeparator(String(input));
@@ -10010,7 +11907,7 @@ function requireErrors() {
       } else {
         received = inspect2(input);
       }
-      return `The value of "${str}" is out of range. It must be ${range}. Received ${received}`;
+      return `The value of "${str}" is out of range. It must be ${range2}. Received ${received}`;
     },
     RangeError
   );
@@ -19242,7 +21139,7 @@ ieee754$1.write = function(buffer2, value, offset, isLE, mLen, nBytes) {
   );
   E(
     "ERR_OUT_OF_RANGE",
-    function(str, range, input) {
+    function(str, range2, input) {
       let msg = `The value of "${str}" is out of range.`;
       let received = input;
       if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {
@@ -19254,7 +21151,7 @@ ieee754$1.write = function(buffer2, value, offset, isLE, mLen, nBytes) {
         }
         received += "n";
       }
-      msg += ` It must be ${range}. Received ${received}`;
+      msg += ` It must be ${range2}. Received ${received}`;
       return msg;
     },
     RangeError
@@ -19277,15 +21174,15 @@ ieee754$1.write = function(buffer2, value, offset, isLE, mLen, nBytes) {
   function checkIntBI(value, min, max2, buf, offset, byteLength3) {
     if (value > max2 || value < min) {
       const n = typeof min === "bigint" ? "n" : "";
-      let range;
+      let range2;
       {
         if (min === 0 || min === BigInt(0)) {
-          range = `>= 0${n} and < 2${n} ** ${(byteLength3 + 1) * 8}${n}`;
+          range2 = `>= 0${n} and < 2${n} ** ${(byteLength3 + 1) * 8}${n}`;
         } else {
-          range = `>= -(2${n} ** ${(byteLength3 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength3 + 1) * 8 - 1}${n}`;
+          range2 = `>= -(2${n} ** ${(byteLength3 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength3 + 1) * 8 - 1}${n}`;
         }
       }
-      throw new errors2.ERR_OUT_OF_RANGE("value", range, value);
+      throw new errors2.ERR_OUT_OF_RANGE("value", range2, value);
     }
     checkBounds(buf, offset, byteLength3);
   }
@@ -19517,7 +21414,7 @@ const pkg$c = {
   description: "Web Audio API device driver"
 };
 async function cli$c(options) {
-  options.kernel.log?.debug(`${pkg$c.name} CLI`, options.args);
+  options.kernel.log.debug(`${pkg$c.name} CLI`, options.args);
   const usage = `
 Usage: audio <command>
 
@@ -20033,7 +21930,7 @@ async function cli$a(options) {
           win.close();
           resolve2(true);
         } catch (error) {
-          kernel.log?.error("Error requesting Bluetooth device", error);
+          kernel.log.error("Error requesting Bluetooth device", error);
           kernel.storage.session.removeItem("permission:bluetooth");
           win.close();
           const dialog = kernel.windows.dialog({
@@ -20902,7 +22799,7 @@ const pkg$7 = {
   description: "WebGPU device driver"
 };
 async function cli$7(options) {
-  options.kernel.log?.debug(`${pkg$7.name} CLI`, options.args);
+  options.kernel.log.debug(`${pkg$7.name} CLI`, options.args);
   const usage = `
 Usage: gpu <command>
 
@@ -22439,7 +24336,7 @@ async function getDrivers(kernel) {
       });
     }
   } catch (error) {
-    kernel.log?.error(`Failed to initialize WebGL device: ${error}`);
+    kernel.log.error(`Failed to initialize WebGL device: ${error}`);
   }
   return drivers;
 }
@@ -22582,7 +24479,7 @@ class Dom {
   }
   async topbar(show) {
     if (!this._topbar) return;
-    const { default: topbar } = await import("./topbar.min-xBbuiIjv.js").then((n) => n.t);
+    const { default: topbar } = await import("./topbar.min-CDkSVOxV.js").then((n) => n.t);
     this._topbarShow = show ?? !this._topbarShow;
     if (this._topbarShow) topbar.show();
     else topbar.hide();
@@ -27184,16 +29081,21 @@ class Filesystem {
     const tarball = await this.fs.readFile(tarballPath);
     const decompressed = pako.ungzip(tarball);
     const tar = await TarReader.load(decompressed);
+    const hasPackageDir = tar.fileInfos.some((file) => file.name.startsWith("package/"));
+    const stripPrefix = hasPackageDir ? "package/" : "";
     for (const file of tar.fileInfos) {
+      if (hasPackageDir && !file.name.startsWith(stripPrefix)) continue;
+      const relativePath = hasPackageDir ? file.name.slice(stripPrefix.length) : file.name;
+      if (!relativePath) continue;
       try {
-        await this.fs.mkdir(path.join(extractPath, file.name.endsWith("/") ? file.name : path.dirname(file.name)), { mode: 493, recursive: true });
-      } catch {
-      }
-      if (file.name.endsWith("/")) continue;
-      try {
+        if (relativePath.endsWith("/")) {
+          await this.fs.mkdir(path.join(extractPath, relativePath), { mode: 493, recursive: true });
+          continue;
+        }
+        await this.fs.mkdir(path.join(extractPath, path.dirname(relativePath)), { mode: 493, recursive: true });
         const blob = tar.getFileBlob(file.name);
         const binaryData = await blob.arrayBuffer().then((buffer2) => new Uint8Array(buffer2));
-        const filePath = path.join(extractPath, file.name);
+        const filePath = path.join(extractPath, relativePath);
         await this.fs.writeFile(filePath, binaryData, { encoding: "binary", mode: 420 });
       } catch (error) {
         console.error(`Failed to extract file ${file.name}: ${error}`);
@@ -50613,7 +52515,7 @@ async function createSimpleWebSocket(url) {
     case "node": {
       let WebSocket2;
       try {
-        WebSocket2 = (await import("./browser-C0q0NWWv.js").then((n) => n.b)).default;
+        WebSocket2 = (await import("./browser-D_CtuxSB.js").then((n) => n.b)).default;
       } catch (error) {
         try {
           WebSocket2 = __require("ws");
@@ -69555,7 +71457,7 @@ const TerminalCommands = (kernel, shell, terminal) => {
         { name: "reinstall", type: Boolean, description: "Reinstall the package if it is already installed" }
       ],
       run: async (argv) => {
-        const { default: install } = await import("./install-C64fBUI2.js");
+        const { default: install } = await import("./install-Ds1oWgTf.js");
         return await install({ kernel, shell, terminal, args: [argv.package, argv.registry, argv.reinstall] });
       }
     }),
@@ -71171,8 +73073,8 @@ const DefaultTerminalOptions = {
   },
   linkHandler: {
     allowNonHttpProtocols: true,
-    activate: (event, text13, range) => {
-      console.log("activate", event, text13, range);
+    activate: (event, text13, range2) => {
+      console.log("activate", event, text13, range2);
       if (text13.startsWith("http")) window.open(text13, "_blank", "noopener,noreferrer");
       if (text13.startsWith("ecmaos://")) {
         const [protocol, argstr] = text13.replace("ecmaos://", "").split("?");
@@ -71291,7 +73193,7 @@ class Terminal extends xtermExports.Terminal {
         this._kernel.events.dispatch(TerminalEvents.MESSAGE, { terminal: this, message: event });
         if (event.data.startsWith("@ecmaos/metal")) {
           const [name, version2, id, encodedPublicKey] = event.data.split(":");
-          this._kernel.log?.info(`${name}:${version2}:${id} connected`);
+          this._kernel.log.info(`${name}:${version2}:${id} connected`);
           this._socketKey = JSON.parse(atob(encodedPublicKey));
         }
       });
@@ -71524,7 +73426,7 @@ class Terminal extends xtermExports.Terminal {
           this._cmd = "";
           this._cursorPosition = 0;
           this.unlisten();
-          this.write(this.prompt());
+          this.write("\n" + this.prompt());
           this.listen();
           return;
         case "l":
@@ -71560,7 +73462,7 @@ class Terminal extends xtermExports.Terminal {
             try {
               this._kernel.storage.local.setItem(`history:${uid}`, JSON.stringify(this._history[uid] || []));
             } catch (error) {
-              this._kernel.log?.error("Failed to save history", error);
+              this._kernel.log.error("Failed to save history", error);
             }
           }
           this._historyPosition = this._history[uid]?.length || 0;
@@ -71574,7 +73476,7 @@ class Terminal extends xtermExports.Terminal {
         }
         this._cmd = "";
         this._cursorPosition = 0;
-        this.write("\n" + ansi$5.erase.inLine(2) + this.prompt());
+        this.write(ansi$5.erase.inLine(2) + this.prompt());
         break;
       case "Backspace":
         if (this._cursorPosition > 0) {
@@ -74415,7 +76317,7 @@ class Process {
     this._command = options.command || "";
     this._cwd = options.cwd || options.shell?.cwd || "/";
     this._entry = options.entry || ((params) => {
-      options.kernel?.log?.silly(params);
+      options.kernel?.log.silly(params);
       return Promise.resolve(0);
     });
     this._events = new Events();
@@ -74589,7 +76491,7 @@ class Service {
           data: await this._kernel.filesystem.fs.readFile(data.file)
         });
       } catch (error) {
-        this._kernel.log?.error(error instanceof Error ? error.message : "Unknown error");
+        this._kernel.log.error(error instanceof Error ? error.message : "Unknown error");
         event.source?.postMessage({
           type: "fs",
           file: data.file,
@@ -74603,10 +76505,10 @@ class Service {
         try {
           switch (data.type) {
             case "log":
-              this._kernel.log?.info(`[ServiceWorker] ${data.message}`);
+              this._kernel.log.info(`[ServiceWorker] ${data.message}`);
               break;
             case "error":
-              this._kernel.log?.error(`[ServiceWorker] ${data.message}`);
+              this._kernel.log.error(`[ServiceWorker] ${data.message}`);
               break;
             case "fs":
               sendFile(event);
@@ -74614,7 +76516,7 @@ class Service {
           }
         } catch (error) {
           if (data.type === "fs") {
-            this._kernel.log?.error(`[ServiceWorker] Error reading file ${data.file}: ${error instanceof Error ? error.message : "Unknown error"}`);
+            this._kernel.log.error(`[ServiceWorker] Error reading file ${data.file}: ${error instanceof Error ? error.message : "Unknown error"}`);
             event.source?.postMessage({
               type: "fs",
               file: data.file,
@@ -74651,7 +76553,7 @@ class Service {
     registration.addEventListener("progress", () => {
       if (!registration.downloadTotal) return;
       const percent = Math.round(registration.downloaded / registration.downloadTotal * 100);
-      this._kernel.log?.info(`${percent}% of ${urls.length} files downloaded.`);
+      this._kernel.log.info(`${percent}% of ${urls.length} files downloaded.`);
     });
     navigator.serviceWorker.addEventListener("message", async (e2) => {
       const root = this._kernel.shell.cwd || "/tmp";
@@ -74663,9 +76565,9 @@ class Service {
             const response = await fetch(url);
             const buffer2 = await response.arrayBuffer();
             await this._kernel.filesystem.fs.writeFile(`${destination}/${url.split("/").pop()}`, new Uint8Array(buffer2));
-            this._kernel.log?.info(`Saved ${url} to ${destination}/${url.split("/").pop()}.`);
+            this._kernel.log.info(`Saved ${url} to ${destination}/${url.split("/").pop()}.`);
           } catch (error) {
-            this._kernel.log?.error(`Failed to fetch ${url}: ${error}`);
+            this._kernel.log.error(`Failed to fetch ${url}: ${error}`);
           }
         }
         delete this._fetches[id];
@@ -75189,21 +77091,21 @@ class Storage {
       const open2 = this.indexed.open(name, options.indexed?.version || 1);
       open2.onsuccess = () => {
         this._db = open2.result;
-        this._kernel.log?.silly(`IndexedDB connection to ${name} successful`);
+        this._kernel.log.silly(`IndexedDB connection to ${name} successful`);
       };
       open2.onerror = () => {
-        this._kernel.log?.error("IndexedDB connection failed");
+        this._kernel.log.error("IndexedDB connection failed");
       };
       open2.onupgradeneeded = (event) => {
         const db = open2.result;
-        db.onerror = (event2) => this._kernel.log?.error("IndexedDB connection failed", event2);
+        db.onerror = (event2) => this._kernel.log.error("IndexedDB connection failed", event2);
         const store = db.createObjectStore("ecmaos:storage", { keyPath: "id", autoIncrement: true });
         switch (event.newVersion) {
           case 1:
             store.createIndex("data", "data", { unique: false });
             break;
         }
-        this._kernel.log?.silly(`IndexedDB schema ${event.newVersion === 1 ? "created" : "updated to version ${event.newVersion}"}`);
+        this._kernel.log.silly(`IndexedDB schema ${event.newVersion === 1 ? "created" : "updated to version ${event.newVersion}"}`);
       };
     }
   }
@@ -75219,7 +77121,7 @@ class Storage {
       if (!usage) throw new Error("Storage usage not available");
       return usage;
     } catch (error) {
-      this._kernel.log?.error("Storage usage failed", error);
+      this._kernel.log.error("Storage usage failed", error);
       return null;
     }
   }
@@ -75319,7 +77221,7 @@ class Users {
       if (shadowEntry) {
         const [, , , password, publicKey, encryptedPrivateKey] = shadowEntry.split(":");
         if (!publicKey || !encryptedPrivateKey) {
-          kernel.log?.warn(`User ${username} has no keypair`);
+          kernel.log.warn(`User ${username} has no keypair`);
           continue;
         }
         const keypair = { publicKey: JSON.parse(atob(publicKey)), privateKey: encryptedPrivateKey };
@@ -75334,7 +77236,7 @@ class Users {
           keypair
         }, { noWrite: true, noHome: true, noHash: true });
       } else {
-        kernel.log?.warn(`User ${username} not found in /etc/shadow`);
+        kernel.log.warn(`User ${username} not found in /etc/shadow`);
       }
     }
   }
@@ -78437,7 +80339,7 @@ ieee754.write = function(buffer2, value, offset, isLE, mLen, nBytes) {
   );
   E(
     "ERR_OUT_OF_RANGE",
-    function(str, range, input) {
+    function(str, range2, input) {
       let msg = `The value of "${str}" is out of range.`;
       let received = input;
       if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {
@@ -78449,7 +80351,7 @@ ieee754.write = function(buffer2, value, offset, isLE, mLen, nBytes) {
         }
         received += "n";
       }
-      msg += ` It must be ${range}. Received ${received}`;
+      msg += ` It must be ${range2}. Received ${received}`;
       return msg;
     },
     RangeError
@@ -78472,15 +80374,15 @@ ieee754.write = function(buffer2, value, offset, isLE, mLen, nBytes) {
   function checkIntBI(value, min, max2, buf, offset, byteLength3) {
     if (value > max2 || value < min) {
       const n = typeof min === "bigint" ? "n" : "";
-      let range;
+      let range2;
       {
         if (min === 0 || min === BigInt(0)) {
-          range = `>= 0${n} and < 2${n} ** ${(byteLength3 + 1) * 8}${n}`;
+          range2 = `>= 0${n} and < 2${n} ** ${(byteLength3 + 1) * 8}${n}`;
         } else {
-          range = `>= -(2${n} ** ${(byteLength3 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength3 + 1) * 8 - 1}${n}`;
+          range2 = `>= -(2${n} ** ${(byteLength3 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength3 + 1) * 8 - 1}${n}`;
         }
       }
-      throw new errors2.ERR_OUT_OF_RANGE("value", range, value);
+      throw new errors2.ERR_OUT_OF_RANGE("value", range2, value);
     }
     checkBounds(buf, offset, byteLength3);
   }
@@ -82593,10 +84495,10 @@ var createBIOS = (() => {
     return moduleRtn;
   };
 })();
-const __vite_import_meta_env__ = { "AUTHOR": { "name": "Jay Mathis", "email": "code@mathis.network", "url": "https://github.com/mathiscode" }, "BASE_URL": "/", "DESCRIPTION": "ecmaOS: Micro-kernel and framework for web technologies", "DEV": false, "HOMEPAGE": "https://ecmaos.sh", "KNOWN_ISSUES": ["Keyboard is broken on mobile; ecmaOS is not mobile-friendly at this time", "Don't expect any sort of POSIX compliance at this stage", "Most commands/devices are very basic implementations, not complete reproductions", "stdin/stdout/stderr streams and redirection can be wonky and don't work everywhere, but are coming along", "CTRL-C will return you to a prompt, but doesn't currently interrupt a process", "Lots of unfinished work; watch your step"], "MODE": "production", "NAME": "@ecmaos/kernel", "PROD": true, "REPOSITORY": "https://github.com/ecmaos/ecmaos", "SSR": false, "TIPS": ["You can 'run' some devices that offer a CLI - for example, '/dev/battery --help'"], "VERSION": "0.2.4", "VITE_APP_SHOW_DEFAULT_LOGIN": "true", "VITE_AUTOLOGIN_PASSWORD": "root", "VITE_AUTOLOGIN_USERNAME": "root", "VITE_KERNEL_INTERVALS_PROC": "1000", "VITE_KERNEL_MODULES": "@ecmaos-modules/sample@0.1.2", "VITE_METAL_SOCKET": "ws://localhost:30445/socket", "VITE_PORT": "30443" };
+const __vite_import_meta_env__ = { "AUTHOR": { "name": "Jay Mathis", "email": "code@mathis.network", "url": "https://github.com/mathiscode" }, "BASE_URL": "/", "DESCRIPTION": "ecmaOS: Micro-kernel and framework for web technologies", "DEV": false, "HOMEPAGE": "https://ecmaos.sh", "KNOWN_ISSUES": ["Keyboard is broken on mobile; ecmaOS is not mobile-friendly at this time", "Don't expect any sort of POSIX compliance at this stage", "Most commands/devices are very basic implementations, not complete reproductions", "stdin/stdout/stderr streams and redirection can be wonky and don't work everywhere, but are coming along", "CTRL-C will return you to a prompt, but doesn't currently interrupt a process", "Lots of unfinished work; watch your step"], "MODE": "production", "NAME": "@ecmaos/kernel", "PROD": true, "REPOSITORY": "https://github.com/ecmaos/ecmaos", "SSR": false, "TIPS": ["If it ever fails to boot, check your logs or try clearing all data", "You can run some devices that offer a CLI - e.g. '/dev/battery --help'", "Use the 'install' command to install packages - e.g. 'install @ecmaos-apps/news'", "Use the 'news' command to see the latest news about ecmaOS", "Type 'ls /bin' to see all built-in commands"], "VERSION": "0.2.7", "VITE_APP_SHOW_DEFAULT_LOGIN": "true", "VITE_AUTOLOGIN_PASSWORD": "root", "VITE_AUTOLOGIN_USERNAME": "root", "VITE_KERNEL_INTERVALS_PROC": "1000", "VITE_KERNEL_MODULES": "@ecmaos-modules/boilerplate@0.1.0", "VITE_METAL_SOCKET": "ws://localhost:30445/socket", "VITE_PORT": "30443", "VITE_RECOMMENDED_APPS": "@ecmaos-apps/code,@ecmaos-apps/webamp,@ecmaos-apps/news" };
 var define_import_meta_env_AUTHOR_default = { name: "Jay Mathis", email: "code@mathis.network", url: "https://github.com/mathiscode" };
 var define_import_meta_env_KNOWN_ISSUES_default = ["Keyboard is broken on mobile; ecmaOS is not mobile-friendly at this time", "Don't expect any sort of POSIX compliance at this stage", "Most commands/devices are very basic implementations, not complete reproductions", "stdin/stdout/stderr streams and redirection can be wonky and don't work everywhere, but are coming along", "CTRL-C will return you to a prompt, but doesn't currently interrupt a process", "Lots of unfinished work; watch your step"];
-var define_import_meta_env_TIPS_default = ["You can 'run' some devices that offer a CLI - for example, '/dev/battery --help'"];
+var define_import_meta_env_TIPS_default = ["If it ever fails to boot, check your logs or try clearing all data", "You can run some devices that offer a CLI - e.g. '/dev/battery --help'", "Use the 'install' command to install packages - e.g. 'install @ecmaos-apps/news'", "Use the 'news' command to see the latest news about ecmaOS", "Type 'ls /bin' to see all built-in commands"];
 const DefaultKernelOptions = {
   dom: DefaultDomOptions,
   log: DefaultLogOptions,
@@ -82637,7 +84539,7 @@ class Kernel {
     /** Name of the kernel */
     __publicField(this, "name", "@ecmaos/kernel");
     /** Version string of the kernel */
-    __publicField(this, "version", "0.2.4");
+    __publicField(this, "version", "0.2.7");
     /** Authentication and authorization service */
     __publicField(this, "auth");
     /** BIOS module providing low-level functionality */
@@ -82660,7 +84562,7 @@ class Kernel {
     __publicField(this, "intervals");
     /** Keyboard interface */
     __publicField(this, "keyboard");
-    /** Logging system, null if disabled */
+    /** Logging system */
     __publicField(this, "log");
     /** Memory management service */
     __publicField(this, "memory");
@@ -82707,7 +84609,7 @@ class Kernel {
     this.i18n = new I18n2(this.options.i18n);
     this.intervals = new Intervals();
     this.keyboard = navigator.keyboard;
-    this.log = this.options.log ? new Log(this.options.log) : null;
+    this.log = this.options.log ? new Log(this.options.log) : new Log();
     this.memory = new Memory();
     this.modules = /* @__PURE__ */ new Map();
     this.processes = new ProcessManager();
@@ -82750,7 +84652,7 @@ class Kernel {
     try {
       this.dom.topbar();
       this.terminal.unlisten();
-      this.log?.attachTransport((logObj) => {
+      this.log.attachTransport((logObj) => {
         if (!logObj?.["_meta"]) return;
         const acceptedLevels = ["WARN", "ERROR"];
         if (!acceptedLevels.includes(logObj["_meta"].logLevelName)) return;
@@ -82789,9 +84691,9 @@ class Kernel {
           logoFiglet = figlet.textSync(__vite_import_meta_env__["FIGLET_TEXT"] || "ECMAOS", { font: figletFont });
           this.terminal.writeln(colorFiglet(figletColor, logoFiglet));
         } catch (error) {
-          this.log?.error(`Failed to load figlet font ${figletFont}: ${error.message}`);
+          this.log.error(`Failed to load figlet font ${figletFont}: ${error.message}`);
         }
-        this.terminal.writeln(`${this.terminal.createSpecialLink("https://ecmaos.sh", "@ecmaos/kernel")} v${"0.2.4"}`);
+        this.terminal.writeln(`${this.terminal.createSpecialLink("https://ecmaos.sh", "@ecmaos/kernel")} v${"0.2.7"}`);
         this.terminal.writeln(`${t2("kernel.madeBy", "Made with ❤️  by Jay Mathis")} ${this.terminal.createSpecialLink(
           define_import_meta_env_AUTHOR_default?.url || "https://github.com/mathiscode",
           `${define_import_meta_env_AUTHOR_default?.name} <${define_import_meta_env_AUTHOR_default?.email}>`
@@ -82810,13 +84712,13 @@ class Kernel {
         spinner.start();
         if (logoFiglet) console.log(`%c${logoFiglet}`, "color: green");
         console.log(`%c${"https://github.com/ecmaos/ecmaos"}`, "color: blue; text-decoration: underline; font-size: 16px");
-        this.log.info(`${"@ecmaos/kernel"} v${"0.2.4"}`);
+        this.log.info(`${"@ecmaos/kernel"} v${"0.2.7"}`);
         if (Notification?.permission === "default") Notification.requestPermission();
-        if (Notification?.permission === "denied") this.log?.warn(t2("kernel.permissionNotificationDenied", "Notification permission denied"));
+        if (Notification?.permission === "denied") this.log.warn(t2("kernel.permissionNotificationDenied", "Notification permission denied"));
         this.intervals.set("title-blink", () => {
           globalThis.document.title = globalThis.document.title.includes("_") ? "ecmaos# " : "ecmaos# _";
         }, 600);
-        this.toast.success(`${"@ecmaos/kernel"} v${"0.2.4"}`);
+        this.toast.success(`${"@ecmaos/kernel"} v${"0.2.7"}`);
       }
       await this.configure({ filesystem: Filesystem.options() });
       const requiredPaths = [
@@ -82859,7 +84761,7 @@ class Kernel {
         if (specialPermissions[path2]) mode2 = specialPermissions[path2];
         if (!await this.filesystem.fs.exists(path2)) await this.filesystem.fs.mkdir(path2, { recursive: true, mode: mode2 });
       }
-      this.log?.attachTransport((logObj) => {
+      this.log.attachTransport((logObj) => {
         if (!logObj._meta) return;
         const formattedDate = new Date(logObj._meta.date).toLocaleString(this.memory.config.get("locale") || "en-US", {
           year: "numeric",
@@ -82886,7 +84788,7 @@ class Kernel {
       await this.registerProc();
       await this.registerPackages();
       this.intervals.set("/proc", this.registerProc.bind(this), "1000");
-      const modules = "@ecmaos-modules/sample@0.1.2";
+      const modules = "@ecmaos-modules/boilerplate@0.1.0";
       if (modules) {
         const mods = modules.split(",");
         for (const mod of mods) {
@@ -82895,14 +84797,14 @@ class Kernel {
             const name = spec?.[1];
             const version2 = spec?.[2];
             if (!name) {
-              this.log?.error(`Failed to load module ${mod}: Invalid package name format`);
+              this.log.error(`Failed to load module ${mod}: Invalid package name format`);
               continue;
             }
             if (!version2) {
-              this.log?.error(`Failed to load module ${mod}: No version specified`);
+              this.log.error(`Failed to load module ${mod}: No version specified`);
               continue;
             }
-            this.log?.info(`Loading module ${name}@${version2}`);
+            this.log.info(`Loading module ${name}@${version2}`);
             const [scope, pkg2] = name.split("/");
             const pkgPath = `/usr/lib/${scope ? `${scope}/` : ""}${pkg2}/${version2}`;
             const exists2 = await this.filesystem.fs.exists(pkgPath);
@@ -82912,11 +84814,11 @@ class Kernel {
               if (result !== 0) throw new Error(`Failed to install module ${name}@${version2}: ${result}`);
               if (!await this.filesystem.fs.exists(pkgPath)) throw new Error(`Failed to install module ${name}@${version2}: ${result}`);
             }
-            const pkgJson = await this.filesystem.fs.readFile(`${pkgPath}/package/package.json`, "utf-8");
+            const pkgJson = await this.filesystem.fs.readFile(`${pkgPath}/package.json`, "utf-8");
             const pkgData = JSON.parse(pkgJson);
             const mainFile = this.getPackageMainExport(pkgData);
             if (!mainFile) throw new Error(`Failed to load module ${name}@${version2}: No main export found`);
-            const mainPath = path.join(pkgPath, "package", mainFile);
+            const mainPath = path.join(pkgPath, mainFile);
             const module = await import(
               /* @vite-ignore */
               `/swapi/fs${mainPath}`
@@ -82925,7 +84827,7 @@ class Kernel {
             module.init?.(this.id);
             this.modules.set(modname, module);
           } catch (error) {
-            this.log?.error(`Failed to load module ${mod}: ${error.message}`);
+            this.log.error(`Failed to load module ${mod}: ${error.message}`);
           }
         }
       }
@@ -82933,7 +84835,7 @@ class Kernel {
         if (!await this.filesystem.fs.exists("/etc/passwd")) await this.users.add({ username: "root", password: "root", home: "/root" }, { noHome: true });
         else await this.users.load();
       } catch (err2) {
-        this.log?.error(err2);
+        this.log.error(err2);
         this.terminal.writeln(chalk$1.red(err2.message));
         throw err2;
       }
@@ -82997,7 +84899,7 @@ class Kernel {
         async exit() {
         }
       }
-      if (!await this.filesystem.fs.exists("/boot/init")) await this.filesystem.fs.writeFile("/boot/init", "#!ecmaos:script:init\n\n");
+      if (!await this.filesystem.fs.exists("/boot/init")) await this.filesystem.fs.writeFile("/boot/init", "#!ecmaos:bin:script:init\n\n");
       const initProcess = new InitProcess({
         args: [],
         command: "init",
@@ -83010,11 +84912,25 @@ class Kernel {
       });
       initProcess.start();
       this._state = KernelState.RUNNING;
+      if (!this.storage.local.getItem("ecmaos:first-boot")) {
+        const recommendedApps = "@ecmaos-apps/code,@ecmaos-apps/webamp,@ecmaos-apps/news";
+        if (recommendedApps) {
+          const apps = recommendedApps.split(",");
+          this.terminal.writeln("\n" + chalk$1.yellow.bold(this.i18n.t("kernel.recommendedApps", "Recommended apps:")));
+          this.terminal.writeln(chalk$1.green(apps.map((app) => `- ${app}`).join("\n")));
+          this.terminal.write(chalk$1.green.bold(this.i18n.t("kernel.installRecommendedApps", "Do you want to install the recommended apps? (Y/n)")));
+          const answer = await this.terminal.readline();
+          if (answer.toLowerCase()[0] === "y" || answer === "") {
+            for (const app of apps) await this.shell.execute(`/bin/install --reinstall ${app}`);
+          }
+        }
+        this.storage.local.setItem("ecmaos:first-boot", Date.now().toString());
+      }
       this.terminal.write(ansi$5.erase.inLine(2) + this.terminal.prompt());
       this.terminal.focus();
       this.terminal.listen();
     } catch (error) {
-      this.log?.error(error);
+      this.log.error(error);
       this._state = KernelState.PANIC;
       this.events.dispatch(KernelEvents.PANIC, { error });
       this.toast.error({
@@ -83086,7 +85002,7 @@ class Kernel {
   async execute(options) {
     try {
       if (!await this.filesystem.exists(options.command)) {
-        this.log?.error(`File not found for execution: ${options.command}`);
+        this.log.error(`File not found for execution: ${options.command}`);
         return -1;
       }
       if (options.command.startsWith("/dev/")) {
@@ -83099,25 +85015,25 @@ class Kernel {
       switch (header.type) {
         case "bin":
           switch (header.namespace) {
-            case "terminal": {
+            case "terminal":
+            // left for backward-compatibility
+            case "command":
               if (!header.name) return -1;
               exitCode = await this.executeCommand({ ...options, command: header.name });
               break;
-            }
-            case "app": {
+            case "app":
               if (!header.name) return -1;
               exitCode = await this.executeApp({ ...options, command: header.name, file: options.command });
               break;
-            }
+            case "script":
+              exitCode = await this.executeScript(options);
+              break;
+            case "node":
+              exitCode = await this.executeNode(options);
+              break;
           }
           ;
           break;
-        case "node":
-          exitCode = await this.executeNode(options);
-          break;
-        case "script":
-          exitCode = await this.executeScript(options);
-          break;
       }
       exitCode = exitCode ?? 0;
       options.shell.env.set("?", exitCode.toString());
@@ -83125,7 +85041,7 @@ class Kernel {
       return exitCode;
     } catch (error) {
       console.error(error);
-      this.log?.error(error);
+      this.log.error(error);
       options.shell.env.set("?", "-1");
       return -1;
     }
@@ -83138,18 +85054,9 @@ class Kernel {
   async executeApp(options) {
     try {
       const contents = await this.filesystem.fs.readFile(options.file, "utf-8");
-      const filePath = path.dirname(await this.filesystem.fs.readlink(options.file));
-      const modifiedContents = contents.replace(
-        /from ['"]([^'"]+)['"]/g,
-        (match, importPath) => {
-          if (!importPath.startsWith(".")) return match;
-          const resolvedPath = path.join(filePath, importPath);
-          const extensions = [".js", ".css"];
-          const withExtension = extensions.some((ext) => resolvedPath.endsWith(ext)) ? resolvedPath : `${resolvedPath}.js`;
-          return `from "${location.protocol}//${location.host}/swapi/fs${withExtension}"`;
-        }
-      );
-      const blob = new Blob([modifiedContents], { type: "application/javascript" });
+      const binLink = await this.filesystem.fs.readlink(options.file);
+      const filePath = path.dirname(binLink);
+      const blob = new Blob([await this.replaceImports(contents, filePath)], { type: "text/javascript" });
       const url = URL.createObjectURL(blob);
       try {
         const module = await import(
@@ -83174,7 +85081,7 @@ class Kernel {
         URL.revokeObjectURL(url);
       }
     } catch (error) {
-      this.log?.error(`Failed to execute app: ${error}`);
+      this.log.error(`Failed to execute app: ${error}`);
       options.terminal?.writeln(chalk$1.red(error.message));
       return -1;
     }
@@ -83212,7 +85119,7 @@ class Kernel {
    */
   async executeDevice(device, args = [], shell = this.shell) {
     if (!device || !device.cli) {
-      this.log?.error(`Device not found or does not have a CLI`);
+      this.log.error(`Device not found or does not have a CLI`);
       return -1;
     }
     let deviceProcess = new Process({
@@ -83235,7 +85142,7 @@ class Kernel {
       shell.setPositionalParameters([`/dev/${device.pkg.name}`, ...args]);
       await deviceProcess.start();
     } catch (error) {
-      this.log?.error(error);
+      this.log.error(error);
       this.terminal.writeln(chalk$1.red(error.message));
       return -2;
     } finally {
@@ -83245,23 +85152,42 @@ class Kernel {
   }
   /**
    * Executes a node script (or tries to)
+   *
+   * @remarks
+   * Don't expect it to work; this will help develop further emulation layers
+   *
    * @param options - Execution options containing script path and shell
    * @returns Exit code of the script
    */
   async executeNode(options) {
     if (!options.command) return -1;
     try {
-      const code2 = await this.filesystem.fs.readFile(options.command, "utf-8");
-      if (!code2) return -1;
-      const blob = new Blob([code2], { type: "text/javascript" });
+      const contents = await this.filesystem.fs.readFile(options.command, "utf-8");
+      if (!contents) return -1;
+      const binLink = await this.filesystem.fs.readlink(options.command);
+      const filePath = path.dirname(binLink);
+      const blob = new Blob([await this.replaceImports(contents, filePath)], { type: "text/javascript" });
       const url = URL.createObjectURL(blob);
-      const script = document.createElement("script");
-      script.type = "module";
-      script.src = url;
-      document.head.appendChild(script);
+      const module = await import(
+        /* @vite-ignore */
+        url
+      );
+      const main = module?.main || module?.default;
+      if (typeof main !== "function") throw new Error("No main function found in module");
+      const process2 = this.processes.create({
+        args: options.args || [],
+        command: options.command,
+        kernel: this,
+        shell: options.shell || this.shell,
+        terminal: options.terminal || this.terminal,
+        uid: options.shell.credentials.uid,
+        gid: options.shell.credentials.gid,
+        entry: async () => await main()
+      });
+      await process2.start();
       return 0;
     } catch (error) {
-      this.log?.error(`Failed to execute node script: ${error}`);
+      this.log.error(`Failed to execute node script: ${error}`);
       this.terminal.writeln(chalk$1.red(error.message));
       return -1;
     }
@@ -83274,8 +85200,8 @@ class Kernel {
   async executeScript(options) {
     const header = await this.readFileHeader(options.command);
     if (!header) return -1;
-    if (header.type !== "script") {
-      this.log?.error(`File is not a script: ${options.command}`);
+    if (header.type !== "bin" || header.namespace !== "script") {
+      this.log.error(`File is not a script: ${options.command}`);
       return -1;
     }
     const script = await this.filesystem.fs.readFile(options.command, "utf-8");
@@ -83285,7 +85211,7 @@ class Kernel {
         await options.shell.execute(line3);
       }
       return 0;
-    } else this.log?.error(`Script ${options.command} not found`);
+    } else this.log.error(`Script ${options.command} not found`);
     return -1;
   }
   /**
@@ -83329,9 +85255,7 @@ class Kernel {
         if (!type) return null;
         return { type, namespace, name };
       }
-      if (header.startsWith("#!/usr/bin/env node")) {
-        return { type: "node" };
-      }
+      if (header.startsWith("#!/usr/bin/env node")) return { type: "bin", namespace: "node", name: "node" };
       return null;
     };
     return new Promise((resolve2, reject) => {
@@ -83343,7 +85267,7 @@ class Kernel {
           readable2.on("error", (error) => reject(error));
           readable2.on("close", () => resolve2(null));
         } catch (error) {
-          this.log?.error(error);
+          this.log.error(error);
           reject(error);
         }
       })();
@@ -83353,7 +85277,7 @@ class Kernel {
    * Reboots the kernel by performing a shutdown and page reload
    */
   async reboot() {
-    this.log?.warn(this.i18n.t("Rebooting"));
+    this.log.warn(this.i18n.t("Rebooting"));
     await this.shutdown();
     globalThis.location.reload();
   }
@@ -83366,7 +85290,7 @@ class Kernel {
     const whitelistedCommands = Object.entries(TerminalCommands(this, this.shell, this.terminal)).filter(([name]) => !this.options.blacklist?.commands?.includes(name));
     for (const [name] of whitelistedCommands) {
       if (await this.filesystem.fs.exists(`/bin/${name}`)) continue;
-      await this.filesystem.fs.writeFile(`/bin/${name}`, `#!ecmaos:bin:terminal:${name}`, { mode: 493 });
+      await this.filesystem.fs.writeFile(`/bin/${name}`, `#!ecmaos:bin:command:${name}`, { mode: 493 });
     }
   }
   /**
@@ -83392,48 +85316,45 @@ class Kernel {
       this.events.on(event, async (detail) => {
         switch (event) {
           case KernelEvents.PANIC:
-            this.log?.fatal("KernelPanic:", detail);
+            this.log.fatal("KernelPanic:", detail);
             break;
         }
       });
     }
   }
   /**
-   * Registers the packages.
+   * Registers the packages from /etc/packages that should be auto-loaded on boot.
    * @returns {Promise<void>} A promise that resolves when the packages are registered.
    */
   async registerPackages() {
     try {
       const packagesData = await this.filesystem.fs.readFile("/etc/packages", "utf-8");
-      const packages = JSON.parse(packagesData);
+      const packages = packagesData.split("\n").filter(Boolean).filter((pkg2) => !pkg2.startsWith("#"));
       for (const pkg2 of packages) {
-        const pkgJson = await this.filesystem.fs.readFile(`/usr/lib/${pkg2.name}/${pkg2.version}/package/package.json`, "utf-8");
-        const pkgData = JSON.parse(pkgJson);
-        const mainFile = this.getPackageMainExport(pkgData);
-        if (!mainFile) {
-          this.log?.warn(`No main entry point found for package ${pkg2.name}`);
-          continue;
-        }
+        const spec = pkg2.match(/(@[^/]+\/[^@]+|[^@]+)(?:@([^/]+))?/);
+        const name = spec?.[1];
+        if (!name || !await this.filesystem.fs.exists(`/usr/lib/${name}`)) continue;
+        const versions = await this.filesystem.fs.readdir(`/usr/lib/${name}`);
+        const version2 = semver.maxSatisfying(versions, spec?.[2] || "*") || spec?.[2] || "*";
+        const pkgData = await this.filesystem.fs.readFile(`/usr/lib/${name}/${version2}/package.json`, "utf-8");
+        const pkgJson = JSON.parse(pkgData);
+        const mainFile = this.getPackageMainExport(pkgJson);
+        if (!mainFile) continue;
+        const filePath = `/usr/lib/${name}/${version2}/${mainFile}`;
+        const fileContents = await this.filesystem.fs.readFile(filePath, "utf-8");
+        const blob = new Blob([fileContents], { type: "text/javascript" });
+        const url = URL.createObjectURL(blob);
         try {
-          const filePath = `/usr/lib/${pkg2.name}/${pkg2.version}/package/${mainFile}`;
-          const fileContents = await this.filesystem.fs.readFile(filePath, "utf-8");
-          const type = pkgData.type === "module" || mainFile === pkgData.module ? "module" : "text/javascript";
-          const blob = new Blob([fileContents], { type });
-          const url = URL.createObjectURL(blob);
-          try {
-            this.log?.debug(`Loading package ${pkg2.name} v${pkg2.version}`);
-            const imports = await import(
-              /* @vite-ignore */
-              url
-            );
-            this.packages.set(pkg2.name, imports);
-          } catch (err2) {
-            this.log?.error(`Failed to load package ${pkg2.name} v${pkg2.version}: ${err2}`);
-          } finally {
-            URL.revokeObjectURL(url);
-          }
+          this.log.info(`Loading package ${name} v${version2}`);
+          const imports = await import(
+            /* @vite-ignore */
+            url
+          );
+          this.packages.set(name, imports);
         } catch (err2) {
-          this.log?.error(`Failed to read main file for package ${pkg2.name} v${pkg2.version}: ${err2}`);
+          this.log.error(`Failed to load package ${name} v${version2}: ${err2}`);
+        } finally {
+          URL.revokeObjectURL(url);
         }
       }
     } catch {
@@ -83449,7 +85370,7 @@ class Kernel {
       memory: "?",
       platform: navigator.userAgentData?.platform || navigator?.platform || navigator.userAgent,
       querystring: location.search,
-      version: `${"@ecmaos/kernel"} ${"0.2.4"}`,
+      version: `${"@ecmaos/kernel"} ${"0.2.7"}`,
       language: navigator.language,
       host: location.host,
       userAgent: navigator.userAgent,
@@ -83466,7 +85387,7 @@ class Kernel {
         const { downlink, effectiveType, rtt, saveData } = navigator.connection;
         contents.connection = JSON.stringify({ downlink, effectiveType, rtt, saveData }, null, 2);
       } catch {
-        this.log?.warn("Failed to get connection data");
+        this.log.warn("Failed to get connection data");
       }
     }
     if ("deviceMemory" in navigator) contents.memory = `>= ${navigator.deviceMemory}GB`;
@@ -83474,10 +85395,32 @@ class Kernel {
       try {
         await this.filesystem.fs.writeFile(`/proc/${key}`, value ?? new Uint8Array(), { flag: "w+", mode: 511 });
       } catch (error) {
-        this.log?.warn(`Failed to write proc data: ${key}`, error);
+        this.log.warn(`Failed to write proc data: ${key}`, error);
       }
     }
   }
+  /**
+   * Replaces imports in a script with SWAPI URLs
+   *
+   * @remarks
+   * I would love to just use import maps, but we need dynamic import maps
+   * This is probably not our long-term solution
+   *
+   * @param {string} contents - The script contents
+   * @returns {Promise<string>} The modified script contents
+   */
+  async replaceImports(contents, packagePath) {
+    const replacements = {};
+    const importRegex = /from ['"]([^'"]+)['"]/g;
+    const matches = contents.match(importRegex);
+    for (const match of matches || []) {
+      const importPath = match.replace(/from ['"]|['"]/g, "");
+      const exists2 = await this.filesystem.fs.exists(`/usr/lib/${path.join(packagePath, importPath)}`);
+      if (exists2) replacements[match] = `from "${location.protocol}//${location.host}/swapi/fs${path.join(packagePath, importPath)}"`;
+    }
+    for (const [match, replacement] of Object.entries(replacements)) contents = contents.replace(match, replacement);
+    return contents;
+  }
   /**
    * Shuts down the kernel.
    * @returns {Promise<void>} A promise that resolves when the kernel is shut down.
@@ -83500,7 +85443,7 @@ class Kernel {
       useCredentials(cred);
       result = await operation();
     } catch (error) {
-      this.log?.error(error);
+      this.log.error(error);
     } finally {
       useCredentials(currentCredentials);
     }
@@ -83515,9 +85458,9 @@ const empty = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePropert
 }, Symbol.toStringTag, { value: "Module" }));
 export {
   Kernel as K,
-  path as a,
   chalk$1 as c,
   getDefaultExportFromCjs$2 as g,
-  process$1$1 as p
+  path as p,
+  semver as s
 };
-//# sourceMappingURL=empty-BMkCc_7L.js.map
+//# sourceMappingURL=empty--zdtkf0T.js.map