@vercel/python-analysis 0.1.1

package/dist/manifest/uv-config/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/manifest/uv-python-version-parser.d.ts

@@ -0,0 +1,28 @@
+import type { Pep440Constraint } from './pep440';
+import type { PythonRequest } from './python-specifiers';
+/**
+ * uv supports these request formats in --python and .python-version:
+ * - <version> (e.g. 3, 3.12, 3.12.3)
+ * - <version-specifier> (e.g. >=3.12,<3.13)
+ * - <version><short-variant> (e.g. 3.13t, 3.12.0d)
+ * - <version>+<variant> (e.g. 3.13+freethreaded, 3.12.0+debug, 3.14+gil)
+ * - <implementation> (e.g. cpython or cp)
+ * - <implementation>@<version>
+ * - <implementation><version> (e.g. cpython3.12 or cp312)
+ * - <implementation><version-specifier> (e.g. cpython>=3.12,<3.13)
+ * - <implementation>-<version>-<os>-<arch>-<libc> (e.g. cpython-3.12.3-macos-aarch64-none)
+ *
+ * plus local interpreter requests, which we obviously cannot support
+ * - <executable-path> (e.g. /opt/homebrew/bin/python3)
+ * - <executable-name> (e.g. mypython3)
+ * - <install-dir> (e.g. /some/environment/)
+ */
+export declare function pythonRequestFromConstraint(constraint: Pep440Constraint[]): PythonRequest;
+/**
+ * Parse the contents of a `.python-version` file.
+ */
+export declare function parsePythonVersionFile(content: string): PythonRequest[] | null;
+/**
+ * Parse a single uv python request (as in `--python ...` or `.python-version` contents).
+ */
+export declare function parseUvPythonRequest(input: string): PythonRequest | null;

package/dist/manifest/uv-python-version-parser.js

