@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/copy/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_copy as require_copy$1 } from "./copy.js";
+import { require_copy_sync } from "./copy-sync.js";
+//#region node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/copy/index.js
+var require_copy = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const u = require_universalify().fromPromise;
+	module.exports = {
+		copy: u(require_copy$1()),
+		copySync: require_copy_sync()
+	};
+}));
+//#endregion
+export default require_copy();
+export { require_copy };

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

@@ -0,0 +1,43 @@
+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_remove } from "../remove/index.js";
+//#region node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/empty/index.js
+var require_empty = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const u = require_universalify().fromPromise;
+	const fs = require_fs();
+	const path = __require("path");
+	const mkdir = require_mkdirs();
+	const remove = require_remove();
+	const emptyDir = u(async function emptyDir(dir) {
+		let items;
+		try {
+			items = await fs.readdir(dir);
+		} catch {
+			return mkdir.mkdirs(dir);
+		}
+		return Promise.all(items.map((item) => remove.remove(path.join(dir, item))));
+	});
+	function emptyDirSync(dir) {
+		let items;
+		try {
+			items = fs.readdirSync(dir);
+		} catch {
+			return mkdir.mkdirsSync(dir);
+		}
+		items.forEach((item) => {
+			item = path.join(dir, item);
+			remove.removeSync(item);
+		});
+	}
+	module.exports = {
+		emptyDirSync,
+		emptydirSync: emptyDirSync,
+		emptyDir,
+		emptydir: emptyDir
+	};
+}));
+//#endregion
+export default require_empty();
+export { require_empty };

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

@@ -0,0 +1,53 @@
+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";
+//#region node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/ensure/file.js
+var require_file = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const u = require_universalify().fromPromise;
+	const path = __require("path");
+	const fs = require_fs();
+	const mkdir = require_mkdirs();
+	async function createFile(file) {
+		let stats;
+		try {
+			stats = await fs.stat(file);
+		} catch {}
+		if (stats && stats.isFile()) return;
+		const dir = path.dirname(file);
+		let dirStats = null;
+		try {
+			dirStats = await fs.stat(dir);
+		} catch (err) {
+			if (err.code === "ENOENT") {
+				await mkdir.mkdirs(dir);
+				await fs.writeFile(file, "");
+				return;
+			} else throw err;
+		}
+		if (dirStats.isDirectory()) await fs.writeFile(file, "");
+		else await fs.readdir(dir);
+	}
+	function createFileSync(file) {
+		let stats;
+		try {
+			stats = fs.statSync(file);
+		} catch {}
+		if (stats && stats.isFile()) return;
+		const dir = path.dirname(file);
+		try {
+			if (!fs.statSync(dir).isDirectory()) fs.readdirSync(dir);
+		} catch (err) {
+			if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
+			else throw err;
+		}
+		fs.writeFileSync(file, "");
+	}
+	module.exports = {
+		createFile: u(createFile),
+		createFileSync
+	};
+}));
+//#endregion
+export default require_file();
+export { require_file };

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

@@ -0,0 +1,27 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_file } from "./file.js";
+import { require_link } from "./link.js";
+import { require_symlink } from "./symlink.js";
+//#region node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/ensure/index.js
+var require_ensure = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { createFile, createFileSync } = require_file();
+	const { createLink, createLinkSync } = require_link();
+	const { createSymlink, createSymlinkSync } = require_symlink();
+	module.exports = {
+		createFile,
+		createFileSync,
+		ensureFile: createFile,
+		ensureFileSync: createFileSync,
+		createLink,
+		createLinkSync,
+		ensureLink: createLink,
+		ensureLinkSync: createLinkSync,
+		createSymlink,
+		createSymlinkSync,
+		ensureSymlink: createSymlink,
+		ensureSymlinkSync: createSymlinkSync
+	};
+}));
+//#endregion
+export default require_ensure();
+export { require_ensure };

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

