@aigne/afs-git 1.11.0-beta → 1.11.0-beta.2

package/LICENSE.md

@@ -1,93 +1,26 @@
-Elastic License 2.0
+# Proprietary License
 
-URL: https://www.elastic.co/licensing/elastic-license
+Copyright (c) 2024-2025 ArcBlock, Inc. All Rights Reserved.
 
-## Acceptance
+This software and associated documentation files (the "Software") are proprietary
+and confidential. Unauthorized copying, modification, distribution, or use of
+this Software, via any medium, is strictly prohibited.
 
-By using the software, you agree to all of the terms and conditions below.
+The Software is provided for internal use only within ArcBlock, Inc. and its
+authorized affiliates.
 
-## Copyright License
+## No License Granted
 
-The licensor grants you a non-exclusive, royalty-free, worldwide,
-non-sublicensable, non-transferable license to use, copy, distribute, make
-available, and prepare derivative works of the software, in each case subject to
-the limitations and conditions below.
+No license, express or implied, is granted to any party for any purpose.
+All rights are reserved by ArcBlock, Inc.
 
-## Limitations
+## Public Artifact Distribution
 
-You may not provide the software to third parties as a hosted or managed
-service, where the service provides users with access to any substantial set of
-the features or functionality of the software.
+Portions of this Software may be released publicly under separate open-source
+licenses (such as MIT License) through designated public repositories. Such
+public releases are governed by their respective licenses and do not affect
+the proprietary nature of this repository.
 
-You may not move, change, disable, or circumvent the license key functionality
-in the software, and you may not remove or obscure any functionality in the
-software that is protected by the license key.
+## Contact
 
-You may not alter, remove, or obscure any licensing, copyright, or other notices
-of the licensor in the software. Any use of the licensor’s trademarks is subject
-to applicable law.
-
-## Patents
-
-The licensor grants you a license, under any patent claims the licensor can
-license, or becomes able to license, to make, have made, use, sell, offer for
-sale, import and have imported the software, in each case subject to the
-limitations and conditions in this license. This license does not cover any
-patent claims that you cause to be infringed by modifications or additions to
-the software. If you or your company make any written claim that the software
-infringes or contributes to infringement of any patent, your patent license for
-the software granted under these terms ends immediately. If your company makes
-such a claim, your patent license ends immediately for work on behalf of your
-company.
-
-## Notices
-
-You must ensure that anyone who gets a copy of any part of the software from you
-also gets a copy of these terms.
-
-If you modify the software, you must include in any modified copies of the
-software prominent notices stating that you have modified the software.
-
-## No Other Rights
-
-These terms do not imply any licenses other than those expressly granted in
-these terms.
-
-## Termination
-
-If you use the software in violation of these terms, such use is not licensed,
-and your licenses will automatically terminate. If the licensor provides you
-with a notice of your violation, and you cease all violation of this license no
-later than 30 days after you receive that notice, your licenses will be
-reinstated retroactively. However, if you violate these terms after such
-reinstatement, any additional violation of these terms will cause your licenses
-to terminate automatically and permanently.
-
-## No Liability
-
-*As far as the law allows, the software comes as is, without any warranty or
-condition, and the licensor will not be liable to you for any damages arising
-out of these terms or the use or nature of the software, under any kind of
-legal claim.*
-
-## Definitions
-
-The **licensor** is the entity offering these terms, and the **software** is the
-software the licensor makes available under these terms, including any portion
-of it.
-
-**you** refers to the individual or entity agreeing to these terms.
-
-**your company** is any legal entity, sole proprietorship, or other kind of
-organization that you work for, plus all organizations that have control over,
-are under the control of, or are under common control with that
-organization. **control** means ownership of substantially all the assets of an
-entity, or the power to direct its management and policies by vote, contract, or
-otherwise. Control can be direct or indirect.
-
-**your licenses** are all the licenses granted to you for the software under
-these terms.
-
-**use** means anything you do with the software requiring one of your licenses.
-
-**trademark** means trademarks, service marks, and similar rights.
+For licensing inquiries, contact: legal@arcblock.io

package/README.md