@@ -0,0 +1,268 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var uv_python_version_parser_exports = {};
+__export(uv_python_version_parser_exports, {
+  parsePythonVersionFile: () => parsePythonVersionFile,
+  parseUvPythonRequest: () => parseUvPythonRequest,
+  pythonRequestFromConstraint: () => pythonRequestFromConstraint
+});
+module.exports = __toCommonJS(uv_python_version_parser_exports);
+var import_pep440 = require("./pep440");
+var import_python_specifiers = require("./python-specifiers");
+function pythonRequestFromConstraint(constraint) {
+  return {
+    implementation: "cpython",
+    version: {
+      constraint,
+      variant: "default"
+    }
+  };
+}
+function parsePythonVersionFile(content) {
+  const lines = content.split(/\r?\n/);
+  const requests = [];
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i] ?? "";
+    const trimmed = raw.trim();
+    if (!trimmed)
+      continue;
+    if (trimmed.startsWith("#"))
+      continue;
+    const parsed = parseUvPythonRequest(trimmed);
+    if (parsed != null) {
+      requests.push(parsed);
+    }
+  }
+  if (requests.length === 0) {
+    return null;
+  } else {
+    return requests;
+  }
+}
+function parseUvPythonRequest(input) {
+  const raw = input.trim();
+  if (!raw) {
+    return null;
+  }
+  const lowercase = raw.toLowerCase();
+  if (lowercase === "any" || lowercase === "default") {
+    return {};
+  }
+  for (const [implName, implementation] of Object.entries(
+    import_python_specifiers.PythonImplementation.knownNames()
+  )) {
+    if (lowercase.startsWith(implName)) {
+      let rest = lowercase.substring(implName.length);
+      if (rest.length === 0) {
+        return {
+          implementation
+        };
+      }
+      if (rest[0] === "@") {
+        rest = rest.substring(1);
+      }
+      const version2 = parseVersionRequest(rest);
+      if (version2 != null) {
+        return {
+          implementation,
+          version: version2
+        };
+      }
+    }
+  }
+  const version = parseVersionRequest(lowercase);
+  if (version != null) {
+    return {
+      implementation: "cpython",
+      version
+    };
+  }
+  return tryParsePlatformRequest(lowercase);
+}
+function parseVersionRequest(input) {
+  const [version, variant] = parseVariantSuffix(input);
+  let parsedVer = (0, import_pep440.parsePep440Version)(version);
+  if (parsedVer != null) {
+    if (parsedVer.release.length === 1) {
+      const converted = splitWheelTagVersion(version);
+      if (converted != null) {
+        const convertedVer = (0, import_pep440.parsePep440Version)(converted);
+        if (convertedVer != null) {
+          parsedVer = convertedVer;
+        }
+      }
+    }
+    return {
+      constraint: (0, import_pep440.pep440ConstraintFromVersion)(parsedVer),
+      variant
+    };
+  }
+  const parsedConstr = (0, import_pep440.parsePep440Constraint)(version);
+  if (parsedConstr?.length) {
+    return {
+      constraint: parsedConstr,
+      variant
+    };
+  }
+  return null;
+}
+function splitWheelTagVersion(version) {
+  if (!/^\d+$/.test(version)) {
+    return null;
+  }
+  if (version.length < 2) {
+    return null;
+  }
+  const major = version[0];
+  const minorStr = version.substring(1);
+  const minor = parseInt(minorStr, 10);
+  if (isNaN(minor) || minor > 255) {
+    return null;
+  }
+  return `${major}.${minor}`;
+}
+function rfindNumericChar(s) {
+  for (let i = s.length - 1; i >= 0; i--) {
+    const code = s.charCodeAt(i);
+    if (code >= 48 && code <= 57)
+      return i;
+  }
+  return -1;
+}
+function parseVariantSuffix(vrs) {
+  let pos = rfindNumericChar(vrs);
+  if (pos < 0) {
+    return [vrs, "default"];
+  }
+  pos += 1;
+  if (pos + 1 > vrs.length) {
+    return [vrs, "default"];
+  }
+  let variant = vrs.substring(pos);
+  if (variant[0] === "+") {
+    variant = variant.substring(1);
+  }
+  const prefix = vrs.substring(0, pos);
+  return [prefix, import_python_specifiers.PythonVariant.parse(variant)];
+}
+function tryParsePlatformRequest(raw) {
+  const parts = raw.split("-");
+  let partIdx = 0;
+  const state = ["implementation", "version", "os", "arch", "libc", "end"];
+  let stateIdx = 0;
+  let implementation;
+  let version;
+  let os;
+  let arch;
+  let libc;
+  let implOrVersionFailed = false;
+  for (; ; ) {
+    if (partIdx >= parts.length || state[stateIdx] === "end") {
+      break;
+    }
+    const part = parts[partIdx].toLowerCase();
+    if (part.length === 0) {
+      break;
+    }
+    switch (state[stateIdx]) {
+      case "implementation":
+        if (part === "any") {
+          partIdx += 1;
+          stateIdx += 1;
+          continue;
+        }
+        implementation = import_python_specifiers.PythonImplementation.parse(part);
+        if (import_python_specifiers.PythonImplementation.isUnknown(implementation)) {
+          implementation = void 0;
+          stateIdx += 1;
+          implOrVersionFailed = true;
+          continue;
+        }
+        stateIdx += 1;
+        partIdx += 1;
+        break;
+      case "version":
+        if (part === "any") {
+          partIdx += 1;
+          stateIdx += 1;
+          continue;
+        }
+        version = parseVersionRequest(part);
+        if (version == null) {
+          version = void 0;
+          stateIdx += 1;
+          implOrVersionFailed = true;
+          continue;
+        }
+        stateIdx += 1;
+        partIdx += 1;
+        break;
+      case "os":
+        if (part === "any") {
+          partIdx += 1;
+          stateIdx += 1;
+          continue;
+        }
+        os = part;
+        stateIdx += 1;
+        partIdx += 1;
+        break;
+      case "arch":
+        if (part === "any") {
+          partIdx += 1;
+          stateIdx += 1;
+          continue;
+        }
+        arch = part;
+        stateIdx += 1;
+        partIdx += 1;
+        break;
+      case "libc":
+        if (part === "any") {
+          partIdx += 1;
+          stateIdx += 1;
+          continue;
+        }
+        libc = part;
+        stateIdx += 1;
+        partIdx += 1;
+        break;
+      default:
+        break;
+    }
+  }
+  if (implOrVersionFailed && implementation === void 0 && version === void 0) {
+    return null;
+  }
+  let platform;
+  if (os !== void 0 || arch !== void 0 || libc !== void 0) {
+    platform = {
+      os,
+      arch,
+      libc
+    };
+  }
+  return { implementation, version, platform };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parsePythonVersionFile,
+  parseUvPythonRequest,
+  pythonRequestFromConstraint
+});