@@ -0,0 +1,56 @@
+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";
+import { require_stat } from "../util/stat.js";
+//#region node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/ensure/link.js
+var require_link = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const u = require_universalify().fromPromise;
+	const path = __require("path");
+	const fs = require_fs();
+	const mkdir = require_mkdirs();
+	const { pathExists } = require_path_exists();
+	const { areIdentical } = require_stat();
+	async function createLink(srcpath, dstpath) {
+		let dstStat;
+		try {
+			dstStat = await fs.lstat(dstpath);
+		} catch {}
+		let srcStat;
+		try {
+			srcStat = await fs.lstat(srcpath);
+		} catch (err) {
+			err.message = err.message.replace("lstat", "ensureLink");
+			throw err;
+		}
+		if (dstStat && areIdentical(srcStat, dstStat)) return;
+		const dir = path.dirname(dstpath);
+		if (!await pathExists(dir)) await mkdir.mkdirs(dir);
+		await fs.link(srcpath, dstpath);
+	}
+	function createLinkSync(srcpath, dstpath) {
+		let dstStat;
+		try {
+			dstStat = fs.lstatSync(dstpath);
+		} catch {}
+		try {
+			const srcStat = fs.lstatSync(srcpath);
+			if (dstStat && areIdentical(srcStat, dstStat)) return;
+		} catch (err) {
+			err.message = err.message.replace("lstat", "ensureLink");
+			throw err;
+		}
+		const dir = path.dirname(dstpath);
+		if (fs.existsSync(dir)) return fs.linkSync(srcpath, dstpath);
+		mkdir.mkdirsSync(dir);
+		return fs.linkSync(srcpath, dstpath);
+	}
+	module.exports = {
+		createLink: u(createLink),
+		createLinkSync
+	};
+}));
+//#endregion
+export default require_link();
+export { require_link };

package/dist/node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/ensure/symlink-paths.js

@@ -0,0 +1,89 @@
+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_path_exists } from "../path-exists/index.js";
+//#region node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/ensure/symlink-paths.js
+var require_symlink_paths = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path = __require("path");
+	const fs = require_fs();
+	const { pathExists } = require_path_exists();
+	const u = require_universalify().fromPromise;
+	/**
+	* Function that returns two types of paths, one relative to symlink, and one
+	* relative to the current working directory. Checks if path is absolute or
+	* relative. If the path is relative, this function checks if the path is
+	* relative to symlink or relative to current working directory. This is an
+	* initiative to find a smarter `srcpath` to supply when building symlinks.
+	* This allows you to determine which path to use out of one of three possible
+	* types of source paths. The first is an absolute path. This is detected by
+	* `path.isAbsolute()`. When an absolute path is provided, it is checked to
+	* see if it exists. If it does it's used, if not an error is returned
+	* (callback)/ thrown (sync). The other two options for `srcpath` are a
+	* relative url. By default Node's `fs.symlink` works by creating a symlink
+	* using `dstpath` and expects the `srcpath` to be relative to the newly
+	* created symlink. If you provide a `srcpath` that does not exist on the file
+	* system it results in a broken symlink. To minimize this, the function
+	* checks to see if the 'relative to symlink' source file exists, and if it
+	* does it will use it. If it does not, it checks if there's a file that
+	* exists that is relative to the current working directory, if does its used.
+	* This preserves the expectations of the original fs.symlink spec and adds
+	* the ability to pass in `relative to current working direcotry` paths.
+	*/
+	async function symlinkPaths(srcpath, dstpath) {
+		if (path.isAbsolute(srcpath)) {
+			try {
+				await fs.lstat(srcpath);
+			} catch (err) {
+				err.message = err.message.replace("lstat", "ensureSymlink");
+				throw err;
+			}
+			return {
+				toCwd: srcpath,
+				toDst: srcpath
+			};
+		}
+		const dstdir = path.dirname(dstpath);
+		const relativeToDst = path.join(dstdir, srcpath);
+		if (await pathExists(relativeToDst)) return {
+			toCwd: relativeToDst,
+			toDst: srcpath
+		};
+		try {
+			await fs.lstat(srcpath);
+		} catch (err) {
+			err.message = err.message.replace("lstat", "ensureSymlink");
+			throw err;
+		}
+		return {
+			toCwd: srcpath,
+			toDst: path.relative(dstdir, srcpath)
+		};
+	}
+	function symlinkPathsSync(srcpath, dstpath) {
+		if (path.isAbsolute(srcpath)) {
+			if (!fs.existsSync(srcpath)) throw new Error("absolute srcpath does not exist");
+			return {
+				toCwd: srcpath,
+				toDst: srcpath
+			};
+		}
+		const dstdir = path.dirname(dstpath);
+		const relativeToDst = path.join(dstdir, srcpath);
+		if (fs.existsSync(relativeToDst)) return {
+			toCwd: relativeToDst,
+			toDst: srcpath
+		};
+		if (!fs.existsSync(srcpath)) throw new Error("relative srcpath does not exist");
+		return {
+			toCwd: srcpath,
+			toDst: path.relative(dstdir, srcpath)
+		};
+	}
+	module.exports = {
+		symlinkPaths: u(symlinkPaths),
+		symlinkPathsSync
+	};
+}));
+//#endregion
+export default require_symlink_paths();
+export { require_symlink_paths };