@@ -226,7 +226,3 @@ await aigne.invoke(agent, {
   message: "Review the authentication code in src/auth/",
 });
 ```
-
-## License
-
-This project is licensed under the [Elastic-2.0](../../LICENSE.md) License.

package/dist/index.cjs

@@ -9,11 +9,12 @@ let simple_git = require("simple-git");
 let zod = require("zod");
 
 //#region src/index.ts
-const execFileAsync = (0, node_util.promisify)(node_child_process.execFile);
 const LIST_MAX_LIMIT = 1e3;
+const execFileAsync = (0, node_util.promisify)(node_child_process.execFile);
 const afsGitOptionsSchema = (0, _aigne_afs_utils_zod.camelize)(zod.z.object({
 	name: (0, _aigne_afs_utils_zod.optionalize)(zod.z.string()),
-	repoPath: zod.z.string().describe("The path to the git repository"),
+	repoPath: (0, _aigne_afs_utils_zod.optionalize)(zod.z.string().describe("The path to the git repository")),
+	remoteUrl: (0, _aigne_afs_utils_zod.optionalize)(zod.z.string().describe("Remote repository URL (https or git protocol)")),
 	description: (0, _aigne_afs_utils_zod.optionalize)(zod.z.string().describe("A description of the repository")),
 	branches: (0, _aigne_afs_utils_zod.optionalize)(zod.z.array(zod.z.string()).describe("List of branches to expose")),
 	accessMode: (0, _aigne_afs_utils_zod.optionalize)(zod.z.enum(["readonly", "readwrite"]).describe("Access mode for this module")),
@@ -21,35 +22,107 @@ const afsGitOptionsSchema = (0, _aigne_afs_utils_zod.camelize)(zod.z.object({
 	commitAuthor: (0, _aigne_afs_utils_zod.optionalize)(zod.z.object({
 		name: zod.z.string(),
 		email: zod.z.string()
-	}))
-}));
+	})),
+	depth: (0, _aigne_afs_utils_zod.optionalize)(zod.z.number().describe("Clone depth for shallow clone")),
+	autoCleanup: (0, _aigne_afs_utils_zod.optionalize)(zod.z.boolean().describe("Automatically clean up cloned repository on cleanup()")),
+	cloneOptions: (0, _aigne_afs_utils_zod.optionalize)(zod.z.object({ auth: (0, _aigne_afs_utils_zod.optionalize)(zod.z.object({
+		username: (0, _aigne_afs_utils_zod.optionalize)(zod.z.string()),
+		password: (0, _aigne_afs_utils_zod.optionalize)(zod.z.string())
+	})) }))
+}).refine((data) => data.repoPath || data.remoteUrl, { message: "Either repoPath or remoteUrl must be provided" }));
 var AFSGit = class AFSGit {
 	static schema() {
 		return afsGitOptionsSchema;
 	}
 	static async load({ filepath, parsed }) {
-		return new AFSGit({
+		const instance = new AFSGit({
 			...await AFSGit.schema().parseAsync(parsed),
 			cwd: (0, node_path.dirname)(filepath)
 		});
+		await instance.ready();
+		return instance;
 	}
+	initPromise;
 	git;
 	tempBase;
 	worktrees = /* @__PURE__ */ new Map();
 	repoHash;
+	isAutoCloned = false;
+	clonedPath;
+	repoPath;
 	constructor(options) {
 		this.options = options;
 		(0, _aigne_afs_utils_zod.zodParse)(afsGitOptionsSchema, options);
 		let repoPath;
-		if ((0, node_path.isAbsolute)(options.repoPath)) repoPath = options.repoPath;
-		else repoPath = (0, node_path.join)(options.cwd || process.cwd(), options.repoPath);
-		this.options.repoPath = repoPath;
-		this.name = options.name || (0, node_path.basename)(repoPath) || "git";
+		let repoName;
+		if (options.repoPath) {
+			repoPath = (0, node_path.isAbsolute)(options.repoPath) ? options.repoPath : (0, node_path.join)(options.cwd || process.cwd(), options.repoPath);
+			repoName = (0, node_path.basename)(repoPath);
+		} else if (options.remoteUrl) {
+			const urlParts = options.remoteUrl.split("/");
+			repoName = urlParts[urlParts.length - 1]?.replace(/\.git$/, "") || "git";
+			const repoHash = (0, node_crypto.createHash)("md5").update(options.remoteUrl).digest("hex").substring(0, 8);
+			repoPath = (0, node_path.join)((0, node_os.tmpdir)(), `afs-git-remote-${repoHash}`);
+		} else throw new Error("Either repoPath or remoteUrl must be provided");
+		this.repoPath = repoPath;
+		this.name = options.name || repoName;
 		this.description = options.description;
 		this.accessMode = options.accessMode ?? "readonly";
-		this.git = (0, simple_git.simpleGit)(repoPath);
 		this.repoHash = (0, node_crypto.createHash)("md5").update(repoPath).digest("hex").substring(0, 8);
 		this.tempBase = (0, node_path.join)((0, node_os.tmpdir)(), `afs-git-${this.repoHash}`);
+		this.git = null;
+		this.initPromise = this.initialize();
+	}
+	/**
+	* Wait for async initialization to complete
+	*/
+	async ready() {
+		await this.initPromise;
+	}
+	/**
+	* Async initialization logic (runs in constructor)
+	* Handles cloning remote repositories if needed
+	*/
+	async initialize() {
+		const options = this.options;
+		if (options.remoteUrl) {
+			const targetPath = options.repoPath ? (0, node_path.isAbsolute)(options.repoPath) ? options.repoPath : (0, node_path.join)(options.cwd || process.cwd(), options.repoPath) : this.repoPath;
+			if (!options.repoPath) this.isAutoCloned = true;
+			if (!await (0, node_fs_promises.stat)(targetPath).then(() => true).catch(() => false)) {
+				const singleBranch = options.branches?.length === 1 ? options.branches[0] : void 0;
+				await AFSGit.cloneRepository(options.remoteUrl, targetPath, {
+					depth: options.depth ?? 1,
+					branch: singleBranch,
+					auth: options.cloneOptions?.auth
+				});
+			}
+			if (targetPath !== this.repoPath) {
+				this.repoPath = targetPath;
+				this.repoHash = (0, node_crypto.createHash)("md5").update(targetPath).digest("hex").substring(0, 8);
+				this.tempBase = (0, node_path.join)((0, node_os.tmpdir)(), `afs-git-${this.repoHash}`);
+			}
+			this.clonedPath = this.isAutoCloned ? targetPath : void 0;
+		}
+		this.git = (0, simple_git.simpleGit)(this.repoPath);
+	}
+	/**
+	* Clone a remote repository to local path
+	*/
+	static async cloneRepository(remoteUrl, targetPath, options = {}) {
+		const git = (0, simple_git.simpleGit)();
+		const cloneArgs = [];
+		if (options.depth) cloneArgs.push("--depth", options.depth.toString());
+		if (options.branch) cloneArgs.push("--branch", options.branch, "--single-branch");
+		let cloneUrl = remoteUrl;
+		if (options.auth?.username && options.auth?.password) {
+			if (remoteUrl.startsWith("https://")) {
+				const url = new URL(remoteUrl);
+				url.username = encodeURIComponent(options.auth.username);
+				url.password = encodeURIComponent(options.auth.password);
+				cloneUrl = url.toString();
+			}
+		}
+		await git.clone(cloneUrl, targetPath, cloneArgs);
 	}
 	name;
 	description;
@@ -136,8 +209,8 @@ var AFSGit = class AFSGit {
 	async ensureWorktree(branch) {
 		if (this.worktrees.has(branch)) return this.worktrees.get(branch);
 		if ((await this.git.revparse(["--abbrev-ref", "HEAD"])).trim() === branch) {
-			this.worktrees.set(branch, this.options.repoPath);
-			return this.options.repoPath;
+			this.worktrees.set(branch, this.repoPath);
+			return this.repoPath;
 		}
 		const worktreePath = (0, node_path.join)(this.tempBase, branch);
 		if (!await (0, node_fs_promises.stat)(worktreePath).then(() => true).catch(() => false)) {
@@ -242,18 +315,36 @@ var AFSGit = class AFSGit {
 		return `/${encodedBranch}/${filePath}`;
 	}
 	async list(path, options) {
+		await this.ready();
 		const { branch, filePath } = this.parsePath(path);
-		if (!branch) return { data: (await this.getBranches()).map((name) => {
-			const encodedPath = this.buildPath(name);
-			return {
-				id: encodedPath,
-				path: encodedPath,
-				metadata: { type: "directory" }
-			};
-		}) };
+		const maxDepth = options?.maxDepth ?? 1;
+		const limit = Math.min(options?.limit || LIST_MAX_LIMIT, LIST_MAX_LIMIT);
+		if (!branch) {
+			const branches = await this.getBranches();
+			const entries = [];
+			for (const name of branches) {
+				if (entries.length >= limit) break;
+				const encodedPath = this.buildPath(name);
+				entries.push({
+					id: encodedPath,
+					path: encodedPath,
+					metadata: { type: "directory" }
+				});
+				if (maxDepth > 1) {
+					const branchResult = await this.listWithGitLsTree(name, "", {
+						...options,
+						maxDepth: maxDepth - 1,
+						limit: limit - entries.length
+					});
+					entries.push(...branchResult.data);
+				}
+			}
+			return { data: entries };
+		}
 		return this.listWithGitLsTree(branch, filePath, options);
 	}
 	async read(path, _options) {
+		await this.ready();
 		const { branch, filePath } = this.parsePath(path);
 		if (!branch) return { data: {
 			id: "/",
@@ -322,6 +413,7 @@ var AFSGit = class AFSGit {
 		}
 	}
 	async write(path, entry, options) {
+		await this.ready();
 		const { branch, filePath } = this.parsePath(path);
 		if (!branch || !filePath) throw new Error("Cannot write to root or branch root");
 		const worktreePath = await this.ensureWorktree(branch);
@@ -366,6 +458,7 @@ var AFSGit = class AFSGit {
 		} };
 	}
 	async delete(path, options) {
+		await this.ready();
 		const { branch, filePath } = this.parsePath(path);
 		if (!branch || !filePath) throw new Error("Cannot delete root or branch root");
 		const worktreePath = await this.ensureWorktree(branch);
@@ -388,6 +481,7 @@ var AFSGit = class AFSGit {
 		return { message: `Successfully deleted: ${path}` };
 	}
 	async rename(oldPath, newPath, options) {
+		await this.ready();
 		const { branch: oldBranch, filePath: oldFilePath } = this.parsePath(oldPath);
 		const { branch: newBranch, filePath: newFilePath } = this.parsePath(newPath);
 		if (!oldBranch || !oldFilePath) throw new Error("Cannot rename from root or branch root");
@@ -418,6 +512,7 @@ var AFSGit = class AFSGit {
 		return { message: `Successfully renamed '${oldPath}' to '${newPath}'` };
 	}
 	async search(path, query, options) {
+		await this.ready();
 		const { branch, filePath } = this.parsePath(path);
 		if (!branch) return {
 			data: [],
@@ -476,9 +571,32 @@ var AFSGit = class AFSGit {
 		}
 	}
 	/**
+	* Fetch latest changes from remote
+	*/
+	async fetch() {
+		await this.ready();
+		await this.git.fetch();
+	}
+	/**
+	* Pull latest changes from remote for current branch
+	*/
+	async pull() {
+		await this.ready();
+		await this.git.pull();
+	}
+	/**
+	* Push local changes to remote
+	*/
+	async push(branch) {
+		await this.ready();
+		if (branch) await this.git.push("origin", branch);
+		else await this.git.push();
+	}
+	/**
 	* Cleanup all worktrees (useful when unmounting)
 	*/
 	async cleanup() {
+		await this.ready();
 		for (const [_branch, worktreePath] of this.worktrees) try {
 			await this.git.raw([
 				"worktree",
@@ -494,6 +612,13 @@ var AFSGit = class AFSGit {
 				force: true
 			});
 		} catch {}
+		const autoCleanup = this.options.autoCleanup ?? true;
+		if (this.isAutoCloned && autoCleanup && this.clonedPath) try {
+			await (0, node_fs_promises.rm)(this.clonedPath, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
 	}
 };
 

package/dist/index.d.cts

@@ -4,8 +4,28 @@ import { z } from "zod";
 //#region src/index.d.ts
 interface AFSGitOptions {
   name?: string;
-  repoPath: string;
+  /**
+       * Local path to git repository.
+       * If remoteUrl is provided and repoPath doesn't exist, will clone to this path.
+       * If remoteUrl is provided and repoPath is not specified, clones to temp directory.
+       */
+  repoPath?: string;
+  /**
+       * Remote repository URL (https or git protocol).
+       * If provided, will clone the repository if repoPath doesn't exist.
+       * Examples:
+       * - https://github.com/user/repo.git
+       * - git@github.com:user/repo.git
+       */
+  remoteUrl?: string;
   description?: string;
+  /**
+       * List of branches to expose/access.
+       * Also used for clone optimization when cloning from remoteUrl:
+       * - Single branch (e.g., ['main']): Uses --single-branch for faster clone
+       * - Multiple branches: Clones all branches, filters access to specified ones
+       * - Not specified: All branches are accessible
+       */
   branches?: string[];
   /**
        * Access mode for this module.
@@ -26,14 +46,38 @@ interface AFSGitOptions {
     name: string;
     email: string;
   };
+  /**
+       * Clone depth for shallow clone (only used when cloning from remoteUrl)
+       * @default 1
+       */
+  depth?: number;
+  /**
+       * Automatically clean up cloned repository on cleanup()
+       * Only applies when repository was auto-cloned to temp directory
+       * @default true
+       */
+  autoCleanup?: boolean;
+  /**
+       * Git clone options (only used when cloning from remoteUrl)
+       */
+  cloneOptions?: {
+    /**
+             * Authentication credentials for private repositories
+             */
+    auth?: {
+      username?: string;
+      password?: string;
+    };
+  };
 }
 declare class AFSGit implements AFSModule {
   options: AFSGitOptions & {
     cwd?: string;
   };
-  static schema(): z.ZodEffects<z.ZodObject<{
+  static schema(): z.ZodEffects<z.ZodEffects<z.ZodObject<{
     name: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
-    repoPath: z.ZodString;
+    repoPath: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    remoteUrl: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
     description: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
     branches: z.ZodType<string[] | undefined, z.ZodTypeDef, string[] | undefined>;
     accessMode: z.ZodType<"readonly" | "readwrite" | undefined, z.ZodTypeDef, "readonly" | "readwrite" | undefined>;
@@ -45,9 +89,23 @@ declare class AFSGit implements AFSModule {
       name: string;
       email: string;
     } | undefined>;
+    depth: z.ZodType<number | undefined, z.ZodTypeDef, number | undefined>;
+    autoCleanup: z.ZodType<boolean | undefined, z.ZodTypeDef, boolean | undefined>;
+    cloneOptions: z.ZodType<{
+      auth?: {
+        username?: string | undefined;
+        password?: string | undefined;
+      } | undefined;
+    } | undefined, z.ZodTypeDef, {
+      auth?: {
+        username?: string | undefined;
+        password?: string | undefined;
+      } | undefined;
+    } | undefined>;
   }, "strip", z.ZodTypeAny, {
-    repoPath: string;
     name?: string | undefined;
+    repoPath?: string | undefined;
+    remoteUrl?: string | undefined;
     description?: string | undefined;
     branches?: string[] | undefined;
     accessMode?: "readonly" | "readwrite" | undefined;
@@ -56,9 +114,18 @@ declare class AFSGit implements AFSModule {
       name: string;
       email: string;
     } | undefined;
+    depth?: number | undefined;
+    autoCleanup?: boolean | undefined;
+    cloneOptions?: {
+      auth?: {
+        username?: string | undefined;
+        password?: string | undefined;
+      } | undefined;
+    } | undefined;
   }, {
-    repoPath: string;
     name?: string | undefined;
+    repoPath?: string | undefined;
+    remoteUrl?: string | undefined;
     description?: string | undefined;
     branches?: string[] | undefined;
     accessMode?: "readonly" | "readwrite" | undefined;
@@ -67,9 +134,18 @@ declare class AFSGit implements AFSModule {
       name: string;
       email: string;
     } | undefined;
+    depth?: number | undefined;
+    autoCleanup?: boolean | undefined;
+    cloneOptions?: {
+      auth?: {
+        username?: string | undefined;
+        password?: string | undefined;
+      } | undefined;
+    } | undefined;
   }>, {
-    repoPath: string;
     name?: string | undefined;
+    repoPath?: string | undefined;
+    remoteUrl?: string | undefined;
     description?: string | undefined;
     branches?: string[] | undefined;
     accessMode?: "readonly" | "readwrite" | undefined;
@@ -78,18 +154,83 @@ declare class AFSGit implements AFSModule {
       name: string;
       email: string;
     } | undefined;
+    depth?: number | undefined;
+    autoCleanup?: boolean | undefined;
+    cloneOptions?: {
+      auth?: {
+        username?: string | undefined;
+        password?: string | undefined;
+      } | undefined;
+    } | undefined;
+  }, {
+    name?: string | undefined;
+    repoPath?: string | undefined;
+    remoteUrl?: string | undefined;
+    description?: string | undefined;
+    branches?: string[] | undefined;
+    accessMode?: "readonly" | "readwrite" | undefined;
+    autoCommit?: boolean | undefined;
+    commitAuthor?: {
+      name: string;
+      email: string;
+    } | undefined;
+    depth?: number | undefined;
+    autoCleanup?: boolean | undefined;
+    cloneOptions?: {
+      auth?: {
+        username?: string | undefined;
+        password?: string | undefined;
+      } | undefined;
+    } | undefined;
+  }>, {
+    name?: string | undefined;
+    repoPath?: string | undefined;
+    remoteUrl?: string | undefined;
+    description?: string | undefined;
+    branches?: string[] | undefined;
+    accessMode?: "readonly" | "readwrite" | undefined;
+    autoCommit?: boolean | undefined;
+    commitAuthor?: {
+      name: string;
+      email: string;
+    } | undefined;
+    depth?: number | undefined;
+    autoCleanup?: boolean | undefined;
+    cloneOptions?: {
+      auth?: {
+        username?: string | undefined;
+        password?: string | undefined;
+      } | undefined;
+    } | undefined;
   }, any>;
   static load({
     filepath,
     parsed
   }: AFSModuleLoadParams): Promise<AFSGit>;
+  private initPromise;
   private git;
   private tempBase;
   private worktrees;
   private repoHash;
+  private isAutoCloned;
+  private clonedPath?;
+  private repoPath;
   constructor(options: AFSGitOptions & {
     cwd?: string;
   });
+  /**
+       * Wait for async initialization to complete
+       */
+  ready(): Promise<void>;
+  /**
+       * Async initialization logic (runs in constructor)
+       * Handles cloning remote repositories if needed
+       */
+  private initialize;
+  /**
+       * Clone a remote repository to local path
+       */
+  private static cloneRepository;
   name: string;
   description?: string;
   accessMode: AFSAccessMode;
@@ -138,6 +279,18 @@ declare class AFSGit implements AFSModule {
     message?: string;
   }>;
   search(path: string, query: string, options?: AFSSearchOptions): Promise<AFSSearchResult>;
+  /**
+       * Fetch latest changes from remote
+       */
+  fetch(): Promise<void>;
+  /**
+       * Pull latest changes from remote for current branch
+       */
+  pull(): Promise<void>;
+  /**
+       * Push local changes to remote
+       */
+  push(branch?: string): Promise<void>;
   /**
        * Cleanup all worktrees (useful when unmounting)
        */

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;;;UAkCiB,aAAA;EAAA,IAAA;EAAA,QAAA;EAAA,WAAA;EAAA,QAAA;EAAA;AA+CjB;;;;;EA/CiB,UAAA,GAWF,aAAA;EAAA;AAoCf;;;EApCe,UAAA;EAAA;AAoCf;;EApCe,YAAA;IAAA,IAAA;IAAA,KAAA;EAAA;AAAA;AAAA,cAoCF,MAAA,YAAkB,SAAA;EAAA,OAAA,EAeD,aAAA;IAAA,GAAA;EAAA;EAAA,OAAA,OAAA,GAdf,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,SAAA;IAAA,IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAI2B,mBAAA,GAAmB,OAAA,CAAA,MAAA;EAAA,QAAA,GAAA;EAAA,QAAA,QAAA;EAAA,QAAA,SAAA;EAAA,QAAA,QAAA;EAAA,YAAA,OAAA,EAU/B,aAAA;IAAA,GAAA;EAAA;EAAA,IAAA;EAAA,WAAA;EAAA,UAAA,EAwBhB,aAAA;EAAA;;;;;;;;;EAAA,QAAA,SAAA;EAAA;;;EAAA,QAAA,WAAA;EAAA;;;EAAA,QAAA,YAAA;EAAA;;;EAAA,QAAA,WAAA;EAAA;;;EAAA,QAAA,cAAA;EAAA;;;EAAA,QAAA,iBAAA;EAAA;;;;;;EAAA,QAAA,SAAA;EAAA,KAAA,IAAA,UAAA,OAAA,GA8PuB,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAAA,KAAA,IAAA,UAAA,QAAA,GAwBxB,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAAA,MAAA,IAAA,UAAA,KAAA,EA+FpD,oBAAA,EAAA,OAAA,GACG,eAAA,GACT,OAAA,CAAQ,cAAA;EAAA,OAAA,IAAA,UAAA,OAAA,GA6E0B,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EAAA,OAAA,OAAA,UAAA,OAAA,UAAA,OAAA,GAmDpD,gBAAA,GACT,OAAA;IAAA,OAAA;EAAA;EAAA,OAAA,IAAA,UAAA,KAAA,UAAA,OAAA,GAwEiD,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EAAA;;;EAAA,QAAA,GAsF9D,OAAA;AAAA"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;;;UAiCiB,aAAA;EAAA,IAAA;EAAA;AA6GjB;;;;EA7GiB,QAAA;EAAA;AA6GjB;;;;;;EA7GiB,SAAA;EAAA,WAAA;EAAA;AA6GjB;;;;;;EA7GiB,QAAA;EAAA;AA6GjB;;;;;EA7GiB,UAAA,GA+BF,aAAA;EAAA;AA8Ef;;;EA9Ee,UAAA;EAAA;AA8Ef;;EA9Ee,YAAA;IAAA,IAAA;IAAA,KAAA;EAAA;EAAA;AA8Ef;;;EA9Ee,KAAA;EAAA;AA8Ef;;;;EA9Ee,WAAA;EAAA;AA8Ef;;EA9Ee,YAAA;IAAA;AA8Ef;;IA9Ee,IAAA;MAAA,QAAA;MAAA,QAAA;IAAA;EAAA;AAAA;AAAA,cA8EF,MAAA,YAAkB,SAAA;EAAA,OAAA,EAqBD,aAAA;IAAA,GAAA;EAAA;EAAA,OAAA,OAAA,GApBf,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,SAAA;IAAA,IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAI2B,mBAAA,GAAmB,OAAA,CAAA,MAAA;EAAA,QAAA,WAAA;EAAA,QAAA,GAAA;EAAA,QAAA,QAAA;EAAA,QAAA,SAAA;EAAA,QAAA,QAAA;EAAA,QAAA,YAAA;EAAA,QAAA,UAAA;EAAA,QAAA,QAAA;EAAA,YAAA,OAAA,EAgB/B,aAAA;IAAA,GAAA;EAAA;EAAA;;;EAAA,MAAA,GAgDb,OAAA;EAAA;;;;EAAA,QAAA,UAAA;EAAA;;;EAAA,eAAA,eAAA;EAAA,IAAA;EAAA,WAAA;EAAA,UAAA,EAgGH,aAAA;EAAA;;;;;;;;;EAAA,QAAA,SAAA;EAAA;;;EAAA,QAAA,WAAA;EAAA;;;EAAA,QAAA,YAAA;EAAA;;;EAAA,QAAA,WAAA;EAAA;;;EAAA,QAAA,cAAA;EAAA;;;EAAA,QAAA,iBAAA;EAAA;;;;;;EAAA,QAAA,SAAA;EAAA,KAAA,IAAA,UAAA,OAAA,GA8PuB,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAAA,KAAA,IAAA,UAAA,QAAA,GAyCxB,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAAA,MAAA,IAAA,UAAA,KAAA,EAgGpD,oBAAA,EAAA,OAAA,GACG,eAAA,GACT,OAAA,CAAQ,cAAA;EAAA,OAAA,IAAA,UAAA,OAAA,GA2E0B,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EAAA,OAAA,OAAA,UAAA,OAAA,UAAA,OAAA,GAoDpD,gBAAA,GACT,OAAA;IAAA,OAAA;EAAA;EAAA,OAAA,IAAA,UAAA,KAAA,UAAA,OAAA,GAyEiD,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EAAA;;;EAAA,MAAA,GAuFhE,OAAA;EAAA;;;EAAA,KAAA,GAQD,OAAA;EAAA;;;EAAA,KAAA,MAAA,YAQe,OAAA;EAAA;;;EAAA,QAAA,GAYZ,OAAA;AAAA"}