@visulima/package 3.4.2 → 3.4.3

package/dist/package-json.mjs

@@ -1 +1,413 @@
-var A=Object.defineProperty;var c=(e,n)=>A(e,"name",{value:n,configurable:!0});import{existsSync as N}from"node:fs";import{installPackage as $}from"@antfu/install-pkg";import O from"@inquirer/confirm";import{findUp as T,readJson as _,findUpSync as C,readJsonSync as J,writeJson as K,writeJsonSync as F}from"@visulima/fs";import{NotFoundError as E}from"@visulima/fs/error";import{toPath as m,parseJson as U}from"@visulima/fs/utils";import{join as j}from"@visulima/path";import P from"normalize-package-data";var q=Object.defineProperty,f=c((e,n)=>q(e,"name",{value:n,configurable:!0}),"s");const p=f(e=>{const n=typeof e;return e!==null&&(n==="object"||n==="function")},"isObject"),M=f(e=>p(e)&&Object.keys(e).length===0,"isEmptyObject"),k=new Set(["__proto__","prototype","constructor"]),Y=new Set("0123456789");function l(e){const n=[];let r="",t="start",o=!1;for(const a of e)switch(a){case"\\":{if(t==="index")throw new Error("Invalid character in an index");if(t==="indexEnd")throw new Error("Invalid character after an index");o&&(r+=a),t="property",o=!o;break}case".":{if(t==="index")throw new Error("Invalid character in an index");if(t==="indexEnd"){t="property";break}if(o){o=!1,r+=a;break}if(k.has(r))return[];n.push(r),r="",t="property";break}case"[":{if(t==="index")throw new Error("Invalid character in an index");if(t==="indexEnd"){t="index";break}if(o){o=!1,r+=a;break}if(t==="property"){if(k.has(r))return[];n.push(r),r=""}t="index";break}case"]":{if(t==="index"){n.push(Number.parseInt(r,10)),r="",t="indexEnd";break}if(t==="indexEnd")throw new Error("Invalid character after an index")}default:{if(t==="index"&&!Y.has(a))throw new Error("Invalid character in an index");if(t==="indexEnd")throw new Error("Invalid character after an index");t==="start"&&(t="property"),o&&(o=!1,r+="\\"),r+=a}}switch(o&&(r+="\\"),t){case"property":{if(k.has(r))return[];n.push(r);break}case"index":throw new Error("Index was not closed");case"start":{n.push("");break}}return n}c(l,"d");f(l,"getPathSegments");function w(e,n){if(typeof n!="number"&&Array.isArray(e)){const r=Number.parseInt(n,10);return Number.isInteger(r)&&e[r]===e[n]}return!1}c(w,"l");f(w,"isStringIndex");function b(e,n){if(w(e,n))throw new Error("Cannot use string index")}c(b,"p");f(b,"assertNotStringIndex");function u(e,n,r){if(!p(e)||typeof n!="string")return r===void 0?e:r;const t=l(n);if(t.length===0)return r;for(let o=0;o<t.length;o++){const a=t[o];if(w(e,a)?e=o===t.length-1?void 0:null:e=e[a],e==null){if(o!==t.length-1)return r;break}}return e===void 0?r:e}c(u,"getProperty");f(u,"getProperty");function z(e,n,r){if(!p(e)||typeof n!="string")return e;const t=e,o=l(n);for(let a=0;a<o.length;a++){const s=o[a];b(e,s),a===o.length-1?e[s]=r:p(e[s])||(e[s]=typeof o[a+1]=="number"?[]:{}),e=e[s]}return t}c(z,"setProperty");f(z,"setProperty");function B(e,n){if(!p(e)||typeof n!="string")return!1;const r=l(n);for(let t=0;t<r.length;t++){const o=r[t];if(b(e,o),t===r.length-1)return delete e[o],!0;if(e=e[o],!p(e))return!1}}c(B,"deleteProperty");f(B,"deleteProperty");function y(e,n){if(!p(e)||typeof n!="string")return!1;const r=l(n);if(r.length===0)return!1;for(const t of r){if(!p(e)||!(t in e)||w(e,t))return!1;e=e[t]}return!0}c(y,"hasProperty");f(y,"hasProperty");function I(e){if(typeof e!="string")throw new TypeError("Expected a string");return e.replaceAll(/[\\.[]/g,"\\$&")}c(I,"escapePath");f(I,"escapePath");function x(e){const n=Object.entries(e);return Array.isArray(e)?n.map(([r,t])=>[Number(r),t]):n}c(x,"h");f(x,"entries");function S(e){let n="";for(let[r,t]of x(e))typeof t=="number"?n+=`[${t}]`:(t=I(t),n+=r===0?t:`.${t}`);return n}c(S,"w");f(S,"stringifyPath");function*v(e,n=[]){if(!p(e)||M(e)){n.length>0&&(yield S(n));return}for(const[r,t]of x(e))yield*v(t,[...n,r])}c(v,"y$1");f(v,"deepKeysIterator");function G(e){return[...v(e)]}c(G,"deepKeys");f(G,"deepKeys");const H=typeof process.stdout<"u"&&!process.versions?.deno&&!globalThis.window;var L=Object.defineProperty,d=c((e,n)=>L(e,"name",{value:n,configurable:!0}),"r");const D=new Map,re=d(async(e,n={})=>{const r={type:"file"};e&&(r.cwd=e);const t=await T("package.json",r);if(!t)throw new E("No such file or directory, for package.json found.");const o=n.cache&&typeof n.cache!="boolean"?n.cache:D;if(n.cache&&o.has(t))return o.get(t);const a=await _(t);P(a);const s={packageJson:a,path:t};return o.set(t,s),s},"findPackageJson"),oe=d((e,n={})=>{const r={type:"file"};e&&(r.cwd=e);const t=C("package.json",r);if(!t)throw new E("No such file or directory, for package.json found.");const o=n.cache&&typeof n.cache!="boolean"?n.cache:D;if(n.cache&&o.has(t))return o.get(t);const a=J(t);P(a);const s={packageJson:a,path:t};return o.set(t,s),s},"findPackageJsonSync"),ae=d(async(e,n={})=>{const{cwd:r,...t}=n,o=m(n.cwd??process.cwd());await K(j(o,"package.json"),e,t)},"writePackageJson"),se=d((e,n={})=>{const{cwd:r,...t}=n,o=m(n.cwd??process.cwd());F(j(o,"package.json"),e,t)},"writePackageJsonSync"),ce=d(e=>{const n=e!==null&&typeof e=="object"&&!Array.isArray(e);if(!n&&typeof e!="string")throw new TypeError("`packageFile` should be either an `object` or a `string`.");const r=n?structuredClone(e):N(e)?J(e):U(e);return P(r),r},"parsePackageJson"),ie=d((e,n,r)=>u(e,n,r),"getPackageJsonProperty"),fe=d((e,n)=>y(e,n),"hasPackageJsonProperty"),pe=d((e,n,r)=>{const t=u(e,"dependencies",{}),o=u(e,"devDependencies",{}),a=u(e,"peerDependencies",{}),s={...t,...o,...r?.peerDeps===!1?{}:a};for(const g of n)if(y(s,g))return!0;return!1},"hasPackageJsonAnyDependency"),de=d(async(e,n,r="dependencies",t={})=>{if(process.env.CI||H&&!process.stdout?.isTTY){console.warn("Skipping package installation because the process is not interactive.");return}const o=u(e,"dependencies",{}),a=u(e,"devDependencies",{}),s=u(e,"peerDependencies",{}),g=[],i={deps:!0,devDeps:!0,peerDeps:!1,...t};for(const h of n)i.deps&&y(o,h)||i.devDeps&&y(a,h)||i.peerDeps&&y(s,h)||g.push(h);if(typeof i.confirm?.message=="function"&&(i.confirm.message=i.confirm.message(g)),i.confirm?.message===void 0){const h=`${g.length===1?"Package is":"Packages are"} required for this config: ${g.join(", ")}. Do you want to install them?`;i.confirm===void 0?i.confirm={message:h}:i.confirm.message=h}await O(i.confirm)&&await $(g,{...i.installPackage,cwd:i.cwd?m(i.cwd):void 0,dev:r==="devDependencies"})},"ensurePackages");export{de as ensurePackages,re as findPackageJson,oe as findPackageJsonSync,ie as getPackageJsonProperty,pe as hasPackageJsonAnyDependency,fe as hasPackageJsonProperty,ce as parsePackageJson,ae as writePackageJson,se as writePackageJsonSync};
+import { existsSync } from 'node:fs';
+import { installPackage } from '@antfu/install-pkg';
+import confirm from '@inquirer/confirm';
+import { findUp, readJson, findUpSync, readJsonSync, writeJson, writeJsonSync } from '@visulima/fs';
+import { NotFoundError } from '@visulima/fs/error';
+import { toPath, parseJson } from '@visulima/fs/utils';
+import { join } from '@visulima/path';
+import normalizeData from 'normalize-package-data';
+
+var __defProp$1 = Object.defineProperty;
+var __name$1 = (target, value) => __defProp$1(target, "name", { value, configurable: true });
+const isObject = /* @__PURE__ */ __name$1((value) => {
+  const type = typeof value;
+  return value !== null && (type === "object" || type === "function");
+}, "isObject");
+const isEmptyObject = /* @__PURE__ */ __name$1((value) => isObject(value) && Object.keys(value).length === 0, "isEmptyObject");
+const disallowedKeys = /* @__PURE__ */ new Set([
+  "__proto__",
+  "prototype",
+  "constructor"
+]);
+const digits = new Set("0123456789");
+function getPathSegments(path) {
+  const parts = [];
+  let currentSegment = "";
+  let currentPart = "start";
+  let isIgnoring = false;
+  for (const character of path) {
+    switch (character) {
+      case "\\": {
+        if (currentPart === "index") {
+          throw new Error("Invalid character in an index");
+        }
+        if (currentPart === "indexEnd") {
+          throw new Error("Invalid character after an index");
+        }
+        if (isIgnoring) {
+          currentSegment += character;
+        }
+        currentPart = "property";
+        isIgnoring = !isIgnoring;
+        break;
+      }
+      case ".": {
+        if (currentPart === "index") {
+          throw new Error("Invalid character in an index");
+        }
+        if (currentPart === "indexEnd") {
+          currentPart = "property";
+          break;
+        }
+        if (isIgnoring) {
+          isIgnoring = false;
+          currentSegment += character;
+          break;
+        }
+        if (disallowedKeys.has(currentSegment)) {
+          return [];
+        }
+        parts.push(currentSegment);
+        currentSegment = "";
+        currentPart = "property";
+        break;
+      }
+      case "[": {
+        if (currentPart === "index") {
+          throw new Error("Invalid character in an index");
+        }
+        if (currentPart === "indexEnd") {
+          currentPart = "index";
+          break;
+        }
+        if (isIgnoring) {
+          isIgnoring = false;
+          currentSegment += character;
+          break;
+        }
+        if (currentPart === "property") {
+          if (disallowedKeys.has(currentSegment)) {
+            return [];
+          }
+          parts.push(currentSegment);
+          currentSegment = "";
+        }
+        currentPart = "index";
+        break;
+      }
+      case "]": {
+        if (currentPart === "index") {
+          parts.push(Number.parseInt(currentSegment, 10));
+          currentSegment = "";
+          currentPart = "indexEnd";
+          break;
+        }
+        if (currentPart === "indexEnd") {
+          throw new Error("Invalid character after an index");
+        }
+      }
+      default: {
+        if (currentPart === "index" && !digits.has(character)) {
+          throw new Error("Invalid character in an index");
+        }
+        if (currentPart === "indexEnd") {
+          throw new Error("Invalid character after an index");
+        }
+        if (currentPart === "start") {
+          currentPart = "property";
+        }
+        if (isIgnoring) {
+          isIgnoring = false;
+          currentSegment += "\\";
+        }
+        currentSegment += character;
+      }
+    }
+  }
+  if (isIgnoring) {
+    currentSegment += "\\";
+  }
+  switch (currentPart) {
+    case "property": {
+      if (disallowedKeys.has(currentSegment)) {
+        return [];
+      }
+      parts.push(currentSegment);
+      break;
+    }
+    case "index": {
+      throw new Error("Index was not closed");
+    }
+    case "start": {
+      parts.push("");
+      break;
+    }
+  }
+  return parts;
+}
+__name$1(getPathSegments, "getPathSegments");
+function isStringIndex(object, key) {
+  if (typeof key !== "number" && Array.isArray(object)) {
+    const index = Number.parseInt(key, 10);
+    return Number.isInteger(index) && object[index] === object[key];
+  }
+  return false;
+}
+__name$1(isStringIndex, "isStringIndex");
+function assertNotStringIndex(object, key) {
+  if (isStringIndex(object, key)) {
+    throw new Error("Cannot use string index");
+  }
+}
+__name$1(assertNotStringIndex, "assertNotStringIndex");
+function getProperty(object, path, value) {
+  if (!isObject(object) || typeof path !== "string") {
+    return value === undefined ? object : value;
+  }
+  const pathArray = getPathSegments(path);
+  if (pathArray.length === 0) {
+    return value;
+  }
+  for (let index = 0; index < pathArray.length; index++) {
+    const key = pathArray[index];
+    if (isStringIndex(object, key)) {
+      object = index === pathArray.length - 1 ? undefined : null;
+    } else {
+      object = object[key];
+    }
+    if (object === undefined || object === null) {
+      if (index !== pathArray.length - 1) {
+        return value;
+      }
+      break;
+    }
+  }
+  return object === undefined ? value : object;
+}
+__name$1(getProperty, "getProperty");
+function setProperty(object, path, value) {
+  if (!isObject(object) || typeof path !== "string") {
+    return object;
+  }
+  const root = object;
+  const pathArray = getPathSegments(path);
+  for (let index = 0; index < pathArray.length; index++) {
+    const key = pathArray[index];
+    assertNotStringIndex(object, key);
+    if (index === pathArray.length - 1) {
+      object[key] = value;
+    } else if (!isObject(object[key])) {
+      object[key] = typeof pathArray[index + 1] === "number" ? [] : {};
+    }
+    object = object[key];
+  }
+  return root;
+}
+__name$1(setProperty, "setProperty");
+function deleteProperty(object, path) {
+  if (!isObject(object) || typeof path !== "string") {
+    return false;
+  }
+  const pathArray = getPathSegments(path);
+  for (let index = 0; index < pathArray.length; index++) {
+    const key = pathArray[index];
+    assertNotStringIndex(object, key);
+    if (index === pathArray.length - 1) {
+      delete object[key];
+      return true;
+    }
+    object = object[key];
+    if (!isObject(object)) {
+      return false;
+    }
+  }
+}
+__name$1(deleteProperty, "deleteProperty");
+function hasProperty(object, path) {
+  if (!isObject(object) || typeof path !== "string") {
+    return false;
+  }
+  const pathArray = getPathSegments(path);
+  if (pathArray.length === 0) {
+    return false;
+  }
+  for (const key of pathArray) {
+    if (!isObject(object) || !(key in object) || isStringIndex(object, key)) {
+      return false;
+    }
+    object = object[key];
+  }
+  return true;
+}
+__name$1(hasProperty, "hasProperty");
+function escapePath(path) {
+  if (typeof path !== "string") {
+    throw new TypeError("Expected a string");
+  }
+  return path.replaceAll(/[\\.[]/g, "\\$&");
+}
+__name$1(escapePath, "escapePath");
+function entries(value) {
+  const result = Object.entries(value);
+  if (Array.isArray(value)) {
+    return result.map(([key, value2]) => [Number(key), value2]);
+  }
+  return result;
+}
+__name$1(entries, "entries");
+function stringifyPath(pathSegments) {
+  let result = "";
+  for (let [index, segment] of entries(pathSegments)) {
+    if (typeof segment === "number") {
+      result += `[${segment}]`;
+    } else {
+      segment = escapePath(segment);
+      result += index === 0 ? segment : `.${segment}`;
+    }
+  }
+  return result;
+}
+__name$1(stringifyPath, "stringifyPath");
+function* deepKeysIterator(object, currentPath = []) {
+  if (!isObject(object) || isEmptyObject(object)) {
+    if (currentPath.length > 0) {
+      yield stringifyPath(currentPath);
+    }
+    return;
+  }
+  for (const [key, value] of entries(object)) {
+    yield* deepKeysIterator(value, [...currentPath, key]);
+  }
+}
+__name$1(deepKeysIterator, "deepKeysIterator");
+function deepKeys(object) {
+  return [...deepKeysIterator(object)];
+}
+__name$1(deepKeys, "deepKeys");
+
+const isNode = typeof process.stdout < "u" && !process.versions?.deno && !globalThis.window;
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const PackageJsonFileCache = /* @__PURE__ */ new Map();
+const findPackageJson = /* @__PURE__ */ __name(async (cwd, options = {}) => {
+  const findUpConfig = {
+    type: "file"
+  };
+  if (cwd) {
+    findUpConfig.cwd = cwd;
+  }
+  const filePath = await findUp("package.json", findUpConfig);
+  if (!filePath) {
+    throw new NotFoundError("No such file or directory, for package.json found.");
+  }
+  const cache = options.cache && typeof options.cache !== "boolean" ? options.cache : PackageJsonFileCache;
+  if (options.cache && cache.has(filePath)) {
+    return cache.get(filePath);
+  }
+  const packageJson = await readJson(filePath);
+  normalizeData(packageJson);
+  const output = {
+    packageJson,
+    path: filePath
+  };
+  cache.set(filePath, output);
+  return output;
+}, "findPackageJson");
+const findPackageJsonSync = /* @__PURE__ */ __name((cwd, options = {}) => {
+  const findUpConfig = {
+    type: "file"
+  };
+  if (cwd) {
+    findUpConfig.cwd = cwd;
+  }
+  const filePath = findUpSync("package.json", findUpConfig);
+  if (!filePath) {
+    throw new NotFoundError("No such file or directory, for package.json found.");
+  }
+  const cache = options.cache && typeof options.cache !== "boolean" ? options.cache : PackageJsonFileCache;
+  if (options.cache && cache.has(filePath)) {
+    return cache.get(filePath);
+  }
+  const packageJson = readJsonSync(filePath);
+  normalizeData(packageJson);
+  const output = {
+    packageJson,
+    path: filePath
+  };
+  cache.set(filePath, output);
+  return output;
+}, "findPackageJsonSync");
+const writePackageJson = /* @__PURE__ */ __name(async (data, options = {}) => {
+  const { cwd, ...writeOptions } = options;
+  const directory = toPath(options.cwd ?? process.cwd());
+  await writeJson(join(directory, "package.json"), data, writeOptions);
+}, "writePackageJson");
+const writePackageJsonSync = /* @__PURE__ */ __name((data, options = {}) => {
+  const { cwd, ...writeOptions } = options;
+  const directory = toPath(options.cwd ?? process.cwd());
+  writeJsonSync(join(directory, "package.json"), data, writeOptions);
+}, "writePackageJsonSync");
+const parsePackageJson = /* @__PURE__ */ __name((packageFile) => {
+  const isObject = packageFile !== null && typeof packageFile === "object" && !Array.isArray(packageFile);
+  const isString = typeof packageFile === "string";
+  if (!isObject && !isString) {
+    throw new TypeError("`packageFile` should be either an `object` or a `string`.");
+  }
+  const json = isObject ? structuredClone(packageFile) : (
+    // eslint-disable-next-line security/detect-non-literal-fs-filename
+    existsSync(packageFile) ? readJsonSync(packageFile) : parseJson(packageFile)
+  );
+  normalizeData(json);
+  return json;
+}, "parsePackageJson");
+const getPackageJsonProperty = /* @__PURE__ */ __name((packageJson, property, defaultValue) => getProperty(packageJson, property, defaultValue), "getPackageJsonProperty");
+const hasPackageJsonProperty = /* @__PURE__ */ __name((packageJson, property) => hasProperty(packageJson, property), "hasPackageJsonProperty");
+const hasPackageJsonAnyDependency = /* @__PURE__ */ __name((packageJson, arguments_, options) => {
+  const dependencies = getProperty(packageJson, "dependencies", {});
+  const devDependencies = getProperty(packageJson, "devDependencies", {});
+  const peerDependencies = getProperty(packageJson, "peerDependencies", {});
+  const allDependencies = { ...dependencies, ...devDependencies, ...options?.peerDeps === false ? {} : peerDependencies };
+  for (const argument of arguments_) {
+    if (hasProperty(allDependencies, argument)) {
+      return true;
+    }
+  }
+  return false;
+}, "hasPackageJsonAnyDependency");
+const ensurePackages = /* @__PURE__ */ __name(async (packageJson, packages, installKey = "dependencies", options = {}) => {
+  if (process.env.CI || isNode && !process.stdout?.isTTY) {
+    console.warn("Skipping package installation because the process is not interactive.");
+    return;
+  }
+  const dependencies = getProperty(packageJson, "dependencies", {});
+  const devDependencies = getProperty(packageJson, "devDependencies", {});
+  const peerDependencies = getProperty(packageJson, "peerDependencies", {});
+  const nonExistingPackages = [];
+  const config = {
+    deps: true,
+    devDeps: true,
+    peerDeps: false,
+    ...options
+  };
+  for (const packageName of packages) {
+    if (config.deps && hasProperty(dependencies, packageName) || config.devDeps && hasProperty(devDependencies, packageName) || config.peerDeps && hasProperty(peerDependencies, packageName)) {
+      continue;
+    }
+    nonExistingPackages.push(packageName);
+  }
+  if (typeof config.confirm?.message === "function") {
+    config.confirm.message = config.confirm.message(nonExistingPackages);
+  }
+  if (config.confirm?.message === undefined) {
+    const message = `${nonExistingPackages.length === 1 ? "Package is" : "Packages are"} required for this config: ${nonExistingPackages.join(", ")}. Do you want to install them?`;
+    if (config.confirm === undefined) {
+      config.confirm = {
+        message
+      };
+    } else {
+      config.confirm.message = message;
+    }
+  }
+  const answer = await confirm(config.confirm);
+  if (!answer) {
+    return;
+  }
+  await installPackage(nonExistingPackages, {
+    ...config.installPackage,
+    cwd: config.cwd ? toPath(config.cwd) : undefined,
+    dev: installKey === "devDependencies"
+  });
+}, "ensurePackages");
+
+export { ensurePackages, findPackageJson, findPackageJsonSync, getPackageJsonProperty, hasPackageJsonAnyDependency, hasPackageJsonProperty, parsePackageJson, writePackageJson, writePackageJsonSync };

package/dist/package-manager.cjs

@@ -1,13 +1,180 @@
-"use strict";var w=Object.defineProperty;var l=(e,n)=>w(e,"name",{value:n,configurable:!0});Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const P=require("node:child_process"),p=require("node:fs"),o=require("@visulima/fs"),k=require("@visulima/fs/error"),i=require("@visulima/path"),f=require("./package-json.cjs");var v=Object.defineProperty,r=l((e,n)=>v(e,"name",{value:n,configurable:!0}),"r");const d=["yarn.lock","package-lock.json","pnpm-lock.yaml","npm-shrinkwrap.json","bun.lockb"],u=r(e=>{let n;if(d.forEach(t=>{!n&&p.existsSync(i.join(e,t))&&(n=i.join(e,t))}),n)return n;const a=i.join(e,"package.json");if(p.existsSync(a)&&f.parsePackageJson(p.readFileSync(a,"utf8")).packageManager!==void 0)return a},"packageMangerFindUpMatcher"),m=r(e=>{if(!e)throw new k.NotFoundError("Could not find a package manager");if(e.endsWith("package.json")){const n=f.parsePackageJson(e);if(n.packageManager){const a=["npm","yarn","pnpm","bun"].find(t=>n.packageManager.startsWith(t));if(a)return{packageManager:a,path:i.dirname(e)}}}if(e.endsWith("yarn.lock"))return{packageManager:"yarn",path:i.dirname(e)};if(e.endsWith("package-lock.json")||e.endsWith("npm-shrinkwrap.json"))return{packageManager:"npm",path:i.dirname(e)};if(e.endsWith("pnpm-lock.yaml"))return{packageManager:"pnpm",path:i.dirname(e)};if(e.endsWith("bun.lockb"))return{packageManager:"bun",path:i.dirname(e)};throw new k.NotFoundError("Could not find a package manager")},"findPackageManagerOnFile"),S=r(async e=>{const n=await o.findUp(d,{type:"file",...e&&{cwd:e}});if(!n)throw new Error("Could not find lock file");return n},"findLockFile"),j=r(e=>{const n=o.findUpSync(d,{type:"file",...e&&{cwd:e}});if(!n)throw new Error("Could not find lock file");return n},"findLockFileSync"),b=r(async e=>{const n=await o.findUp(u,{...e&&{cwd:e}});return m(n)},"findPackageManager"),F=r(e=>{const n=o.findUpSync(u,{...e&&{cwd:e}});return m(n)},"findPackageManagerSync"),$=r(e=>P.execSync(`${e} --version`).toString("utf8").trim(),"getPackageManagerVersion"),_=r(async()=>{if(!process.env.npm_config_user_agent)return;const e=process.env.npm_config_user_agent.split(" ")[0],n=e.lastIndexOf("/"),a=e.slice(0,Math.max(0,n));return{name:a==="npminstall"?"cnpm":a,version:e.slice(Math.max(0,n+1))}},"identifyInitiatingPackageManager"),E=r((e,n,a)=>{const t=n.length===1?"":"s";if(a.packageManagers===void 0&&(a.packageManagers=["npm","pnpm","yarn"]),a.packageManagers.length===0)throw new Error("No package managers provided, please provide at least one package manager");if(n.length===0)throw new Error("No missing packages provided, please provide at least one missing package");let g=`
-${a.preMessage??""}
-${e} could not find the following package${t}
+'use strict';
 
-  ${n.join(`
-  `)}
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
 
-To install the missing package${t}, please run the following command:
-`;const M=r(s=>s.split("@").includes("@")?s:`${s}@latest`,"atLatest"),h=a.packageManagers.map(s=>{const c=n.map(y=>M(y)).join(" ");switch(s){case"bun":return`  bun add ${c} -D`;case"npm":return`  npm install ${c} --save-dev`;case"pnpm":return`  pnpm add ${c} -D`;case"yarn":return`  yarn add ${c} --dev`;default:throw new Error("Unknown package manager")}});return g+=h.join(`
+const node_child_process = require('node:child_process');
+const node_fs = require('node:fs');
+const fs = require('@visulima/fs');
+const error = require('@visulima/fs/error');
+const path = require('@visulima/path');
+const packageJson = require('./package-json.cjs');
 
-or
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const lockFileNames = ["yarn.lock", "package-lock.json", "pnpm-lock.yaml", "npm-shrinkwrap.json", "bun.lockb"];
+const packageMangerFindUpMatcher = /* @__PURE__ */ __name((directory) => {
+  let lockFile;
+  lockFileNames.forEach((lockFileName) => {
+    if (!lockFile && node_fs.existsSync(path.join(directory, lockFileName))) {
+      lockFile = path.join(directory, lockFileName);
+    }
+  });
+  if (lockFile) {
+    return lockFile;
+  }
+  const packageJsonFilePath = path.join(directory, "package.json");
+  if (node_fs.existsSync(packageJsonFilePath)) {
+    const packageJson$1 = packageJson.parsePackageJson(node_fs.readFileSync(packageJsonFilePath, "utf8"));
+    if (packageJson$1.packageManager !== undefined) {
+      return packageJsonFilePath;
+    }
+  }
+  return undefined;
+}, "packageMangerFindUpMatcher");
+const findPackageManagerOnFile = /* @__PURE__ */ __name((foundFile) => {
+  if (!foundFile) {
+    throw new error.NotFoundError("Could not find a package manager");
+  }
+  if (foundFile.endsWith("package.json")) {
+    const packageJson$1 = packageJson.parsePackageJson(foundFile);
+    if (packageJson$1.packageManager) {
+      const packageManagerNames = ["npm", "yarn", "pnpm", "bun"];
+      const foundPackageManager = packageManagerNames.find((prefix) => packageJson$1.packageManager.startsWith(prefix));
+      if (foundPackageManager) {
+        return {
+          packageManager: foundPackageManager,
+          path: path.dirname(foundFile)
+        };
+      }
+    }
+  }
+  if (foundFile.endsWith("yarn.lock")) {
+    return {
+      packageManager: "yarn",
+      path: path.dirname(foundFile)
+    };
+  }
+  if (foundFile.endsWith("package-lock.json") || foundFile.endsWith("npm-shrinkwrap.json")) {
+    return {
+      packageManager: "npm",
+      path: path.dirname(foundFile)
+    };
+  }
+  if (foundFile.endsWith("pnpm-lock.yaml")) {
+    return {
+      packageManager: "pnpm",
+      path: path.dirname(foundFile)
+    };
+  }
+  if (foundFile.endsWith("bun.lockb")) {
+    return {
+      packageManager: "bun",
+      path: path.dirname(foundFile)
+    };
+  }
+  throw new error.NotFoundError("Could not find a package manager");
+}, "findPackageManagerOnFile");
+const findLockFile = /* @__PURE__ */ __name(async (cwd) => {
+  const filePath = await fs.findUp(lockFileNames, {
+    type: "file",
+    ...cwd && { cwd }
+  });
+  if (!filePath) {
+    throw new Error("Could not find lock file");
+  }
+  return filePath;
+}, "findLockFile");
+const findLockFileSync = /* @__PURE__ */ __name((cwd) => {
+  const filePath = fs.findUpSync(lockFileNames, {
+    type: "file",
+    ...cwd && { cwd }
+  });
+  if (!filePath) {
+    throw new Error("Could not find lock file");
+  }
+  return filePath;
+}, "findLockFileSync");
+const findPackageManager = /* @__PURE__ */ __name(async (cwd) => {
+  const foundFile = await fs.findUp(packageMangerFindUpMatcher, {
+    ...cwd && { cwd }
+  });
+  return findPackageManagerOnFile(foundFile);
+}, "findPackageManager");
+const findPackageManagerSync = /* @__PURE__ */ __name((cwd) => {
+  const foundFile = fs.findUpSync(packageMangerFindUpMatcher, {
+    ...cwd && { cwd }
+  });
+  return findPackageManagerOnFile(foundFile);
+}, "findPackageManagerSync");
+const getPackageManagerVersion = /* @__PURE__ */ __name((name) => node_child_process.execSync(`${name} --version`).toString("utf8").trim(), "getPackageManagerVersion");
+const identifyInitiatingPackageManager = /* @__PURE__ */ __name(async () => {
+  if (!process.env.npm_config_user_agent) {
+    return undefined;
+  }
+  const pmSpec = process.env.npm_config_user_agent.split(" ")[0];
+  const separatorPos = pmSpec.lastIndexOf("/");
+  const name = pmSpec.slice(0, Math.max(0, separatorPos));
+  return {
+    name: name === "npminstall" ? "cnpm" : name,
+    version: pmSpec.slice(Math.max(0, separatorPos + 1))
+  };
+}, "identifyInitiatingPackageManager");
+const generateMissingPackagesInstallMessage = /* @__PURE__ */ __name((packageName, missingPackages, options) => {
+  const s = missingPackages.length === 1 ? "" : "s";
+  if (options.packageManagers === undefined) {
+    options.packageManagers = ["npm", "pnpm", "yarn"];
+  }
+  if (options.packageManagers.length === 0) {
+    throw new Error("No package managers provided, please provide at least one package manager");
+  }
+  if (missingPackages.length === 0) {
+    throw new Error("No missing packages provided, please provide at least one missing package");
+  }
+  let message = `
+${options.preMessage ?? ""}
+${packageName} could not find the following package${s}
 
-`),a.postMessage&&(g+=a.postMessage),g},"generateMissingPackagesInstallMessage");exports.findLockFile=S;exports.findLockFileSync=j;exports.findPackageManager=b;exports.findPackageManagerSync=F;exports.generateMissingPackagesInstallMessage=E;exports.getPackageManagerVersion=$;exports.identifyInitiatingPackageManager=_;
+  ${missingPackages.join("\n  ")}
+
+To install the missing package${s}, please run the following command:
+`;
+  const atLatest = /* @__PURE__ */ __name((name) => {
+    if (!name.split("@").includes("@")) {
+      return `${name}@latest`;
+    }
+    return name;
+  }, "atLatest");
+  const packageManagerCommands = options.packageManagers.map((packageManager) => {
+    const missingPackagesString = missingPackages.map((element) => atLatest(element)).join(" ");
+    switch (packageManager) {
+      case "bun": {
+        return `  bun add ${missingPackagesString} -D`;
+      }
+      case "npm": {
+        return `  npm install ${missingPackagesString} --save-dev`;
+      }
+      case "pnpm": {
+        return `  pnpm add ${missingPackagesString} -D`;
+      }
+      case "yarn": {
+        return `  yarn add ${missingPackagesString} --dev`;
+      }
+      default: {
+        throw new Error("Unknown package manager");
+      }
+    }
+  });
+  message += packageManagerCommands.join("\n\nor\n\n");
+  if (options.postMessage) {
+    message += options.postMessage;
+  }
+  return message;
+}, "generateMissingPackagesInstallMessage");
+
+exports.findLockFile = findLockFile;
+exports.findLockFileSync = findLockFileSync;
+exports.findPackageManager = findPackageManager;
+exports.findPackageManagerSync = findPackageManagerSync;
+exports.generateMissingPackagesInstallMessage = generateMissingPackagesInstallMessage;
+exports.getPackageManagerVersion = getPackageManagerVersion;
+exports.identifyInitiatingPackageManager = identifyInitiatingPackageManager;