@aigne/afs-json 1.1.0 → 1.11.0-beta

package/README.md

@@ -33,7 +33,7 @@ afs.mount(
   new AFSJSON({
     name: "config",
     jsonPath: "./config.json",
-  })
+  }),
 );
 
 // Or mount a YAML file
@@ -41,7 +41,7 @@ afs.mount(
   new AFSJSON({
     name: "app-config",
     jsonPath: "./config.yaml",
-  })
+  }),
 );
 
 // Read the entire JSON/YAML
@@ -86,6 +86,7 @@ version: "1.0.0"
 ```
 
 This YAML structure becomes:
+
 ```
 /config/                              # Root object
 /config/database/                     # Nested object (directory)
@@ -99,6 +100,7 @@ This YAML structure becomes:
 ```
 
 **Format Detection and Persistence:**
+
 - Format is detected automatically from file extension (.json, .yaml, .yml)
 - When writing to a YAML file, changes are saved in YAML format
 - When writing to a JSON file, changes are saved in JSON format
@@ -124,6 +126,7 @@ This YAML structure becomes:
 ```
 
 This structure becomes:
+
 ```
 /config/                    # Root object
 /config/database/           # Nested object (directory)
@@ -161,6 +164,7 @@ This structure becomes:
 ```
 
 This structure becomes:
+
 ```
 /users/                     # Array (directory)
 /users/0/                   # First user object (directory)
@@ -181,23 +185,23 @@ This structure becomes:
 
 ```typescript
 // Read a property from an array object
-const { data } = await afs.read('/modules/users/0/name');
+const { data } = await afs.read("/modules/users/0/name");
 console.log(data?.content); // "Alice"
 
 // Update a nested property in an array object
-await afs.write('/modules/users/0/profile/age', { content: 31 });
+await afs.write("/modules/users/0/profile/age", { content: 31 });
 
 // Add a new property to an array object
-await afs.write('/modules/users/0/active', { content: true });
+await afs.write("/modules/users/0/active", { content: true });
 
 // List all properties of an array object
-const result = await afs.list('/modules/users/0');
+const result = await afs.list("/modules/users/0");
 
 // Search within array objects
-const results = await afs.search('/modules/users', 'Beijing');
+const results = await afs.search("/modules/users", "Beijing");
 
 // Delete from an array (shifts subsequent indices)
