@ontos-ai/knowhere-claw 0.1.4 → 0.1.5

package/dist/node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/mkdirs/make-dir.js

@@ -0,0 +1,33 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_fs } from "../fs/index.js";
+import { require_utils } from "./utils.js";
+//#region node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/mkdirs/make-dir.js
+var require_make_dir = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = require_fs();
+	const { checkPath } = require_utils();
+	const getMode = (options) => {
+		const defaults = { mode: 511 };
+		if (typeof options === "number") return options;
+		return {
+			...defaults,
+			...options
+		}.mode;
+	};
+	module.exports.makeDir = async (dir, options) => {
+		checkPath(dir);
+		return fs.mkdir(dir, {
+			mode: getMode(options),
+			recursive: true
+		});
+	};
+	module.exports.makeDirSync = (dir, options) => {
+		checkPath(dir);
+		return fs.mkdirSync(dir, {
+			mode: getMode(options),
+			recursive: true
+		});
+	};
+}));
+//#endregion
+export default require_make_dir();
+export { require_make_dir };

package/dist/node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/mkdirs/utils.js

@@ -0,0 +1,17 @@
+import { __commonJSMin, __require } from "../../../../../../../_virtual/_rolldown/runtime.js";
+//#region node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/mkdirs/utils.js
+var require_utils = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path = __require("path");
+	module.exports.checkPath = function checkPath(pth) {
+		if (process.platform === "win32") {
+			if (/[<>:"|?*]/.test(pth.replace(path.parse(pth).root, ""))) {
+				const error = /* @__PURE__ */ new Error(`Path contains invalid characters: ${pth}`);
+				error.code = "EINVAL";
+				throw error;
+			}
+		}
+	};
+}));
+//#endregion
+export default require_utils();
+export { require_utils };

package/dist/node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/move/index.js

@@ -0,0 +1,15 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_universalify } from "../../../../../universalify@2.0.1/node_modules/universalify/index.js";
+import { require_move as require_move$1 } from "./move.js";
+import { require_move_sync } from "./move-sync.js";
+//#region node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/move/index.js
+var require_move = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const u = require_universalify().fromPromise;
+	module.exports = {
+		move: u(require_move$1()),
+		moveSync: require_move_sync()
+	};
+}));
+//#endregion
+export default require_move();
+export { require_move };

package/dist/node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/move/move-sync.js

@@ -0,0 +1,56 @@
+import { __commonJSMin, __require } from "../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_graceful_fs } from "../../../../../graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js";
+import { require_mkdirs } from "../mkdirs/index.js";
+import { require_stat } from "../util/stat.js";
+import { require_copy } from "../copy/index.js";
+import { require_remove } from "../remove/index.js";
+//#region node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/move/move-sync.js
+var require_move_sync = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = require_graceful_fs();
+	const path = __require("path");
+	const copySync = require_copy().copySync;
+	const removeSync = require_remove().removeSync;
+	const mkdirpSync = require_mkdirs().mkdirpSync;
+	const stat = require_stat();
+	function moveSync(src, dest, opts) {
+		opts = opts || {};
+		const overwrite = opts.overwrite || opts.clobber || false;
+		const { srcStat, isChangingCase = false } = stat.checkPathsSync(src, dest, "move", opts);
+		stat.checkParentPathsSync(src, srcStat, dest, "move");
+		if (!isParentRoot(dest)) mkdirpSync(path.dirname(dest));
+		return doRename(src, dest, overwrite, isChangingCase);
+	}
+	function isParentRoot(dest) {
+		const parent = path.dirname(dest);
+		return path.parse(parent).root === parent;
+	}
+	function doRename(src, dest, overwrite, isChangingCase) {
+		if (isChangingCase) return rename(src, dest, overwrite);
+		if (overwrite) {
+			removeSync(dest);
+			return rename(src, dest, overwrite);
+		}
+		if (fs.existsSync(dest)) throw new Error("dest already exists.");
+		return rename(src, dest, overwrite);
+	}
+	function rename(src, dest, overwrite) {
+		try {
+			fs.renameSync(src, dest);
+		} catch (err) {
+			if (err.code !== "EXDEV") throw err;
+			return moveAcrossDevice(src, dest, overwrite);
+		}
+	}
+	function moveAcrossDevice(src, dest, overwrite) {
+		copySync(src, dest, {
+			overwrite,
+			errorOnExist: true,
+			preserveTimestamps: true
+		});
+		return removeSync(src);
+	}
+	module.exports = moveSync;
+}));
+//#endregion
+export default require_move_sync();
+export { require_move_sync };

