@poveste/vendors 0.14.0 → 0.15.0

package/dist/client/node_modules/confbox/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "confbox",
+  "version": "0.2.4",
+  "description": "Compact YAML, TOML, JSONC, JSON5 and INI parser and serializer",
+  "keywords": [
+    "config",
+    "ini",
+    "json5",
+    "jsonc",
+    "toml",
+    "unjs",
+    "yaml"
+  ],
+  "license": "MIT",
+  "repository": "unjs/confbox",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./ini": "./dist/ini.mjs",
+    "./json5": "./dist/json5.mjs",
+    "./jsonc": "./dist/jsonc.mjs",
+    "./toml": "./dist/toml.mjs",
+    "./yaml": "./dist/yaml.mjs"
+  },
+  "scripts": {
+    "build": "obuild",
+    "dev": "vitest dev --coverage",
+    "bench": "pnpm build && node test/bench.mjs",
+    "lint": "oxlint && oxfmt --check src test",
+    "lint:fix": "oxlint --fix && oxfmt src test",
+    "prepack": "pnpm build",
+    "release": "pnpm test && pnpm build && changelogen --release && npm publish && git push --follow-tags",
+    "test": "pnpm lint && pnpm test:types && vitest run --coverage",
+    "test:types": "tsgo --noEmit --skipLibCheck"
+  },
+  "devDependencies": {
+    "@types/ini": "^4.1.1",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^25.2.1",
+    "@typescript/native-preview": "7.0.0-dev.20260206.1",
+    "@vitest/coverage-v8": "^4.0.18",
+    "automd": "^0.4.3",
+    "changelogen": "^0.6.2",
+    "detect-indent": "^7.0.2",
+    "ini": "^6.0.0",
+    "jiti": "^2.6.1",
+    "js-toml": "^1.0.2",
+    "js-yaml": "^4.1.1",
+    "json5": "^2.2.3",
+    "jsonc-parser": "^3.3.1",
+    "mitata": "^1.0.34",
+    "obuild": "^0.4.26",
+    "oxfmt": "^0.28.0",
+    "oxlint": "^1.43.0",
+    "smol-toml": "^1.6.0",
+    "toml": "^3.0.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18",
+    "yaml": "^2.8.2"
+  },
+  "packageManager": "pnpm@10.28.2"
+}

package/dist/client/node_modules/exsolve/dist/index.d.mts

@@ -0,0 +1,66 @@
+/**
+ * Options to configure module resolution.
+ */
+type ResolveOptions = {
+  /**
+   * A URL, path, or array of URLs/paths from which to resolve the module.
+   * If not provided, resolution starts from the current working directory.
+   * You can use `import.meta.url` to mimic the behavior of `import.meta.resolve()`.
+   * For better performance, use a `file://` URL or path that ends with `/`.
+   */
+  from?: string | URL | (string | URL)[];
+  /**
+   * Resolve cache (enabled by default with a shared global object).
+   * Can be set to `false` to disable or a custom `Map` to bring your own cache object.
+   */
+  cache?: boolean | Map<string, unknown>;
+  /**
+   * Additional file extensions to check.
+   * For better performance, use explicit extensions and avoid this option.
+   */
+  extensions?: string[];
+  /**
+   * Conditions to apply when resolving package exports.
+   * Defaults to `["node", "import"]`.
+   * Conditions are applied without order.
+   */
+  conditions?: string[];
+  /**
+   * Path suffixes to check.
+   * For better performance, use explicit paths and avoid this option.
+   * Example: `["", "/index"]`
+   */
+  suffixes?: string[];
+  /**
+   * If set to `true` and the module cannot be resolved,
+   * the resolver returns `undefined` instead of throwing an error.
+   */
+  try?: boolean;
+};
+type ResolverOptions = Omit<ResolveOptions, "try">;
+type ResolveRes<Opts extends ResolveOptions> = Opts["try"] extends true ? string | undefined : string;
+/**
+ * Synchronously resolves a module url based on the options provided.
+ *
+ * @param {string} input - The identifier or path of the module to resolve.
+ * @param {ResolveOptions} [options] - Options to resolve the module. See {@link ResolveOptions}.
+ * @returns {string} The resolved URL as a string.
+ */
+declare function resolveModuleURL<O extends ResolveOptions>(input: string | URL, options?: O): ResolveRes<O>;
+/**
+ * Synchronously resolves a module then converts it to a file path
+ *
+ * (throws error if reolved path is not file:// scheme)
+ *
+ * @param {string} id - The identifier or path of the module to resolve.
+ * @param {ResolveOptions} [options] - Options to resolve the module. See {@link ResolveOptions}.
+ * @returns {string} The resolved URL as a string.
+ */
+declare function resolveModulePath<O extends ResolveOptions>(id: string | URL, options?: O): ResolveRes<O>;
+declare function createResolver(defaults?: ResolverOptions): {
+  resolveModuleURL: <O extends ResolveOptions>(id: string | URL, opts: ResolveOptions) => ResolveRes<O>;
+  resolveModulePath: <O extends ResolveOptions>(id: string | URL, opts: ResolveOptions) => ResolveRes<O>;
+  clearResolveCache: () => void;
+};
+declare function clearResolveCache(): void;
+export { type ResolveOptions, type ResolverOptions, clearResolveCache, createResolver, resolveModulePath, resolveModuleURL };