package/dist/types.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Types-only entrypoint for @vercel/python-analysis.
+ *
+ * Import from this module to avoid pulling in Zod and other runtime dependencies.
+ *
+ * @example
+ * import type { PyProjectToml, UvConfig } from '@vercel/python-analysis/types';
+ *
+ * @module types
+ */
+export type { License, LicenseObject, Person, PyProjectBuildSystem, PyProjectDependencyGroups, PyProjectProject, PyProjectToml, PyProjectToolSection, Readme, ReadmeObject, } from './manifest/pyproject/types';
+export type { UvConfig, UvConfigWorkspace, UvIndexEntry, } from './manifest/uv-config/types';
+export type { PipfileDependency, PipfileDependencyDetail, PipfileLike, PipfileLockLike, PipfileLockMeta, PipfileSource, } from './manifest/pipfile/types';
+export type { DependencySource, HashDigest, NormalizedRequirement, } from './manifest/requirement/types';
+export type { PythonBuild, PythonConstraint, PythonImplementation, PythonPlatformRequest, PythonRequest, PythonVariant, PythonVersion, PythonVersionRequest, UnknownPythonImplementation, } from './manifest/python-specifiers';
+export type { PythonConfig, PythonConfigs, PythonManifest, PythonManifestOrigin, PythonPackage, PythonVersionConfig, } from './manifest/package';
+export type { PythonSelectionResult } from './manifest/python-selector';

package/dist/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/util/config.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+/**
+ * Parse config content and validate it against a zod schema.
+ *
+ * @param content - Raw file content
+ * @param filename - File path (used for error messages and format detection)
+ * @param schema - Zod schema to validate against
+ * @param filetype - Optional file type override (e.g., '.toml', '.json')
+ * @returns Validated and typed config object
+ */
+export declare function parseConfig<T>(content: string, filename: string, schema: z.ZodType<T>, filetype?: string | undefined): T;
+/**
+ * Read a config file if it exists and validate it against a zod schema.
+ *
+ * @param filename - Path to the config file
+ * @param schema - Zod schema to validate against
+ * @param filetype - Optional file type override (e.g., '.toml', '.json')
+ * @returns Validated config object, or null if file doesn't exist
+ */
+export declare function readConfigIfExists<T>(filename: string, schema: z.ZodType<T>, filetype?: string | undefined): Promise<T | null>;

package/dist/util/config.js

@@ -0,0 +1,100 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var config_exports = {};
+__export(config_exports, {
+  parseConfig: () => parseConfig,
+  readConfigIfExists: () => readConfigIfExists
+});
+module.exports = __toCommonJS(config_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_js_yaml = __toESM(require("js-yaml"));
+var import_smol_toml = __toESM(require("smol-toml"));
+var import_fs = require("./fs");
+var import_error = require("./error");
+function parseRawConfig(content, filename, filetype = void 0) {
+  if (filetype === void 0) {
+    filetype = import_node_path.default.extname(filename.toLowerCase());
+  }
+  try {
+    if (filetype === ".json") {
+      return JSON.parse(content);
+    } else if (filetype === ".toml") {
+      return import_smol_toml.default.parse(content);
+    } else if (filetype === ".yaml" || filetype === ".yml") {
+      return import_js_yaml.default.load(content, { filename });
+    } else {
+      throw new import_error.PythonAnalysisError({
+        message: `Could not parse config file "${filename}": unrecognized config format`,
+        code: "PYTHON_CONFIG_UNKNOWN_FORMAT",
+        path: filename
+      });
+    }
+  } catch (error) {
+    if (error instanceof import_error.PythonAnalysisError) {
+      throw error;
+    }
+    if (error instanceof Error) {
+      throw new import_error.PythonAnalysisError({
+        message: `Could not parse config file "${filename}": ${error.message}`,
+        code: "PYTHON_CONFIG_PARSE_ERROR",
+        path: filename
+      });
+    }
+    throw error;
+  }
+}
+function parseConfig(content, filename, schema, filetype = void 0) {
+  const raw = parseRawConfig(content, filename, filetype);
+  const result = schema.safeParse(raw);
+  if (!result.success) {
+    const issues = result.error.issues.map((issue) => {
+      const path2 = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+      return `  - ${path2}: ${issue.message}`;
+    }).join("\n");
+    throw new import_error.PythonAnalysisError({
+      message: `Invalid config in "${filename}":
+${issues}`,
+      code: "PYTHON_CONFIG_VALIDATION_ERROR",
+      path: filename
+    });
+  }
+  return result.data;
+}
+async function readConfigIfExists(filename, schema, filetype = void 0) {
+  const content = await (0, import_fs.readFileTextIfExists)(filename);
+  if (content == null) {
+    return null;
+  }
+  return parseConfig(content, filename, schema, filetype);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseConfig,
+  readConfigIfExists
+});

package/dist/util/error.d.ts