package/dist/node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/move/move.js

@@ -0,0 +1,49 @@
+import { __commonJSMin, __require } from "../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_fs } from "../fs/index.js";
+import { require_mkdirs } from "../mkdirs/index.js";
+import { require_path_exists } from "../path-exists/index.js";
+import { require_stat } from "../util/stat.js";
+import { require_copy } from "../copy/index.js";
+import { require_remove } from "../remove/index.js";
+//#region node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/move/move.js
+var require_move = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = require_fs();
+	const path = __require("path");
+	const { copy } = require_copy();
+	const { remove } = require_remove();
+	const { mkdirp } = require_mkdirs();
+	const { pathExists } = require_path_exists();
+	const stat = require_stat();
+	async function move(src, dest, opts = {}) {
+		const overwrite = opts.overwrite || opts.clobber || false;
+		const { srcStat, isChangingCase = false } = await stat.checkPaths(src, dest, "move", opts);
+		await stat.checkParentPaths(src, srcStat, dest, "move");
+		const destParent = path.dirname(dest);
+		if (path.parse(destParent).root !== destParent) await mkdirp(destParent);
+		return doRename(src, dest, overwrite, isChangingCase);
+	}
+	async function doRename(src, dest, overwrite, isChangingCase) {
+		if (!isChangingCase) {
+			if (overwrite) await remove(dest);
+			else if (await pathExists(dest)) throw new Error("dest already exists.");
+		}
+		try {
+			await fs.rename(src, dest);
+		} catch (err) {
+			if (err.code !== "EXDEV") throw err;
+			await moveAcrossDevice(src, dest, overwrite);
+		}
+	}
+	async function moveAcrossDevice(src, dest, overwrite) {
+		await copy(src, dest, {
+			overwrite,
+			errorOnExist: true,
+			preserveTimestamps: true
+		});
+		return remove(src);
+	}
+	module.exports = move;
+}));
+//#endregion
+export default require_move();
+export { require_move };

package/dist/node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/output-file/index.js

@@ -0,0 +1,30 @@
+import { __commonJSMin, __require } from "../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_universalify } from "../../../../../universalify@2.0.1/node_modules/universalify/index.js";
+import { require_fs } from "../fs/index.js";
+import { require_mkdirs } from "../mkdirs/index.js";
+import { require_path_exists } from "../path-exists/index.js";
+//#region node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/output-file/index.js
+var require_output_file = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const u = require_universalify().fromPromise;
+	const fs = require_fs();
+	const path = __require("path");
+	const mkdir = require_mkdirs();
+	const pathExists = require_path_exists().pathExists;
+	async function outputFile(file, data, encoding = "utf-8") {
+		const dir = path.dirname(file);
+		if (!await pathExists(dir)) await mkdir.mkdirs(dir);
+		return fs.writeFile(file, data, encoding);
+	}
+	function outputFileSync(file, ...args) {
+		const dir = path.dirname(file);
+		if (!fs.existsSync(dir)) mkdir.mkdirsSync(dir);
+		fs.writeFileSync(file, ...args);
+	}
+	module.exports = {
+		outputFile: u(outputFile),
+		outputFileSync
+	};
+}));
+//#endregion
+export default require_output_file();
+export { require_output_file };

package/dist/node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/path-exists/index.js

@@ -0,0 +1,18 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_universalify } from "../../../../../universalify@2.0.1/node_modules/universalify/index.js";
+import { require_fs } from "../fs/index.js";
+//#region node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/path-exists/index.js
+var require_path_exists = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const u = require_universalify().fromPromise;
+	const fs = require_fs();
+	function pathExists(path) {
+		return fs.access(path).then(() => true).catch(() => false);
+	}
+	module.exports = {
+		pathExists: u(pathExists),
+		pathExistsSync: fs.existsSync
+	};
+}));
+//#endregion
+export default require_path_exists();
+export { require_path_exists };

package/dist/node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/remove/index.js

