@antongolub/lockfile 0.0.0-snapshot.2 → 0.0.0-snapshot.21

package/target/es6/index.js

@@ -1,4 +1,7 @@
-// src/main/ts/util.ts
+// src/main/ts/common.ts
+import semver from "semver";
+import { topo, traverseDeps } from "@semrel-extra/topo";
+var getSources = (snapshot) => Object.values(snapshot).map((entry) => entry.source.id).filter(Boolean);
 var parseIntegrity = (integrity) => integrity ? integrity.split(" ").reduce((m, item) => {
   const [k, v] = item.split("-");
   if (k === "sha512" || k === "sha256" || k === "sha1" || k === "checksum") {
@@ -8,7 +11,63 @@ var parseIntegrity = (integrity) => integrity ? integrity.split(" ").reduce((m,
   }
   return m;
 }, {}) : {};
-var sortObject = (unordered) => Object.entries({ ...unordered }).sort(([a], [b]) => a > b ? 1 : -1).reduce(
+var formatIntegrity = (hashes) => {
+  const checksum = hashes["checksum"];
+  if (checksum) {
+    return checksum;
+  }
+  return Object.entries(hashes).map(([k, v]) => `${k}-${v}`).join(" ");
+};
+var parseTarballUrl = (resolution) => {
+  const [tgz, br, _name, org, ...rest] = resolution.split("/").reverse();
+  if (br !== "-") {
+    return null;
+  }
+  const hasScope = org[0] === "@";
+  const name = hasScope ? `${org}/${_name}` : _name;
+  const id = tgz.slice(_name.length + 1, tgz.lastIndexOf(".tgz"));
+  return {
+    type: "npm",
+    name,
+    id,
+    registry: rest.reverse().join("/") + (hasScope ? "" : "/" + org),
+    hash: tgz.slice((tgz + "#").indexOf("#"))
+  };
+};
+var formatTarballUrl = (name, version6, registry = "https://registry.npmjs.org", hash = "") => `${registry}/${name}/-/${name.slice(name.indexOf("/") + 1)}-${version6}.tgz${hash}`;
+var gitProtocols = ["git", "git+ssh", "git+http", "git+https", "git+file"];
+var refProtocols = ["npm", "github", "workspace", "semver", "tag", "patch", "link", "portal", "file", ...gitProtocols];
+var normalizeDeps = (deps) => processDeps(deps, normalizeReference);
+var processDeps = (deps, formatter = (v) => v, opts = {}) => deps && Object.entries(deps).reduce((m, [k, v]) => {
+  m[k] = formatter(v + "", opts);
+  return m;
+}, {});
+var normalizeReference = (ref) => {
+  if (refProtocols.some((p) => ref.startsWith(p + ":"))) {
+    return ref;
+  }
+  if (semver.validRange(ref)) {
+    return "semver:" + ref;
+  }
+  if (ref.includes(".git")) {
+    return "git:" + ref;
+  }
+  if (ref.includes("/")) {
+    return "github:" + ref;
+  }
+  return "tag:" + ref;
+};
+var referenceKeysSorter = (a, b) => {
+  const _a = a.includes("npm:");
+  const _b = b.includes("npm:");
+  return _a === _b ? 0 : +_b - +_a;
+};
+
+// src/main/ts/util.ts
+import fs from "node:fs/promises";
+import path from "node:path";
+import * as process from "node:process";
+var sortObject = (unordered, predicate = ([a], [b]) => a > b ? 1 : -1) => Object.entries({ ...unordered }).sort(predicate).reduce(
   (obj, [key, value]) => {
     obj[key] = value;
     return obj;
@@ -21,41 +80,170 @@ var flushObject = (obj) => {
   }
   return obj;
 };
+var debug = Object.assign((...chunks) => {
+  if (!debug.enable)
+    return;
+  console.log(...chunks);
+}, {
+  enable: process.env.DEBUG,
+  json(data, name = `debug-${Math.random().toString(16).slice(2)}.json`, base = path.resolve(process.cwd(), "temp")) {
+    if (!this.enable)
+      return;
+    if (typeof data === "string") {
+      this.json(name, data);
+      return;
+    }
+    const _data = typeof data === "function" ? data() : data;
+    fs.writeFile(path.resolve(base, name), JSON.stringify(_data, null, 2));
+  }
+});
+var unique = (arr) => [...new Set(arr)];
 
-// src/main/ts/npm-1.ts
-import fs from "fs";
-var parse = async (lockfile, pkg) => {
-  const lf = await JSON.parse(lockfile);
-  const manifest = await JSON.parse(pkg);
-  const workspaces = {
-    "": {
-      name: manifest.name,
-      path: ".",
-      manifest
+// src/main/ts/analyze.ts
+var getDeps = (entry) => {
+  if (!getDeps.cache.has(entry)) {
+    getDeps.cache.set(entry, {
+      ...sortObject(entry.dependencies || {}),
+      ...sortObject({ ...entry.devDependencies, ...entry.optionalDependencies })
+    });
+  }
+  return getDeps.cache.get(entry);
+};
+getDeps.cache = /* @__PURE__ */ new WeakMap();
+var walk = (ctx) => {
+  const { root, entry = root, prefix, depth = 0, parentId, idx, id = idx.getEntryId(entry), parents = [] } = ctx;
+  const key = (prefix ? prefix + "," : "") + entry.name;
+  if (id === void 0) {
+    throw new TypeError(`Invalid snapshot: ${key}`);
+  }
+  if (!idx.tree[key]) {
+    const chunks = key.split(",");
+    idx.tree[key] = {
+      key,
+      chunks,
+      id,
+      name: entry.name,
+      version: entry.version,
+      entry,
+      parents
+    };
+    if (root.dependencies?.[chunks[1]]) {
+      idx.prod.add(entry);
+    }
+    if (parentId !== void 0) {
+      idx.edges.push([parentId, id]);
+      return;
+    }
+    if (depth) {
+      return;
+    }
+  }
+  const stack = [];
+  const dependencies = getDeps(entry);
+  Object.entries(dependencies).forEach(([name, range]) => {
+    const _entry = idx.getEntryByRange(name, range);
+    if (!_entry) {
+      throw new Error(`inconsistent snapshot: ${name} ${range}`);
+    }
+    idx.bound(entry, _entry);
+    if (parents.includes(entry)) {
+      return;
+    }
+    const _ctx = { root, entry: _entry, prefix: key, depth: depth + 1, parentId: id, idx, parents: [...parents, entry] };
+    stack.push(_ctx);
+    walk(_ctx);
+  });
+  stack.forEach(walk);
+};
+var getId = (name, version6 = "") => name ? `${name}@${version6}` : "";
+var analyze = (snapshot) => {
+  const entries = Object.values(snapshot);
+  const roots = entries.filter((e) => e.source.type === "workspace");
+  const prod = new Set(roots);
+  const deps = /* @__PURE__ */ new Map();
+  const edges = [];
+  const tree = {};
+  const rangeMap = /* @__PURE__ */ new Map();
+  const idx = {
+    snapshot,
+    roots,
+    edges,
+    tree,
+    prod,
+    entries,
+    bound(from, to) {
+      const deps2 = this.getEntryDeps(from);
+      if (deps2.includes(to)) {
+        return;
+      }
+      deps2.push(to);
+    },
+    getEntryId({ name, version: version6 }) {
+      return getId(name, version6);
+    },
+    getEntry(name, version6) {
+      return snapshot[name] || snapshot[getId(name, version6)];
+    },
+    getEntryByRange(name, range) {
+      const key = getId(name, range);
+      if (rangeMap.has(key)) {
+        return rangeMap.get(key);
+      }
+      const _ranges = [range, range.replace("semver:", "npm:"), range.replace("npm:", "semver:")];
+      const found = entries.find(({ name: _name, ranges }) => name === _name && _ranges.some(ranges.includes.bind(ranges)));
+      rangeMap.set(key, found);
+      return found;
+    },
+    getEntryDeps(entry) {
+      if (!deps.has(entry)) {
+        deps.set(entry, []);
+      }
+      return deps.get(entry);
     }
   };
-  const entries = {
+  const now = Date.now();
+  roots.forEach((root) => {
+    const isRoot = root.source.id === ".";
+    if (isRoot && !root.manifest)
+      return;
+    walk({ root, idx, id: isRoot ? "" : void 0 });
+  });
+  debug("analyze duration=", Date.now() - now, "deptree size=", Object.keys(tree).length);
+  debug.json("deptree.json", Object.values(tree).map(({ parents, name }) => [...parents.map((p) => p.name).slice(1), name].join(",")));
+  return idx;
+};
+
+// src/main/ts/formats/npm-1.ts
+var version = "npm-1";
+var check = (lockfile) => lockfile.includes('  "lockfileVersion": 1');
+var parse = (lockfile, pkg) => {
+  const lf = JSON.parse(lockfile);
+  const manifest = JSON.parse(pkg);
+  const snapshot = {
     "": {
       name: manifest.name,
       version: manifest.version,
-      dependencies: {
-        ...manifest.dependencies,
-        ...manifest.devDependencies
-      },
+      dependencies: manifest.dependencies,
+      devDependencies: manifest.devDependencies,
       hashes: {},
-      ranges: []
+      source: {
+        type: "workspace",
+        id: "."
+      },
+      ranges: [],
+      manifest
     }
   };
   const getClosestVersion = (name, ...deps) => deps.find((dep) => dep[name])?.[name]?.version;
-  const upsertEntry = (name, version, data = {}) => {
-    const key = `${name}@${version}`;
-    if (!entries[key]) {
-      entries[key] = { name, version, ranges: [] };
+  const upsertEntry = (name, version6, data = {}) => {
+    const key = `${name}@${version6}`;
+    if (!snapshot[key]) {
+      snapshot[key] = { name, version: version6, ranges: [] };
     }
-    return Object.assign(entries[key], data);
+    return Object.assign(snapshot[key], data);
   };
-  const pushRange = (name, version, range) => {
-    const entry = upsertEntry(name, version);
+  const pushRange = (name, version6, range) => {
+    const entry = upsertEntry(name, version6);
     if (!entry.ranges.includes(range)) {
       entry.ranges.push(range);
       entry.ranges.sort();
@@ -66,72 +254,37 @@ var parse = async (lockfile, pkg) => {
     pushRange(_name, _version, range);
   });
   const extractEntries = (deps, ...parents) => deps && Object.entries(deps).forEach(([name, entry]) => {
-    const requires = entry.requires || entry.dependencies && Object.entries(entry.dependencies).reduce((m, [name2, { version }]) => {
-      m[name2] = version;
+    const requires = entry.requires || entry.dependencies && Object.entries(entry.dependencies).reduce((m, [name2, { version: version6 }]) => {
+      m[name2] = version6;
       return m;
     }, {});
     upsertEntry(name, entry.version, {
       hashes: parseIntegrity(entry.integrity),
-      dependencies: requires
+      dependencies: requires,
+      source: parseResolution(entry.resolved)
     });
     extractEntries(entry.dependencies, deps, ...parents);
     extractRanges(requires, entry.dependencies || {}, deps, ...parents);
   });
   extractEntries(lf.dependencies);
-  extractRanges(entries[""].dependencies, lf.dependencies || {});
-  return {
-    format: "npm-1",
-    entries: sortObject(entries),
-    workspaces
-  };
-};
-var formatIntegrity = (hashes) => Object.entries(hashes).map(([key, value]) => `${key}-${value}`).join(" ");
-var createIndex = () => {
-  const prod = /* @__PURE__ */ new Set();
-  const deps = /* @__PURE__ */ new Map();
-  return {
-    prod,
-    deps,
-    getDeps(entry) {
-      if (!deps.has(entry)) {
-        deps.set(entry, []);
-      }
-      return deps.get(entry);
-    }
-  };
+  extractRanges({
+    ...snapshot[""].dependencies,
+    ...snapshot[""].devDependencies
+  }, lf.dependencies || {});
+  debug.json("npm1-snapshot.json", snapshot);
+  return sortObject(snapshot);
 };
-var isProd = (manifest, name) => !!manifest.dependencies?.[name];
-var format = async (snap) => {
-  const root = snap.workspaces[""].manifest;
-  const entries = Object.values(snap.entries);
-  const idx = createIndex();
-  entries.forEach((entry) => {
-    entry.dependencies && Object.entries(entry.dependencies).forEach(([_name, range]) => {
-      const target = entries.find(({ name, ranges }) => name === _name && ranges.includes(range));
-      if (target) {
-        idx.getDeps(entry).push(target);
-      }
-    });
-  });
-  const deptree = [];
-  const fillTree = (entry, chain = []) => {
-    const deps = idx.getDeps(entry);
-    deps.forEach((c) => isProd(root, chain[0]?.name || c.name) && idx.prod.add(c));
-    deps.sort(
-      (a, b) => idx.prod.has(a) && !idx.prod.has(b) ? -1 : idx.prod.has(b) && !idx.prod.has(a) ? 1 : a.name.localeCompare(b.name)
-    );
-    deps.forEach((dep) => deptree.push([...chain, dep]));
-    deps.forEach((dep) => fillTree(dep, [...chain, dep]));
-  };
-  const getEntry = (name, version) => entries.find((e) => e.name === name && e.version === version);
-  fillTree(getEntry(root.name, root.version));
+var formatIntegrity2 = (hashes) => Object.entries(hashes).map(([key, value]) => `${key}-${value}`).join(" ");
+var preformat = (idx) => {
+  const root = idx.snapshot[""].manifest;
+  const deptree = Object.values(idx.tree).slice(1).map(({ parents, entry }) => [...parents.slice(1), entry]);
+  debug.json("deptree-npm-1.json", deptree.map((entries) => entries.map((e) => e.name).join(",")));
   const formatNpm1LockfileEntry = (entry) => {
-    const { name, version, hashes } = entry;
-    const _name = name.slice(name.indexOf("/") + 1);
+    const { name, version: version6, hashes, source } = entry;
     const _entry = {
-      version,
-      resolved: `https://registry.npmjs.org/${name}/-/${_name}-${version}.tgz`,
-      integrity: formatIntegrity(hashes)
+      version: version6,
+      resolved: formatResolution(source),
+      integrity: formatIntegrity2(hashes)
     };
     if (!idx.prod.has(entry)) {
       _entry.dev = true;
@@ -150,9 +303,9 @@ var format = async (snap) => {
   };
   const nmtree = lf;
   const nodes = [nmtree];
-  const processEntry = (name, version, parents) => {
-    const entry = getEntry(name, version);
-    const deps = idx.getDeps(entry);
+  const processEntry = (name, version6, parents) => {
+    const entry = idx.getEntry(name, version6);
+    const deps = idx.getEntryDeps(entry);
     const queue = [];
     deps.forEach((e) => {
       const closestIndex = parents.findIndex((p) => p.dependencies?.[e.name]);
@@ -170,7 +323,7 @@ var format = async (snap) => {
       nodes.push(parent);
       queue.push([e.name, e.version, _parents]);
     });
-    queue.forEach(([name2, version2, parents2]) => processEntry(name2, version2, parents2));
+    queue.forEach(([name2, version7, parents2]) => processEntry(name2, version7, parents2));
   };
   deptree.forEach((chain) => {
     const entry = chain[chain.length - 1];
@@ -184,25 +337,256 @@ var format = async (snap) => {
     sortObject(node.dependencies || {});
     if (node.requires) {
       const snap1 = Object.entries(node.requires).map(([name, range]) => `${name}@${range}`).join("");
-      const snap2 = Object.entries(node.dependencies || {}).map(([name, { version }]) => `${name}@${version}`).join("");
+      const snap2 = Object.entries(node.dependencies || {}).map(([name, { version: version6 }]) => `${name}@${version6}`).join("");
       if (snap1 === snap2) {
         delete node.requires;
       }
     }
   });
-  fs.writeFileSync("temp/test.json", JSON.stringify(lf, null, 2));
-  fs.writeFileSync("temp/tree.json", JSON.stringify(
-    deptree.map((c) => c.map((e) => `${e.name}@${e.version}`).join(" > ")),
-    null,
-    2
-  ));
-  return JSON.stringify(lf, null, 2);
+  return lf;
+};
+var format = (snap) => JSON.stringify(preformat(analyze(snap)), null, 2);
+var parseResolution = (input) => {
+  if (input.startsWith("github:")) {
+    return {
+      type: "github",
+      name: input.slice(7, -41),
+      id: input.slice(-40)
+    };
+  }
+  const npmResolution = parseTarballUrl(input);
+  if (!npmResolution)
+    throw new TypeError(`Unsupported resolution format: ${input}`);
+  return npmResolution;
+};
+var formatResolution = (source) => {
+  const { type, name, id, registry = "https://registry.npmjs.org" } = source;
+  if (type === "github") {
+    return `github:${name}#${id}`;
+  }
+  return formatTarballUrl(name, id, registry);
 };
 
-// src/main/ts/yarn-1.ts
+// src/main/ts/formats/npm-3.ts
+import semver2 from "semver";
+var version2 = "npm-3";
+var check2 = (lockfile) => lockfile.includes('  "lockfileVersion": 3');
+var parse2 = (lockfile) => {
+  const lf = JSON.parse(lockfile);
+  const snapshot = parsePackages(lf.packages);
+  snapshot[""].manifest = lf.packages[""];
+  debug.json("npm3-snapshot.json", snapshot);
+  return snapshot;
+};
+var formatNmKey = (chunks) => `node_modules/` + chunks.join("/node_modules/");
+var parsePackages = (packages) => {
+  const entries = {};
+  const getClosestPkg = (name, chain, entries2, _range) => {
+    const variants3 = [];
+    const range = _range?.startsWith("npm:") ? _range.slice(_range.lastIndexOf("@") + 1) : _range;
+    let s = 0;
+    while (s < chain.length) {
+      let l = chain.length + 1;
+      while (l--) {
+        const variant = formatNmKey([...chain.slice(s, l), name].filter(Boolean));
+        const entry = entries2[variant];
+        if (entry && (!entry.version || entry.version === range || semver2.satisfies(entry.version, range))) {
+          return [variant, entry];
+        }
+        variants3.push(variant);
+      }
+      s++;
+    }
+    throw new Error(`Malformed lockfile: ${name} ${range}
+${variants3.join("\n")}`);
+  };
+  const processPackage = (path2, pkg) => {
+    if ((pkg.link || path2 === "") && !pkg.name) {
+      return processPackage(path2, {
+        ...pkg,
+        ...packages[pkg.resolved]
+      });
+    }
+    const source = parseResolution2(pkg.resolved);
+    const isNpmAlias = path2.startsWith("node_modules/") && pkg.name;
+    const chain = path2 ? ("/" + path2).split("/node_modules/").filter(Boolean) : [""];
+    const name = !isNpmAlias && pkg.name || chain[chain.length - 1];
+    const version6 = pkg.version;
+    const id = path2 === "" ? path2 : getId(name, version6);
+    if (entries[id]) {
+      return entries[id];
+    }
+    entries[id] = {
+      name,
+      version: version6,
+      ranges: [],
+      hashes: parseIntegrity(pkg.integrity),
+      source,
+      dependencies: pkg.dependencies,
+      engines: pkg.engines,
+      funding: pkg.funding,
+      bin: pkg.bin,
+      devDependencies: pkg.devDependencies,
+      peerDependencies: pkg.peerDependencies,
+      optionalDependencies: pkg.optionalDependencies,
+      license: pkg.license
+    };
+    Object.entries(getDeps(entries[id])).forEach(([_name, range]) => {
+      const [_path, _entry] = getClosestPkg(_name, chain, packages, range);
+      const { ranges } = processPackage(_path, _entry);
+      if (!ranges.includes(range)) {
+        ranges.push(range);
+        ranges.sort();
+      }
+    });
+    return entries[id];
+  };
+  Object.entries(packages).forEach(([path2, entry]) => (path2.startsWith("node_modules/") || path2 === "") && processPackage(path2, entry));
+  return sortObject(entries);
+};
+var buildNmtree = (idx) => {
+  const snap = idx.snapshot;
+  const nmtree = Object.values(idx.tree).reduce((result, { key, id, chunks }) => {
+    const entry = snap[id];
+    if (!entry) {
+      throw new Error(`Malformed snapshot: ${id}`);
+    }
+    const grandparent = chunks[1];
+    const cl = chunks.length;
+    let l = 0;
+    while (l <= cl) {
+      const [name, ...parents] = [...chunks].reverse();
+      let i = 0;
+      while (i < parents.length) {
+        const __key = parents.slice(i, i + l).reverse();
+        const _key = [...__key, name];
+        const variant = formatNmKey(_key);
+        const found = result[variant];
+        if (found) {
+          if (found.entry === entry) {
+            return result;
+          }
+        } else {
+          const pEntry = result[formatNmKey(__key)]?.entry;
+          const ppEntry = idx.getEntry(idx.tree[chunks.slice(0, cl - i - l).join(",")]?.id);
+          if (__key.length && pEntry !== ppEntry) {
+            i++;
+            continue;
+          }
+          result[variant] = { entry, parent: grandparent };
+          return result;
+        }
+        i++;
+      }
+      l++;
+    }
+    if (entry.source.type === "workspace") {
+      result[formatNmKey([entry.name])] = { entry, parent: "" };
+    }
+    return result;
+  }, {});
+  debug.json("npm3-nmtree.json", nmtree);
+  return nmtree;
+};
+var preformat2 = (idx) => {
+  const snap = idx.snapshot;
+  const nmtree = buildNmtree(idx);
+  const manifest = snap[""].manifest;
+  const packages = sortObject(
+    Object.entries(nmtree).reduce((m, [k, { entry, parent }]) => {
+      if (entry.source.type === "workspace") {
+        if (entry.source.id === ".") {
+          m[""] = manifest;
+          return m;
+        }
+        m[`node_modules/${entry.name}`] = {
+          resolved: entry.source.id,
+          link: true
+        };
+        m[entry.source.id] = {
+          name: entry.name,
+          version: entry.version,
+          license: entry.license,
+          dependencies: entry.dependencies,
+          bin: entry.bin,
+          devDependencies: entry.devDependencies
+        };
+        return m;
+      }
+      m[k] = {
+        version: entry.version,
+        resolved: formatResolution2(entry.source),
+        integrity: formatIntegrity(entry.hashes)
+      };
+      if (!idx.prod.has(entry)) {
+        m[k].dev = true;
+      }
+      m[k].dependencies = entry.dependencies;
+      m[k].bin = entry.bin;
+      m[k].engines = entry.engines;
+      m[k].funding = entry.funding;
+      m[k].peerDependencies = entry.peerDependencies;
+      m[k].optionalDependencies = entry.optionalDependencies;
+      return m;
+    }, {})
+  );
+  return {
+    name: manifest.name,
+    version: manifest.version,
+    lockfileVersion: 3,
+    requires: true,
+    packages
+  };
+};
+var format2 = (snapshot) => JSON.stringify(preformat2(analyze(snapshot)), null, 2);
+var parseResolution2 = (input) => {
+  if (!input?.includes("://")) {
+    return {
+      type: "workspace",
+      id: input || "."
+    };
+  }
+  if (input.startsWith("git+ssh://git@github.com/")) {
+    return {
+      name: input.slice(25, -45),
+      id: input.slice(-40),
+      type: "github"
+    };
+  }
+  const npmResolution = parseTarballUrl(input);
+  if (!npmResolution)
+    throw new TypeError(`Unsupported resolution format: ${input}`);
+  return npmResolution;
+};
+var formatResolution2 = ({ type, id, name, registry, hash }) => {
+  if (type === "github") {
+    return `git+ssh://git@github.com/${name}.git#${id}`;
+  }
+  return formatTarballUrl(name, id, registry, hash);
+};
+
+// src/main/ts/formats/npm-2.ts
+var version3 = "npm-2";
+var check3 = (lockfile) => lockfile.includes('  "lockfileVersion": 2');
+var preformat3 = (idx) => {
+  const lfnpm1 = preformat(idx);
+  const lfnpm3 = preformat2(idx);
+  return {
+    name: lfnpm1.name,
+    version: lfnpm1.version,
+    lockfileVersion: 2,
+    requires: true,
+    packages: lfnpm3.packages,
+    dependencies: lfnpm1.dependencies
+  };
+};
+var format3 = (snapshot) => JSON.stringify(preformat3(analyze(snapshot)), null, 2);
+
+// src/main/ts/formats/yarn-classic.ts
 import { load, dump } from "js-yaml";
 var kvEntryPattern = /^(\s+)"?([^"]+)"?\s"?([^"]+)"?$/;
-var check = (value) => value.includes("# yarn lockfile v1");
+var version4 = "yarn-classic";
+var check4 = (value) => value.includes("# yarn lockfile v1");
 var preparse = (value) => {
   const lines = value.split("\n");
   const _value = lines.map((line) => {
@@ -220,67 +604,88 @@ var preparse = (value) => {
   }, "").join("\n");
   return load(_value);
 };
-var parseIntegrity2 = (integrity) => integrity.split(" ").reduce((m, item) => {
-  const [k, v] = item.split("-");
-  if (k === "sha512" || k === "sha256" || k === "sha1" || k === "checksum") {
-    m[k] = v;
-  }
-  return m;
-}, {});
-var parse2 = async (value) => {
-  const raw = await preparse(value);
-  const snapshot = {
-    entries: {},
-    workspaces: {},
-    format: "yarn-1"
-  };
+var parse3 = (value, pkg) => {
+  const manifest = JSON.parse(pkg);
+  const raw = preparse(value);
+  const snapshot = {};
   Object.entries(raw).forEach((value2) => {
     const [_key, _entry] = value2;
+    const { version: version6, integrity, dependencies, optionalDependencies, resolved } = _entry;
+    const hashes = parseIntegrity(integrity);
+    const source = parseResolution3(resolved);
     const chunks = _key.split(", ");
-    const ranges = chunks.map((r) => r.slice(r.lastIndexOf("@") + 1)).sort();
-    const { version, integrity, dependencies, optionalDependencies, resolved: source } = _entry;
-    const name = chunks[0].slice(0, chunks[0].lastIndexOf("@"));
-    const key = `${name}@${version}`;
-    const hashes = parseIntegrity2(integrity);
-    snapshot.entries[key] = {
-      name,
-      version,
-      ranges,
-      hashes,
-      dependencies,
-      optionalDependencies,
-      source
-    };
+    const names = unique(chunks.map((c) => c.slice(0, c.indexOf("@", 1))));
+    for (const name of names) {
+      const ranges = chunks.filter((c) => c.startsWith(`${name}@`)).map((r) => r.slice(r.indexOf("@", 1) + 1)).sort();
+      const key = `${name}@${version6}`;
+      snapshot[key] = {
+        name,
+        version: version6,
+        ranges,
+        hashes,
+        dependencies,
+        optionalDependencies,
+        source
+      };
+    }
   });
+  snapshot[""] = {
+    name: manifest.name,
+    version: manifest.version,
+    ranges: [],
+    hashes: {},
+    source: {
+      type: "workspace",
+      id: "."
+    },
+    manifest,
+    dependencies: manifest.dependencies,
+    devDependencies: manifest.devDependencies,
+    optionalDependencies: manifest.optionalDependencies
+  };
+  debug.json("yarn-classic-snapshot.json", snapshot);
   return snapshot;
 };
-var preformat = (value) => {
+var preformat4 = (idx) => {
+  const { snapshot } = idx;
   const lf = {};
-  Object.values(value.entries).forEach((entry) => {
-    const { name, version, ranges, hashes, dependencies, optionalDependencies, source } = entry;
-    const key = ranges.map((r) => `${name}@${r}`).join(", ");
+  const rangemap = {};
+  Object.values(snapshot).forEach((entry) => {
+    const { name, version: version6, ranges, hashes, dependencies, optionalDependencies, source } = entry;
+    const resolved = formatResolution3(source);
+    const alias = rangemap[resolved];
     const integrity = Object.entries(hashes).map(([k, v]) => `${k}-${v}`).join(" ");
+    const keys = ranges.map((r) => `${name}@${r}`);
+    if (alias) {
+      keys.push(...alias.keys);
+      keys.sort(referenceKeysSorter);
+      delete lf[alias.key];
+    }
+    const key = keys.join(", ");
+    rangemap[resolved] = { keys, key, name };
     lf[key] = {
-      version,
-      resolved: source,
+      version: version6,
+      resolved,
       integrity,
       dependencies,
       optionalDependencies
     };
   });
+  delete lf[""];
   return lf;
 };
-var format2 = (value) => {
-  const lf = preformat(value);
+var format4 = (snapshot) => {
+  const lf = preformat4({ snapshot });
   const lines = dump(lf, {
     quotingType: '"',
     flowLevel: -1,
     lineWidth: -1,
-    forceQuotes: true
+    forceQuotes: true,
+    noRefs: true
   }).split("\n");
   const _value = lines.map((line) => {
     if (line.length !== 0 && line.charAt(0) !== " ") {
-      const chunks = line.slice(0, -1).replaceAll('"', "").split(", ").map((chunk) => chunk.startsWith("@") || chunk.includes(" ") ? `"${chunk}"` : chunk);
+      const chunks = line.slice(0, -1).replaceAll('"', "").split(", ").map((chunk) => chunk.startsWith("@") || chunk.includes(" ") || chunk.includes("npm:") ? `"${chunk}"` : chunk);
       return `
 ${chunks.join(", ")}:`;
     }
@@ -298,61 +703,116 @@ ${chunks.join(", ")}:`;
 
 ${_value}`;
 };
+var parseResolution3 = (input) => {
+  if (input.startsWith("https://codeload.github.com/")) {
+    return {
+      type: "github",
+      name: input.slice(28, -48),
+      id: input.slice(-40)
+    };
+  }
+  const npmResolution = parseTarballUrl(input);
+  if (!npmResolution)
+    throw new TypeError(`Unsupported resolution format: ${input}`);
+  return npmResolution;
+};
+var formatResolution3 = ({ type, id, name = "", registry = "https://registry.yarnpkg.com", hash = "" }) => {
+  if (type === "github") {
+    return `https://codeload.github.com/${name}/tar.gz/${id}`;
+  }
+  return formatTarballUrl(name, id, registry, hash);
+};
 
-// src/main/ts/yarn-5.ts
+// src/main/ts/formats/yarn-berry.ts
 import { load as load2, dump as dump2 } from "js-yaml";
-var check2 = (value) => value.includes(`
+var version5 = "yarn-berry";
+var check5 = (value) => value.includes(`
 __metadata:
-  version: 5
-`);
-var parse3 = async (lockfile, pkg) => {
-  const snapshot = {
-    entries: {},
-    workspaces: {},
-    format: "yarn-5"
-  };
+  version:`);
+var parse4 = (lockfile, pkg) => {
+  const manifest = JSON.parse(pkg);
+  const snapshot = {};
   const raw = load2(lockfile);
   delete raw.__metadata;
   Object.entries(raw).forEach((value) => {
     const [_key, _entry] = value;
+    const { version: version6, checksum, dependencies, dependenciesMeta, optionalDependencies, peerDependencies, peerDependenciesMeta, resolution, bin, conditions } = _entry;
     const chunks = _key.split(", ");
-    const ranges = chunks.map((r) => r.slice(r.lastIndexOf("@") + 1)).sort();
-    const { version, checksum, dependencies, dependenciesMeta, optionalDependencies, peerDependencies, peerDependenciesMeta, resolution: source, bin, conditions } = _entry;
-    const name = chunks[0].slice(0, chunks[0].lastIndexOf("@"));
-    const key = `${name}@${version}`;
-    const hashes = parseIntegrity(checksum);
-    snapshot.entries[key] = {
-      name,
-      version,
-      ranges,
-      hashes,
-      dependencies,
-      dependenciesMeta,
-      optionalDependencies,
-      peerDependencies,
-      peerDependenciesMeta,
-      source,
-      bin,
-      conditions
-    };
+    const names = unique(chunks.map((c) => c.slice(0, c.indexOf("@", 1))));
+    for (const name of names) {
+      const key = `${name}@${version6}`;
+      if (_key.includes("#")) {
+        snapshot[key].patch = {
+          resolution,
+          refs: chunks,
+          checksum
+        };
+        return;
+      }
+      const ranges = chunks.filter((c) => c.startsWith(`${name}@`)).map((r) => r.slice(r.indexOf("@", 1) + 1)).map(normalizeReference);
+      const hashes = parseIntegrity(checksum);
+      const source = parseResolution4(resolution);
+      snapshot[key] = {
+        name,
+        version: version6,
+        ranges,
+        hashes,
+        source,
+        dependencies: normalizeDeps(dependencies),
+        dependenciesMeta,
+        optionalDependencies: normalizeDeps(optionalDependencies),
+        peerDependencies: normalizeDeps(peerDependencies),
+        peerDependenciesMeta,
+        bin,
+        conditions
+      };
+      if (source.type === "workspace") {
+      }
+    }
   });
+  snapshot[""] = {
+    name: manifest.name,
+    version: manifest.version,
+    ranges: [],
+    hashes: {},
+    source: {
+      type: "workspace",
+      id: "."
+    },
+    manifest,
+    dependencies: normalizeDeps(manifest.dependencies),
+    devDependencies: normalizeDeps(manifest.devDependencies),
+    optionalDependencies: normalizeDeps(manifest.optionalDependencies)
+  };
+  debug.json("yarn-berry-snapshot.json", snapshot);
   return snapshot;
 };
-var preformat2 = (value) => {
+var preformat5 = (idx) => {
+  const { snapshot } = idx;
   const lf = {};
-  Object.values(value.entries).forEach((entry) => {
-    const { name, version, ranges, hashes: { checksum }, dependencies, dependenciesMeta, optionalDependencies, peerDependencies, peerDependenciesMeta, source, bin, conditions } = entry;
-    const key = ranges.map((r) => `${name}@${r}`).join(", ");
-    const isLocal = version === "0.0.0-use.local";
+  const rangemap = {};
+  Object.values(snapshot).forEach((entry) => {
+    const { name, version: version6, ranges, hashes: { checksum }, dependencies, dependenciesMeta, optionalDependencies, peerDependencies, peerDependenciesMeta, source, patch, bin, conditions } = entry;
+    const resolution = formatResolution4(source);
+    const alias = rangemap[resolution];
+    const isLocal = version6 === "0.0.0-use.local";
     const languageName = isLocal ? "unknown" : "node";
     const linkType = isLocal ? "soft" : "hard";
+    const keys = ranges.map((r) => `${name}@${formatReference(r, { semverAsNpm: true, isLocal })}`);
+    if (alias) {
+      keys.push(...alias.keys);
+      keys.sort(referenceKeysSorter);
+      delete lf[alias.key];
+    }
+    const key = keys.join(", ");
+    rangemap[resolution] = { keys, key, name };
     lf[key] = {
-      version,
-      resolution: source,
-      dependencies,
+      version: version6,
+      resolution,
+      dependencies: formatDeps(dependencies),
       dependenciesMeta,
-      optionalDependencies,
-      peerDependencies,
+      optionalDependencies: formatDeps(optionalDependencies),
+      peerDependencies: formatDeps(peerDependencies),
       peerDependenciesMeta,
       bin,
       checksum,
@@ -360,21 +820,30 @@ var preformat2 = (value) => {
       languageName,
       linkType
     };
+    if (patch) {
+      lf[patch.refs.join(", ")] = {
+        ...lf[key],
+        resolution: patch.resolution,
+        checksum: patch.checksum
+      };
+    }
   });
-  return lf;
+  delete lf[""];
+  return sortObject(lf);
 };
-var format3 = (value) => {
+var format5 = (snapshot, { __metadata = {
+  version: 5,
+  cacheKey: 8
+} } = {}) => {
   const lines = dump2({
-    __metadata: {
-      version: 5,
-      cacheKey: 8
-    },
-    ...preformat2(value)
+    __metadata,
+    ...preformat5({ snapshot })
   }, {
     quotingType: '"',
     flowLevel: -1,
     lineWidth: -1,
-    forceQuotes: false
+    forceQuotes: false,
+    noRefs: true
   }).split("\n").map((line) => {
     if (line === "__metadata:") {
       return `
@@ -394,30 +863,92 @@ ${line}`;
 # Manual changes might be lost - proceed with caution!
 ${_value}`;
 };
+var formatReference = (input, opts = {}) => {
+  const colonPos = input.indexOf(":");
+  const protocol = input.slice(0, colonPos);
+  const ref = input.slice(colonPos + 1);
+  if (protocol === "git" || protocol === "tag") {
+    return ref;
+  }
+  if (protocol === "semver") {
+    return opts.semverAsNpm && !opts.isLocal ? "npm:" + ref : /^\d+$/.test(ref) ? +ref : ref;
+  }
+  return input;
+};
+var formatDeps = (deps, opts) => processDeps(deps, formatReference, opts);
+var parseResolution4 = (input) => {
+  const colonPos = input.indexOf(":");
+  const atPos = input.indexOf("@", 1);
+  const name = input.slice(0, atPos);
+  if (colonPos === -1) {
+    return {
+      name,
+      id: input.slice(atPos + 1),
+      type: "npm"
+    };
+  }
+  if (input.includes("https://github.com")) {
+    return {
+      type: "github",
+      name: input.slice(atPos + 20, -52),
+      id: input.slice(-40),
+      alias: input.slice(0, input.indexOf("@", 1))
+    };
+  }
+  return {
+    name,
+    id: input.slice(colonPos + 1),
+    type: input.slice(atPos + 1, colonPos)
+  };
+};
+var formatResolution4 = ({ name, id, type = "npm", alias = name, hash }) => {
+  if (type === "github") {
+    return `${alias}@https://github.com/${name}.git#commit=${id}`;
+  }
+  return `${name}@${type === "semver" ? "" : type + ":"}${id}`;
+};
 
-// src/main/ts/common.ts
-var getSources = (snapshot) => Object.values(snapshot.entries).map((entry) => entry.source).filter(Boolean);
-
-// src/main/ts/index.ts
-var foo = "bar";
-var parse4 = async (lockfile, pkg) => {
-  if (check(lockfile)) {
-    return parse2(lockfile);
+// src/main/ts/parse.ts
+var isPkgJson = (input) => input.startsWith("{") && input.includes('"name":');
+var variants = [
+  [check, parse],
+  [check3, parse2],
+  [check2, parse2],
+  [check4, parse3],
+  [check5, parse4]
+];
+var parse5 = (...inputs) => {
+  const [lockfile, ...pkgJsons] = inputs.map((input) => input.toString("utf8"));
+  const [, parser] = variants.find(([check6]) => check6(lockfile)) || [];
+  if (!parser) {
+    throw new TypeError("Unsupported lockfile format");
+  }
+  if (!pkgJsons.every(isPkgJson)) {
+    throw new TypeError("Invalid package json");
   }
-  if (check2(lockfile)) {
-    return parse3(lockfile, pkg);
+  return parser(lockfile, ...pkgJsons);
+};
+
+// src/main/ts/format.ts
+var variants2 = [
+  [version, format],
+  [version3, format3],
+  [version2, format2],
+  [version4, format4],
+  [version5, format5]
+];
+var format6 = (snapshot, version6, opts) => {
+  const [, formatter] = variants2.find(([_version]) => version6 === _version) || [];
+  if (!formatter) {
+    throw new TypeError(`Unsupported lockfile format: ${version6}`);
   }
-  return parse(lockfile, pkg);
+  return formatter(snapshot, opts);
 };
 export {
-  foo,
-  format as formatNpm1,
-  format2 as formatYarn1,
-  format3 as formatYarn5,
+  analyze,
+  buildNmtree,
+  format6 as format,
   getSources,
-  parse4 as parse,
-  parse as parseNpm1,
-  parse2 as parseYarn1,
-  parse3 as parseYarn5
+  parse5 as parse
 };
 //# sourceMappingURL=index.js.map