package/dist/node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/ensure/symlink-type.js

@@ -0,0 +1,35 @@
+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/ensure/symlink-type.js
+var require_symlink_type = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = require_fs();
+	const u = require_universalify().fromPromise;
+	async function symlinkType(srcpath, type) {
+		if (type) return type;
+		let stats;
+		try {
+			stats = await fs.lstat(srcpath);
+		} catch {
+			return "file";
+		}
+		return stats && stats.isDirectory() ? "dir" : "file";
+	}
+	function symlinkTypeSync(srcpath, type) {
+		if (type) return type;
+		let stats;
+		try {
+			stats = fs.lstatSync(srcpath);
+		} catch {
+			return "file";
+		}
+		return stats && stats.isDirectory() ? "dir" : "file";
+	}
+	module.exports = {
+		symlinkType: u(symlinkType),
+		symlinkTypeSync
+	};
+}));
+//#endregion
+export default require_symlink_type();
+export { require_symlink_type };

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

@@ -0,0 +1,81 @@
+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";
+import { require_stat } from "../util/stat.js";
+import { require_symlink_paths } from "./symlink-paths.js";
+import { require_symlink_type } from "./symlink-type.js";
+//#region node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/ensure/symlink.js
+var require_symlink = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const u = require_universalify().fromPromise;
+	const path = __require("path");
+	const fs = require_fs();
+	const { mkdirs, mkdirsSync } = require_mkdirs();
+	const { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
+	const { symlinkType, symlinkTypeSync } = require_symlink_type();
+	const { pathExists } = require_path_exists();
+	const { areIdentical } = require_stat();
+	async function createSymlink(srcpath, dstpath, type) {
+		let stats;
+		try {
+			stats = await fs.lstat(dstpath);
+		} catch {}
+		if (stats && stats.isSymbolicLink()) {
+			let srcStat;
+			if (path.isAbsolute(srcpath)) srcStat = await fs.stat(srcpath);
+			else {
+				const dstdir = path.dirname(dstpath);
+				const relativeToDst = path.join(dstdir, srcpath);
+				try {
+					srcStat = await fs.stat(relativeToDst);
+				} catch {
+					srcStat = await fs.stat(srcpath);
+				}
+			}
+			const dstStat = await fs.stat(dstpath);
+			if (areIdentical(srcStat, dstStat)) return;
+		}
+		const relative = await symlinkPaths(srcpath, dstpath);
+		srcpath = relative.toDst;
+		const toType = await symlinkType(relative.toCwd, type);
+		const dir = path.dirname(dstpath);
+		if (!await pathExists(dir)) await mkdirs(dir);
+		return fs.symlink(srcpath, dstpath, toType);
+	}
+	function createSymlinkSync(srcpath, dstpath, type) {
+		let stats;
+		try {
+			stats = fs.lstatSync(dstpath);
+		} catch {}
+		if (stats && stats.isSymbolicLink()) {
+			let srcStat;
+			if (path.isAbsolute(srcpath)) srcStat = fs.statSync(srcpath);
+			else {
+				const dstdir = path.dirname(dstpath);
+				const relativeToDst = path.join(dstdir, srcpath);
+				try {
+					srcStat = fs.statSync(relativeToDst);
+				} catch {
+					srcStat = fs.statSync(srcpath);
+				}
+			}
+			const dstStat = fs.statSync(dstpath);
+			if (areIdentical(srcStat, dstStat)) return;
+		}
+		const relative = symlinkPathsSync(srcpath, dstpath);
+		srcpath = relative.toDst;
+		type = symlinkTypeSync(relative.toCwd, type);
+		const dir = path.dirname(dstpath);
+		if (fs.existsSync(dir)) return fs.symlinkSync(srcpath, dstpath, type);
+		mkdirsSync(dir);
+		return fs.symlinkSync(srcpath, dstpath, type);
+	}
+	module.exports = {
+		createSymlink: u(createSymlink),
+		createSymlinkSync
+	};
+}));
+//#endregion
+export default require_symlink();
+export { require_symlink };

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