package/dist/client/node_modules/exsolve/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "exsolve",
+  "version": "1.1.1",
+  "description": "Module resolution utilities based on Node.js upstream implementation.",
+  "license": "MIT",
+  "repository": "unjs/exsolve",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": "./dist/index.mjs"
+  },
+  "scripts": {
+    "build": "obuild",
+    "dev": "vitest dev",
+    "lint": "oxlint . && oxfmt --check .",
+    "fmt": "automd && oxlint && oxfmt .",
+    "node-ts": "node --disable-warning=ExperimentalWarning --experimental-strip-types",
+    "prepack": "pnpm build",
+    "release": "pnpm test && changelogen --release && npm publish && git push --follow-tags",
+    "test": "pnpm lint && pnpm test:types && vitest run --coverage",
+    "test:types": "tsc --noEmit --skipLibCheck"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.1",
+    "@vitest/coverage-v8": "^4.1.10",
+    "automd": "^0.4.3",
+    "changelogen": "^0.6.2",
+    "eslint-config-unjs": "^0.6.2",
+    "happy-dom": "^20.11.1",
+    "jiti": "^2.7.0",
+    "obuild": "^0.4.38",
+    "oxfmt": "^0.60.0",
+    "oxlint": "^1.75.0",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10"
+  },
+  "packageManager": "pnpm@11.17.0"
+}

package/dist/client/node_modules/fdir/dist/index.d.mts

