@cldmv/slothlet 2.7.1 → 2.8.0

package/README.md

@@ -464,6 +464,7 @@ Creates and loads an API instance with the specified configuration.
 | `apiDepth`  | `number`  | `Infinity`    | Directory traversal depth control - `0` for root only, `Infinity` for all levels                                                                                                                                                                                                                                                                                                                      |
 | `debug`     | `boolean` | `false`       | Enable verbose logging. Can also be set via `--slothletdebug` command line flag or `SLOTHLET_DEBUG=true` environment variable                                                                                                                                                                                                                                                                         |
 | `api_mode`  | `string`  | `"auto"`      | API structure behavior when root-level default functions exist:<br/>• `"auto"`: Automatically detects if root has default function export and creates callable API<br/>• `"function"`: Forces API to be callable (use when you have root-level default function exports)<br/>• `"object"`: Forces API to be object-only (use when you want object interface regardless of exports)                    |
+| `allowApiOverwrite` | `boolean` | `true` | Controls whether `addApi()` can overwrite existing API endpoints:<br/>• `true`: Allow overwrites (default, backwards compatible)<br/>• `false`: Prevent overwrites - logs warning and skips when attempting to overwrite existing endpoints<br/>Applies to both function and object overwrites at the final key of the API path |
 | `context`   | `object`  | `{}`          | Context data object injected into live-binding `context` reference. Available to all loaded modules via `import { context } from "@cldmv/slothlet/runtime"`                                                                                                                                                                                                                                           |
 | `reference` | `object`  | `{}`          | Reference object merged into the API root level. Properties not conflicting with loaded modules are added directly to the API                                                                                                                                                                                                                                                                         |
 | `sanitize`  | `object`  | `{}`          | **🔧 NEW**: Advanced filename-to-API transformation control. Options: `lowerFirst` (boolean), `preserveAllUpper` (boolean), `preserveAllLower` (boolean), `rules` object with `leave` (exact case-sensitive), `leaveInsensitive` (case-insensitive), `upper`/`lower` arrays. Supports exact matches, glob patterns (`*json*`, `http*`), and boundary patterns (`**url**` for surrounded matches only) |
@@ -525,8 +526,9 @@ Returns true if the API is loaded.
 Gracefully shuts down the API and performs comprehensive resource cleanup to prevent hanging processes.
 
 **Cleanup includes:**
+
 - Hook manager state and registered hooks
-- AsyncLocalStorage context and bindings  
+- AsyncLocalStorage context and bindings
 - EventEmitter listeners and AsyncResource instances (including third-party libraries)
 - Instance data and runtime coordination
 
@@ -535,6 +537,107 @@ Gracefully shuts down the API and performs comprehensive resource cleanup to pre
 > [!IMPORTANT]  
 > **🛡️ Process Cleanup**: The shutdown method now performs comprehensive cleanup of all EventEmitter listeners created after slothlet loads, including those from third-party libraries like pg-pool. This prevents hanging AsyncResource instances that could prevent your Node.js process from exiting cleanly.
 