@@ -0,0 +1,113 @@
+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/fs/index.js
+var require_fs = /* @__PURE__ */ __commonJSMin(((exports) => {
+	const u = require_universalify().fromCallback;
+	const fs = require_graceful_fs();
+	const api = [
+		"access",
+		"appendFile",
+		"chmod",
+		"chown",
+		"close",
+		"copyFile",
+		"cp",
+		"fchmod",
+		"fchown",
+		"fdatasync",
+		"fstat",
+		"fsync",
+		"ftruncate",
+		"futimes",
+		"glob",
+		"lchmod",
+		"lchown",
+		"lutimes",
+		"link",
+		"lstat",
+		"mkdir",
+		"mkdtemp",
+		"open",
+		"opendir",
+		"readdir",
+		"readFile",
+		"readlink",
+		"realpath",
+		"rename",
+		"rm",
+		"rmdir",
+		"stat",
+		"statfs",
+		"symlink",
+		"truncate",
+		"unlink",
+		"utimes",
+		"writeFile"
+	].filter((key) => {
+		return typeof fs[key] === "function";
+	});
+	Object.assign(exports, fs);
+	api.forEach((method) => {
+		exports[method] = u(fs[method]);
+	});
+	exports.exists = function(filename, callback) {
+		if (typeof callback === "function") return fs.exists(filename, callback);
+		return new Promise((resolve) => {
+			return fs.exists(filename, resolve);
+		});
+	};
+	exports.read = function(fd, buffer, offset, length, position, callback) {
+		if (typeof callback === "function") return fs.read(fd, buffer, offset, length, position, callback);
+		return new Promise((resolve, reject) => {
+			fs.read(fd, buffer, offset, length, position, (err, bytesRead, buffer) => {
+				if (err) return reject(err);
+				resolve({
+					bytesRead,
+					buffer
+				});
+			});
+		});
+	};
+	exports.write = function(fd, buffer, ...args) {
+		if (typeof args[args.length - 1] === "function") return fs.write(fd, buffer, ...args);
+		return new Promise((resolve, reject) => {
+			fs.write(fd, buffer, ...args, (err, bytesWritten, buffer) => {
+				if (err) return reject(err);
+				resolve({
+					bytesWritten,
+					buffer
+				});
+			});
+		});
+	};
+	exports.readv = function(fd, buffers, ...args) {
+		if (typeof args[args.length - 1] === "function") return fs.readv(fd, buffers, ...args);
+		return new Promise((resolve, reject) => {
+			fs.readv(fd, buffers, ...args, (err, bytesRead, buffers) => {
+				if (err) return reject(err);
+				resolve({
+					bytesRead,
+					buffers
+				});
+			});
+		});
+	};
+	exports.writev = function(fd, buffers, ...args) {
+		if (typeof args[args.length - 1] === "function") return fs.writev(fd, buffers, ...args);
+		return new Promise((resolve, reject) => {
+			fs.writev(fd, buffers, ...args, (err, bytesWritten, buffers) => {
+				if (err) return reject(err);
+				resolve({
+					bytesWritten,
+					buffers
+				});
+			});
+		});
+	};
+	if (typeof fs.realpath.native === "function") exports.realpath.native = u(fs.realpath.native);
+	else process.emitWarning("fs.realpath.native is not a function. Is fs being monkey-patched?", "Warning", "fs-extra-WARN0003");
+}));
+//#endregion
+export default require_fs();
+export { require_fs };

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