-await afs.delete('/modules/users/1', { recursive: true });
+await afs.delete("/modules/users/1", { recursive: true });
 // Now users/2 becomes users/1
 ```
 
@@ -205,15 +209,16 @@ await afs.delete('/modules/users/1', { recursive: true });
 
 ```typescript
 interface AFSJSONOptions {
-  name?: string;              // Module name (default: basename of jsonPath without extension)
-  jsonPath: string;           // Path to JSON or YAML file
-  description?: string;       // Module description
-  accessMode?: "readonly" | "readwrite";  // Access mode (default: "readwrite")
-  agentSkills?: boolean;      // Enable agent skill scanning
+  name?: string; // Module name (default: basename of jsonPath without extension)
+  jsonPath: string; // Path to JSON or YAML file
+  description?: string; // Module description
+  accessMode?: "readonly" | "readwrite"; // Access mode (default: "readwrite")
+  agentSkills?: boolean; // Enable agent skill scanning
 }
 ```
 
 **Note:** File format is automatically detected from the `jsonPath` extension:
+
 - `.json` files are saved as JSON
 - `.yaml` or `.yml` files are saved as YAML
 
@@ -225,7 +230,7 @@ afs.mount(
     name: "readonly-config",
     jsonPath: "./config.json",
     accessMode: "readonly",
-  })
+  }),
 );
 
 // Reading is allowed
@@ -244,7 +249,7 @@ afs.mount(
     name: "settings",
     jsonPath: "./settings.json",
     accessMode: "readwrite",
-  })
+  }),
 );
 
 // Or mount a YAML file
@@ -253,7 +258,7 @@ afs.mount(
     name: "config",
     jsonPath: "./config.yaml",
     accessMode: "readwrite",
-  })
+  }),
 );
 
 // Update a value

package/dist/index.cjs

@@ -0,0 +1,366 @@
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+let _aigne_afs_utils_zod = require("@aigne/afs/utils/zod");
+let yaml = require("yaml");
+let zod = require("zod");
+
+//#region src/index.ts
+const LIST_MAX_LIMIT = 1e3;
+const afsJSONOptionsSchema = (0, _aigne_afs_utils_zod.camelize)(zod.z.object({
+	name: (0, _aigne_afs_utils_zod.optionalize)(zod.z.string()),
+	jsonPath: zod.z.string().describe("The path to the JSON/YAML file to mount"),
+	description: (0, _aigne_afs_utils_zod.optionalize)(zod.z.string().describe("A description of the JSON module")),
+	accessMode: (0, _aigne_afs_utils_zod.optionalize)(zod.z.enum(["readonly", "readwrite"]).describe("Access mode for this module")),
+	agentSkills: (0, _aigne_afs_utils_zod.optionalize)(zod.z.boolean().describe("Enable automatic agent skill scanning for this module"))
+}));
+/**
+* AFS module for mounting JSON/YAML files as virtual file systems.
+*
+* JSON/YAML objects are treated as directories, and properties/array items as files.
+* Supports nested structures and path-based access to data values.
+*/
+var AFSJSON = class AFSJSON {
+	static schema() {
+		return afsJSONOptionsSchema;
+	}
+	static async load({ filepath, parsed }) {
+		return new AFSJSON({
+			...await AFSJSON.schema().parseAsync(parsed),
+			cwd: (0, node_path.dirname)(filepath)
+		});
+	}
+	jsonData = null;
+	fileStats = {};
+	fileFormat = "json";
+	constructor(options) {
+		this.options = options;
+		(0, _aigne_afs_utils_zod.zodParse)(afsJSONOptionsSchema, options);
+		let jsonPath;
+		jsonPath = options.jsonPath.replaceAll("${CWD}", process.cwd());
+		if (jsonPath.startsWith("~/")) jsonPath = (0, node_path.join)(process.env.HOME || "", jsonPath.slice(2));
+		if (!(0, node_path.isAbsolute)(jsonPath)) jsonPath = (0, node_path.join)(options.cwd || process.cwd(), jsonPath);
+		const ext = (0, node_path.extname)(jsonPath).toLowerCase();
+		this.fileFormat = ext === ".yaml" || ext === ".yml" ? "yaml" : "json";
+		const extensions = [
+			".json",
+			".yaml",
+			".yml"
+		];
+		let name = (0, node_path.basename)(jsonPath);
+		for (const e of extensions) if (name.endsWith(e)) {
+			name = name.slice(0, -e.length);
+			break;
+		}
+		this.name = options.name || name || "json";
+		this.description = options.description;
+		this.agentSkills = options.agentSkills;
+		this.accessMode = options.accessMode ?? (options.agentSkills ? "readonly" : "readwrite");
+		this.options.jsonPath = jsonPath;
+	}
+	name;
+	description;
+	accessMode;
+	agentSkills;
+	/**
+	* Load JSON/YAML data from file. Called lazily on first access.
+	* Uses YAML parser which can handle both JSON and YAML formats.
+	*/
+	async ensureLoaded() {
+		if (this.jsonData !== null) return;
+		try {
+			const stats = await (0, node_fs_promises.stat)(this.options.jsonPath);
+			this.fileStats = {
+				birthtime: stats.birthtime,
+				mtime: stats.mtime
+			};
+			this.jsonData = (0, yaml.parse)(await (0, node_fs_promises.readFile)(this.options.jsonPath, "utf8"));
+		} catch (error) {
+			if (error.code === "ENOENT") this.jsonData = {};
+			else throw error;
+		}
+	}
+	/**
+	* Save JSON/YAML data back to file. Only called in readwrite mode.
+	*/
+	async saveToFile() {
+		let content;
+		if (this.fileFormat === "yaml") content = (0, yaml.stringify)(this.jsonData);
+		else content = JSON.stringify(this.jsonData, null, 2);
+		await (0, node_fs_promises.writeFile)(this.options.jsonPath, content, "utf8");
+		const stats = await (0, node_fs_promises.stat)(this.options.jsonPath);
+		this.fileStats = {
+			birthtime: this.fileStats.birthtime || stats.birthtime,
+			mtime: stats.mtime
+		};
+	}
+	/**
+	* Normalize path to ensure consistent format
+	*/
+	normalizePath(path) {
+		let normalized = path.startsWith("/") ? path : `/${path}`;
+		if (normalized.length > 1 && normalized.endsWith("/")) normalized = normalized.slice(0, -1);
+		return normalized;
+	}
+	/**
+	* Get path segments from normalized path
+	*/
+	getPathSegments(path) {
+		const normalized = this.normalizePath(path);
+		if (normalized === "/") return [];
+		return normalized.slice(1).split("/");
+	}
+	/**
+	* Navigate to a value in the JSON structure using path segments
+	*/
+	getValueAtPath(data, segments) {
+		let current = data;
+		for (const segment of segments) {
+			if (current == null) return void 0;
+			if (Array.isArray(current)) {
+				const index = Number.parseInt(segment, 10);
+				if (Number.isNaN(index) || index < 0 || index >= current.length) return;
+				current = current[index];
+			} else if (typeof current === "object") current = current[segment];
+			else return;
+		}
+		return current;
+	}
+	/**
+	* Set a value in the JSON structure at the given path
+	*/
+	setValueAtPath(data, segments, value) {
+		if (segments.length === 0) throw new Error("Cannot set value at root path");
+		let current = data;
+		for (let i = 0; i < segments.length - 1; i++) {
+			const segment = segments[i];
+			const nextSegment = segments[i + 1];
+			if (Array.isArray(current)) {
+				const index = Number.parseInt(segment, 10);
+				if (Number.isNaN(index) || index < 0) throw new Error(`Invalid array index: ${segment}`);
+				while (current.length <= index) current.push(null);
+				if (current[index] == null) current[index] = !Number.isNaN(Number.parseInt(nextSegment, 10)) ? [] : {};
+				current = current[index];
+			} else if (typeof current === "object") {
+				if (current[segment] == null) current[segment] = !Number.isNaN(Number.parseInt(nextSegment, 10)) ? [] : {};
+				current = current[segment];
+			} else throw new Error(`Cannot set property on non-object at ${segments.slice(0, i + 1).join("/")}`);
+		}
+		const lastSegment = segments[segments.length - 1];
+		if (Array.isArray(current)) {
+			const index = Number.parseInt(lastSegment, 10);
+			if (Number.isNaN(index) || index < 0) throw new Error(`Invalid array index: ${lastSegment}`);
+			current[index] = value;
+		} else if (typeof current === "object") current[lastSegment] = value;
+		else throw new Error("Cannot set property on non-object");
+	}
+	/**
+	* Delete a value from the JSON structure at the given path
+	*/
+	deleteValueAtPath(data, segments) {
+		if (segments.length === 0) throw new Error("Cannot delete root path");
+		let current = data;
+		for (let i = 0; i < segments.length - 1; i++) {
+			const segment = segments[i];
+			if (Array.isArray(current)) {
+				const index = Number.parseInt(segment, 10);
+				if (Number.isNaN(index) || index < 0 || index >= current.length) return false;
+				current = current[index];
+			} else if (typeof current === "object") {
+				if (!(segment in current)) return false;
+				current = current[segment];
+			} else return false;
+		}
+		const lastSegment = segments[segments.length - 1];
+		if (Array.isArray(current)) {
+			const index = Number.parseInt(lastSegment, 10);
+			if (Number.isNaN(index) || index < 0 || index >= current.length) return false;
+			current.splice(index, 1);
+			return true;
+		}
+		if (typeof current === "object") {
+			if (!(lastSegment in current)) return false;
+			delete current[lastSegment];
+			return true;
+		}
+		return false;
+	}
+	/**
+	* Check if a value is a "directory" (object or array with children)
+	*/
+	isDirectory(value) {
+		if (Array.isArray(value)) return true;
+		if (typeof value === "object" && value !== null) return true;
+		return false;
+	}
+	/**
+	* Get children of a directory value
+	*/
+	getChildren(value) {
+		if (Array.isArray(value)) return value.map((item, index) => ({
+			key: String(index),
+			value: item
+		}));
+		if (typeof value === "object" && value !== null) return Object.entries(value).map(([key, val]) => ({
+			key,
+			value: val
+		}));
+		return [];
+	}
+	/**
+	* Convert a JSON value to an AFSEntry
+	*/
+	valueToAFSEntry(path, value) {
+		const isDir = this.isDirectory(value);
+		const children = isDir ? this.getChildren(value) : [];
+		return {
+			id: path,
+			path,
+			content: isDir ? void 0 : value,
+			createdAt: this.fileStats.birthtime,
+			updatedAt: this.fileStats.mtime,
+			metadata: {
+				type: isDir ? "directory" : "file",
+				childrenCount: isDir ? children.length : void 0
+			}
+		};
+	}
+	async list(path, options) {
+		await this.ensureLoaded();
+		const normalizedPath = this.normalizePath(path);
+		const limit = Math.min(options?.limit || LIST_MAX_LIMIT, LIST_MAX_LIMIT);
+		const maxChildren = typeof options?.maxChildren === "number" ? options.maxChildren : Number.MAX_SAFE_INTEGER;
+		const maxDepth = options?.maxDepth ?? 1;
+		const segments = this.getPathSegments(normalizedPath);
+		const value = this.getValueAtPath(this.jsonData, segments);
+		if (value === void 0) throw new Error(`Path not found: ${normalizedPath}`);
+		const entries = [];
+		const queue = [{
+			path: normalizedPath,
+			value,
+			depth: 0
+		}];
+		while (queue.length > 0) {
+			const item = queue.shift();
+			if (!item) break;
+			const { path: itemPath, value: itemValue, depth } = item;
+			const entry = this.valueToAFSEntry(itemPath, itemValue);
+			entries.push(entry);
+			if (entries.length >= limit) {
+				if (entry.metadata) entry.metadata.childrenTruncated = true;
+				break;
+			}
+			if (this.isDirectory(itemValue) && depth < maxDepth) {
+				const children = this.getChildren(itemValue);
+				const childrenToProcess = children.length > maxChildren ? children.slice(0, maxChildren) : children;
+				if (childrenToProcess.length < children.length && entry.metadata) entry.metadata.childrenTruncated = true;
+				for (const child of childrenToProcess) {
+					const childPath = itemPath === "/" ? `/${child.key}` : `${itemPath}/${child.key}`;
+					queue.push({
+						path: childPath,
+						value: child.value,
+						depth: depth + 1
+					});
+				}
+			}
+		}
+		return { data: entries };
+	}
+	async read(path, _options) {
+		await this.ensureLoaded();
+		const normalizedPath = this.normalizePath(path);
+		const segments = this.getPathSegments(normalizedPath);
+		const value = this.getValueAtPath(this.jsonData, segments);
+		if (value === void 0) return {
+			data: void 0,
+			message: `Path not found: ${normalizedPath}`
+		};
+		return { data: this.valueToAFSEntry(normalizedPath, value) };
+	}
+	async write(path, entry, _options) {
+		await this.ensureLoaded();
+		const normalizedPath = this.normalizePath(path);
+		const segments = this.getPathSegments(normalizedPath);
+		this.setValueAtPath(this.jsonData, segments, entry.content);
+		await this.saveToFile();
+		const newValue = this.getValueAtPath(this.jsonData, segments);
+		const isDir = this.isDirectory(newValue);
+		const children = isDir ? this.getChildren(newValue) : [];
+		return { data: {
+			id: normalizedPath,
+			path: normalizedPath,
+			content: entry.content,
+			summary: entry.summary,
+			description: entry.description,
+			createdAt: this.fileStats.birthtime,
+			updatedAt: this.fileStats.mtime,
+			metadata: {
+				...entry.metadata,
+				type: isDir ? "directory" : "file",
+				childrenCount: isDir ? children.length : void 0
+			},
+			userId: entry.userId,
+			sessionId: entry.sessionId,
+			linkTo: entry.linkTo
+		} };
+	}
+	async delete(path, options) {
+		await this.ensureLoaded();
+		const normalizedPath = this.normalizePath(path);
+		const segments = this.getPathSegments(normalizedPath);
+		const value = this.getValueAtPath(this.jsonData, segments);
+		if (value === void 0) throw new Error(`Path not found: ${normalizedPath}`);
+		if (this.isDirectory(value) && this.getChildren(value).length > 0 && !options?.recursive) throw new Error(`Cannot delete directory '${normalizedPath}' without recursive option. Set recursive: true to delete directories.`);
+		this.deleteValueAtPath(this.jsonData, segments);
+		await this.saveToFile();
+		return { message: `Successfully deleted: ${normalizedPath}` };
+	}
+	async rename(oldPath, newPath, options) {
+		await this.ensureLoaded();
+		const normalizedOldPath = this.normalizePath(oldPath);
+		const normalizedNewPath = this.normalizePath(newPath);
+		const oldSegments = this.getPathSegments(normalizedOldPath);
+		const newSegments = this.getPathSegments(normalizedNewPath);
+		const oldValue = this.getValueAtPath(this.jsonData, oldSegments);
+		if (oldValue === void 0) throw new Error(`Source path not found: ${normalizedOldPath}`);
+		if (this.getValueAtPath(this.jsonData, newSegments) !== void 0 && !options?.overwrite) throw new Error(`Destination '${normalizedNewPath}' already exists. Set overwrite: true to replace it.`);
+		this.setValueAtPath(this.jsonData, newSegments, oldValue);
+		this.deleteValueAtPath(this.jsonData, oldSegments);
+		await this.saveToFile();
+		return { message: `Successfully renamed '${normalizedOldPath}' to '${normalizedNewPath}'` };
+	}
+	async search(path, query, options) {
+		await this.ensureLoaded();
+		const normalizedPath = this.normalizePath(path);
+		const limit = Math.min(options?.limit || LIST_MAX_LIMIT, LIST_MAX_LIMIT);
+		const caseSensitive = options?.caseSensitive ?? false;
+		const segments = this.getPathSegments(normalizedPath);
+		const rootValue = this.getValueAtPath(this.jsonData, segments);
+		if (rootValue === void 0) throw new Error(`Path not found: ${normalizedPath}`);
+		const entries = [];
+		const searchQuery = caseSensitive ? query : query.toLowerCase();
+		const searchInValue = (valuePath, value) => {
+			if (entries.length >= limit) return;
+			let matched = false;
+			if (!this.isDirectory(value)) {
+				const valueStr = typeof value === "string" ? value : JSON.stringify(value);
+				if ((caseSensitive ? valueStr : valueStr.toLowerCase()).includes(searchQuery)) matched = true;
+			}
+			if (matched) entries.push(this.valueToAFSEntry(valuePath, value));
+			if (this.isDirectory(value)) {
+				const children = this.getChildren(value);
+				for (const child of children) {
+					if (entries.length >= limit) break;
+					searchInValue(valuePath === "/" ? `/${child.key}` : `${valuePath}/${child.key}`, child.value);
+				}
+			}
+		};
+		searchInValue(normalizedPath, rootValue);
+		return {
+			data: entries,
+			message: entries.length >= limit ? `Results truncated to limit ${limit}` : void 0
+		};
+	}
+};
+
+//#endregion
+exports.AFSJSON = AFSJSON;

package/dist/index.d.cts

@@ -0,0 +1,122 @@
+import { AFSAccessMode, AFSDeleteOptions, AFSDeleteResult, AFSListOptions, AFSListResult, AFSModule, AFSModuleLoadParams, AFSReadOptions, AFSReadResult, AFSRenameOptions, AFSRenameResult, AFSSearchOptions, AFSSearchResult, AFSWriteEntryPayload, AFSWriteOptions, AFSWriteResult } from "@aigne/afs";
+import { z } from "zod";
+
+//#region src/index.d.ts
+interface AFSJSONOptions {
+  name?: string;
+  jsonPath: string;
+  description?: string;
+  /**
+       * Access mode for this module.
+       * - "readonly": Only read operations are allowed
+       * - "readwrite": All operations are allowed (default, unless agentSkills is enabled)
+       * @default "readwrite" (or "readonly" when agentSkills is true)
+       */
+  accessMode?: AFSAccessMode;
+  /**
+       * Enable automatic agent skill scanning for this module.
+       * When enabled, defaults accessMode to "readonly" if not explicitly set.
+       * @default false
+       */
+  agentSkills?: boolean;
+}
+/**
+ * AFS module for mounting JSON/YAML files as virtual file systems.
+ *
+ * JSON/YAML objects are treated as directories, and properties/array items as files.
+ * Supports nested structures and path-based access to data values.
+ */
+declare class AFSJSON implements AFSModule {
+  options: AFSJSONOptions & {
+    cwd?: string;
+  };
+  static schema(): z.ZodEffects<z.ZodObject<{
+    name: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    jsonPath: z.ZodString;
+    description: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    accessMode: z.ZodType<"readonly" | "readwrite" | undefined, z.ZodTypeDef, "readonly" | "readwrite" | undefined>;
+    agentSkills: z.ZodType<boolean | undefined, z.ZodTypeDef, boolean | undefined>;
+  }, "strip", z.ZodTypeAny, {
+    jsonPath: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    accessMode?: "readonly" | "readwrite" | undefined;
+    agentSkills?: boolean | undefined;
+  }, {
+    jsonPath: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    accessMode?: "readonly" | "readwrite" | undefined;
+    agentSkills?: boolean | undefined;
+  }>, {
+    jsonPath: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    accessMode?: "readonly" | "readwrite" | undefined;
+    agentSkills?: boolean | undefined;
+  }, any>;
+  static load({
+    filepath,
+    parsed
+  }: AFSModuleLoadParams): Promise<AFSJSON>;
+  private jsonData;
+  private fileStats;
+  private fileFormat;
+  constructor(options: AFSJSONOptions & {
+    cwd?: string;
+  });
+  name: string;
+  description?: string;
+  accessMode: AFSAccessMode;
+  agentSkills?: boolean;
+  /**
+       * Load JSON/YAML data from file. Called lazily on first access.
+       * Uses YAML parser which can handle both JSON and YAML formats.
+       */
+  private ensureLoaded;
+  /**
+       * Save JSON/YAML data back to file. Only called in readwrite mode.
+       */
+  private saveToFile;
+  /**
+       * Normalize path to ensure consistent format
+       */
+  private normalizePath;
+  /**
+       * Get path segments from normalized path
+       */
+  private getPathSegments;
+  /**
+       * Navigate to a value in the JSON structure using path segments
+       */
+  private getValueAtPath;
+  /**
+       * Set a value in the JSON structure at the given path
+       */
+  private setValueAtPath;
+  /**
+       * Delete a value from the JSON structure at the given path
+       */
+  private deleteValueAtPath;
+  /**
+       * Check if a value is a "directory" (object or array with children)
+       */
+  private isDirectory;
+  /**
+       * Get children of a directory value
+       */
+  private getChildren;
+  /**
+       * Convert a JSON value to an AFSEntry
+       */
+  private valueToAFSEntry;
+  list(path: string, options?: AFSListOptions): Promise<AFSListResult>;
+  read(path: string, _options?: AFSReadOptions): Promise<AFSReadResult>;
+  write(path: string, entry: AFSWriteEntryPayload, _options?: AFSWriteOptions): Promise<AFSWriteResult>;
+  delete(path: string, options?: AFSDeleteOptions): Promise<AFSDeleteResult>;
+  rename(oldPath: string, newPath: string, options?: AFSRenameOptions): Promise<AFSRenameResult>;
+  search(path: string, query: string, options?: AFSSearchOptions): Promise<AFSSearchResult>;
+}
+//#endregion
+export { AFSJSON, AFSJSONOptions };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;;;UA4BiB,cAAA;EAAA,IAAA;EAAA,QAAA;EAAA,WAAA;EAAA;AAuCjB;;;;;EAvCiB,UAAA,GAUF,aAAA;EAAA;AA6Bf;;;;EA7Be,WAAA;AAAA;AAAA;AA6Bf;;;;;AA7Be,cA6BF,OAAA,YAAmB,SAAA;EAAA,OAAA,EAiBF,cAAA;IAAA,GAAA;EAAA;EAAA,OAAA,OAAA,GAhBf,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,SAAA;IAAA,IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;KAI2B,mBAAA,GAAmB,OAAA,CAAA,OAAA;EAAA,QAAA,QAAA;EAAA,QAAA,SAAA;EAAA,QAAA,UAAA;EAAA,YAAA,OAAA,EAY/B,cAAA;IAAA,GAAA;EAAA;EAAA,IAAA;EAAA,WAAA;EAAA,UAAA,EAwChB,aAAA;EAAA,WAAA;EAAA;;;;EAAA,QAAA,YAAA;EAAA;;;EAAA,QAAA,UAAA;EAAA;;;EAAA,QAAA,aAAA;EAAA;;;EAAA,QAAA,eAAA;EAAA;;;EAAA,QAAA,cAAA;EAAA;;;EAAA,QAAA,cAAA;EAAA;;;EAAA,QAAA,iBAAA;EAAA;;;EAAA,QAAA,WAAA;EAAA;;;EAAA,QAAA,WAAA;EAAA;;;EAAA,QAAA,eAAA;EAAA,KAAA,IAAA,UAAA,OAAA,GAkPuB,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAAA,KAAA,IAAA,UAAA,QAAA,GAmExB,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAAA,MAAA,IAAA,UAAA,KAAA,EAmBpD,oBAAA,EAAA,QAAA,GACI,eAAA,GACV,OAAA,CAAQ,cAAA;EAAA,OAAA,IAAA,UAAA,OAAA,GAqC0B,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EAAA,OAAA,OAAA,UAAA,OAAA,UAAA,OAAA,GA2BpD,gBAAA,GACT,OAAA,CAAQ,eAAA;EAAA,OAAA,IAAA,UAAA,KAAA,UAAA,OAAA,GA+ByC,gBAAA,GAAmB,OAAA,CAAQ,eAAA;AAAA"}