@valbuild/shared 0.148.7 → 0.149.7

package/dist/acquireTypes-de10005d.cjs.dev.js

@@ -0,0 +1,1815 @@
+'use strict';
+
+var slicedToArray = require('./slicedToArray-62e428df.cjs.dev.js');
+var createForOfIteratorHelper = require('./createForOfIteratorHelper-d86bb352.cjs.dev.js');
+var yaml = require('yaml');
+
+/**
+ * The parts of a `pnpm-lock.yaml` (lockfile version 9) that decide what
+ * `pnpm install` puts in `node_modules`.
+ *
+ * Only what the layout needs is kept: each importer's direct dependencies,
+ * each package's integrity and platform constraints, and each snapshot's own
+ * dependencies. Everything is a plain string as pnpm wrote it -- a reference
+ * such as `19.3.0(react@19.3.0)` is turned into a snapshot key by
+ * {@link snapshotKeyOf}, as pnpm's lockfile crate does.
+ */
+
+/** An importer's dependencies, alias to the reference pnpm locked it at. */
+
+/** A lockfile this cannot read: not YAML, or not pnpm's version 9 shape. */
+var LockfileError = /*#__PURE__*/function (_Error) {
+  function LockfileError() {
+    slicedToArray._classCallCheck(this, LockfileError);
+    return slicedToArray._callSuper(this, LockfileError, arguments);
+  }
+  slicedToArray._inherits(LockfileError, _Error);
+  return slicedToArray._createClass(LockfileError);
+}(/*#__PURE__*/slicedToArray._wrapNativeSuper(Error));
+function isRecord(value) {
+  return createForOfIteratorHelper._typeof(value) === "object" && value !== null && !Array.isArray(value);
+}
+
+/** YAML reads `1.0` as a number; a lockfile means the text. */
+function textOf(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  return null;
+}
+function stringList(value) {
+  if (value === undefined || value === null) return null;
+  if (Array.isArray(value)) {
+    return value.flatMap(function (item) {
+      var text = textOf(item);
+      return text === null ? [] : [text];
+    });
+  }
+  var text = textOf(value);
+  return text === null ? null : [text];
+}
+
+/** `alias: <reference>` in a snapshot, or `alias: { specifier, version }` in an importer. */
+function referenceMap(value, where) {
+  var out = {};
+  if (value === undefined || value === null) return out;
+  if (!isRecord(value)) {
+    throw new LockfileError("".concat(where, " is not a map of dependencies."));
+  }
+  for (var _i = 0, _Object$entries = Object.entries(value); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = slicedToArray._slicedToArray(_Object$entries[_i], 2),
+      alias = _Object$entries$_i[0],
+      entry = _Object$entries$_i[1];
+    var version = isRecord(entry) ? textOf(entry["version"]) : textOf(entry);
+    if (version === null) {
+      throw new LockfileError("".concat(where, " has no version for ").concat(alias, "."));
+    }
+    out[alias] = version;
+  }
+  return out;
+}
+
+/**
+ * Reads a pnpm 9 lockfile. pnpm 11 and later may put a document of their own
+ * (the package manager's dependencies) before the project's, so the document
+ * read is the one that has `importers`.
+ */
+function parsePnpmLockfile(text) {
+  var documents;
+  try {
+    documents = yaml.parseAllDocuments(text).flatMap(function (document) {
+      if (!("toJS" in document)) return [];
+      if (document.errors.length > 0) {
+        throw new LockfileError(document.errors[0].message);
+      }
+      return [document.toJS({
+        maxAliasCount: -1
+      })];
+    });
+  } catch (error) {
+    if (error instanceof LockfileError) throw error;
+    throw new LockfileError("pnpm-lock.yaml is not YAML: ".concat(error instanceof Error ? error.message : String(error)));
+  }
+  var lockfile = documents.find(function (document) {
+    return isRecord(document) && "importers" in document;
+  });
+  if (!isRecord(lockfile)) {
+    throw new LockfileError("pnpm-lock.yaml has no importers.");
+  }
+  var version = textOf(lockfile["lockfileVersion"]);
+  if (version === null || !/^9(\.|$)/.test(version)) {
+    throw new LockfileError("pnpm-lock.yaml is lockfile version ".concat(version !== null && version !== void 0 ? version : "(none)", "; only version 9 (pnpm 9 and later) can be read."));
+  }
+  var importers = {};
+  var rawImporters = lockfile["importers"];
+  if (!isRecord(rawImporters)) {
+    throw new LockfileError("pnpm-lock.yaml's importers is not a map.");
+  }
+  for (var _i2 = 0, _Object$entries2 = Object.entries(rawImporters); _i2 < _Object$entries2.length; _i2++) {
+    var _Object$entries2$_i = slicedToArray._slicedToArray(_Object$entries2[_i2], 2),
+      id = _Object$entries2$_i[0],
+      raw = _Object$entries2$_i[1];
+    var importer = isRecord(raw) ? raw : {};
+    var where = "importer '".concat(id, "'");
+    importers[id] = {
+      dependencies: referenceMap(importer["dependencies"], where),
+      devDependencies: referenceMap(importer["devDependencies"], where),
+      optionalDependencies: referenceMap(importer["optionalDependencies"], where)
+    };
+  }
+  var packages = {};
+  var rawPackages = lockfile["packages"];
+  if (isRecord(rawPackages)) {
+    for (var _i3 = 0, _Object$entries3 = Object.entries(rawPackages); _i3 < _Object$entries3.length; _i3++) {
+      var _Object$entries3$_i = slicedToArray._slicedToArray(_Object$entries3[_i3], 2),
+        key = _Object$entries3$_i[0],
+        _raw = _Object$entries3$_i[1];
+      var info = isRecord(_raw) ? _raw : {};
+      var resolution = isRecord(info["resolution"]) ? info["resolution"] : {};
+      packages[key] = {
+        integrity: textOf(resolution["integrity"]),
+        tarball: textOf(resolution["tarball"]),
+        os: stringList(info["os"]),
+        cpu: stringList(info["cpu"]),
+        libc: stringList(info["libc"]),
+        hasBin: info["hasBin"] === true
+      };
+    }
+  }
+  var snapshots = {};
+  var rawSnapshots = lockfile["snapshots"];
+  if (isRecord(rawSnapshots)) {
+    for (var _i4 = 0, _Object$entries4 = Object.entries(rawSnapshots); _i4 < _Object$entries4.length; _i4++) {
+      var _Object$entries4$_i = slicedToArray._slicedToArray(_Object$entries4[_i4], 2),
+        _key = _Object$entries4$_i[0],
+        _raw2 = _Object$entries4$_i[1];
+      var snapshot = isRecord(_raw2) ? _raw2 : {};
+      var _where = "snapshot '".concat(_key, "'");
+      snapshots[_key] = {
+        dependencies: referenceMap(snapshot["dependencies"], _where),
+        optionalDependencies: referenceMap(snapshot["optionalDependencies"], _where),
+        optional: snapshot["optional"] === true
+      };
+    }
+  }
+  return {
+    importers: importers,
+    packages: packages,
+    snapshots: snapshots
+  };
+}
+
+/**
+ * The index of the `@` between a key's name and its version: the first one
+ * after a scope's leading `@`.
+ */
+function versionSeparator(key) {
+  return key.indexOf("@", 1);
+}
+
+/** `@scope/name` of `@scope/name@1.0.0(peer@2.0.0)`. */
+function nameOfKey(key) {
+  var at = versionSeparator(key);
+  return at < 0 ? key : key.slice(0, at);
+}
+
+/** `1.0.0` of `@scope/name@1.0.0(peer@2.0.0)`: the version, without peers. */
+function versionOfKey(key) {
+  var at = versionSeparator(key);
+  var rest = at < 0 ? "" : key.slice(at + 1);
+  var peers = rest.indexOf("(");
+  return peers < 0 ? rest : rest.slice(0, peers);
+}
+
+/** The `packages:` key a snapshot key's metadata is under: the key without its peers. */
+function packageKeyOf(snapshotKey) {
+  return "".concat(nameOfKey(snapshotKey), "@").concat(versionOfKey(snapshotKey));
+}
+
+/**
+ * Whether a reference names another package (an npm alias, `foo:
+ * string-width@4.2.3`) rather than a version of the alias itself. pnpm's
+ * `looks_like_alias`: a leading `@` is a scoped name, and otherwise the `@`
+ * has to come before any `:` or `(`.
+ */
+function looksLikeAlias(reference) {
+  if (reference.startsWith("@")) return true;
+  var at = reference.indexOf("@");
+  if (at < 0) return false;
+  var colon = reference.indexOf(":");
+  var paren = reference.indexOf("(");
+  return (colon < 0 || at < colon) && (paren < 0 || at < paren);
+}
+
+/**
+ * The snapshot a dependency reference points at, or `null` for a `link:` to
+ * a directory (a workspace sibling), which is not in the virtual store.
+ */
+function snapshotKeyOf(alias, reference) {
+  if (reference.startsWith("link:")) return null;
+  if (looksLikeAlias(reference)) return reference;
+  return "".concat(alias, "@").concat(reference);
+}
+
+/**
+ * SHA-256 of a string's UTF-8, as lowercase hex, synchronously.
+ *
+ * pnpm names a virtual-store directory that is too long, or has upper case
+ * in it, with a hash of the name, and the layout is computed synchronously.
+ * `crypto.subtle` is asynchronous and only exists in a secure context, and
+ * `@valbuild/core`'s `Internal.getSHA256Hash` would bring all of core into
+ * the typecheck worker for this one function (168 kB of its 286), so this is
+ * the plain algorithm (FIPS 180-4). `pnpmLayout.test.ts` checks it against
+ * the hashed names a real `pnpm install` made, and against Node's own.
+ */
+var K = new Uint32Array([0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2]);
+var rotr = function rotr(x, n) {
+  return x >>> n | x << 32 - n;
+};
+function sha256Hex(text) {
+  var bytes = new TextEncoder().encode(text);
+  // The message, a 1 bit, zeros, and its length in bits as 64 bits: a
+  // multiple of 64 bytes.
+  var blocks = Math.ceil((bytes.length + 9) / 64);
+  var padded = new Uint8Array(blocks * 64);
+  padded.set(bytes);
+  padded[bytes.length] = 0x80;
+  var view = new DataView(padded.buffer);
+  var bits = bytes.length * 8;
+  view.setUint32(padded.length - 8, Math.floor(bits / 0x100000000));
+  view.setUint32(padded.length - 4, bits >>> 0);
+  var h = new Uint32Array([0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19]);
+  var w = new Uint32Array(64);
+  for (var block = 0; block < blocks; block++) {
+    for (var i = 0; i < 16; i++) w[i] = view.getUint32(block * 64 + i * 4);
+    for (var _i = 16; _i < 64; _i++) {
+      var w15 = w[_i - 15];
+      var w2 = w[_i - 2];
+      var s0 = rotr(w15, 7) ^ rotr(w15, 18) ^ w15 >>> 3;
+      var s1 = rotr(w2, 17) ^ rotr(w2, 19) ^ w2 >>> 10;
+      w[_i] = w[_i - 16] + s0 + w[_i - 7] + s1 >>> 0;
+    }
+    var _h = slicedToArray._slicedToArray(h, 8),
+      a = _h[0],
+      b = _h[1],
+      c = _h[2],
+      d = _h[3],
+      e = _h[4],
+      f = _h[5],
+      g = _h[6],
+      hh = _h[7];
+    for (var _i2 = 0; _i2 < 64; _i2++) {
+      var _s = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      var ch = e & f ^ ~e & g;
+      var t1 = hh + _s + ch + K[_i2] + w[_i2] >>> 0;
+      var _s2 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      var maj = a & b ^ a & c ^ b & c;
+      var t2 = _s2 + maj >>> 0;
+      hh = g;
+      g = f;
+      f = e;
+      e = d + t1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 >>> 0;
+    }
+    h[0] = h[0] + a >>> 0;
+    h[1] = h[1] + b >>> 0;
+    h[2] = h[2] + c >>> 0;
+    h[3] = h[3] + d >>> 0;
+    h[4] = h[4] + e >>> 0;
+    h[5] = h[5] + f >>> 0;
+    h[6] = h[6] + g >>> 0;
+    h[7] = h[7] + hh >>> 0;
+  }
+  return Array.from(h, function (word) {
+    return word.toString(16).padStart(8, "0");
+  }).join("");
+}
+
+/**
+ * What `pnpm install --frozen-lockfile` puts in `node_modules`, computed from
+ * the lockfile alone, as a table of symlinks.
+ *
+ * Ported from pnpm's own crates (valbuild/pnpm, pacquet 12.13.0):
+ * `deps-path/src/dep_path_to_filename.rs` names each snapshot's directory in
+ * the virtual store, and `deps-restorer/src/hoist.rs` decides which
+ * transitive dependencies are also linked into the private hoist
+ * (`node_modules/.pnpm/node_modules`). The defaults are pnpm 12's: hoist
+ * `["*"]` privately, nothing publicly, virtual store names at most 120 bytes,
+ * no global virtual store. `pnpmLayout.test.ts` compares the result with
+ * what a real install left on disk.
+ *
+ * Every path is absolute, under `root` (default `/project`), with `/`
+ * separators.
+ */
+
+/** What `pnpm install` checks optional packages' `os`, `cpu` and `libc` against. */
+
+/**
+ * Linux on x64 with glibc: what a CI runner and the build are, and so the
+ * install the typecheck is compared with. It only decides which optional,
+ * platform-specific packages exist, which hardly ever carry types.
+ */
+var DEFAULT_PLATFORM = {
+  os: "linux",
+  cpu: "x64",
+  libc: "glibc"
+};
+var DEFAULT_VIRTUAL_STORE_DIR_MAX_LENGTH = 120;
+var encoder = new TextEncoder();
+var byteLength = function byteLength(text) {
+  return encoder.encode(text).length;
+};
+
+/** The first 32 hex characters of the SHA-256 of `input`: pnpm's `create_short_hash`. */
+function shortHash(input) {
+  return sha256Hex(input).slice(0, 32);
+}
+
+/** The longest prefix of `text` that is at most `bytes` bytes of UTF-8. */
+function prefixOfBytes(text, bytes) {
+  if (byteLength(text) <= bytes) return text;
+  var out = "";
+  var used = 0;
+  var _iterator = createForOfIteratorHelper._createForOfIteratorHelper(text),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _char = _step.value;
+      var size = byteLength(_char);
+      if (used + size > bytes) break;
+      out += _char;
+      used += size;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return out;
+}
+function hashSuffixVirtualStoreName(filename, hashInput, maxLength) {
+  var cap = Math.max(0, maxLength - 33);
+  return "".concat(prefixOfBytes(filename, cap), "_").concat(shortHash(hashInput));
+}
+function shortenVirtualStoreName(filename, maxLength) {
+  var needsShortening = byteLength(filename) > maxLength || filename !== filename.toLowerCase() && !filename.startsWith("file+");
+  return needsShortening ? hashSuffixVirtualStoreName(filename, filename, maxLength) : filename;
+}
+var RESERVED_VERSION_PREFIXES = new Set(["bitbucket", "catalog", "custom", "file", "git", "github", "gitlab", "http", "https", "jsr", "link", "npm", "pkg", "runtime", "ssh", "tool", "workspace"]);
+var SEMVER = /^v?\d+\.\d+\.\d+(-[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?(\+[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?$/;
+
+/** `registry:1.0.0`: a version qualified by a named registry, which escapes unambiguously. */
+function isRegistryQualifiedVersion(version) {
+  var colon = version.indexOf(":");
+  if (colon < 0) return false;
+  var registry = version.slice(0, colon);
+  return registry !== "" && !RESERVED_VERSION_PREFIXES.has(registry) && /^[A-Za-z][A-Za-z0-9._-]*$/.test(registry) && SEMVER.test(version.slice(colon + 1));
+}
+
+/**
+ * Whether escaping the URL or path of a non-registry dependency could map
+ * two distinct dep paths to one name (`has_ambiguous_escape`).
+ */
+function hasAmbiguousEscape(depPath) {
+  var _depPath$split$;
+  var packageId = (_depPath$split$ = depPath.split("(")[0]) !== null && _depPath$split$ !== void 0 ? _depPath$split$ : "";
+  if (packageId.startsWith("/")) packageId = packageId.slice(1);
+  var version;
+  if (packageId.startsWith("file:")) {
+    version = packageId;
+  } else {
+    var at = packageId.indexOf("@", 1);
+    if (at < 0) return false;
+    version = packageId.slice(at + 1);
+  }
+  var colon = version.indexOf(":");
+  if (colon < 0) return false;
+  if (isRegistryQualifiedVersion(version)) return false;
+  var location = version.slice(colon + 1);
+  if (location.startsWith("//")) location = location.slice(2);
+  return /[+\\:*?"<>|#]/.test(location);
+}
+function depPathToFilenameUnescaped(depPath) {
+  if (depPath.startsWith("file:")) return depPath.replace(":", "+");
+  var trimmed = depPath.startsWith("/") ? depPath.slice(1) : depPath;
+  return trimmed;
+}
+
+/**
+ * The directory name of a snapshot in the virtual store: pnpm's
+ * `dep_path_to_filename`. `@scope/foo@1.0.0(bar@2.0.0)` is
+ * `@scope+foo@1.0.0_bar@2.0.0`; a name longer than `maxLength` bytes, or with
+ * upper case letters, is cut and given a hash of the whole.
+ */
+function depPathToFilename(depPath) {
+  var maxLength = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DEFAULT_VIRTUAL_STORE_DIR_MAX_LENGTH;
+  var filename = depPathToFilenameUnescaped(depPath).replace(/[\\/:*?"<>|#]/g, "+");
+  if (filename.includes("(")) {
+    if (filename.endsWith(")")) filename = filename.slice(0, -1);
+    filename = filename.split(")(").join("_").replace(/[()]/g, "_");
+  }
+  var kept = filename.replace(/[. ]+$/, "").length;
+  var trailing = filename.length - kept;
+  var ambiguous = hasAmbiguousEscape(depPath);
+  if (trailing > 0) {
+    var escaped = filename.slice(0, kept) + "+".repeat(trailing);
+    return hashSuffixVirtualStoreName(escaped, ambiguous ? depPath : filename, maxLength);
+  }
+  if (ambiguous) {
+    return hashSuffixVirtualStoreName(filename, depPath, maxLength);
+  }
+  return shortenVirtualStoreName(filename, maxLength);
+}
+
+/**
+ * pnpm's `WildcardMatcher` lists: `*` is any run of characters, `?` one, a
+ * leading `!` excludes, and a later exclude cancels an earlier include.
+ */
+function createMatcher(patterns) {
+  if (patterns.length === 0) return function () {
+    return false;
+  };
+  var compiled = patterns.map(function (pattern) {
+    var ignore = pattern.startsWith("!");
+    var glob = ignore ? pattern.slice(1) : pattern;
+    var source = glob.split("").map(function (_char2) {
+      return _char2 === "*" ? ".*" : _char2 === "?" ? "." : _char2.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    }).join("");
+    return {
+      ignore: ignore,
+      regexp: new RegExp("^".concat(source, "$"), "s")
+    };
+  });
+  var hasInclude = compiled.some(function (pattern) {
+    return !pattern.ignore;
+  });
+  var hasIgnore = compiled.some(function (pattern) {
+    return pattern.ignore;
+  });
+  if (compiled.length === 1) {
+    var only = compiled[0];
+    return function (input) {
+      return only.regexp.test(input) !== only.ignore;
+    };
+  }
+  if (!hasIgnore) {
+    return function (input) {
+      return compiled.some(function (pattern) {
+        return pattern.regexp.test(input);
+      });
+    };
+  }
+  if (!hasInclude) {
+    return function (input) {
+      return !compiled.some(function (pattern) {
+        return pattern.regexp.test(input);
+      });
+    };
+  }
+  return function (input) {
+    var matched = false;
+    var _iterator2 = createForOfIteratorHelper._createForOfIteratorHelper(compiled),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var pattern = _step2.value;
+        if (!pattern.regexp.test(input)) continue;
+        matched = !pattern.ignore;
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+    return matched;
+  };
+}
+
+/** npm's `checkList`: `any`, a list of allowed values, or of `!`excluded ones. */
+function platformAllows(list, value) {
+  if (list === null || list.length === 0) return true;
+  if (list.length === 1 && list[0] === "any") return true;
+  if (value === null) return true;
+  var match = false;
+  var excluded = 0;
+  var _iterator3 = createForOfIteratorHelper._createForOfIteratorHelper(list),
+    _step3;
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var entry = _step3.value;
+      if (entry.startsWith("!")) {
+        if (entry.slice(1) === value) return false;
+        excluded++;
+      } else if (entry === value) {
+        match = true;
+      }
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  return match || excluded === list.length;
+}
+var OS_TOKENS = {
+  aix: "aix",
+  android: "android",
+  darwin: "darwin",
+  macos: "darwin",
+  osx: "darwin",
+  freebsd: "freebsd",
+  linux: "linux",
+  netbsd: "netbsd",
+  openbsd: "openbsd",
+  openharmony: "openharmony",
+  sunos: "sunos",
+  win32: "win32",
+  windows: "win32"
+};
+var CPU_TOKENS = {
+  arm: "arm",
+  armv6: "arm",
+  armv7: "arm",
+  arm64: "arm64",
+  aarch64: "arm64",
+  ia32: "ia32",
+  loong64: "loong64",
+  mips64el: "mips64el",
+  ppc64: "ppc64",
+  ppc64le: "ppc64",
+  riscv64: "riscv64",
+  s390x: "s390x",
+  x64: "x64",
+  amd64: "x64",
+  wasm32: "wasm32"
+};
+var LIBC_TOKENS = {
+  glibc: "glibc",
+  gnu: "glibc",
+  gnueabihf: "glibc",
+  musl: "musl",
+  musleabihf: "musl"
+};
+function tokenValues(tokens, table) {
+  var values = [];
+  var _iterator4 = createForOfIteratorHelper._createForOfIteratorHelper(tokens),
+    _step4;
+  try {
+    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+      var token = _step4.value;
+      var value = Object.prototype.hasOwnProperty.call(table, token) ? table[token] : undefined;
+      if (value !== undefined && !values.includes(value)) values.push(value);
+    }
+  } catch (err) {
+    _iterator4.e(err);
+  } finally {
+    _iterator4.f();
+  }
+  return values.length > 0 ? values : null;
+}
+
+/**
+ * The platform an optional package is for, with what its name says filling
+ * in what its manifest leaves out: `lightningcss-linux-x64-musl` declares
+ * `os` and `cpu` but not `libc`. pnpm's `inferred_platform`.
+ */
+function wantedPlatform(name, info) {
+  var _info$os, _info$cpu, _info$libc;
+  if (info.os !== null && info.cpu !== null && info.libc !== null) return info;
+  var bare = name.includes("/") ? name.slice(name.indexOf("/") + 1) : name;
+  var tokens = bare.toLowerCase().split(/[-_.]/);
+  var os = tokenValues(tokens, OS_TOKENS);
+  var cpu = tokenValues(tokens, CPU_TOKENS);
+  var libc = tokenValues(tokens, LIBC_TOKENS);
+  if (os === null && cpu === null && libc === null) return info;
+  var declares = info.os !== null || info.cpu !== null || info.libc !== null;
+  if (!declares && os === null) return info;
+  return {
+    os: (_info$os = info.os) !== null && _info$os !== void 0 ? _info$os : os,
+    cpu: (_info$cpu = info.cpu) !== null && _info$cpu !== void 0 ? _info$cpu : cpu,
+    libc: (_info$libc = info.libc) !== null && _info$libc !== void 0 ? _info$libc : libc
+  };
+}
+function isInstallable(name, info, platform) {
+  var wanted = wantedPlatform(name, info);
+  return platformAllows(wanted.os, platform.os) && platformAllows(wanted.cpu, platform.cpu) && platformAllows(wanted.libc, platform.libc);
+}
+
+/**
+ * The snapshots the importers reach, not passing through any in `blocked`:
+ * pnpm's `collect_reachable`.
+ */
+function reachableSnapshots(lockfile, blocked) {
+  var seen = new Set();
+  var queue = [];
+  var visit = function visit(alias, reference) {
+    var key = snapshotKeyOf(alias, reference);
+    if (key === null || seen.has(key) || blocked.has(key)) return;
+    if (!lockfile.snapshots[key]) return;
+    seen.add(key);
+    queue.push(key);
+  };
+  for (var _i = 0, _Object$values = Object.values(lockfile.importers); _i < _Object$values.length; _i++) {
+    var importer = _Object$values[_i];
+    for (var _i2 = 0, _arr = [importer.dependencies, importer.devDependencies, importer.optionalDependencies]; _i2 < _arr.length; _i2++) {
+      var group = _arr[_i2];
+      for (var _i3 = 0, _Object$entries = Object.entries(group); _i3 < _Object$entries.length; _i3++) {
+        var _Object$entries$_i = slicedToArray._slicedToArray(_Object$entries[_i3], 2),
+          alias = _Object$entries$_i[0],
+          reference = _Object$entries$_i[1];
+        visit(alias, reference);
+      }
+    }
+  }
+  for (var key = queue.shift(); key !== undefined; key = queue.shift()) {
+    var snapshot = lockfile.snapshots[key];
+    for (var _i4 = 0, _arr2 = [snapshot.dependencies, snapshot.optionalDependencies]; _i4 < _arr2.length; _i4++) {
+      var _group = _arr2[_i4];
+      for (var _i5 = 0, _Object$entries2 = Object.entries(_group); _i5 < _Object$entries2.length; _i5++) {
+        var _Object$entries2$_i = slicedToArray._slicedToArray(_Object$entries2[_i5], 2),
+          _alias = _Object$entries2$_i[0],
+          _reference = _Object$entries2$_i[1];
+        visit(_alias, _reference);
+      }
+    }
+  }
+  return seen;
+}
+
+/**
+ * The snapshots `pnpm install` leaves out on `platform`: the optional ones
+ * that are not for it (`compute_skipped_snapshots`), and then everything the
+ * importers can reach only through one of those
+ * (`extend_skipped_with_dependency_closure`).
+ */
+function skippedSnapshots(lockfile, platform) {
+  var skipped = new Set();
+  for (var _i6 = 0, _Object$entries3 = Object.entries(lockfile.snapshots); _i6 < _Object$entries3.length; _i6++) {
+    var _Object$entries3$_i = slicedToArray._slicedToArray(_Object$entries3[_i6], 2),
+      key = _Object$entries3$_i[0],
+      snapshot = _Object$entries3$_i[1];
+    var info = lockfile.packages[packageKeyOf(key)];
+    if (snapshot.optional && info && !isInstallable(nameOfKey(key), info, platform)) {
+      skipped.add(key);
+    }
+  }
+  if (skipped.size === 0) return skipped;
+  var all = reachableSnapshots(lockfile, new Set());
+  var kept = reachableSnapshots(lockfile, skipped);
+  var _iterator5 = createForOfIteratorHelper._createForOfIteratorHelper(all),
+    _step5;
+  try {
+    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+      var _key = _step5.value;
+      if (!kept.has(_key)) skipped.add(_key);
+    }
+  } catch (err) {
+    _iterator5.e(err);
+  } finally {
+    _iterator5.f();
+  }
+  return skipped;
+}
+
+/** `a/b/../c` → `a/c`, for absolute `/`-separated paths. */
+function normalizePath(path) {
+  var out = [];
+  var _iterator6 = createForOfIteratorHelper._createForOfIteratorHelper(path.split("/")),
+    _step6;
+  try {
+    for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+      var segment = _step6.value;
+      if (segment === "" || segment === ".") continue;
+      if (segment === "..") out.pop();else out.push(segment);
+    }
+  } catch (err) {
+    _iterator6.e(err);
+  } finally {
+    _iterator6.f();
+  }
+  return "/".concat(out.join("/"));
+}
+
+/** Each hoisted alias: a snapshot in the virtual store, or a workspace project's directory. */
+
+/** Dependencies, then optional ones, each sorted by alias: `snapshot_children`. */
+function snapshotChildren(lockfile, key) {
+  var snapshot = lockfile.snapshots[key];
+  var children = new Map();
+  for (var _i7 = 0, _arr3 = [snapshot.dependencies, snapshot.optionalDependencies]; _i7 < _arr3.length; _i7++) {
+    var group = _arr3[_i7];
+    var _iterator7 = createForOfIteratorHelper._createForOfIteratorHelper(Object.keys(group).sort(compareBytes)),
+      _step7;
+    try {
+      for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+        var alias = _step7.value;
+        var child = snapshotKeyOf(alias, group[alias]);
+        if (child !== null) children.set(alias, child);
+      }
+    } catch (err) {
+      _iterator7.e(err);
+    } finally {
+      _iterator7.f();
+    }
+  }
+  return children;
+}
+
+/** Rust's `str` order: by code unit, which for these names is by byte. */
+function compareBytes(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+/**
+ * Each importer's direct dependencies, alias to snapshot key, for the hoist:
+ * `build_direct_deps_by_importer`. Importers in id order; within one, the
+ * aliases of devDependencies, then dependencies, then optionalDependencies,
+ * each sorted, with the first group that resolves an alias owning it.
+ */
+function directDepsByImporter(lockfile) {
+  var result = new Map();
+  var _iterator8 = createForOfIteratorHelper._createForOfIteratorHelper(Object.keys(lockfile.importers).sort(compareBytes)),
+    _step8;
+  try {
+    for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+      var id = _step8.value;
+      var importer = lockfile.importers[id];
+      var resolved = new Map();
+      for (var _i8 = 0, _arr4 = [importer.dependencies, importer.devDependencies, importer.optionalDependencies]; _i8 < _arr4.length; _i8++) {
+        var group = _arr4[_i8];
+        for (var _i9 = 0, _Object$entries4 = Object.entries(group); _i9 < _Object$entries4.length; _i9++) {
+          var _Object$entries4$_i = slicedToArray._slicedToArray(_Object$entries4[_i9], 2),
+            alias = _Object$entries4$_i[0],
+            reference = _Object$entries4$_i[1];
+          var key = snapshotKeyOf(alias, reference);
+          if (key !== null && !resolved.has(alias)) resolved.set(alias, key);
+        }
+      }
+      var deps = new Map();
+      for (var _i0 = 0, _arr5 = [importer.devDependencies, importer.dependencies, importer.optionalDependencies]; _i0 < _arr5.length; _i0++) {
+        var _group2 = _arr5[_i0];
+        var _iterator9 = createForOfIteratorHelper._createForOfIteratorHelper(Object.keys(_group2).sort(compareBytes)),
+          _step9;
+        try {
+          for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+            var _alias2 = _step9.value;
+            var _key2 = resolved.get(_alias2);
+            if (_key2 !== undefined && !deps.has(_alias2)) deps.set(_alias2, _key2);
+          }
+        } catch (err) {
+          _iterator9.e(err);
+        } finally {
+          _iterator9.f();
+        }
+      }
+      result.set(id, deps);
+    }
+  } catch (err) {
+    _iterator8.e(err);
+  } finally {
+    _iterator8.f();
+  }
+  return result;
+}
+
+/**
+ * Which aliases are hoisted, and to which snapshot each points:
+ * `get_hoisted_dependencies`, for an install with no workspace packages to
+ * hoist and root dependencies that the virtual store can reach.
+ *
+ * The graph is walked in pnpm's graph-walker order -- each step's children
+ * are the next step, depth first over steps -- and the entries are then
+ * sorted by depth and virtual-store name. The first entry to claim an alias
+ * (lower-cased) wins it; the root importer's own aliases are claimed from the
+ * start, as they are already in `node_modules`.
+ */
+function hoist(lockfile, graph, skipped, kindOf, workspacePackages) {
+  var _direct$get$keys, _direct$get;
+  var direct = directDepsByImporter(lockfile);
+  var merged = new Map();
+  var _iterator0 = createForOfIteratorHelper._createForOfIteratorHelper(direct.values()),
+    _step0;
+  try {
+    for (_iterator0.s(); !(_step0 = _iterator0.n()).done;) {
+      var deps = _step0.value;
+      var _iterator16 = createForOfIteratorHelper._createForOfIteratorHelper(deps),
+        _step16;
+      try {
+        for (_iterator16.s(); !(_step16 = _iterator16.n()).done;) {
+          var _step16$value = slicedToArray._slicedToArray(_step16.value, 2),
+            _alias3 = _step16$value[0],
+            key = _step16$value[1];
+          if (!merged.has(_alias3)) merged.set(_alias3, key);
+        }
+      } catch (err) {
+        _iterator16.e(err);
+      } finally {
+        _iterator16.f();
+      }
+    }
+  } catch (err) {
+    _iterator0.e(err);
+  } finally {
+    _iterator0.f();
+  }
+  var visited = new Set();
+  var directNodes = [];
+  var _iterator1 = createForOfIteratorHelper._createForOfIteratorHelper(direct.values()),
+    _step1;
+  try {
+    for (_iterator1.s(); !(_step1 = _iterator1.n()).done;) {
+      var _deps = _step1.value;
+      var _iterator17 = createForOfIteratorHelper._createForOfIteratorHelper(_deps.values()),
+        _step17;
+      try {
+        for (_iterator17.s(); !(_step17 = _iterator17.n()).done;) {
+          var _key3 = _step17.value;
+          if (graph.has(_key3) && !visited.has(_key3)) {
+            visited.add(_key3);
+            directNodes.push(_key3);
+          }
+        }
+      } catch (err) {
+        _iterator17.e(err);
+      } finally {
+        _iterator17.f();
+      }
+    }
+  } catch (err) {
+    _iterator1.e(err);
+  } finally {
+    _iterator1.f();
+  }
+  var entries = [{
+    depth: -1,
+    sortKey: "",
+    children: merged
+  }];
+  var steps = [{
+    nodes: directNodes,
+    depth: 0
+  }];
+  for (var step = steps.pop(); step; step = steps.pop()) {
+    var _iterator10 = createForOfIteratorHelper._createForOfIteratorHelper(step.nodes),
+      _step10;
+    try {
+      for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
+        var node = _step10.value;
+        var _ref = graph.get(node),
+          sortKey = _ref.sortKey,
+          children = _ref.children;
+        entries.push({
+          depth: step.depth,
+          sortKey: sortKey,
+          children: children
+        });
+      }
+    } catch (err) {
+      _iterator10.e(err);
+    } finally {
+      _iterator10.f();
+    }
+    var next = step.nodes.map(function (node) {
+      var nodes = [];
+      var _iterator11 = createForOfIteratorHelper._createForOfIteratorHelper(graph.get(node).children.values()),
+        _step11;
+      try {
+        for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
+          var child = _step11.value;
+          if (graph.has(child) && !visited.has(child)) {
+            visited.add(child);
+            nodes.push(child);
+          }
+        }
+      } catch (err) {
+        _iterator11.e(err);
+      } finally {
+        _iterator11.f();
+      }
+      return nodes;
+    });
+    var _iterator12 = createForOfIteratorHelper._createForOfIteratorHelper(next.reverse()),
+      _step12;
+    try {
+      for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
+        var nodes = _step12.value;
+        if (nodes.length > 0) steps.push({
+          nodes: nodes,
+          depth: step.depth + 1
+        });
+      }
+    } catch (err) {
+      _iterator12.e(err);
+    } finally {
+      _iterator12.f();
+    }
+  }
+  entries.sort(function (a, b) {
+    return a.depth - b.depth || compareBytes(a.sortKey, b.sortKey);
+  });
+  var claimed = new Set(slicedToArray._toConsumableArray((_direct$get$keys = (_direct$get = direct.get(".")) === null || _direct$get === void 0 ? void 0 : _direct$get.keys()) !== null && _direct$get$keys !== void 0 ? _direct$get$keys : []).map(function (alias) {
+    return alias.toLowerCase();
+  }));
+  var hoisted = new Map();
+  /*
+   * Named workspace projects are considered after every importer's direct
+   * dependencies and before anything transitive; a name that two projects
+   * share (ignoring case) is hoisted for neither.
+   */
+  var workspaceDone = false;
+  var hoistWorkspace = function hoistWorkspace() {
+    workspaceDone = true;
+    var candidates = slicedToArray._toConsumableArray(workspacePackages).flatMap(function (_ref2) {
+      var _ref3 = slicedToArray._slicedToArray(_ref2, 2),
+        name = _ref3[0],
+        dir = _ref3[1];
+      var kind = kindOf(name);
+      return kind !== null && !claimed.has(name.toLowerCase()) ? [{
+        name: name,
+        dir: dir,
+        kind: kind
+      }] : [];
+    });
+    var counts = new Map();
+    var _iterator13 = createForOfIteratorHelper._createForOfIteratorHelper(candidates),
+      _step13;
+    try {
+      for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {
+        var _counts$get;
+        var name = _step13.value.name;
+        var normalized = name.toLowerCase();
+        counts.set(normalized, ((_counts$get = counts.get(normalized)) !== null && _counts$get !== void 0 ? _counts$get : 0) + 1);
+      }
+    } catch (err) {
+      _iterator13.e(err);
+    } finally {
+      _iterator13.f();
+    }
+    var _iterator14 = createForOfIteratorHelper._createForOfIteratorHelper(candidates),
+      _step14;
+    try {
+      for (_iterator14.s(); !(_step14 = _iterator14.n()).done;) {
+        var _step14$value = _step14.value,
+          _name = _step14$value.name,
+          dir = _step14$value.dir,
+          kind = _step14$value.kind;
+        var _normalized = _name.toLowerCase();
+        if (counts.get(_normalized) !== 1 || claimed.has(_normalized)) continue;
+        claimed.add(_normalized);
+        hoisted.set(_name, {
+          kind: kind,
+          target: {
+            dir: dir
+          }
+        });
+      }
+    } catch (err) {
+      _iterator14.e(err);
+    } finally {
+      _iterator14.f();
+    }
+  };
+  for (var _i1 = 0, _entries = entries; _i1 < _entries.length; _i1++) {
+    var entry = _entries[_i1];
+    if (!workspaceDone && entry.depth >= 0) hoistWorkspace();
+    var _iterator15 = createForOfIteratorHelper._createForOfIteratorHelper(entry.children),
+      _step15;
+    try {
+      for (_iterator15.s(); !(_step15 = _iterator15.n()).done;) {
+        var _step15$value = slicedToArray._slicedToArray(_step15.value, 2),
+          alias = _step15$value[0],
+          child = _step15$value[1];
+        var kind = kindOf(alias);
+        if (kind === null) continue;
+        var normalized = alias.toLowerCase();
+        if (claimed.has(normalized)) continue;
+        // A missing or skipped node does not claim the alias, so a later one
+        // with the same alias still can.
+        if (!graph.has(child) || skipped.has(child)) continue;
+        claimed.add(normalized);
+        hoisted.set(alias, {
+          kind: kind,
+          target: {
+            snapshot: child
+          }
+        });
+      }
+    } catch (err) {
+      _iterator15.e(err);
+    } finally {
+      _iterator15.f();
+    }
+  }
+  if (!workspaceDone) hoistWorkspace();
+  return hoisted;
+}
+
+/** A setting in `pnpm-workspace.yaml` the layout cannot follow. */
+var UnsupportedLayoutError = /*#__PURE__*/function (_Error) {
+  function UnsupportedLayoutError() {
+    slicedToArray._classCallCheck(this, UnsupportedLayoutError);
+    return slicedToArray._callSuper(this, UnsupportedLayoutError, arguments);
+  }
+  slicedToArray._inherits(UnsupportedLayoutError, _Error);
+  return slicedToArray._createClass(UnsupportedLayoutError);
+}(/*#__PURE__*/slicedToArray._wrapNativeSuper(Error));
+function isPatternList(value) {
+  return Array.isArray(value) && value.every(function (item) {
+    return typeof item === "string";
+  });
+}
+
+/**
+ * The settings in `pnpm-workspace.yaml` that change the layout: `hoist`,
+ * `hoistPattern`, `publicHoistPattern`, `shamefullyHoist` and
+ * `virtualStoreDirMaxLength`. pnpm 11 and later read these from there and not
+ * from `.npmrc`. `nodeLinker` other than `isolated` is a different layout
+ * altogether, and refused.
+ */
+function layoutOptionsOfWorkspace(workspace) {
+  var options = {};
+  var linker = workspace["nodeLinker"];
+  if (linker !== undefined && linker !== "isolated") {
+    throw new UnsupportedLayoutError("pnpm-workspace.yaml sets nodeLinker to ".concat(String(linker), "; only the default, isolated, can be typechecked."));
+  }
+  if (workspace["enableGlobalVirtualStore"] === true) {
+    throw new UnsupportedLayoutError("pnpm-workspace.yaml sets enableGlobalVirtualStore, whose layout cannot be typechecked yet.");
+  }
+  var hoistPattern = workspace["hoistPattern"];
+  if (isPatternList(hoistPattern)) options.hoistPattern = hoistPattern;
+  if (workspace["hoist"] === false) options.hoistPattern = [];
+  var publicHoistPattern = workspace["publicHoistPattern"];
+  if (isPatternList(publicHoistPattern)) {
+    options.publicHoistPattern = publicHoistPattern;
+  }
+  if (workspace["shamefullyHoist"] === true) options.publicHoistPattern = ["*"];
+  if (workspace["hoistWorkspacePackages"] === false) {
+    options.hoistWorkspacePackages = false;
+  }
+  var maxLength = workspace["virtualStoreDirMaxLength"];
+  if (typeof maxLength === "number") options.virtualStoreDirMaxLength = maxLength;
+  return options;
+}
+
+/** What `pnpm install` would put in `node_modules` for this lockfile. */
+function computePnpmLayout(lockfile) {
+  var _options$root, _options$virtualStore, _options$hoistPattern, _options$publicHoistP;
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var root = normalizePath((_options$root = options.root) !== null && _options$root !== void 0 ? _options$root : "/project");
+  var maxLength = (_options$virtualStore = options.virtualStoreDirMaxLength) !== null && _options$virtualStore !== void 0 ? _options$virtualStore : DEFAULT_VIRTUAL_STORE_DIR_MAX_LENGTH;
+  var platform = options.platform === undefined ? DEFAULT_PLATFORM : options.platform;
+  var virtualStore = "".concat(root, "/node_modules/.pnpm");
+  var join = function join(dir, relative) {
+    return normalizePath("".concat(dir, "/").concat(relative));
+  };
+  var importerDir = function importerDir(id) {
+    return id === "." ? root : join(root, id);
+  };
+  var skipped = platform === null ? new Set() : skippedSnapshots(lockfile, platform);
+  var storeNames = new Map();
+  var storeName = function storeName(key) {
+    var name = storeNames.get(key);
+    if (name === undefined) {
+      name = depPathToFilename(key, maxLength);
+      storeNames.set(key, name);
+    }
+    return name;
+  };
+  var packageDir = function packageDir(key) {
+    return "".concat(virtualStore, "/").concat(storeName(key), "/node_modules/").concat(nameOfKey(key));
+  };
+  var links = new Map();
+  var packages = new Map();
+  var importers = new Map();
+
+  /** A dependency reference, linked from `modulesDir/<alias>`; `link:` is relative to `base`. */
+  var linkDependency = function linkDependency(modulesDir, alias, reference, base) {
+    var path = "".concat(modulesDir, "/").concat(alias);
+    if (links.has(path)) return;
+    if (reference.startsWith("link:")) {
+      links.set(path, join(base, reference.slice("link:".length)));
+      return;
+    }
+    var key = snapshotKeyOf(alias, reference);
+    if (key === null || skipped.has(key) || !lockfile.snapshots[key]) return;
+    var target = packageDir(key);
+    if (target !== path) links.set(path, target);
+  };
+  for (var _i10 = 0, _Object$entries5 = Object.entries(lockfile.importers); _i10 < _Object$entries5.length; _i10++) {
+    var _Object$entries5$_i = slicedToArray._slicedToArray(_Object$entries5[_i10], 2),
+      id = _Object$entries5$_i[0],
+      importer = _Object$entries5$_i[1];
+    var dir = importerDir(id);
+    importers.set(id, dir);
+    for (var _i11 = 0, _arr6 = [importer.dependencies, importer.devDependencies, importer.optionalDependencies]; _i11 < _arr6.length; _i11++) {
+      var group = _arr6[_i11];
+      for (var _i12 = 0, _Object$entries6 = Object.entries(group); _i12 < _Object$entries6.length; _i12++) {
+        var _Object$entries6$_i = slicedToArray._slicedToArray(_Object$entries6[_i12], 2),
+          alias = _Object$entries6$_i[0],
+          reference = _Object$entries6$_i[1];
+        linkDependency("".concat(dir, "/node_modules"), alias, reference, dir);
+      }
+    }
+  }
+  var graph = new Map();
+  for (var _i13 = 0, _Object$entries7 = Object.entries(lockfile.snapshots); _i13 < _Object$entries7.length; _i13++) {
+    var _info$integrity;
+    var _Object$entries7$_i = slicedToArray._slicedToArray(_Object$entries7[_i13], 2),
+      key = _Object$entries7$_i[0],
+      snapshot = _Object$entries7$_i[1];
+    var packageKey = packageKeyOf(key);
+    var info = lockfile.packages[packageKey];
+    if (info) {
+      graph.set(key, {
+        children: snapshotChildren(lockfile, key),
+        sortKey: storeName(key)
+      });
+    }
+    if (skipped.has(key)) continue;
+    var _dir = packageDir(key);
+    var version = versionOfKey(key);
+    packages.set(_dir, {
+      snapshot: key,
+      name: nameOfKey(key),
+      version: version,
+      integrity: (_info$integrity = info === null || info === void 0 ? void 0 : info.integrity) !== null && _info$integrity !== void 0 ? _info$integrity : null,
+      fromRegistry: SEMVER.test(version) && !(info !== null && info !== void 0 && info.tarball)
+    });
+    var modulesDir = "".concat(virtualStore, "/").concat(storeName(key), "/node_modules");
+    for (var _i14 = 0, _arr7 = [snapshot.dependencies, snapshot.optionalDependencies]; _i14 < _arr7.length; _i14++) {
+      var _group3 = _arr7[_i14];
+      for (var _i15 = 0, _Object$entries8 = Object.entries(_group3); _i15 < _Object$entries8.length; _i15++) {
+        var _Object$entries8$_i = slicedToArray._slicedToArray(_Object$entries8[_i15], 2),
+          _alias4 = _Object$entries8$_i[0],
+          _reference2 = _Object$entries8$_i[1];
+        linkDependency(modulesDir, _alias4, _reference2, root);
+      }
+    }
+  }
+  var isPrivate = createMatcher((_options$hoistPattern = options.hoistPattern) !== null && _options$hoistPattern !== void 0 ? _options$hoistPattern : ["*"]);
+  var isPublic = createMatcher((_options$publicHoistP = options.publicHoistPattern) !== null && _options$publicHoistP !== void 0 ? _options$publicHoistP : []);
+  var workspacePackages = new Map();
+  if (options.hoistWorkspacePackages !== false) {
+    for (var _i16 = 0, _Object$entries9 = Object.entries((_options$workspaceNam = options.workspaceNames) !== null && _options$workspaceNam !== void 0 ? _options$workspaceNam : {}); _i16 < _Object$entries9.length; _i16++) {
+      var _options$workspaceNam;
+      var _Object$entries9$_i = slicedToArray._slicedToArray(_Object$entries9[_i16], 2),
+        _id = _Object$entries9$_i[0],
+        name = _Object$entries9$_i[1];
+      if (_id !== "." && lockfile.importers[_id]) {
+        workspacePackages.set(name, importerDir(_id));
+      }
+    }
+  }
+  var hoisted = hoist(lockfile, graph, skipped, function (alias) {
+    return isPublic(alias) ? "public" : isPrivate(alias) ? "private" : null;
+  }, workspacePackages);
+  var _iterator18 = createForOfIteratorHelper._createForOfIteratorHelper(hoisted),
+    _step18;
+  try {
+    for (_iterator18.s(); !(_step18 = _iterator18.n()).done;) {
+      var _step18$value = slicedToArray._slicedToArray(_step18.value, 2),
+        _alias5 = _step18$value[0],
+        _step18$value$ = _step18$value[1],
+        kind = _step18$value$.kind,
+        target = _step18$value$.target;
+      var _modulesDir = kind === "public" ? "".concat(root, "/node_modules") : "".concat(virtualStore, "/node_modules");
+      var path = "".concat(_modulesDir, "/").concat(_alias5);
+      if (!links.has(path)) {
+        links.set(path, "dir" in target ? target.dir : packageDir(target.snapshot));
+      }
+    }
+  } catch (err) {
+    _iterator18.e(err);
+  } finally {
+    _iterator18.f();
+  }
+  return {
+    root: root,
+    virtualStore: virtualStore,
+    links: links,
+    packages: packages,
+    importers: importers,
+    skipped: skipped
+  };
+}
+
+/**
+ * Files in memory, with directory symlinks: enough of a disk for
+ * TypeScript's module resolution to see `node_modules` as pnpm leaves it.
+ *
+ * Files are written at their real paths. A link maps a path to the directory
+ * it points at, and every read goes through `realpath` first, so
+ * `/project/node_modules/react/index.d.ts` reads the file written at
+ * `/project/node_modules/.pnpm/react@19.3.0/node_modules/react/index.d.ts`.
+ *
+ * The directory index is what makes resolution work, and it needs two things
+ * a list of files does not give: every directory a file is in (TypeScript
+ * asks `directoryExists` before it looks inside), and every linked directory
+ * -- a link's own name is listed in its parent, and the directory it points
+ * at exists even before anything has been written into it. Without the
+ * first, packages are reported missing; without the second, so are packages
+ * whose files have not been fetched, and `node_modules/@types` cannot be
+ * listed.
+ *
+ * Every lookup of a path is also reported to `onLookup`, with the real path
+ * it resolved to, so that a caller can tell which packages TypeScript went
+ * looking in.
+ */
+var LinkedFileSystem = /*#__PURE__*/function () {
+  function LinkedFileSystem(links) {
+    slicedToArray._classCallCheck(this, LinkedFileSystem);
+    createForOfIteratorHelper._defineProperty(this, "files", new Map());
+    /** Real directory → the names of its entries, files and directories (links included). */
+    createForOfIteratorHelper._defineProperty(this, "directories", new Map());
+    createForOfIteratorHelper._defineProperty(this, "links", void 0);
+    /** The links never change, so neither does a path's real path. */
+    createForOfIteratorHelper._defineProperty(this, "realpaths", new Map());
+    createForOfIteratorHelper._defineProperty(this, "onLookup", null);
+    this.links = links;
+    this.addDirectory("/");
+    var _iterator = createForOfIteratorHelper._createForOfIteratorHelper(links),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _step$value = slicedToArray._slicedToArray(_step.value, 2),
+          link = _step$value[0],
+          target = _step$value[1];
+        this.addDirectory(target);
+        this.addEntry(link, "directory");
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+  return slicedToArray._createClass(LinkedFileSystem, [{
+    key: "entriesOf",
+    value: function entriesOf(realDir) {
+      var entries = this.directories.get(realDir);
+      if (!entries) {
+        entries = {
+          files: new Set(),
+          directories: new Set()
+        };
+        this.directories.set(realDir, entries);
+      }
+      return entries;
+    }
+
+    /** `dir` and every directory above it. */
+  }, {
+    key: "addDirectory",
+    value: function addDirectory(dir) {
+      for (var at = dir;; at = parentOf(at)) {
+        var known = this.directories.has(at);
+        this.entriesOf(at);
+        if (at === "/") return;
+        this.entriesOf(parentOf(at)).directories.add(baseName(at));
+        if (known) return;
+      }
+    }
+
+    /** Lists `path` in its parent; the parent's real path, as `path` may sit under a link. */
+  }, {
+    key: "addEntry",
+    value: function addEntry(path, kind) {
+      var parent = this.realpath(parentOf(path));
+      this.addDirectory(parent);
+      var entries = this.entriesOf(parent);
+      if (kind === "file") entries.files.add(baseName(path));else entries.directories.add(baseName(path));
+    }
+
+    /** Resolves every link along `path`, as `fs.realpathSync` does. */
+  }, {
+    key: "realpath",
+    value: function realpath(path) {
+      var known = this.realpaths.get(path);
+      if (known !== undefined) return known;
+      var real = this.resolveLinks(path);
+      this.realpaths.set(path, real);
+      return real;
+    }
+  }, {
+    key: "resolveLinks",
+    value: function resolveLinks(path) {
+      var current = normalizePath(path);
+      for (var hops = 0; hops < 40; hops++) {
+        var segments = current.split("/").slice(1);
+        var resolved = null;
+        for (var i = segments.length; i > 0; i--) {
+          var prefix = "/".concat(segments.slice(0, i).join("/"));
+          var target = this.links.get(prefix);
+          if (target !== undefined) {
+            var rest = segments.slice(i).join("/");
+            resolved = rest === "" ? target : "".concat(target, "/").concat(rest);
+            break;
+          }
+        }
+        if (resolved === null) return current;
+        current = resolved;
+      }
+      return current;
+    }
+  }, {
+    key: "writeFile",
+    value: function writeFile(realPath, text) {
+      var path = normalizePath(realPath);
+      this.files.set(path, text);
+      this.addEntry(path, "file");
+    }
+  }, {
+    key: "lookup",
+    value: function lookup(path) {
+      var _this$onLookup;
+      var real = this.realpath(path);
+      (_this$onLookup = this.onLookup) === null || _this$onLookup === void 0 || _this$onLookup.call(this, real);
+      return real;
+    }
+  }, {
+    key: "readFile",
+    value: function readFile(path) {
+      return this.files.get(this.lookup(path));
+    }
+  }, {
+    key: "fileExists",
+    value: function fileExists(path) {
+      return this.files.has(this.lookup(path));
+    }
+  }, {
+    key: "directoryExists",
+    value: function directoryExists(path) {
+      return this.directories.has(this.lookup(path));
+    }
+
+    /** The directories in `path`, links to directories included. */
+  }, {
+    key: "getDirectories",
+    value: function getDirectories(path) {
+      var entries = this.directories.get(this.lookup(path));
+      return entries ? slicedToArray._toConsumableArray(entries.directories).sort() : [];
+    }
+
+    /** The files in `path`. */
+  }, {
+    key: "getFiles",
+    value: function getFiles(path) {
+      var entries = this.directories.get(this.lookup(path));
+      return entries ? slicedToArray._toConsumableArray(entries.files).sort() : [];
+    }
+
+    /** Every file written, by real path. */
+  }, {
+    key: "allFiles",
+    value: function allFiles() {
+      return this.files.keys();
+    }
+  }]);
+}();
+function parentOf(path) {
+  var slash = path.lastIndexOf("/");
+  return slash <= 0 ? "/" : path.slice(0, slash);
+}
+function baseName(path) {
+  return path.slice(path.lastIndexOf("/") + 1);
+}
+
+/**
+ * adept's `/types/<partition>/<name>@<version>`: a package version's
+ * declaration files and every `package.json`, by path relative to the
+ * package's root, and the names of its JavaScript files.
+ */
+
+/**
+ * Where bundles and compilers come from. In the Studio that is adept,
+ * through the Studio's server (`adeptSources.ts`); tests and Node scripts
+ * give their own.
+ */
+
+/**
+ * A failed request for a bundle or a compiler, by what can be done about it.
+ * `status` 401 means signed out, and stops the whole check: every other
+ * request would fail the same way.
+ */
+var SourceError = /*#__PURE__*/function (_Error) {
+  function SourceError(message, code, retryable) {
+    var _this;
+    var status = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+    slicedToArray._classCallCheck(this, SourceError);
+    _this = slicedToArray._callSuper(this, SourceError, [message]);
+    _this.code = code;
+    _this.retryable = retryable;
+    _this.status = status;
+    return _this;
+  }
+  slicedToArray._inherits(SourceError, _Error);
+  return slicedToArray._createClass(SourceError);
+}(/*#__PURE__*/slicedToArray._wrapNativeSuper(Error));
+
+/** A package whose types could not be had, so the check that follows is incomplete. */
+
+var DECLARATION = /\.d\.[mc]?ts$/;
+
+/**
+ * The package a bare specifier names: `react` of `react/jsx-runtime`,
+ * `@tanstack/react-router` of itself. `null` for anything that is not looked
+ * up in `node_modules`: relative and absolute paths, `#subpath` imports and
+ * `node:` and other schemes.
+ */
+function packageNameOf(specifier) {
+  if (specifier === "" || specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("#") || /^[A-Za-z][A-Za-z0-9+.-]*:/.test(specifier)) {
+    return null;
+  }
+  var parts = specifier.split("/");
+  if (specifier.startsWith("@")) {
+    return parts[0].length > 1 && parts[1] ? "".concat(parts[0], "/").concat(parts[1]) : null;
+  }
+  return parts[0];
+}
+
+/** `@types/node` for `node`, `@types/scope__name` for `@scope/name`. */
+function typesPackageOf(name) {
+  return "@types/".concat(name.startsWith("@") ? name.slice(1).replace("/", "__") : name);
+}
+
+/** The package directory a real path is in: up to the name after its last `node_modules`. */
+function packageDirOf(realPath) {
+  var at = realPath.lastIndexOf("/node_modules/");
+  if (at < 0) return null;
+  var rest = realPath.slice(at + "/node_modules/".length).split("/");
+  var name = rest[0].startsWith("@") ? rest.slice(0, 2).join("/") : rest[0];
+  if (name === "" || name.startsWith(".") || name.startsWith("@") && !name.includes("/")) {
+    return null;
+  }
+  return "".concat(realPath.slice(0, at), "/node_modules/").concat(name);
+}
+
+/** A bundle path that stays inside its package. */
+function isSafeRelative(path) {
+  return path !== "" && !path.startsWith("/") && !path.split("/").some(function (segment) {
+    return segment === ".." || segment === "";
+  });
+}
+
+/**
+ * Fetches the types a project's imports reach, and only those, and writes
+ * each bundle at its snapshot's directory in the virtual store, so that the
+ * layout's links make it visible wherever pnpm would.
+ *
+ * {@link wantImportsOf} scans a file's imports and type references; each
+ * bare one is looked for as Node looks for it, from the file's directory up
+ * through each `node_modules` (and its `@types` twin), and the nearest level
+ * that has it is fetched. A fetched bundle's declaration files are scanned in
+ * turn, so type dependencies are followed transitively. {@link wantPackage}
+ * fetches a package by directory, for when TypeScript itself went looking in
+ * one.
+ */
+var TypeAcquisition = /*#__PURE__*/function () {
+  function TypeAcquisition(ts, fs, layout, sources) {
+    var concurrency = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 8;
+    slicedToArray._classCallCheck(this, TypeAcquisition);
+    createForOfIteratorHelper._defineProperty(this, "started", new Set());
+    createForOfIteratorHelper._defineProperty(this, "running", new Set());
+    createForOfIteratorHelper._defineProperty(this, "queue", []);
+    createForOfIteratorHelper._defineProperty(this, "fatal", null);
+    createForOfIteratorHelper._defineProperty(this, "missing", []);
+    createForOfIteratorHelper._defineProperty(this, "stats", {
+      scanned: 0,
+      resolved: 0,
+      files: 0,
+      stubs: 0,
+      bytes: 0
+    });
+    this.ts = ts;
+    this.fs = fs;
+    this.layout = layout;
+    this.sources = sources;
+    this.concurrency = concurrency;
+  }
+
+  /** Whether `dir` is a package this has fetched, or tried to. */
+  return slicedToArray._createClass(TypeAcquisition, [{
+    key: "has",
+    value: function has(dir) {
+      return this.started.has(dir);
+    }
+
+    /** The installed package at a real directory, if it is one. */
+  }, {
+    key: "packageAt",
+    value: function packageAt(dir) {
+      return this.layout.packages.get(dir);
+    }
+
+    /**
+     * The packages a bare name reaches from `fromDir`: at the nearest
+     * `node_modules` that has the package or its `@types`, both.
+     */
+  }, {
+    key: "findPackages",
+    value: function findPackages(fromDir, name) {
+      var _this2 = this;
+      var typesName = typesPackageOf(name);
+      var _loop = function _loop() {
+          var modules = at === "/" ? "/node_modules" : "".concat(at, "/node_modules");
+          var found = [name, typesName].flatMap(function (candidate) {
+            var real = _this2.fs.realpath("".concat(modules, "/").concat(candidate));
+            return _this2.layout.packages.has(real) ? [real] : [];
+          });
+          if (found.length > 0) return {
+            v: found
+          };
+          if (at === "/") return {
+            v: []
+          };
+        },
+        _ret;
+      for (var at = fromDir;; at = parentOf(at)) {
+        _ret = _loop();
+        if (_ret) return _ret.v;
+      }
+    }
+
+    /** Wants what a bare specifier names, from a file in `fromDir`. */
+  }, {
+    key: "wantSpecifier",
+    value: function wantSpecifier(fromDir, specifier) {
+      var name = packageNameOf(specifier);
+      if (name === null) return;
+      var _iterator = createForOfIteratorHelper._createForOfIteratorHelper(this.findPackages(fromDir, name)),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var dir = _step.value;
+          this.wantPackage(dir, "scanned");
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+
+    /** Wants every package a file's imports and type references reach. */
+  }, {
+    key: "wantImportsOf",
+    value: function wantImportsOf(realPath, text) {
+      var info = this.ts.preProcessFile(text, true, true);
+      var dir = parentOf(realPath);
+      var _iterator2 = createForOfIteratorHelper._createForOfIteratorHelper(info.importedFiles),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var imported = _step2.value;
+          this.wantSpecifier(dir, imported.fileName);
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      var _iterator3 = createForOfIteratorHelper._createForOfIteratorHelper(info.typeReferenceDirectives),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var reference = _step3.value;
+          this.wantSpecifier(dir, reference.fileName);
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+    }
+  }, {
+    key: "wantPackage",
+    value: function wantPackage(dir, via) {
+      if (this.started.has(dir) || !this.layout.packages.has(dir)) return;
+      this.started.add(dir);
+      this.queue.push({
+        dir: dir,
+        via: via
+      });
+      this.pump();
+    }
+  }, {
+    key: "pump",
+    value: function pump() {
+      var _this3 = this;
+      var _loop2 = function _loop2() {
+        var next = _this3.queue.shift();
+        var task = _this3.fetch(next.dir, next.via)["finally"](function () {
+          _this3.running["delete"](task);
+          _this3.pump();
+        });
+        _this3.running.add(task);
+      };
+      while (this.running.size < this.concurrency && this.queue.length > 0) {
+        _loop2();
+      }
+    }
+
+    /** Resolves when everything wanted so far, and everything that wanted, is fetched. */
+  }, {
+    key: "settle",
+    value: (function () {
+      var _settle = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee() {
+        return slicedToArray._regenerator().w(function (_context) {
+          while (1) switch (_context.n) {
+            case 0:
+              if (!(this.running.size > 0)) {
+                _context.n = 3;
+                break;
+              }
+              _context.n = 1;
+              return Promise.race(this.running);
+            case 1:
+              if (!(this.fatal !== null)) {
+                _context.n = 2;
+                break;
+              }
+              throw this.fatal;
+            case 2:
+              _context.n = 0;
+              break;
+            case 3:
+              if (!(this.fatal !== null)) {
+                _context.n = 4;
+                break;
+              }
+              throw this.fatal;
+            case 4:
+              return _context.a(2);
+          }
+        }, _callee, this);
+      }));
+      function settle() {
+        return _settle.apply(this, arguments);
+      }
+      return settle;
+    }())
+  }, {
+    key: "fetch",
+    value: function () {
+      var _fetch = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee2(dir, via) {
+        var pkg, ref, bundle, attempt, _retryable, _i, _Object$entries, _Object$entries$_i, path, text, _iterator4, _step4, stub, _i2, _Object$entries2, _Object$entries2$_i, _path, _text, _t, _t2;
+        return slicedToArray._regenerator().w(function (_context2) {
+          while (1) switch (_context2.p = _context2.n) {
+            case 0:
+              pkg = this.layout.packages.get(dir);
+              ref = {
+                name: pkg.name,
+                version: pkg.version,
+                integrity: pkg.integrity
+              };
+              if (pkg.fromRegistry) {
+                _context2.n = 1;
+                break;
+              }
+              this.missing.push(createForOfIteratorHelper._objectSpread2(createForOfIteratorHelper._objectSpread2({}, ref), {}, {
+                code: "not-from-registry",
+                message: "".concat(pkg.name, " is not installed from a registry by version, so its types cannot be fetched."),
+                retryable: false
+              }));
+              return _context2.a(2);
+            case 1:
+              bundle = null;
+              attempt = 0;
+            case 2:
+              if (!(attempt < 2 && bundle === null)) {
+                _context2.n = 9;
+                break;
+              }
+              _context2.p = 3;
+              _context2.n = 4;
+              return this.sources.types(ref);
+            case 4:
+              bundle = _context2.v;
+              _context2.n = 8;
+              break;
+            case 5:
+              _context2.p = 5;
+              _t = _context2.v;
+              if (!(_t instanceof SourceError && _t.status === 401)) {
+                _context2.n = 6;
+                break;
+              }
+              this.fatal = _t;
+              return _context2.a(2);
+            case 6:
+              _retryable = _t instanceof SourceError ? _t.retryable : true;
+              if (!(_retryable && attempt === 0)) {
+                _context2.n = 7;
+                break;
+              }
+              return _context2.a(3, 8);
+            case 7:
+              this.missing.push(createForOfIteratorHelper._objectSpread2(createForOfIteratorHelper._objectSpread2({}, ref), {}, {
+                code: _t instanceof SourceError ? _t.code : "network",
+                message: _t instanceof Error ? _t.message : String(_t),
+                retryable: _retryable
+              }));
+              return _context2.a(2);
+            case 8:
+              attempt++;
+              _context2.n = 2;
+              break;
+            case 9:
+              if (!(bundle === null)) {
+                _context2.n = 10;
+                break;
+              }
+              return _context2.a(2);
+            case 10:
+              this.stats[via]++;
+              _i = 0, _Object$entries = Object.entries(bundle.files);
+            case 11:
+              if (!(_i < _Object$entries.length)) {
+                _context2.n = 14;
+                break;
+              }
+              _Object$entries$_i = slicedToArray._slicedToArray(_Object$entries[_i], 2), path = _Object$entries$_i[0], text = _Object$entries$_i[1];
+              if (isSafeRelative(path)) {
+                _context2.n = 12;
+                break;
+              }
+              return _context2.a(3, 13);
+            case 12:
+              this.fs.writeFile("".concat(dir, "/").concat(path), text);
+              this.stats.files++;
+              this.stats.bytes += text.length;
+            case 13:
+              _i++;
+              _context2.n = 11;
+              break;
+            case 14:
+              _iterator4 = createForOfIteratorHelper._createForOfIteratorHelper(bundle.stubs);
+              _context2.p = 15;
+              _iterator4.s();
+            case 16:
+              if ((_step4 = _iterator4.n()).done) {
+                _context2.n = 19;
+                break;
+              }
+              stub = _step4.value;
+              if (isSafeRelative(stub)) {
+                _context2.n = 17;
+                break;
+              }
+              return _context2.a(3, 18);
+            case 17:
+              if (!Object.prototype.hasOwnProperty.call(bundle.files, stub)) {
+                this.fs.writeFile("".concat(dir, "/").concat(stub), "");
+                this.stats.stubs++;
+              }
+            case 18:
+              _context2.n = 16;
+              break;
+            case 19:
+              _context2.n = 21;
+              break;
+            case 20:
+              _context2.p = 20;
+              _t2 = _context2.v;
+              _iterator4.e(_t2);
+            case 21:
+              _context2.p = 21;
+              _iterator4.f();
+              return _context2.f(21);
+            case 22:
+              for (_i2 = 0, _Object$entries2 = Object.entries(bundle.files); _i2 < _Object$entries2.length; _i2++) {
+                _Object$entries2$_i = slicedToArray._slicedToArray(_Object$entries2[_i2], 2), _path = _Object$entries2$_i[0], _text = _Object$entries2$_i[1];
+                if (DECLARATION.test(_path) && isSafeRelative(_path)) {
+                  this.wantImportsOf("".concat(dir, "/").concat(_path), _text);
+                }
+              }
+            case 23:
+              return _context2.a(2);
+          }
+        }, _callee2, this, [[15, 20, 21, 22], [3, 5]]);
+      }));
+      function fetch(_x, _x2) {
+        return _fetch.apply(this, arguments);
+      }
+      return fetch;
+    }()
+  }]);
+}();
+
+exports.LinkedFileSystem = LinkedFileSystem;
+exports.LockfileError = LockfileError;
+exports.SourceError = SourceError;
+exports.TypeAcquisition = TypeAcquisition;
+exports.UnsupportedLayoutError = UnsupportedLayoutError;
+exports.computePnpmLayout = computePnpmLayout;
+exports.layoutOptionsOfWorkspace = layoutOptionsOfWorkspace;
+exports.normalizePath = normalizePath;
+exports.packageDirOf = packageDirOf;
+exports.packageNameOf = packageNameOf;
+exports.parentOf = parentOf;
+exports.parsePnpmLockfile = parsePnpmLockfile;
+exports.typesPackageOf = typesPackageOf;