@@ -0,0 +1,27 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_universalify } from "../../../../../universalify@2.0.1/node_modules/universalify/index.js";
+import { require_graceful_fs } from "../../../../../graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js";
+//#region node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/remove/index.js
+var require_remove = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = require_graceful_fs();
+	const u = require_universalify().fromCallback;
+	function remove(path, callback) {
+		fs.rm(path, {
+			recursive: true,
+			force: true
+		}, callback);
+	}
+	function removeSync(path) {
+		fs.rmSync(path, {
+			recursive: true,
+			force: true
+		});
+	}
+	module.exports = {
+		remove: u(remove),
+		removeSync
+	};
+}));
+//#endregion
+export default require_remove();
+export { require_remove };

package/dist/node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/util/async.js

@@ -0,0 +1,15 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.js";
+//#region node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/util/async.js
+var require_async = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	async function asyncIteratorConcurrentProcess(iterator, fn) {
+		const promises = [];
+		for await (const item of iterator) promises.push(fn(item).then(() => null, (err) => err ?? /* @__PURE__ */ new Error("unknown error")));
+		await Promise.all(promises.map((promise) => promise.then((possibleErr) => {
+			if (possibleErr !== null) throw possibleErr;
+		})));
+	}
+	module.exports = { asyncIteratorConcurrentProcess };
+}));
+//#endregion
+export default require_async();
+export { require_async };

package/dist/node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/util/stat.js

@@ -0,0 +1,131 @@
+import { __commonJSMin, __require } from "../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_universalify } from "../../../../../universalify@2.0.1/node_modules/universalify/index.js";
+import { require_fs } from "../fs/index.js";
+//#region node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/util/stat.js
+var require_stat = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = require_fs();
+	const path = __require("path");
+	const u = require_universalify().fromPromise;
+	function getStats(src, dest, opts) {
+		const statFunc = opts.dereference ? (file) => fs.stat(file, { bigint: true }) : (file) => fs.lstat(file, { bigint: true });
+		return Promise.all([statFunc(src), statFunc(dest).catch((err) => {
+			if (err.code === "ENOENT") return null;
+			throw err;
+		})]).then(([srcStat, destStat]) => ({
+			srcStat,
+			destStat
+		}));
+	}
+	function getStatsSync(src, dest, opts) {
+		let destStat;
+		const statFunc = opts.dereference ? (file) => fs.statSync(file, { bigint: true }) : (file) => fs.lstatSync(file, { bigint: true });
+		const srcStat = statFunc(src);
+		try {
+			destStat = statFunc(dest);
+		} catch (err) {
+			if (err.code === "ENOENT") return {
+				srcStat,
+				destStat: null
+			};
+			throw err;
+		}
+		return {
+			srcStat,
+			destStat
+		};
+	}
+	async function checkPaths(src, dest, funcName, opts) {
+		const { srcStat, destStat } = await getStats(src, dest, opts);
+		if (destStat) {
+			if (areIdentical(srcStat, destStat)) {
+				const srcBaseName = path.basename(src);
+				const destBaseName = path.basename(dest);
+				if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) return {
+					srcStat,
+					destStat,
+					isChangingCase: true
+				};
+				throw new Error("Source and destination must not be the same.");
+			}
+			if (srcStat.isDirectory() && !destStat.isDirectory()) throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
+			if (!srcStat.isDirectory() && destStat.isDirectory()) throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`);
+		}
+		if (srcStat.isDirectory() && isSrcSubdir(src, dest)) throw new Error(errMsg(src, dest, funcName));
+		return {
+			srcStat,
+			destStat
+		};
+	}
+	function checkPathsSync(src, dest, funcName, opts) {
+		const { srcStat, destStat } = getStatsSync(src, dest, opts);
+		if (destStat) {
+			if (areIdentical(srcStat, destStat)) {
+				const srcBaseName = path.basename(src);
+				const destBaseName = path.basename(dest);
+				if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) return {
+					srcStat,
+					destStat,
+					isChangingCase: true
+				};
+				throw new Error("Source and destination must not be the same.");
+			}
+			if (srcStat.isDirectory() && !destStat.isDirectory()) throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
+			if (!srcStat.isDirectory() && destStat.isDirectory()) throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`);
+		}
+		if (srcStat.isDirectory() && isSrcSubdir(src, dest)) throw new Error(errMsg(src, dest, funcName));
+		return {
+			srcStat,
+			destStat
+		};
+	}
+	async function checkParentPaths(src, srcStat, dest, funcName) {
+		const srcParent = path.resolve(path.dirname(src));
+		const destParent = path.resolve(path.dirname(dest));
+		if (destParent === srcParent || destParent === path.parse(destParent).root) return;
+		let destStat;
+		try {
+			destStat = await fs.stat(destParent, { bigint: true });
+		} catch (err) {
+			if (err.code === "ENOENT") return;
+			throw err;
+		}
+		if (areIdentical(srcStat, destStat)) throw new Error(errMsg(src, dest, funcName));
+		return checkParentPaths(src, srcStat, destParent, funcName);
+	}
+	function checkParentPathsSync(src, srcStat, dest, funcName) {
+		const srcParent = path.resolve(path.dirname(src));
+		const destParent = path.resolve(path.dirname(dest));
+		if (destParent === srcParent || destParent === path.parse(destParent).root) return;
+		let destStat;
+		try {
+			destStat = fs.statSync(destParent, { bigint: true });
+		} catch (err) {
+			if (err.code === "ENOENT") return;
+			throw err;
+		}
+		if (areIdentical(srcStat, destStat)) throw new Error(errMsg(src, dest, funcName));
+		return checkParentPathsSync(src, srcStat, destParent, funcName);
+	}
+	function areIdentical(srcStat, destStat) {
+		return destStat.ino !== void 0 && destStat.dev !== void 0 && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev;
+	}
+	function isSrcSubdir(src, dest) {
+		const srcArr = path.resolve(src).split(path.sep).filter((i) => i);
+		const destArr = path.resolve(dest).split(path.sep).filter((i) => i);
+		return srcArr.every((cur, i) => destArr[i] === cur);
+	}
+	function errMsg(src, dest, funcName) {
+		return `Cannot ${funcName} '${src}' to a subdirectory of itself, '${dest}'.`;
+	}
+	module.exports = {
+		checkPaths: u(checkPaths),
+		checkPathsSync,
+		checkParentPaths: u(checkParentPaths),
+		checkParentPathsSync,
+		isSrcSubdir,
+		areIdentical
+	};
+}));
+//#endregion
+export default require_stat();
+export { require_stat };