@@ -0,0 +1,39 @@
+export declare const isErrnoException: (error: unknown, code?: string | undefined) => error is NodeJS.ErrnoException;
+interface PythonAnalysisErrorProps {
+    /**
+     * The error message to display to the end-user.
+     * Should be short yet descriptive of what went wrong.
+     */
+    message: string;
+    /**
+     * A unique error code for this particular error.
+     * Should start with `PYTHON_` prefix.
+     */
+    code: string;
+    /**
+     * The path to the file that caused the error, if applicable.
+     */
+    path?: string;
+    /**
+     * Optional hyperlink to documentation with more information about this error.
+     */
+    link?: string;
+    /**
+     * Optional "action" to display before the `link`, such as "Learn More".
+     */
+    action?: string;
+}
+/**
+ * This error should be thrown from Python analysis functions
+ * when encountering configuration or manifest parsing errors.
+ * This is necessary to provide clear error messages without stack traces.
+ */
+export declare class PythonAnalysisError extends Error {
+    hideStackTrace: boolean;
+    code: string;
+    path?: string;
+    link?: string;
+    action?: string;
+    constructor({ message, code, path, link, action }: PythonAnalysisErrorProps);
+}
+export {};

package/dist/util/error.js

@@ -0,0 +1,54 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var error_exports = {};
+__export(error_exports, {
+  PythonAnalysisError: () => PythonAnalysisError,
+  isErrnoException: () => isErrnoException
+});
+module.exports = __toCommonJS(error_exports);
+var import_node_util = __toESM(require("node:util"));
+const isErrnoException = (error, code = void 0) => {
+  return import_node_util.default.types.isNativeError(error) && "code" in error && (code === void 0 || error.code === code);
+};
+class PythonAnalysisError extends Error {
+  constructor({ message, code, path, link, action }) {
+    super(message);
+    this.hideStackTrace = true;
+    this.name = "PythonAnalysisError";
+    this.code = code;
+    this.path = path;
+    this.link = link;
+    this.action = action;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PythonAnalysisError,
+  isErrnoException
+});

package/dist/util/fs.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+/** Absolute filesystem path. */
+export type AbsPath = string;
+/** Relative filesystem path. */
+export type RelPath = string;
+/** Any filesystem path */
+export type Path = AbsPath | RelPath;
+export declare function readFileIfExists(file: Path): Promise<Buffer | null>;
+export declare function readFileTextIfExists(file: Path, encoding?: BufferEncoding): Promise<string | null>;
+export declare function normalizePath(p: Path): AbsPath;
+/**
+ * Check if a path is at or below a parent path in the directory tree.
+ *
+ * @param somePath - The path to check
+ * @param parentPath - The potential parent/ancestor path
+ * @returns True if `somePath` is equal to `parentPath` or is a subdirectory
+ *          of `parentPath`.
+ *
+ * @example
+ * isSubpath('/a/b/c', '/a/b') // true - c is under b
+ * isSubpath('/a/b', '/a/b')   // true - same path
+ * isSubpath('/a/b', '/a/b/c') // false - b is above c
+ * isSubpath('/a/x', '/a/b')   // false - x is not under b
+ */
+export declare function isSubpath(somePath: Path, parentPath: Path): boolean;

package/dist/util/fs.js

@@ -0,0 +1,75 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fs_exports = {};
+__export(fs_exports, {
+  isSubpath: () => isSubpath,
+  normalizePath: () => normalizePath,
+  readFileIfExists: () => readFileIfExists,
+  readFileTextIfExists: () => readFileTextIfExists
+});
+module.exports = __toCommonJS(fs_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_fs_extra = require("fs-extra");
+var import_error = require("./error");
+async function readFileIfExists(file) {
+  try {
+    return await (0, import_fs_extra.readFile)(file);
+  } catch (error) {
+    if (!(0, import_error.isErrnoException)(error, "ENOENT")) {
+      throw error;
+    }
+  }
+  return null;
+}
+async function readFileTextIfExists(file, encoding = "utf8") {
+  const data = await readFileIfExists(file);
+  if (data == null) {
+    return null;
+  } else {
+    return data.toString(encoding);
+  }
+}
+function normalizePath(p) {
+  let np = import_node_path.default.normalize(p);
+  if (np.endsWith(import_node_path.default.sep)) {
+    np = np.slice(0, -1);
+  }
+  return np;
+}
+function isSubpath(somePath, parentPath) {
+  const rel = import_node_path.default.relative(parentPath, somePath);
+  return rel === "" || !rel.startsWith("..") && !import_node_path.default.isAbsolute(rel);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isSubpath,
+  normalizePath,
+  readFileIfExists,
+  readFileTextIfExists
+});

package/dist/util/type.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Type guard to check if a value is a plain object (not null, array, or primitive).
+ *
+ * @param value - Value to check
+ * @returns True if value is a plain object
+ */
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;