@@ -0,0 +1,155 @@
+/// <reference types="node" />
+import * as nativeFs from "fs";
+import picomatch from "picomatch";
+
+//#region src/api/aborter.d.ts
+/**
+ * AbortController is not supported on Node 14 so we use this until we can drop
+ * support for Node 14.
+ */
+declare class Aborter {
+  aborted: boolean;
+  abort(): void;
+}
+//#endregion
+//#region src/api/queue.d.ts
+type OnQueueEmptyCallback = (error: Error | null, output: WalkerState) => void;
+/**
+ * This is a custom stateless queue to track concurrent async fs calls.
+ * It increments a counter whenever a call is queued and decrements it
+ * as soon as it completes. When the counter hits 0, it calls onQueueEmpty.
+ */
+declare class Queue {
+  private onQueueEmpty?;
+  count: number;
+  constructor(onQueueEmpty?: OnQueueEmptyCallback | undefined);
+  enqueue(): number;
+  dequeue(error: Error | null, output: WalkerState): void;
+}
+//#endregion
+//#region src/types.d.ts
+type Counts = {
+  files: number;
+  directories: number;
+  /**
+   * @deprecated use `directories` instead. Will be removed in v7.0.
+   */
+  dirs: number;
+};
+type Group = {
+  directory: string;
+  files: string[];
+  /**
+   * @deprecated use `directory` instead. Will be removed in v7.0.
+   */
+  dir: string;
+};
+type GroupOutput = Group[];
+type OnlyCountsOutput = Counts;
+type PathsOutput = string[];
+type Output = OnlyCountsOutput | PathsOutput | GroupOutput;
+type FSLike = {
+  readdir: typeof nativeFs.readdir;
+  readdirSync: typeof nativeFs.readdirSync;
+  realpath: typeof nativeFs.realpath;
+  realpathSync: typeof nativeFs.realpathSync;
+  stat: typeof nativeFs.stat;
+  statSync: typeof nativeFs.statSync;
+};
+type WalkerState = {
+  root: string;
+  paths: string[];
+  groups: Group[];
+  counts: Counts;
+  options: Options;
+  queue: Queue;
+  controller: Aborter;
+  fs: FSLike;
+  symlinks: Map<string, string>;
+  visited: string[];
+};
+type ResultCallback<TOutput extends Output> = (error: Error | null, output: TOutput) => void;
+type FilterPredicate = (path: string, isDirectory: boolean) => boolean;
+type ExcludePredicate = (dirName: string, dirPath: string) => boolean;
+type PathSeparator = "/" | "\\";
+type Options<TGlobFunction = unknown> = {
+  includeBasePath?: boolean;
+  includeDirs?: boolean;
+  normalizePath?: boolean;
+  maxDepth: number;
+  maxFiles?: number;
+  resolvePaths?: boolean;
+  suppressErrors: boolean;
+  group?: boolean;
+  onlyCounts?: boolean;
+  filters: FilterPredicate[];
+  resolveSymlinks?: boolean;
+  useRealPaths?: boolean;
+  excludeFiles?: boolean;
+  excludeSymlinks?: boolean;
+  exclude?: ExcludePredicate;
+  relativePaths?: boolean;
+  pathSeparator: PathSeparator;
+  signal?: AbortSignal;
+  globFunction?: TGlobFunction;
+  fs?: FSLike;
+};
+type GlobMatcher = (test: string) => boolean;
+type GlobFunction = (glob: string | string[], ...params: unknown[]) => GlobMatcher;
+type GlobParams<T> = T extends ((globs: string | string[], ...params: infer TParams extends unknown[]) => GlobMatcher) ? TParams : [];
+//#endregion
+//#region src/builder/api-builder.d.ts
+declare class APIBuilder<TReturnType extends Output> {
+  private readonly root;
+  private readonly options;
+  constructor(root: string, options: Options);
+  withPromise(): Promise<TReturnType>;
+  withCallback(cb: ResultCallback<TReturnType>): void;
+  sync(): TReturnType;
+}
+//#endregion
+//#region src/builder/index.d.ts
+declare class Builder<TReturnType extends Output = PathsOutput, TGlobFunction = typeof picomatch> {
+  private readonly globCache;
+  private options;
+  private globFunction?;
+  constructor(options?: Partial<Options<TGlobFunction>>);
+  group(): Builder<GroupOutput, TGlobFunction>;
+  withPathSeparator(separator: "/" | "\\"): this;
+  withBasePath(): this;
+  withRelativePaths(): this;
+  withDirs(): this;
+  withMaxDepth(depth: number): this;
+  withMaxFiles(limit: number): this;
+  withFullPaths(): this;
+  withErrors(): this;
+  withSymlinks({
+    resolvePaths
+  }?: {
+    resolvePaths?: boolean | undefined;
+  }): this;
+  withAbortSignal(signal: AbortSignal): this;
+  normalize(): this;
+  filter(predicate: FilterPredicate): this;
+  onlyDirs(): this;
+  exclude(predicate: ExcludePredicate): this;
+  onlyCounts(): Builder<OnlyCountsOutput, TGlobFunction>;
+  crawl(root?: string): APIBuilder<TReturnType>;
+  withGlobFunction<TFunc>(fn: TFunc): Builder<TReturnType, TFunc>;
+  /**
+   * @deprecated Pass options using the constructor instead:
+   * ```ts
+   * new fdir(options).crawl("/path/to/root");
+   * ```
+   * This method will be removed in v7.0
+   */
+  crawlWithOptions(root: string, options: Partial<Options<TGlobFunction>>): APIBuilder<TReturnType>;
+  glob(...patterns: string[]): Builder<TReturnType, TGlobFunction>;
+  globWithOptions(patterns: string[]): Builder<TReturnType, TGlobFunction>;
+  globWithOptions(patterns: string[], ...options: GlobParams<TGlobFunction>): Builder<TReturnType, TGlobFunction>;
+}
+//#endregion
+//#region src/index.d.ts
+type Fdir = typeof Builder;
+//#endregion
+export { Counts, ExcludePredicate, FSLike, Fdir, FilterPredicate, GlobFunction, GlobMatcher, GlobParams, Group, GroupOutput, OnlyCountsOutput, Options, Output, PathSeparator, PathsOutput, ResultCallback, WalkerState, Builder as fdir };