package/dist/node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/util/utimes.js

@@ -0,0 +1,34 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_universalify } from "../../../../../universalify@2.0.1/node_modules/universalify/index.js";
+import { require_fs } from "../fs/index.js";
+//#region node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/util/utimes.js
+var require_utimes = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = require_fs();
+	const u = require_universalify().fromPromise;
+	async function utimesMillis(path, atime, mtime) {
+		const fd = await fs.open(path, "r+");
+		let closeErr = null;
+		try {
+			await fs.futimes(fd, atime, mtime);
+		} finally {
+			try {
+				await fs.close(fd);
+			} catch (e) {
+				closeErr = e;
+			}
+		}
+		if (closeErr) throw closeErr;
+	}
+	function utimesMillisSync(path, atime, mtime) {
+		const fd = fs.openSync(path, "r+");
+		fs.futimesSync(fd, atime, mtime);
+		return fs.closeSync(fd);
+	}
+	module.exports = {
+		utimesMillis: u(utimesMillis),
+		utimesMillisSync
+	};
+}));
+//#endregion
+export default require_utimes();
+export { require_utimes };

package/dist/node_modules/.pnpm/fs.realpath@1.0.0/node_modules/fs.realpath/index.js

@@ -0,0 +1,51 @@
+import { __commonJSMin, __require } from "../../../../../_virtual/_rolldown/runtime.js";
+import { require_old } from "./old.js";
+//#region node_modules/.pnpm/fs.realpath@1.0.0/node_modules/fs.realpath/index.js
+var require_fs_realpath = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = realpath;
+	realpath.realpath = realpath;
+	realpath.sync = realpathSync;
+	realpath.realpathSync = realpathSync;
+	realpath.monkeypatch = monkeypatch;
+	realpath.unmonkeypatch = unmonkeypatch;
+	var fs = __require("fs");
+	var origRealpath = fs.realpath;
+	var origRealpathSync = fs.realpathSync;
+	var version = process.version;
+	var ok = /^v[0-5]\./.test(version);
+	var old = require_old();
+	function newError(er) {
+		return er && er.syscall === "realpath" && (er.code === "ELOOP" || er.code === "ENOMEM" || er.code === "ENAMETOOLONG");
+	}
+	function realpath(p, cache, cb) {
+		if (ok) return origRealpath(p, cache, cb);
+		if (typeof cache === "function") {
+			cb = cache;
+			cache = null;
+		}
+		origRealpath(p, cache, function(er, result) {
+			if (newError(er)) old.realpath(p, cache, cb);
+			else cb(er, result);
+		});
+	}
+	function realpathSync(p, cache) {
+		if (ok) return origRealpathSync(p, cache);
+		try {
+			return origRealpathSync(p, cache);
+		} catch (er) {
+			if (newError(er)) return old.realpathSync(p, cache);
+			else throw er;
+		}
+	}
+	function monkeypatch() {
+		fs.realpath = realpath;
+		fs.realpathSync = realpathSync;
+	}
+	function unmonkeypatch() {
+		fs.realpath = origRealpath;
+		fs.realpathSync = origRealpathSync;
+	}
+}));
+//#endregion
+export default require_fs_realpath();
+export { require_fs_realpath };