@@ -0,0 +1,29 @@
+import { __commonJSMin } 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_copy } from "./copy/index.js";
+import { require_remove } from "./remove/index.js";
+import { require_empty } from "./empty/index.js";
+import { require_ensure } from "./ensure/index.js";
+import { require_output_file } from "./output-file/index.js";
+import { require_json } from "./json/index.js";
+import { require_move } from "./move/index.js";
+//#region node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/index.js
+var require_lib = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		...require_fs(),
+		...require_copy(),
+		...require_empty(),
+		...require_ensure(),
+		...require_json(),
+		...require_mkdirs(),
+		...require_move(),
+		...require_output_file(),
+		...require_path_exists(),
+		...require_remove()
+	};
+}));
+//#endregion
+export default require_lib();
+export { require_lib };

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

@@ -0,0 +1,22 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_universalify } from "../../../../../universalify@2.0.1/node_modules/universalify/index.js";
+import { require_jsonfile } from "./jsonfile.js";
+import { require_output_json } from "./output-json.js";
+import { require_output_json_sync } from "./output-json-sync.js";
+//#region node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/json/index.js
+var require_json = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const u = require_universalify().fromPromise;
+	const jsonFile = require_jsonfile();
+	jsonFile.outputJson = u(require_output_json());
+	jsonFile.outputJsonSync = require_output_json_sync();
+	jsonFile.outputJSON = jsonFile.outputJson;
+	jsonFile.outputJSONSync = jsonFile.outputJsonSync;
+	jsonFile.writeJSON = jsonFile.writeJson;
+	jsonFile.writeJSONSync = jsonFile.writeJsonSync;
+	jsonFile.readJSON = jsonFile.readJson;
+	jsonFile.readJSONSync = jsonFile.readJsonSync;
+	module.exports = jsonFile;
+}));
+//#endregion
+export default require_json();
+export { require_json };

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

@@ -0,0 +1,15 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_jsonfile as require_jsonfile$1 } from "../../../../../jsonfile@6.2.0/node_modules/jsonfile/index.js";
+//#region node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/json/jsonfile.js
+var require_jsonfile = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const jsonFile = require_jsonfile$1();
+	module.exports = {
+		readJson: jsonFile.readFile,
+		readJsonSync: jsonFile.readFileSync,
+		writeJson: jsonFile.writeFile,
+		writeJsonSync: jsonFile.writeFileSync
+	};
+}));
+//#endregion
+export default require_jsonfile();
+export { require_jsonfile };

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

@@ -0,0 +1,15 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_utils } from "../../../../../jsonfile@6.2.0/node_modules/jsonfile/utils.js";
+import { require_output_file } from "../output-file/index.js";
+//#region node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/json/output-json-sync.js
+var require_output_json_sync = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { stringify } = require_utils();
+	const { outputFileSync } = require_output_file();
+	function outputJsonSync(file, data, options) {
+		outputFileSync(file, stringify(data, options), options);
+	}
+	module.exports = outputJsonSync;
+}));
+//#endregion
+export default require_output_json_sync();
+export { require_output_json_sync };

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

@@ -0,0 +1,15 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_utils } from "../../../../../jsonfile@6.2.0/node_modules/jsonfile/utils.js";
+import { require_output_file } from "../output-file/index.js";
+//#region node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/json/output-json.js
+var require_output_json = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { stringify } = require_utils();
+	const { outputFile } = require_output_file();
+	async function outputJson(file, data, options = {}) {
+		await outputFile(file, stringify(data, options), options);
+	}
+	module.exports = outputJson;
+}));
+//#endregion
+export default require_output_json();
+export { require_output_json };

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

@@ -0,0 +1,20 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_universalify } from "../../../../../universalify@2.0.1/node_modules/universalify/index.js";
+import { require_make_dir } from "./make-dir.js";
+//#region node_modules/.pnpm/fs-extra@11.3.4/node_modules/fs-extra/lib/mkdirs/index.js
+var require_mkdirs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const u = require_universalify().fromPromise;
+	const { makeDir: _makeDir, makeDirSync } = require_make_dir();
+	const makeDir = u(_makeDir);
+	module.exports = {
+		mkdirs: makeDir,
+		mkdirsSync: makeDirSync,
+		mkdirp: makeDir,
+		mkdirpSync: makeDirSync,
+		ensureDir: makeDir,
+		ensureDirSync: makeDirSync
+	};
+}));
+//#endregion
+export default require_mkdirs();
+export { require_mkdirs };