package/dist/client/node_modules/fdir/package.json

@@ -0,0 +1,103 @@
+{
+  "name": "fdir",
+  "version": "6.5.0",
+  "description": "The fastest directory crawler & globbing alternative to glob, fast-glob, & tiny-glob. Crawls 1m files in < 1s",
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.cts",
+  "type": "module",
+  "scripts": {
+    "prepublishOnly": "npm run test && npm run build",
+    "build": "tsdown",
+    "format": "prettier --write src __tests__ benchmarks",
+    "test": "vitest run __tests__/",
+    "test:coverage": "vitest run --coverage __tests__/",
+    "test:watch": "vitest __tests__/",
+    "bench": "ts-node benchmarks/benchmark.js",
+    "bench:glob": "ts-node benchmarks/glob-benchmark.ts",
+    "bench:fdir": "ts-node benchmarks/fdir-benchmark.ts",
+    "release": "./scripts/release.sh"
+  },
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thecodrr/fdir.git"
+  },
+  "keywords": [
+    "util",
+    "os",
+    "sys",
+    "fs",
+    "walk",
+    "crawler",
+    "directory",
+    "files",
+    "io",
+    "tiny-glob",
+    "glob",
+    "fast-glob",
+    "speed",
+    "javascript",
+    "nodejs"
+  ],
+  "author": "thecodrr <thecodrr@protonmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/thecodrr/fdir/issues"
+  },
+  "homepage": "https://github.com/thecodrr/fdir#readme",
+  "devDependencies": {
+    "@types/glob": "^8.1.0",
+    "@types/mock-fs": "^4.13.4",
+    "@types/node": "^20.9.4",
+    "@types/picomatch": "^4.0.0",
+    "@types/tap": "^15.0.11",
+    "@vitest/coverage-v8": "^0.34.6",
+    "all-files-in-tree": "^1.1.2",
+    "benny": "^3.7.1",
+    "csv-to-markdown-table": "^1.3.1",
+    "expect": "^29.7.0",
+    "fast-glob": "^3.3.2",
+    "fdir1": "npm:fdir@1.2.0",
+    "fdir2": "npm:fdir@2.1.0",
+    "fdir3": "npm:fdir@3.4.2",
+    "fdir4": "npm:fdir@4.1.0",
+    "fdir5": "npm:fdir@5.0.0",
+    "fs-readdir-recursive": "^1.1.0",
+    "get-all-files": "^4.1.0",
+    "glob": "^10.3.10",
+    "klaw-sync": "^6.0.0",
+    "mock-fs": "^5.2.0",
+    "picomatch": "^4.0.2",
+    "prettier": "^3.5.3",
+    "recur-readdir": "0.0.1",
+    "recursive-files": "^1.0.2",
+    "recursive-fs": "^2.1.0",
+    "recursive-readdir": "^2.2.3",
+    "rrdir": "^12.1.0",
+    "systeminformation": "^5.21.17",
+    "tiny-glob": "^0.2.9",
+    "ts-node": "^10.9.1",
+    "tsdown": "^0.12.5",
+    "typescript": "^5.3.2",
+    "vitest": "^0.34.6",
+    "walk-sync": "^3.0.0"
+  },
+  "peerDependencies": {
+    "picomatch": "^3 || ^4"
+  },
+  "peerDependenciesMeta": {
+    "picomatch": {
+      "optional": true
+    }
+  },
+  "module": "./dist/index.mjs",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  }
+}