package/dist/node_modules/.pnpm/fs.realpath@1.0.0/node_modules/fs.realpath/old.js

@@ -0,0 +1,171 @@
+import { __commonJSMin, __require } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region node_modules/.pnpm/fs.realpath@1.0.0/node_modules/fs.realpath/old.js
+var require_old = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var pathModule = __require("path");
+	var isWindows = process.platform === "win32";
+	var fs = __require("fs");
+	var DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG);
+	function rethrow() {
+		var callback;
+		if (DEBUG) {
+			var backtrace = /* @__PURE__ */ new Error();
+			callback = debugCallback;
+		} else callback = missingCallback;
+		return callback;
+		function debugCallback(err) {
+			if (err) {
+				backtrace.message = err.message;
+				err = backtrace;
+				missingCallback(err);
+			}
+		}
+		function missingCallback(err) {
+			if (err) {
+				if (process.throwDeprecation) throw err;
+				else if (!process.noDeprecation) {
+					var msg = "fs: missing callback " + (err.stack || err.message);
+					if (process.traceDeprecation) console.trace(msg);
+					else console.error(msg);
+				}
+			}
+		}
+	}
+	function maybeCallback(cb) {
+		return typeof cb === "function" ? cb : rethrow();
+	}
+	pathModule.normalize;
+	if (isWindows) var nextPartRe = /(.*?)(?:[\/\\]+|$)/g;
+	else var nextPartRe = /(.*?)(?:[\/]+|$)/g;
+	if (isWindows) var splitRootRe = /^(?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/][^\\\/]+)?[\\\/]*/;
+	else var splitRootRe = /^[\/]*/;
+	exports.realpathSync = function realpathSync(p, cache) {
+		p = pathModule.resolve(p);
+		if (cache && Object.prototype.hasOwnProperty.call(cache, p)) return cache[p];
+		var original = p, seenLinks = {}, knownHard = {};
+		var pos;
+		var current;
+		var base;
+		var previous;
+		start();
+		function start() {
+			var m = splitRootRe.exec(p);
+			pos = m[0].length;
+			current = m[0];
+			base = m[0];
+			previous = "";
+			if (isWindows && !knownHard[base]) {
+				fs.lstatSync(base);
+				knownHard[base] = true;
+			}
+		}
+		while (pos < p.length) {
+			nextPartRe.lastIndex = pos;
+			var result = nextPartRe.exec(p);
+			previous = current;
+			current += result[0];
+			base = previous + result[1];
+			pos = nextPartRe.lastIndex;
+			if (knownHard[base] || cache && cache[base] === base) continue;
+			var resolvedLink;
+			if (cache && Object.prototype.hasOwnProperty.call(cache, base)) resolvedLink = cache[base];
+			else {
+				var stat = fs.lstatSync(base);
+				if (!stat.isSymbolicLink()) {
+					knownHard[base] = true;
+					if (cache) cache[base] = base;
+					continue;
+				}
+				var linkTarget = null;
+				if (!isWindows) {
+					var id = stat.dev.toString(32) + ":" + stat.ino.toString(32);
+					if (seenLinks.hasOwnProperty(id)) linkTarget = seenLinks[id];
+				}
+				if (linkTarget === null) {
+					fs.statSync(base);
+					linkTarget = fs.readlinkSync(base);
+				}
+				resolvedLink = pathModule.resolve(previous, linkTarget);
+				if (cache) cache[base] = resolvedLink;
+				if (!isWindows) seenLinks[id] = linkTarget;
+			}
+			p = pathModule.resolve(resolvedLink, p.slice(pos));
+			start();
+		}
+		if (cache) cache[original] = p;
+		return p;
+	};
+	exports.realpath = function realpath(p, cache, cb) {
+		if (typeof cb !== "function") {
+			cb = maybeCallback(cache);
+			cache = null;
+		}
+		p = pathModule.resolve(p);
+		if (cache && Object.prototype.hasOwnProperty.call(cache, p)) return process.nextTick(cb.bind(null, null, cache[p]));
+		var original = p, seenLinks = {}, knownHard = {};
+		var pos;
+		var current;
+		var base;
+		var previous;
+		start();
+		function start() {
+			var m = splitRootRe.exec(p);
+			pos = m[0].length;
+			current = m[0];
+			base = m[0];
+			previous = "";
+			if (isWindows && !knownHard[base]) fs.lstat(base, function(err) {
+				if (err) return cb(err);
+				knownHard[base] = true;
+				LOOP();
+			});
+			else process.nextTick(LOOP);
+		}
+		function LOOP() {
+			if (pos >= p.length) {
+				if (cache) cache[original] = p;
+				return cb(null, p);
+			}
+			nextPartRe.lastIndex = pos;
+			var result = nextPartRe.exec(p);
+			previous = current;
+			current += result[0];
+			base = previous + result[1];
+			pos = nextPartRe.lastIndex;
+			if (knownHard[base] || cache && cache[base] === base) return process.nextTick(LOOP);
+			if (cache && Object.prototype.hasOwnProperty.call(cache, base)) return gotResolvedLink(cache[base]);
+			return fs.lstat(base, gotStat);
+		}
+		function gotStat(err, stat) {
+			if (err) return cb(err);
+			if (!stat.isSymbolicLink()) {
+				knownHard[base] = true;
+				if (cache) cache[base] = base;
+				return process.nextTick(LOOP);
+			}
+			if (!isWindows) {
+				var id = stat.dev.toString(32) + ":" + stat.ino.toString(32);
+				if (seenLinks.hasOwnProperty(id)) return gotTarget(null, seenLinks[id], base);
+			}
+			fs.stat(base, function(err) {
+				if (err) return cb(err);
+				fs.readlink(base, function(err, target) {
+					if (!isWindows) seenLinks[id] = target;
+					gotTarget(err, target);
+				});
+			});
+		}
+		function gotTarget(err, target, base) {
+			if (err) return cb(err);
+			var resolvedLink = pathModule.resolve(previous, target);
+			if (cache) cache[base] = resolvedLink;
+			gotResolvedLink(resolvedLink);
+		}
+		function gotResolvedLink(resolvedLink) {
+			p = pathModule.resolve(resolvedLink, p.slice(pos));
+			start();
+		}
+	};
+}));
+//#endregion
+export default require_old();
+export { require_old };

package/dist/node_modules/.pnpm/gauge@3.0.2/node_modules/gauge/base-theme.js

@@ -0,0 +1,21 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+import { require_spin } from "./spin.js";
+import { require_progress_bar } from "./progress-bar.js";
+//#region node_modules/.pnpm/gauge@3.0.2/node_modules/gauge/base-theme.js
+var require_base_theme = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var spin = require_spin();
+	var progressBar = require_progress_bar();
+	module.exports = {
+		activityIndicator: function(values, theme, width) {
+			if (values.spun == null) return;
+			return spin(theme, values.spun);
+		},
+		progressbar: function(values, theme, width) {
+			if (values.completed == null) return;
+			return progressBar(theme, width, values.completed);
+		}
+	};
+}));
+//#endregion
+export default require_base_theme();
+export { require_base_theme };