+#### `api.addApi(apiPath, folderPath)` ⇒ `Promise<void>` ⭐ NEW
+
+Dynamically extend your API at runtime by loading additional modules and merging them into a specified path.
+
+**Parameters:**
+
+| Param        | Type     | Description                                                         |
+| ------------ | -------- | ------------------------------------------------------------------- |
+| `apiPath`    | `string` | Dotted path where modules will be added (e.g., `"runtime.plugins"`) |
+| `folderPath` | `string` | Path to folder containing modules to load (relative or absolute)    |
+
+**Returns:** `Promise<void>` - Resolves when the API extension is complete
+
+**Features:**
+
+- ✅ **Dynamic Loading**: Add modules after initial API creation
+- ✅ **Path Creation**: Automatically creates intermediate objects for nested paths
+- ✅ **Smart Merging**: Merges into existing objects or creates new namespaces
+- ✅ **Mode Respect**: Uses same loading mode (lazy/eager) as parent API
+- ✅ **Live Binding Updates**: Automatically updates `self`, `context`, and `reference`
+- ✅ **Function Support**: Can traverse through functions (slothlet's function.property pattern)
+- ✅ **Validation**: Prevents extension through primitives, validates path format
+- ✅ **Overwrite Protection**: Optional `allowApiOverwrite` config prevents accidental endpoint overwrites
+
+**Configuration:**
+
+The `allowApiOverwrite` option controls whether `addApi` can overwrite existing endpoints:
+
+```javascript
+// Default behavior - allows overwrites (backwards compatible)
+const api = await slothlet({ 
+    dir: "./api",
+    allowApiOverwrite: true // default
+});
+await api.addApi("tools", "./new-tools"); // Overwrites existing api.tools
+
+// Protected mode - prevents overwrites
+const api = await slothlet({ 
+    dir: "./api",
+    allowApiOverwrite: false // protection enabled
+});
+await api.addApi("tools", "./new-tools"); // Logs warning and skips
+// Console: "[slothlet] Skipping addApi: API path "tools" final key "tools" already exists..."
+```
+
+**Usage Examples:**
+
+```javascript
+const api = await slothlet({ dir: "./api" });
+
+// Add modules to nested path
+await api.addApi("runtime.plugins", "./plugins");
+api.runtime.plugins.myPlugin(); // New modules accessible
+
+// Add to root level
+await api.addApi("utilities", "./utils");
+api.utilities.helperFunc(); // Root-level addition
+
+// Deep nesting (creates intermediate objects)
+await api.addApi("services.external.github", "./integrations/github");
+api.services.external.github.getUser(); // Deep path created
+
+// Merge into existing namespace
+await api.addApi("math", "./advanced-math"); // Merges with existing api.math
+api.math.add(2, 3); // Original functions preserved
+api.math.advancedCalc(); // New functions added
+```
+
+**Path Validation:**
+
+```javascript
+// ❌ Invalid paths throw errors
+await api.addApi("", "./modules"); // Empty string
+await api.addApi(".path", "./modules"); // Leading dot
+await api.addApi("path.", "./modules"); // Trailing dot
+await api.addApi("path..name", "./modules"); // Consecutive dots
+
+// ✅ Valid paths
+await api.addApi("simple", "./modules"); // Single segment
+await api.addApi("nested.path", "./modules"); // Dotted path
+await api.addApi("very.deep.nested", "./modules"); // Multi-level
+```
+
+**Type Safety:**
+
+```javascript
+// ✅ Can extend through objects and functions
+api.logger = { info: () => {} };
+await api.addApi("logger.plugins", "./logger-plugins"); // Works - object
+
+api.handler = () => "handler";
+await api.addApi("handler.middleware", "./middleware"); // Works - function
+
+// ❌ Cannot extend through primitives
+api.config.timeout = 5000;
+await api.addApi("config.timeout.advanced", "./modules"); // Throws error
+```
+
+> [!WARNING]  
+> **⚠️ Concurrency Limitation:** The `addApi` method is **not thread-safe**. Concurrent calls to `addApi` with overlapping paths may result in race conditions and inconsistent API state. Ensure calls are properly sequenced using `await` or other synchronization mechanisms. Do not call `addApi` from multiple threads/workers simultaneously.
+
 > [!NOTE]  
 > **📚 For detailed API documentation with comprehensive parameter descriptions, method signatures, and examples, see [docs/API.md](https://github.com/CLDMV/slothlet/blob/HEAD/docs/API.md)**
 

package/dist/slothlet.mjs

@@ -140,7 +140,7 @@ const slothletObject = {
 	reference: {},
 	mode: "singleton",
 	loaded: false,
-	config: { lazy: false, apiDepth: Infinity, debug: DEBUG, dir: null, sanitize: null },
+	config: { lazy: false, apiDepth: Infinity, debug: DEBUG, dir: null, sanitize: null, allowApiOverwrite: true },
 	_dispose: null,
 	_boundAPIShutdown: null,
 	instanceId: null, 
@@ -994,9 +994,12 @@ const slothletObject = {
 		
 		
 		
+
+		
+		const instance = this;
 		this.safeDefine(boundApi, "describe", function (showAll = false) {
 			
-			if (this.config && this.config.lazy) {
+			if (instance.config && instance.config.lazy) {
 				if (!showAll) {
 					return Reflect.ownKeys(boundApi);
 				}
@@ -1052,17 +1055,36 @@ const slothletObject = {
 		} else {
 			this._boundAPIShutdown = null;
 		}
+
+		
+		
+		
+		const hasUserDefinedShutdown = this._boundAPIShutdown !== null;
+
 		const shutdownDesc = Object.getOwnPropertyDescriptor(boundApi, "shutdown");
 		if (!shutdownDesc || shutdownDesc.configurable) {
 			Object.defineProperty(boundApi, "shutdown", {
 				value: this.shutdown.bind(this),
 				writable: true,
 				configurable: true,
-				enumerable: true
+				enumerable: hasUserDefinedShutdown 
 			});
 		} else if (this.config && this.config.debug) {
 			console.warn("Could not redefine boundApi.shutdown: not configurable");
 		}
+
+		
+		const addApiDesc = Object.getOwnPropertyDescriptor(boundApi, "addApi");
+		if (!addApiDesc || addApiDesc.configurable) {
+			Object.defineProperty(boundApi, "addApi", {
+				value: this.addApi.bind(this),
+				writable: true,
+				configurable: true,
+				enumerable: false 
+			});
+		} else if (this.config && this.config.debug) {
+			console.warn("Could not redefine boundApi.addApi: not configurable");
+		}
 		
 
 		
@@ -1074,21 +1096,21 @@ const slothletObject = {
 	},
 
 	
-	safeDefine(obj, key, value) {
+	safeDefine(obj, key, value, enumerable = false) {
 		const desc = Object.getOwnPropertyDescriptor(obj, key);
 		if (!desc) {
 			Object.defineProperty(obj, key, {
 				value,
 				writable: true,
 				configurable: true,
-				enumerable: true
+				enumerable
 			});
 		} else if (desc.configurable) {
 			Object.defineProperty(obj, key, {
 				value,
 				writable: true,
 				configurable: true,
-				enumerable: true
+				enumerable
 			});
 		} else if (this.config && this.config.debug) {
 			console.warn(`Could not redefine boundApi.${key}: not configurable`);
@@ -1111,6 +1133,220 @@ const slothletObject = {
 	},
 
 	
+	async addApi(apiPath, folderPath) {
+		if (!this.loaded) {
+			throw new Error("[slothlet] Cannot add API: API not loaded. Call create() or load() first.");
+		}
+
+		
+		if (typeof apiPath !== "string") {
+			throw new TypeError("[slothlet] addApi: 'apiPath' must be a string.");
+		}
+		const normalizedApiPath = apiPath.trim();
+		if (normalizedApiPath === "") {
+			throw new TypeError("[slothlet] addApi: 'apiPath' must be a non-empty, non-whitespace string.");
+		}
+		const pathParts = normalizedApiPath.split(".");
+		if (pathParts.some((part) => part === "")) {
+			throw new Error(`[slothlet] addApi: 'apiPath' must not contain empty segments. Received: "${normalizedApiPath}"`);
+		}
+
+		
+		if (typeof folderPath !== "string") {
+			throw new TypeError("[slothlet] addApi: 'folderPath' must be a string.");
+		}
+
+		
+		let resolvedFolderPath = folderPath;
+		if (!path.isAbsolute(folderPath)) {
+			resolvedFolderPath = resolvePathFromCaller(folderPath);
+		}
+
+		
+		let stats;
+		try {
+			stats = await fs.stat(resolvedFolderPath);
+		} catch (error) {
+			throw new Error(`[slothlet] addApi: Cannot access folder: ${resolvedFolderPath} - ${error.message}`);
+		}
+		if (!stats.isDirectory()) {
+			throw new Error(`[slothlet] addApi: Path is not a directory: ${resolvedFolderPath}`);
+		}
+
+		if (this.config.debug) {
+			console.log(`[DEBUG] addApi: Loading modules from ${resolvedFolderPath} to path: ${normalizedApiPath}`);
+		}
+
+		
+		let newModules;
+		if (this.config.lazy) {
+			
+			newModules = await this.modes.lazy.create.call(this, resolvedFolderPath, this.config.apiDepth || Infinity, 0);
+		} else {
+			
+			newModules = await this.modes.eager.create.call(this, resolvedFolderPath, this.config.apiDepth || Infinity, 0);
+		}
+
+		if (this.config.debug) {
+			if (newModules && typeof newModules === "object") {
+				console.log(`[DEBUG] addApi: Loaded modules:`, Object.keys(newModules));
+			} else {
+				console.log(
+					`[DEBUG] addApi: Loaded modules (non-object):`,
+					typeof newModules === "function" ? `[Function: ${newModules.name || "anonymous"}]` : newModules
+				);
+			}
+		}
+
+		
+		let currentTarget = this.api;
+		let currentBoundTarget = this.boundapi;
+
+		for (let i = 0; i < pathParts.length - 1; i++) {
+			const part = pathParts[i];
+			const key = this._toapiPathKey(part);
+
+			
+			
+			
+			if (Object.prototype.hasOwnProperty.call(currentTarget, key)) {
+				const existing = currentTarget[key];
+				if (existing === null || (typeof existing !== "object" && typeof existing !== "function")) {
+					throw new Error(
+						`[slothlet] Cannot extend API path "${normalizedApiPath}" through segment "${part}": ` +
+							`existing value is type "${typeof existing}", cannot add properties.`
+					);
+				}
+				
+				
+			} else {
+				currentTarget[key] = {};
+			}
+			if (Object.prototype.hasOwnProperty.call(currentBoundTarget, key)) {
+				const existingBound = currentBoundTarget[key];
+				if (existingBound === null || (typeof existingBound !== "object" && typeof existingBound !== "function")) {
+					throw new Error(
+						`[slothlet] Cannot extend bound API path "${normalizedApiPath}" through segment "${part}": ` +
+							`existing value is type "${typeof existingBound}", cannot add properties.`
+					);
+				}
+				
+			} else {
+				currentBoundTarget[key] = {};
+			}
+
+			
+			currentTarget = currentTarget[key];
+			currentBoundTarget = currentBoundTarget[key];
+		}
+
+		
+		const finalKey = this._toapiPathKey(pathParts[pathParts.length - 1]);
+
+		
+		if (typeof newModules === "function") {
+			
+			
+			if (Object.prototype.hasOwnProperty.call(currentTarget, finalKey)) {
+				const existing = currentTarget[finalKey];
+
+				
+				if (this.config.allowApiOverwrite === false) {
+					console.warn(
+						`[slothlet] Skipping addApi: API path "${normalizedApiPath}" final key "${finalKey}" ` +
+							`already exists (type: "${typeof existing}"). Set allowApiOverwrite: true to allow overwrites.`
+					);
+					return; 
+				}
+
+				
+				if (existing !== null && typeof existing !== "function") {
+					console.warn(
+						`[slothlet] Overwriting existing non-function value at API path "${normalizedApiPath}" ` +
+							`final key "${finalKey}" with a function. Previous type: "${typeof existing}".`
+					);
+				} else if (typeof existing === "function") {
+					
+					console.warn(
+						`[slothlet] Overwriting existing function at API path "${normalizedApiPath}" ` + `final key "${finalKey}" with a new function.`
+					);
+				}
+			}
+			currentTarget[finalKey] = newModules;
+			currentBoundTarget[finalKey] = newModules;
+		} else if (typeof newModules === "object" && newModules !== null) {
+			
+			if (Object.prototype.hasOwnProperty.call(currentTarget, finalKey)) {
+				const existing = currentTarget[finalKey];
+
+				
+				if (this.config.allowApiOverwrite === false && existing !== undefined && existing !== null) {
+					
+					const hasContent = typeof existing === "object" ? Object.keys(existing).length > 0 : true;
+					if (hasContent) {
+						console.warn(
+							`[slothlet] Skipping addApi merge: API path "${normalizedApiPath}" final key "${finalKey}" ` +
+								`already exists with content (type: "${typeof existing}"). Set allowApiOverwrite: true to allow merging.`
+						);
+						return; 
+					}
+				}
+
+				if (existing !== null && typeof existing !== "object" && typeof existing !== "function") {
+					throw new Error(
+						`[slothlet] Cannot merge API at "${normalizedApiPath}": ` +
+							`existing value at final key "${finalKey}" is type "${typeof existing}", cannot merge into primitives.`
+					);
+				}
+			}
+			if (Object.prototype.hasOwnProperty.call(currentBoundTarget, finalKey)) {
+				const existingBound = currentBoundTarget[finalKey];
+				if (existingBound !== null && typeof existingBound !== "object" && typeof existingBound !== "function") {
+					throw new Error(
+						`[slothlet] Cannot merge bound API at "${normalizedApiPath}": ` +
+							`existing value at final key "${finalKey}" is type "${typeof existingBound}", cannot merge into primitives.`
+					);
+				}
+			}
+
+			
+			if (!currentTarget[finalKey]) {
+				currentTarget[finalKey] = {};
+			}
+			if (!currentBoundTarget[finalKey]) {
+				currentBoundTarget[finalKey] = {};
+			}
+
+			
+			
+			
+			
+			
+			Object.assign(currentTarget[finalKey], newModules);
+			Object.assign(currentBoundTarget[finalKey], newModules);
+		} else if (newModules === null || newModules === undefined) {
+			
+			const receivedType = newModules === null ? "null" : "undefined";
+			console.warn(
+				`[slothlet] addApi: No modules loaded from folder at API path "${normalizedApiPath}". ` +
+					`Loaded modules resulted in ${receivedType}. Check that the folder contains valid module files.`
+			);
+		} else {
+			
+			
+			currentTarget[finalKey] = newModules;
+			currentBoundTarget[finalKey] = newModules;
+		}
+
+		
+		this.updateBindings(this.context, this.reference, this.boundapi);
+
+		if (this.config.debug) {
+			console.log(`[DEBUG] addApi: Successfully added modules at ${normalizedApiPath}`);
+		}
+	},
+
+	
 	async shutdown() {
 		
 		
@@ -1216,6 +1452,18 @@ export function mutateLiveBindingFunction(target, source) {
 			}
 		}
 		
+		const managementMethods = ["shutdown", "addApi", "describe"];
+		for (const method of managementMethods) {
+			const desc = Object.getOwnPropertyDescriptor(source, method);
+			if (desc) {
+				try {
+					Object.defineProperty(target, method, desc);
+				} catch {
+					
+				}
+			}
+		}
+		
 		if (typeof source._impl === "function") {
 			target._impl = source._impl;
 		}
@@ -1230,3 +1478,5 @@ export default slothlet;
 
 
 
+
+

package/index.cjs

@@ -30,9 +30,10 @@
  * @param {string} [options.mode="singleton"] - Execution mode (singleton, vm, worker, fork)
  * @param {string} [options.api_mode="auto"] - API structure mode (auto, function, object)
  * @param {string} [options.runtime] - Runtime type ("async", "asynclocalstorage", "live", "livebindings", "experimental")
+ * @param {boolean} [options.allowApiOverwrite=true] - Allow addApi to overwrite existing API endpoints
  * @param {object} [options.context={}] - Context data for live bindings
  * @param {object} [options.reference={}] - Reference objects to merge into API root
- * @returns {Promise<function|object>} The bound API object with live-binding context
+ * @returns {Promise<import("./src/slothlet.mjs").SlothletAPI>} The bound API object with management methods
  *
  * @example // CJS usage
  * const slothlet = require("@cldmv/slothlet");

package/index.mjs

@@ -55,9 +55,10 @@ function normalizeRuntimeType(runtime) {
  * @param {number} [options.apiDepth=Infinity] - Maximum directory depth to scan
  * @param {boolean} [options.debug=false] - Enable debug logging
  * @param {string} [options.api_mode="auto"] - API structure mode (auto, function, object)
+ * @param {boolean} [options.allowApiOverwrite=true] - Allow addApi to overwrite existing API endpoints
  * @param {object} [options.context={}] - Context data for live bindings
  * @param {object} [options.reference={}] - Reference objects to merge into API root
- * @returns {Promise<function|object>} The bound API object with live-binding context
+ * @returns {Promise<import("./src/slothlet.mjs").SlothletAPI>} The bound API object with management methods
  *
  * @example // ESM
  * import slothlet from "@cldmv/slothlet";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@cldmv/slothlet",
-	"version": "2.7.1",
+	"version": "2.8.0",
 	"moduleVersions": {
 		"lazy": "1.3.1",
 		"eager": "1.3.1"

package/types/dist/slothlet.d.mts

@@ -92,6 +92,13 @@ export type SlothletOptions = {
      * - `"object"`: Force API to be plain object with method properties
      */
     api_mode?: string;
+    /**
+     * - Controls whether addApi can overwrite existing API endpoints:
+     * - `true`: Allow overwrites (default, backwards compatible)
+     * - `false`: Prevent overwrites, log warning and skip when attempting to overwrite existing endpoints
+     * - Applies to both function and object overwrites at the final key of the API path
+     */
+    allowApiOverwrite?: boolean;
     /**
      * - Context data object injected into live-binding `context` reference.
      * - Available to all loaded modules via `import { context } from "@cldmv/slothlet/runtime"`. Useful for request data,
@@ -121,14 +128,28 @@ export type SlothletOptions = {
         };
     };
 };
+export type SlothletAPI = {
+    /**
+     * - Shuts down the API instance and cleans up all resources
+     */
+    shutdown: () => Promise<void>;
+    /**
+     * - Dynamically adds API modules from a folder to a specified API path
+     */
+    addApi: (apiPath: string, folderPath: string) => Promise<void>;
+    /**
+     * - Returns metadata about the current API instance configuration. In lazy mode with showAll=false, returns an array of property keys. In lazy mode with showAll=true, returns a Promise resolving to an object. In eager mode, returns a plain object.
+     */
+    describe: (showAll?: boolean) => ((string | symbol)[] | object | Promise<object>);
+};
 /**
  * Creates a slothlet API instance with the specified configuration.
  * This is the main entry point that can be called directly as a function.
  * @async
  * @alias module:@cldmv/slothlet
  * @param {SlothletOptions} [options={}] - Configuration options for creating the API
- * @returns {Promise<function|object>} The bound API object or function
+ * @returns {Promise<SlothletAPI>} The bound API object or function with management methods
  * @public
  */
-export function slothlet(options?: SlothletOptions): Promise<Function | object>;
+export function slothlet(options?: SlothletOptions): Promise<SlothletAPI>;
 //# sourceMappingURL=slothlet.d.mts.map

package/types/dist/slothlet.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"slothlet.d.mts","sourceRoot":"","sources":["../../dist/slothlet.mjs"],"names":[],"mappings":"AAkjDA;;;;;;;;;GASG;AACH,kDARW,WAAS,MAAM,UACf,WAAS,MAAM,QAwCzB;AAt6CD;;;;;;;GAOG;AACH,mBAJU,MAAM,CAIO;AAEvB;;;;;GAKG;AACH,sBAJU,MAAM,CAIU;AAE1B;;;;;GAKG;AACH,wBAJU,MAAM,CAIY;;;;;;;;;UAy5Cd,MAAM;;;;;;WAIN,OAAO;;;;;;;;WAGP,MAAM;;;;;;;;aAKN,MAAM;;;;;;;cAKN,MAAM;;;;;;;eAIN,MAAM;;;;;;;;YAIN,OAAO;;;;;;;eAKP,MAAM;;;;;;cAIN,MAAM;;;;;;gBAGN,MAAM;;;;;;eAMjB;QAA8B,UAAU,GAA7B,OAAO;QACY,gBAAgB,GAAnC,OAAO;QACY,gBAAgB,GAAnC,OAAO;QACW,KAAK,GAClC;YAAqC,KAAK,GAA/B,MAAM,EAAE;YACkB,gBAAgB,GAA1C,MAAM,EAAE;YACkB,KAAK,GAA/B,MAAM,EAAE;YACkB,KAAK,GAA/B,MAAM,EAAE;SACrB;KAAA;;AA18CD;;;;;;;;GAQG;AACH,mCAJW,eAAe,GACb,OAAO,CAAC,WAAS,MAAM,CAAC,CAiCpC"}
+{"version":3,"file":"slothlet.d.mts","sourceRoot":"","sources":["../../dist/slothlet.mjs"],"names":[],"mappings":"AA80DA;;;;;;;;;GASG;AACH,kDARW,WAAS,MAAM,UACf,WAAS,MAAM,QAoDzB;AA9sDD;;;;;;;GAOG;AACH,mBAJU,MAAM,CAIO;AAEvB;;;;;GAKG;AACH,sBAJU,MAAM,CAIU;AAE1B;;;;;GAKG;AACH,wBAJU,MAAM,CAIY;;;;;;;;;UAisDd,MAAM;;;;;;WAIN,OAAO;;;;;;;;WAGP,MAAM;;;;;;;;aAKN,MAAM;;;;;;;cAKN,MAAM;;;;;;;eAIN,MAAM;;;;;;;;YAIN,OAAO;;;;;;;eAKP,MAAM;;;;;;;wBAIN,OAAO;;;;;;cAIP,MAAM;;;;;;gBAGN,MAAM;;;;;;eAMjB;QAA8B,UAAU,GAA7B,OAAO;QACY,gBAAgB,GAAnC,OAAO;QACY,gBAAgB,GAAnC,OAAO;QACW,KAAK,GAClC;YAAqC,KAAK,GAA/B,MAAM,EAAE;YACkB,gBAAgB,GAA1C,MAAM,EAAE;YACkB,KAAK,GAA/B,MAAM,EAAE;YACkB,KAAK,GAA/B,MAAM,EAAE;SACrB;KAAA;;;;;;cAIa,MAAM,OAAO,CAAC,IAAI,CAAC;;;;YACnB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC;;;;cACtD,CAAC,OAAO,CAAC,EAAE,OAAO,KAAK,CAAC,CAAC,MAAM,GAAC,MAAM,CAAC,EAAE,GAAC,MAAM,GAAC,OAAO,CAAC,MAAM,CAAC,CAAC;;AA5vD/E;;;;;;;;GAQG;AACH,mCAJW,eAAe,GACb,OAAO,CAAC,WAAW,CAAC,CAiChC"}