package/dist/client/node_modules/hookable/dist/index.d.ts

@@ -0,0 +1,103 @@
+type HookCallback = (...arguments_: any) => Promise<void> | void;
+interface Hooks {
+    [key: string]: HookCallback;
+}
+type HookKeys<T> = keyof T & string;
+type DeprecatedHook<T> = {
+    message?: string;
+    to: HookKeys<T>;
+};
+type DeprecatedHooks<T> = {
+    [name in HookKeys<T>]: DeprecatedHook<T>;
+};
+type ValueOf<C> = C extends Record<any, any> ? C[keyof C] : never;
+type Strings<T> = Exclude<keyof T, number | symbol>;
+type KnownKeys<T> = keyof {
+    [K in keyof T as string extends K ? never : number extends K ? never : K]: never;
+};
+type StripGeneric<T> = Pick<T, KnownKeys<T> extends keyof T ? KnownKeys<T> : never>;
+type OnlyGeneric<T> = Omit<T, KnownKeys<T> extends keyof T ? KnownKeys<T> : never>;
+type Namespaces<T> = ValueOf<{
+    [key in Strings<T>]: key extends `${infer Namespace}:${string}` ? Namespace : never;
+}>;
+type BareHooks<T> = ValueOf<{
+    [key in Strings<T>]: key extends `${string}:${string}` ? never : key;
+}>;
+type HooksInNamespace<T, Namespace extends string> = ValueOf<{
+    [key in Strings<T>]: key extends `${Namespace}:${infer HookName}` ? HookName : never;
+}>;
+type WithoutNamespace<T, Namespace extends string> = {
+    [key in HooksInNamespace<T, Namespace>]: `${Namespace}:${key}` extends keyof T ? T[`${Namespace}:${key}`] : never;
+};
+type NestedHooks<T> = (Partial<StripGeneric<T>> | Partial<OnlyGeneric<T>>) & Partial<{
+    [key in Namespaces<StripGeneric<T>>]: NestedHooks<WithoutNamespace<T, key>>;
+}> & Partial<{
+    [key in BareHooks<StripGeneric<T>>]: T[key];
+}>;
+
+type InferCallback<HT, HN extends keyof HT> = HT[HN] extends HookCallback ? HT[HN] : never;
+type InferSpyEvent<HT extends Record<string, any>> = {
+    [key in keyof HT]: {
+        name: key;
+        args: Parameters<HT[key]>;
+        context: Record<string, any>;
+    };
+}[keyof HT];
+declare class Hookable<HooksT extends Record<string, any> = Record<string, HookCallback>, HookNameT extends HookKeys<HooksT> = HookKeys<HooksT>> {
+    private _hooks;
+    private _before?;
+    private _after?;
+    private _deprecatedHooks;
+    private _deprecatedMessages?;
+    constructor();
+    hook<NameT extends HookNameT>(name: NameT, function_: InferCallback<HooksT, NameT>, options?: {
+        allowDeprecated?: boolean;
+    }): () => void;
+    hookOnce<NameT extends HookNameT>(name: NameT, function_: InferCallback<HooksT, NameT>): () => void;
+    removeHook<NameT extends HookNameT>(name: NameT, function_: InferCallback<HooksT, NameT>): void;
+    deprecateHook<NameT extends HookNameT>(name: NameT, deprecated: HookKeys<HooksT> | DeprecatedHook<HooksT>): void;
+    deprecateHooks(deprecatedHooks: Partial<Record<HookNameT, DeprecatedHook<HooksT>>>): void;
+    addHooks(configHooks: NestedHooks<HooksT>): () => void;
+    removeHooks(configHooks: NestedHooks<HooksT>): void;
+    removeAllHooks(): void;
+    callHook<NameT extends HookNameT>(name: NameT, ...arguments_: Parameters<InferCallback<HooksT, NameT>>): Promise<any>;
+    callHookParallel<NameT extends HookNameT>(name: NameT, ...arguments_: Parameters<InferCallback<HooksT, NameT>>): Promise<any[]>;
+    callHookWith<NameT extends HookNameT, CallFunction extends (hooks: HookCallback[], arguments_: Parameters<InferCallback<HooksT, NameT>>) => any>(caller: CallFunction, name: NameT, ...arguments_: Parameters<InferCallback<HooksT, NameT>>): ReturnType<CallFunction>;
+    beforeEach(function_: (event: InferSpyEvent<HooksT>) => void): () => void;
+    afterEach(function_: (event: InferSpyEvent<HooksT>) => void): () => void;
+}
+declare function createHooks<T extends Record<string, any>>(): Hookable<T>;
+
+declare function flatHooks<T>(configHooks: NestedHooks<T>, hooks?: T, parentName?: string): T;
+declare function mergeHooks<T>(...hooks: NestedHooks<T>[]): T;
+declare function serial<T>(tasks: T[], function_: (task: T) => Promise<any> | any): Promise<any>;
+/** @deprecated */
+declare function serialCaller(hooks: HookCallback[], arguments_?: any[]): Promise<void>;
+/** @deprecated */
+declare function parallelCaller(hooks: HookCallback[], args?: any[]): Promise<void[]>;
+
+interface CreateDebuggerOptions {
+    /** An optional tag to prefix console logs with */
+    tag?: string;
+    /**
+     * Show hook params to the console output
+     *
+     * Enabled for browsers by default
+     */
+    inspect?: boolean;
+    /**
+     * Use group/groupEnd wrapper around logs happening during a specific hook
+     *
+     * Enabled for browsers by default
+     */
+    group?: boolean;
+    /** Filter which hooks to enable debugger for. Can be a string prefix or fn. */
+    filter?: string | ((event: string) => boolean);
+}
+/** Start debugging hook names and timing in console */
+declare function createDebugger(hooks: Hookable<any>, _options?: CreateDebuggerOptions): {
+    /** Stop debugging and remove listeners */
+    close: () => void;
+};
+
+export { CreateDebuggerOptions, DeprecatedHook, DeprecatedHooks, HookCallback, HookKeys, Hookable, Hooks, NestedHooks, createDebugger, createHooks, flatHooks, mergeHooks, parallelCaller, serial, serialCaller };

