jspm 4.2.0 → 4.4.0

package/dist/cli.js

@@ -294,10 +294,110 @@ var require_sver = __commonJS({
     var MAJOR_RANGE = 1;
     var STABLE_RANGE = 2;
     var EXACT_RANGE = 3;
+    var LOWER_BOUND = 4;
+    var UPPER_BOUND = 5;
+    var INTERSECTION_RANGE = 6;
+    var UNION_RANGE = 7;
     var TYPE = Symbol("type");
     var VERSION = Symbol("version");
+    var RANGE_SET = Symbol("rangeSet");
+    var BOUND_INCLUSIVE = Symbol("boundInclusive");
+    var comparatorRegEx = /^(>=|<=|>|<|=)\s*(.+)$/;
+    var partialRegEx = /^(0|[1-9]\d*)(?:\.(0|[1-9]\d*)(?:\.(0|[1-9]\d*)(?:-([\da-z-]+(?:\.[\da-z-]+)*))?(\+[\da-z-]+)?)?)?$/i;
+    function effectiveVersion(range) {
+      if (range[VERSION])
+        return range[VERSION];
+      if (range[RANGE_SET] && range[RANGE_SET].length > 0)
+        return effectiveVersion(range[RANGE_SET][0]);
+      return null;
+    }
+    function effectiveUpperBound(range) {
+      let type = range[TYPE];
+      if (type === WILDCARD_RANGE || type === LOWER_BOUND)
+        return null;
+      if (type === MAJOR_RANGE)
+        return new Semver(range[VERSION][MAJOR] + 1 + ".0.0");
+      if (type === STABLE_RANGE)
+        return new Semver(range[VERSION][MAJOR] + "." + (range[VERSION][MINOR] + 1) + ".0");
+      if (type === EXACT_RANGE || type === UPPER_BOUND)
+        return range[VERSION];
+      if (type === INTERSECTION_RANGE) {
+        let min = null;
+        for (let r of range[RANGE_SET]) {
+          let ub = effectiveUpperBound(r);
+          if (ub !== null && (min === null || Semver.compare(ub, min) < 0))
+            min = ub;
+        }
+        return min;
+      }
+      if (type === UNION_RANGE) {
+        let max = null;
+        for (let r of range[RANGE_SET]) {
+          let ub = effectiveUpperBound(r);
+          if (ub === null)
+            return null;
+          if (max === null || Semver.compare(ub, max) > 0)
+            max = ub;
+        }
+        return max;
+      }
+      return range[VERSION] || null;
+    }
+    function createUpperBoundFromHyphen(verStr) {
+      let fullVer = verStr.match(semverRegEx);
+      if (fullVer) {
+        return new SemverRange2("<=" + verStr);
+      }
+      let partialMatch = verStr.match(partialRegEx);
+      if (partialMatch) {
+        let major = parseInt(partialMatch[1], 10);
+        let hasMinor = partialMatch[2] !== void 0;
+        let minor = hasMinor ? parseInt(partialMatch[2], 10) : void 0;
+        if (hasMinor) {
+          return new SemverRange2("<" + major + "." + (minor + 1) + ".0");
+        } else {
+          return new SemverRange2("<" + (major + 1) + ".0.0");
+        }
+      }
+      return new SemverRange2("<=" + verStr);
+    }
     var SemverRange2 = class {
       constructor(versionRange) {
+        versionRange = versionRange.trim();
+        versionRange = versionRange.replace(/(>=|<=|>|<|=)\s+/g, "$1");
+        if (versionRange.includes("||")) {
+          let parts = versionRange.split("||").map((p) => p.trim()).filter(Boolean);
+          if (parts.length >= 2) {
+            this[TYPE] = UNION_RANGE;
+            this[RANGE_SET] = parts.map((p) => new SemverRange2(p));
+            return;
+          }
+          if (parts.length === 1)
+            versionRange = parts[0];
+          else {
+            this[TYPE] = WILDCARD_RANGE;
+            return;
+          }
+        }
+        let hyphenMatch = versionRange.match(/^(\S+)\s+-\s+(\S+)$/);
+        if (hyphenMatch) {
+          this[TYPE] = INTERSECTION_RANGE;
+          this[RANGE_SET] = [
+            new SemverRange2(">=" + hyphenMatch[1]),
+            createUpperBoundFromHyphen(hyphenMatch[2])
+          ];
+          return;
+        }
+        let tokens = versionRange.split(/\s+/);
+        if (tokens.length > 1) {
+          this[TYPE] = INTERSECTION_RANGE;
+          this[RANGE_SET] = tokens.map((t) => new SemverRange2(t));
+          return;
+        }
+        versionRange = versionRange.replace(/\.[xX*]/g, "");
+        if (/^[xX*]$/.test(versionRange) || versionRange === "") {
+          versionRange = "*";
+        }
         if (versionRange === "*" || versionRange === "") {
           this[TYPE] = WILDCARD_RANGE;
           return;
@@ -317,7 +417,9 @@ var require_sver = __commonJS({
               this[TYPE] = STABLE_RANGE;
           }
           this[VERSION][PRE] = this[VERSION][PRE] || [];
-        } else if (versionRange.startsWith("^^")) {
+          return;
+        }
+        if (versionRange.startsWith("^^")) {
           this[VERSION] = new Semver(versionRange.substr(2));
           this[TYPE] = MAJOR_RANGE;
         } else if (versionRange[0] === "^") {
@@ -333,13 +435,98 @@ var require_sver = __commonJS({
         } else if (versionRange[0] === "~") {
           this[VERSION] = new Semver(versionRange.substr(1));
           this[TYPE] = STABLE_RANGE;
+        } else if (comparatorRegEx.test(versionRange)) {
+          let match2 = versionRange.match(comparatorRegEx);
+          this._parseComparator(match2[1], match2[2].trim());
+          return;
         } else {
           this[VERSION] = new Semver(versionRange);
           this[TYPE] = EXACT_RANGE;
         }
-        if (this[VERSION][TAG] && this[TYPE] !== EXACT_RANGE)
+        if (this[VERSION] && this[VERSION][TAG] && this[TYPE] !== EXACT_RANGE)
           this[TYPE] = EXACT_RANGE;
       }
+      _parseComparator(op, verStr) {
+        if (op === "=") {
+          let fullVer = verStr.match(semverRegEx);
+          if (fullVer) {
+            this[VERSION] = new Semver(verStr);
+            this[TYPE] = EXACT_RANGE;
+          } else {
+            let temp = new SemverRange2(verStr);
+            this[TYPE] = temp[TYPE];
+            this[VERSION] = temp[VERSION];
+            if (temp[RANGE_SET])
+              this[RANGE_SET] = temp[RANGE_SET];
+            if (temp[BOUND_INCLUSIVE] !== void 0)
+              this[BOUND_INCLUSIVE] = temp[BOUND_INCLUSIVE];
+          }
+          return;
+        }
+        let isLower = op === ">=" || op === ">";
+        let isInclusive = op === ">=" || op === "<=";
+        let partialMatch = verStr.match(partialRegEx);
+        if (!partialMatch) {
+          this[VERSION] = new Semver(op + verStr);
+          this[TYPE] = EXACT_RANGE;
+          return;
+        }
+        let major = parseInt(partialMatch[1], 10);
+        let hasMinor = partialMatch[2] !== void 0;
+        let minor = hasMinor ? parseInt(partialMatch[2], 10) : void 0;
+        let hasPatch = partialMatch[3] !== void 0;
+        if (hasPatch) {
+          this[VERSION] = new Semver(verStr);
+          this[TYPE] = isLower ? LOWER_BOUND : UPPER_BOUND;
+          this[BOUND_INCLUSIVE] = isInclusive;
+        } else if (hasMinor) {
+          if (isLower) {
+            if (isInclusive) {
+              this[VERSION] = new Semver(major + "." + minor + ".0");
+            } else {
+              this[VERSION] = new Semver(major + "." + (minor + 1) + ".0");
+            }
+            this[TYPE] = LOWER_BOUND;
+            this[BOUND_INCLUSIVE] = true;
+          } else {
+            if (isInclusive) {
+              this[VERSION] = new Semver(major + "." + (minor + 1) + ".0");
+            } else {
+              this[VERSION] = new Semver(major + "." + minor + ".0");
+            }
+            this[TYPE] = UPPER_BOUND;
+            this[BOUND_INCLUSIVE] = false;
+          }
+        } else {
+          if (isLower) {
+            if (isInclusive) {
+              this[VERSION] = new Semver(major + ".0.0");
+            } else {
+              this[VERSION] = new Semver(major + 1 + ".0.0");
+            }
+            this[TYPE] = LOWER_BOUND;
+            this[BOUND_INCLUSIVE] = true;
+          } else {
+            if (isInclusive) {
+              this[VERSION] = new Semver(major + 1 + ".0.0");
+            } else {
+              this[VERSION] = new Semver(major + ".0.0");
+            }
+            this[TYPE] = UPPER_BOUND;
+            this[BOUND_INCLUSIVE] = false;
+          }
+        }
+      }
+      _testBound(version3) {
+        if (version3[TAG])
+          return false;
+        let cmp = Semver.compare(version3, this[VERSION]);
+        if (this[TYPE] === LOWER_BOUND)
+          return this[BOUND_INCLUSIVE] ? cmp >= 0 : cmp > 0;
+        if (this[TYPE] === UPPER_BOUND)
+          return this[BOUND_INCLUSIVE] ? cmp <= 0 : cmp < 0;
+        return false;
+      }
       get isExact() {
         return this[TYPE] === EXACT_RANGE;
       }
@@ -358,6 +545,18 @@ var require_sver = __commonJS({
       get isWildcard() {
         return this[TYPE] === WILDCARD_RANGE;
       }
+      get isLowerBound() {
+        return this[TYPE] === LOWER_BOUND;
+      }
+      get isUpperBound() {
+        return this[TYPE] === UPPER_BOUND;
+      }
+      get isIntersection() {
+        return this[TYPE] === INTERSECTION_RANGE;
+      }
+      get isUnion() {
+        return this[TYPE] === UNION_RANGE;
+      }
       get type() {
         switch (this[TYPE]) {
           case WILDCARD_RANGE:
@@ -368,11 +567,25 @@ var require_sver = __commonJS({
             return "stable";
           case EXACT_RANGE:
             return "exact";
+          case LOWER_BOUND:
+            return "lower_bound";
+          case UPPER_BOUND:
+            return "upper_bound";
+          case INTERSECTION_RANGE:
+            return "intersection";
+          case UNION_RANGE:
+            return "union";
         }
       }
       get version() {
         return this[VERSION];
       }
+      get rangeSet() {
+        return this[RANGE_SET];
+      }
+      get boundInclusive() {
+        return this[BOUND_INCLUSIVE];
+      }
       gt(range) {
         return SemverRange2.compare(this, range) === 1;
       }
@@ -389,21 +602,54 @@ var require_sver = __commonJS({
           return unstable || !version3[PRE] && !version3[TAG];
         if (this[TYPE] === EXACT_RANGE)
           return this[VERSION].eq(version3);
-        if (version3[TAG])
-          return false;
-        if (this[VERSION][MAJOR] !== version3[MAJOR])
-          return false;
-        if (this[TYPE] === MAJOR_RANGE ? this[VERSION][MINOR] > version3[MINOR] : this[VERSION][MINOR] !== version3[MINOR])
-          return false;
-        if ((this[TYPE] === MAJOR_RANGE ? this[VERSION][MINOR] === version3[MINOR] : true) && this[VERSION][PATCH] > version3[PATCH])
-          return false;
-        if (version3[PRE] === void 0 || version3[PRE].length === 0)
-          return true;
-        if (this[VERSION][PRE] === void 0 || this[VERSION][PRE].length === 0)
-          return unstable;
-        if (unstable === false && (this[VERSION][MINOR] !== version3[MINOR] || this[VERSION][PATCH] !== version3[PATCH]))
-          return false;
-        return prereleaseCompare(this[VERSION][PRE], version3[PRE]) !== 1;
+        if (this[TYPE] === MAJOR_RANGE || this[TYPE] === STABLE_RANGE) {
+          if (version3[TAG])
+            return false;
+          if (this[VERSION][MAJOR] !== version3[MAJOR])
+            return false;
+          if (this[TYPE] === MAJOR_RANGE ? this[VERSION][MINOR] > version3[MINOR] : this[VERSION][MINOR] !== version3[MINOR])
+            return false;
+          if ((this[TYPE] === MAJOR_RANGE ? this[VERSION][MINOR] === version3[MINOR] : true) && this[VERSION][PATCH] > version3[PATCH])
+            return false;
+          if (version3[PRE] === void 0 || version3[PRE].length === 0)
+            return true;
+          if (this[VERSION][PRE] === void 0 || this[VERSION][PRE].length === 0)
+            return unstable;
+          if (unstable === false && (this[VERSION][MINOR] !== version3[MINOR] || this[VERSION][PATCH] !== version3[PATCH]))
+            return false;
+          return prereleaseCompare(this[VERSION][PRE], version3[PRE]) !== 1;
+        }
+        if (this[TYPE] === LOWER_BOUND || this[TYPE] === UPPER_BOUND) {
+          if (version3[TAG])
+            return false;
+          if (!unstable && version3[PRE] && version3[PRE].length) {
+            if (!this[VERSION][PRE] || !this[VERSION][PRE].length || this[VERSION][MAJOR] !== version3[MAJOR] || this[VERSION][MINOR] !== version3[MINOR] || this[VERSION][PATCH] !== version3[PATCH])
+              return false;
+          }
+          return this._testBound(version3);
+        }
+        if (this[TYPE] === INTERSECTION_RANGE) {
+          if (version3[TAG]) {
+            return this[RANGE_SET].every((r) => r.has(version3, unstable));
+          }
+          if (!unstable && version3[PRE] && version3[PRE].length) {
+            let hasTupleMatch = this[RANGE_SET].some((r) => {
+              let v = r[VERSION];
+              return v && v[PRE] && v[PRE].length && v[MAJOR] === version3[MAJOR] && v[MINOR] === version3[MINOR] && v[PATCH] === version3[PATCH];
+            });
+            if (!hasTupleMatch)
+              return false;
+          }
+          return this[RANGE_SET].every((r) => {
+            if (r[TYPE] === LOWER_BOUND || r[TYPE] === UPPER_BOUND)
+              return r._testBound(version3);
+            return r.has(version3, !unstable ? true : unstable);
+          });
+        }
+        if (this[TYPE] === UNION_RANGE) {
+          return this[RANGE_SET].some((r) => r.has(version3, unstable));
+        }
+        return false;
       }
       contains(range) {
         if (!(range instanceof SemverRange2))
@@ -412,7 +658,19 @@ var require_sver = __commonJS({
           return true;
         if (range[TYPE] === WILDCARD_RANGE)
           return false;
-        return range[TYPE] >= this[TYPE] && this.has(range[VERSION], true);
+        if (this[TYPE] === UNION_RANGE)
+          return this[RANGE_SET].some((r) => r.contains(range));
+        if (range[TYPE] === UNION_RANGE)
+          return range[RANGE_SET].every((r) => this.contains(r));
+        if (range[TYPE] === INTERSECTION_RANGE)
+          return range[RANGE_SET].some((r) => this.contains(r));
+        if (this[TYPE] === INTERSECTION_RANGE)
+          return this[RANGE_SET].every((r) => r.contains(range));
+        if (this[TYPE] <= EXACT_RANGE && range[TYPE] <= EXACT_RANGE)
+          return range[TYPE] >= this[TYPE] && this.has(range[VERSION], true);
+        if ((this[TYPE] === LOWER_BOUND || this[TYPE] === UPPER_BOUND) && range[TYPE] === EXACT_RANGE)
+          return this.has(range[VERSION], true);
+        return false;
       }
       intersect(range) {
         if (!(range instanceof SemverRange2))
@@ -427,23 +685,56 @@ var require_sver = __commonJS({
           return range.has(this[VERSION], true) ? this : void 0;
         if (range[TYPE] === EXACT_RANGE)
           return this.has(range[VERSION], true) ? range : void 0;
-        let higherRange, lowerRange, polarity;
-        if (range[VERSION].gt(this[VERSION])) {
-          higherRange = range;
-          lowerRange = this;
-          polarity = true;
-        } else {
-          higherRange = this;
-          lowerRange = range;
-          polarity = false;
-        }
-        if (!lowerRange.has(higherRange[VERSION], true))
-          return;
-        if (lowerRange[TYPE] === MAJOR_RANGE)
-          return polarity ? range : this;
-        let intersection = new SemverRange2(higherRange[VERSION].toString());
-        intersection[TYPE] = STABLE_RANGE;
-        return intersection;
+        if (this[TYPE] === UNION_RANGE) {
+          let results = this[RANGE_SET].map((r) => r.intersect(range)).filter(Boolean);
+          if (results.length === 0)
+            return void 0;
+          if (results.length === 1)
+            return results[0];
+          let union = Object.create(SemverRange2.prototype);
+          union[TYPE] = UNION_RANGE;
+          union[RANGE_SET] = results;
+          return union;
+        }
+        if (range[TYPE] === UNION_RANGE)
+          return range.intersect(this);
+        if (this[TYPE] === INTERSECTION_RANGE && range[TYPE] === INTERSECTION_RANGE) {
+          let result2 = Object.create(SemverRange2.prototype);
+          result2[TYPE] = INTERSECTION_RANGE;
+          result2[RANGE_SET] = [...this[RANGE_SET], ...range[RANGE_SET]];
+          return result2;
+        }
+        if (this[TYPE] === INTERSECTION_RANGE) {
+          let result2 = Object.create(SemverRange2.prototype);
+          result2[TYPE] = INTERSECTION_RANGE;
+          result2[RANGE_SET] = [...this[RANGE_SET], range];
+          return result2;
+        }
+        if (range[TYPE] === INTERSECTION_RANGE)
+          return range.intersect(this);
+        if (this[TYPE] <= EXACT_RANGE && range[TYPE] <= EXACT_RANGE) {
+          let higherRange, lowerRange, polarity;
+          if (range[VERSION].gt(this[VERSION])) {
+            higherRange = range;
+            lowerRange = this;
+            polarity = true;
+          } else {
+            higherRange = this;
+            lowerRange = range;
+            polarity = false;
+          }
+          if (!lowerRange.has(higherRange[VERSION], true))
+            return;
+          if (lowerRange[TYPE] === MAJOR_RANGE)
+            return polarity ? range : this;
+          let intersection = new SemverRange2(higherRange[VERSION].toString());
+          intersection[TYPE] = STABLE_RANGE;
+          return intersection;
+        }
+        let result = Object.create(SemverRange2.prototype);
+        result[TYPE] = INTERSECTION_RANGE;
+        result[RANGE_SET] = [this, range];
+        return result;
       }
       bestMatch(versions, unstable = false) {
         let maxSemver;
@@ -476,6 +767,14 @@ var require_sver = __commonJS({
             return "~" + version3.toString();
           case EXACT_RANGE:
             return version3.toString();
+          case LOWER_BOUND:
+            return (this[BOUND_INCLUSIVE] ? ">=" : ">") + version3.toString();
+          case UPPER_BOUND:
+            return (this[BOUND_INCLUSIVE] ? "<=" : "<") + version3.toString();
+          case INTERSECTION_RANGE:
+            return this[RANGE_SET].map((r) => r.toString()).join(" ");
+          case UNION_RANGE:
+            return this[RANGE_SET].map((r) => r.toString()).join(" || ");
         }
       }
       toJSON() {
@@ -488,7 +787,9 @@ var require_sver = __commonJS({
       }
       static isValid(range) {
         let semverRange = new SemverRange2(range);
-        return semverRange[TYPE] !== EXACT_RANGE || semverRange[VERSION][TAG] === void 0;
+        if (semverRange[TYPE] === EXACT_RANGE)
+          return semverRange[VERSION][TAG] === void 0;
+        return true;
       }
       static compare(r1, r2) {
         if (!(r1 instanceof SemverRange2))
@@ -501,9 +802,28 @@ var require_sver = __commonJS({
           return 1;
         if (r2[TYPE] === WILDCARD_RANGE)
           return -1;
-        let cmp = Semver.compare(r1[VERSION], r2[VERSION]);
-        if (cmp !== 0) {
+        let u1 = effectiveUpperBound(r1);
+        let u2 = effectiveUpperBound(r2);
+        if (u1 === null && u2 === null) {
+          let v12 = effectiveVersion(r1);
+          let v22 = effectiveVersion(r2);
+          if (v12 && v22)
+            return Semver.compare(v12, v22);
+          return 0;
+        }
+        if (u1 === null)
+          return 1;
+        if (u2 === null)
+          return -1;
+        let cmp = Semver.compare(u1, u2);
+        if (cmp !== 0)
           return cmp;
+        let v1 = effectiveVersion(r1);
+        let v2 = effectiveVersion(r2);
+        if (v1 && v2) {
+          cmp = Semver.compare(v1, v2);
+          if (cmp !== 0)
+            return cmp;
         }
         if (r1[TYPE] === r2[TYPE])
           return 0;
@@ -2321,8 +2641,9 @@ async function writeHtmlOutput(mapFile, generator, pins, env2, flags, silent = f
   } catch (e) {
     throw new JspmError(`Failed to read HTML file ${c4.cyan(mapFile)} for injection.`);
   }
+  const entryPoints = pins.length ? pins : Object.keys(generator.getMap().imports || {});
   const outputHtml = await generator.htmlInject(html, {
-    pins: pins ?? true,
+    pins: entryPoints,
     htmlUrl: generator.mapUrl,
     // URL of the output map
     rootUrl: generator.rootUrl,
@@ -2404,7 +2725,7 @@ async function getGenerator(flags, configOverride = null, inputMap) {
         inputMap: inputMap || await getInputMap(flags),
         env: await getEnv(flags),
         flattenScopes: flags.flattenScopes === false ? false : Boolean(flags.release || flags.flattenScopes),
-        combineSubpaths: flags.combineSubpaths === false ? false : Boolean(flags.release || flags.combineSubpaths),
+        combineSubpaths: flags.combineSubpaths === false ? "none" : "both",
         defaultProvider,
         resolutions: getResolutions(flags),
         cache: getCacheMode(flags),
@@ -2834,7 +3155,7 @@ async function getLatestEsms(generator, provider2) {
     {
       name: "es-module-shims",
       registry: "npm",
-      ranges: [new import_sver.SemverRange("*")]
+      range: new import_sver.SemverRange("*")
     },
     generator.traceMap.installer.defaultProvider
   );
@@ -28741,7 +29062,7 @@ init_utils();
 init_init();
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 import c7 from "picocolors";
-async function install(flags, update) {
+async function install(flags, update = false) {
   const log2 = withType("install/install");
   log2(`Flags: ${JSON.stringify(flags)}`);
   const env2 = await getEnv(flags);
@@ -29142,7 +29463,13 @@ async function build(flags) {
     const { output } = await bundle.generate({
       format: "esm",
       assetFileNames: "[name][extname]",
-      entryFileNames: "[name]",
+      entryFileNames: flags.hashEntries ? (chunkInfo) => {
+        const name = chunkInfo.name;
+        const dotIdx = name.lastIndexOf(".");
+        if (dotIdx !== -1)
+          return `${name.slice(0, dotIdx)}-[hash:8]${name.slice(dotIdx)}`;
+        return "[name]-[hash:8]";
+      } : "[name]",
       chunkFileNames: "lib/[name]-[hash:8].js",
       sourcemap: true,
       compact: flags.minify
@@ -29173,9 +29500,15 @@ async function build(flags) {
       const pjson = JSON.parse(
         readFileSync2(join3(projectConfig.projectPath, "package.json"), "utf8")
       );
-      pjson.exports = JSON.parse(
-        JSON.stringify(pjson.exports).replace(/\.ts"/g, '.js"').replace(/\.mts"/g, '.mjs"')
-      );
+      let exportsStr = JSON.stringify(pjson.exports).replace(/\.ts"/g, '.js"').replace(/\.mts"/g, '.mjs"');
+      if (flags.hashEntries) {
+        for (const chunk of output) {
+          if (chunk.type === "chunk" && chunk.isEntry && chunk.fileName !== chunk.name) {
+            exportsStr = exportsStr.split(chunk.name).join(chunk.fileName);
+          }
+        }
+      }
+      pjson.exports = JSON.parse(exportsStr);
       const outPath = join3(flags.out, "package.json");
       const outDir = dirname3(outPath);
       await mkdir3(outDir, { recursive: true });
@@ -29798,6 +30131,11 @@ async function readJsonFile(filePath, defaultValue = {}) {
 }
 async function eject(flags) {
   const log2 = withType("publish/eject");
+  console.warn(
+    `${c11.yellow(
+      "Warning:"
+    )} jspm publish is experimental and should only be used for prototyping. Unlike the https://ga.jspm.io/ CDN which is stable, reliability guarantees are not provided for publishing on https://jspm.io/. For reliable package delivery, use npm publish \u2014 all npm packages are available on the https://ga.jspm.io/ CDN.`
+  );
   const pkg = flags.eject;
   if (!pkg.startsWith("app:")) {
     throw new JspmError(`Only the app: JSPM registry is currently supported for ejection.`);
@@ -29827,6 +30165,11 @@ async function eject(flags) {
 }
 async function publish(flags = {}) {
   const log2 = withType("publish/publish");
+  console.warn(
+    `${c11.yellow(
+      "Warning:"
+    )} jspm publish is experimental and should only be used for prototyping. Unlike the https://ga.jspm.io/ CDN which is stable, reliability guarantees are not provided for publishing on https://jspm.io/. For reliable package delivery, use npm publish \u2014 all npm packages are available on the https://ga.jspm.io/ CDN.`
+  );
   const { initProject: initProject2 } = await Promise.resolve().then(() => (init_init(), init_exports));
   try {
     const projectConfig = await initProject2({
@@ -33000,7 +33343,7 @@ generateOpts(
       default: "dist"
     }).option("--install", "Generate import map after build completes", {
       default: true
-    }),
+    }).option("--hash-entries", "Hash entry point filenames in the output"),
     true
   )
 ).example(
@@ -33106,6 +33449,11 @@ Download the application package foo@bar into the folder foo, merging its import
 
 Manages publishes to the JSPM providers, currently in experimental preview.
 
+WARNING: jspm publish is experimental and should only be used for prototyping.
+Unlike the https://ga.jspm.io/ CDN which is stable, reliability guarantees are
+not provided for publishing on https://jspm.io/. For reliable package delivery,
+use npm publish \u2014 all npm packages are available on the https://ga.jspm.io/ CDN.
+
 For publishing (default):
 
   jspm publish

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "jspm",
   "type": "module",
-  "version": "4.2.0",
+  "version": "4.4.0",
   "description": "Import Map Package Manager",
   "license": "Apache-2.0",
   "bin": {
@@ -17,7 +17,7 @@
   },
   "dependencies": {
     "@babel/core": "^7.24.7",
-    "@jspm/generator": "^2.7.6",
+    "@jspm/generator": "^2.11.0",
     "@jspm/plugin-rollup": "^1.2.4",
     "ora": "^8.2.0",
     "picocolors": "^1.1.1"