package/dist/client/node_modules/hookable/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "hookable",
+  "version": "5.5.3",
+  "description": "Awaitable hook system",
+  "keywords": [
+    "hook",
+    "hookable",
+    "plugin",
+    "tapable",
+    "tappable"
+  ],
+  "repository": "unjs/hookable",
+  "license": "MIT",
+  "exports": {
+    "import": "./dist/index.mjs",
+    "types": "./dist/index.d.ts",
+    "require": "./dist/index.cjs"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@types/node": "^18.15.11",
+    "@vitest/coverage-c8": "^0.29.8",
+    "changelogen": "^0.5.2",
+    "eslint": "^8.37.0",
+    "eslint-config-unjs": "^0.1.0",
+    "expect-type": "^0.15.0",
+    "prettier": "^2.8.7",
+    "typescript": "^5.0.2",
+    "unbuild": "^1.1.2",
+    "vite": "^4.2.1",
+    "vitest": "^0.29.8"
+  },
+  "packageManager": "pnpm@8.0.0",
+  "scripts": {
+    "build": "unbuild",
+    "dev": "vitest",
+    "lint": "eslint --cache --ext .ts,.js,.mjs,.cjs . && prettier -c src test",
+    "lint:fix": "eslint --cache --ext .ts,.js,.mjs,.cjs . --fix && prettier -c src test -w",
+    "prepublish": "pnpm build",
+    "release": "pnpm test && pnpm build && changelogen --release --push && pnpm publish",
+    "test": "pnpm lint && vitest run --coverage",
+    "test:types": "tsc --noEmit"
+  }
+}

package/dist/client/node_modules/local-pkg/dist/index.d.mts

@@ -0,0 +1,42 @@
+import * as quansync_types from 'quansync/types';
+import { PackageJson } from 'pkg-types';
+
+interface PackageInfo {
+    name: string;
+    rootPath: string;
+    packageJsonPath: string;
+    version: string;
+    packageJson: PackageJson;
+}
+interface PackageResolvingOptions {
+    paths?: string[];
+    /**
+     * @default 'auto'
+     * Resolve path as posix or win32
+     */
+    platform?: 'posix' | 'win32' | 'auto';
+}
+declare function resolveModule(name: string, options?: PackageResolvingOptions): string | undefined;
+declare function importModule<T = any>(path: string): Promise<T>;
+declare function isPackageExists(name: string, options?: PackageResolvingOptions): boolean;
+declare const getPackageInfo: quansync_types.QuansyncFn<{
+    name: string;
+    version: string | undefined;
+    rootPath: string;
+    packageJsonPath: string;
+    packageJson: PackageJson;
+} | undefined, [name: string, options?: PackageResolvingOptions | undefined]>;
+declare const getPackageInfoSync: (name: string, options?: PackageResolvingOptions | undefined) => {
+    name: string;
+    version: string | undefined;
+    rootPath: string;
+    packageJsonPath: string;
+    packageJson: PackageJson;
+} | undefined;
+declare const loadPackageJSON: quansync_types.QuansyncFn<PackageJson | null, [cwd?: Args[0] | undefined]>;
+declare const loadPackageJSONSync: (cwd?: Args[0] | undefined) => PackageJson | null;
+declare const isPackageListed: quansync_types.QuansyncFn<boolean, [name: string, cwd?: string | undefined]>;
+declare const isPackageListedSync: (name: string, cwd?: string | undefined) => boolean;
+
+export { getPackageInfo, getPackageInfoSync, importModule, isPackageExists, isPackageListed, isPackageListedSync, loadPackageJSON, loadPackageJSONSync, resolveModule };
+export type { PackageInfo, PackageResolvingOptions };

package/dist/client/node_modules/local-pkg/dist/index.d.ts

@@ -0,0 +1,42 @@
+import * as quansync_types from 'quansync/types';
+import { PackageJson } from 'pkg-types';
+
+interface PackageInfo {
+    name: string;
+    rootPath: string;
+    packageJsonPath: string;
+    version: string;
+    packageJson: PackageJson;
+}
+interface PackageResolvingOptions {
+    paths?: string[];
+    /**
+     * @default 'auto'
+     * Resolve path as posix or win32
+     */
+    platform?: 'posix' | 'win32' | 'auto';
+}
+declare function resolveModule(name: string, options?: PackageResolvingOptions): string | undefined;
+declare function importModule<T = any>(path: string): Promise<T>;
+declare function isPackageExists(name: string, options?: PackageResolvingOptions): boolean;
+declare const getPackageInfo: quansync_types.QuansyncFn<{
+    name: string;
+    version: string | undefined;
+    rootPath: string;
+    packageJsonPath: string;
+    packageJson: PackageJson;
+} | undefined, [name: string, options?: PackageResolvingOptions | undefined]>;
+declare const getPackageInfoSync: (name: string, options?: PackageResolvingOptions | undefined) => {
+    name: string;
+    version: string | undefined;
+    rootPath: string;
+    packageJsonPath: string;
+    packageJson: PackageJson;
+} | undefined;
+declare const loadPackageJSON: quansync_types.QuansyncFn<PackageJson | null, [cwd?: Args[0] | undefined]>;
+declare const loadPackageJSONSync: (cwd?: Args[0] | undefined) => PackageJson | null;
+declare const isPackageListed: quansync_types.QuansyncFn<boolean, [name: string, cwd?: string | undefined]>;
+declare const isPackageListedSync: (name: string, cwd?: string | undefined) => boolean;
+
+export { getPackageInfo, getPackageInfoSync, importModule, isPackageExists, isPackageListed, isPackageListedSync, loadPackageJSON, loadPackageJSONSync, resolveModule };
+export type { PackageInfo, PackageResolvingOptions };