@gesslar/toolkit 0.5.0 → 0.7.0

package/src/types/Terms.d.ts

@@ -3,10 +3,10 @@
 /**
  * Terms represents an interface definition - what an action promises to provide or accept.
  * It's just the specification, not the negotiation. Contract handles the negotiation.
- * 
+ *
  * Terms can be created from objects, strings (YAML/JSON), or file references.
  * File references use the format "ref://path/to/file" for loading external definitions.
- * 
+ *
  * @example
  * ```typescript
  * // Create terms from object definition
@@ -21,7 +21,7 @@
  *   }
  * })
  * ```
- * 
+ *
  * @example
  * ```typescript
  * // Parse terms from YAML string
@@ -29,13 +29,13 @@
  * accepts:
  *   type: object
  *   properties:
- *     input: 
+ *     input:
  *       type: string
  *       minLength: 1
  * `
  * const parsedTerms = await Terms.parse(yamlData)
  * ```
- * 
+ *
  * @example
  * ```typescript
  * // Parse terms from file reference
@@ -46,9 +46,9 @@
 declare class Terms {
   /**
    * Creates a new Terms instance with the given definition
-   * 
+   *
    * @param definition - The terms definition object describing what is provided or accepted
-   * 
+   *
    * @example
    * ```typescript
    * const terms = new Terms({
@@ -56,7 +56,7 @@ declare class Terms {
    *     type: "object",
    *     properties: {
    *       data: { type: "array", items: { type: "string" } },
-   *       metadata: { 
+   *       metadata: {
    *         type: "object",
    *         properties: {
    *           timestamp: { type: "string", format: "date-time" }
@@ -71,15 +71,15 @@ declare class Terms {
 
   /**
    * Parses terms data from various sources, handling file references
-   * 
+   *
    * @param termsData - Terms data as string (YAML/JSON/file reference) or object
    * @param directoryObject - Directory context for resolving file references (required for ref:// URLs)
    * @returns Promise resolving to parsed terms data object
-   * 
+   *
    * @throws {Sass} If termsData is not a string or object
-   * @throws {Sass} If string data cannot be parsed as YAML or JSON  
+   * @throws {Sass} If string data cannot be parsed as YAML or JSON
    * @throws {Sass} If file reference cannot be loaded (missing directory or file not found)
-   * 
+   *
    * @example
    * ```typescript
    * // Parse from YAML string
@@ -89,9 +89,9 @@ declare class Terms {
    *     pattern: "^[A-Z][a-z]+"
    * `)
    * ```
-   * 
+   *
    * @example
-   * ```typescript  
+   * ```typescript
    * // Parse from JSON string
    * const jsonTerms = await Terms.parse(`{
    *   "accepts": {
@@ -101,14 +101,14 @@ declare class Terms {
    *   }
    * }`)
    * ```
-   * 
+   *
    * @example
    * ```typescript
    * // Parse from file reference
    * const directory = new DirectoryObject("./schemas")
    * const fileTerms = await Terms.parse("ref://api-contract.yaml", directory)
    * ```
-   * 
+   *
    * @example
    * ```typescript
    * // Parse from object (returns as-is)
@@ -118,22 +118,22 @@ declare class Terms {
    * ```
    */
   static parse(
-    termsData: string | object, 
+    termsData: string | object,
     directoryObject?: import('./DirectoryObject.js').default
   ): Promise<object>
 
   /**
    * Get the terms definition object
-   * 
+   *
    * @returns The complete terms definition as provided to the constructor
-   * 
+   *
    * @example
    * ```typescript
    * const terms = new Terms({
    *   accepts: { type: "string" },
    *   provides: { type: "number" }
    * })
-   * 
+   *
    * const definition = terms.definition
    * console.log(definition.accepts)  // { type: "string" }
    * console.log(definition.provides) // { type: "number" }
@@ -142,4 +142,4 @@ declare class Terms {
   get definition(): object
 }
 
-export default Terms
+export default Terms

package/src/types/Type.d.ts

@@ -23,4 +23,4 @@ export default class TypeSpec {
   reduce<T>(callback: (acc: T, spec: TypeSpecDefinition) => T, initialValue: T): T
   find(callback: (spec: TypeSpecDefinition) => boolean): TypeSpecDefinition | undefined
   match(value: unknown, options?: { allowEmpty?: boolean }): boolean
-}
+}

package/src/types/Util.d.ts

@@ -54,6 +54,16 @@ declare class Util {
    */
   static rightAlignText(text: string | number, width?: number): string
 
+  /**
+   * Centre-align a string inside a fixed width (pad with spaces on left).
+   * If the string exceeds width it is returned unchanged.
+   *
+   * @param text - Text to align.
+   * @param width - Target field width (default 80).
+   * @returns Padded string with text centred.
+   */
+  static centreAlignText(text: string | number, width?: number): string
+
   /**
    * Compute sha256 hash (hex) of the provided string.
    *
@@ -174,7 +184,15 @@ declare class Util {
    * @param args - Arguments to pass to event listeners
    * @returns Resolves when all listeners have completed
    */
-  static asyncEmitAnon(emitter: { listeners(event: string): Function[], on(event: string, listener: Function): any, emit(event: string, ...args: unknown[]): any }, event: string, ...args: unknown[]): Promise<void>
+  static asyncEmitAnon(
+    emitter: {
+      listeners(event: string): Function[],
+      on(event: string, listener: Function): any,
+      emit(event: string, ...args: unknown[]): any
+    },
+    event: string,
+    ...args: unknown[]
+  ): Promise<void>
 
   /**
    * Determine the Levenshtein distance between two string values.
@@ -228,7 +246,7 @@ declare class Util {
    * @param trim - Whether to trim whitespace from each line (default: true)
    * @param flags - Array of regex flags to apply (default: [])
    * @returns A new RegExp object with the processed pattern
-   * 
+   *
    * @throws Will throw if input is not a string
    * @throws Will throw if trim is not a boolean
    * @throws Will throw if flags is not an array

package/src/types/index.d.ts

@@ -1,23 +1,17 @@
-// Implementation: ../index.js
-// Core file system abstractions
-export { default as FileObject } from './FileObject.js'
-export { default as DirectoryObject } from './DirectoryObject.js'
-export { default as FS } from './FS.js'
-
-// Utility classes
-export { default as Cache } from './Cache.js'
-export { default as Collection } from './Collection.js'
-export { default as Contract } from './Contract.js'
-export { default as Data } from './Data.js'
-export { default as Glog } from './Glog.js'
-export { default as Sass } from './Sass.js'
-export { default as Schemer } from './Schemer.js'
-export { default as Tantrum } from './Tantrum.js'
-export { default as Term } from './Term.js'
-export { default as Terms } from './Terms.js'
-export { default as Type } from './Type.js'
-export { default as Util } from './Util.js'
-export { default as Valid } from './Valid.js'
-
-// Type exports
-export type { FileParts } from './FS.js'
+export { default as FileObject } from "./lib/FileObject.js";
+export { default as DirectoryObject } from "./lib/DirectoryObject.js";
+export { default as FS } from "./lib/FS.js";
+export { default as Cache } from "./lib/Cache.js";
+export { default as Collection } from "./lib/Collection.js";
+export { default as Contract } from "./lib/Contract.js";
+export { default as Data } from "./lib/Data.js";
+export { default as Glog } from "./lib/Glog.js";
+export { default as Sass } from "./lib/Sass.js";
+export { default as Schemer } from "./lib/Schemer.js";
+export { default as Tantrum } from "./lib/Tantrum.js";
+export { default as Term } from "./lib/Term.js";
+export { default as Terms } from "./lib/Terms.js";
+export { default as Type } from "./lib/TypeSpec.js";
+export { default as Util } from "./lib/Util.js";
+export { default as Valid } from "./lib/Valid.js";
+//# sourceMappingURL=index.d.ts.map

package/src/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.js"],"names":[],"mappings":""}

package/src/types/lib/Cache.d.ts

@@ -0,0 +1,28 @@
+/**
+ * File system cache with automatic invalidation based on modification time.
+ * Provides intelligent caching of parsed JSON5/YAML files with mtime-based
+ * cache invalidation to optimize performance for repeated file access.
+ *
+ * The cache eliminates redundant file reads and parsing when multiple processes
+ * access the same dependency files, while ensuring data freshness through
+ * modification time checking.
+ */
+export default class Cache {
+    /**
+     * Loads and caches parsed file data with automatic invalidation based on
+     * modification time.
+     *
+     * Implements a sophisticated caching strategy that checks file modification
+     * times to determine whether cached data is still valid, ensuring data
+     * freshness while optimizing performance for repeated file access during
+     * parallel processing.
+     *
+     * @param {FileObject} fileObject - The file object to load and cache
+     * @returns {Promise<unknown>} The parsed file data (JSON5 or YAML)
+     * @throws {Sass} If the file cannot be found or accessed
+     */
+    loadCachedData(fileObject: FileObject): Promise<unknown>;
+    #private;
+}
+import FileObject from "./FileObject.js";
+//# sourceMappingURL=Cache.d.ts.map

package/src/types/lib/Cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Cache.d.ts","sourceRoot":"","sources":["../../lib/Cache.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH;IAoBE;;;;;;;;;;;;OAYG;IACH,2BAJW,UAAU,GACR,OAAO,CAAC,OAAO,CAAC,CA6B5B;;CACF;uBAxEsB,iBAAiB"}

package/src/types/lib/Collection.d.ts

@@ -0,0 +1,246 @@
+/**
+ * Utility class for collection operations.
+ * Provides static methods for working with arrays, objects, sets, and maps.
+ */
+export default class Collection {
+    /**
+     * Evaluates an array with a predicate function, optionally in reverse order.
+     * Returns the first truthy result from the predicate.
+     *
+     * @param {Array<unknown>} collection - The array to evaluate
+     * @param {(value: unknown, index: number, array: Array<unknown>) => unknown} predicate - Function to evaluate each element
+     * @param {boolean} [forward] - Whether to iterate forward (true) or backward (false). Defaults to true
+     * @returns {unknown|undefined} The first truthy result from the predicate, or undefined
+     * @throws {Sass} If collection is not an array or predicate is not a function
+     */
+    static evalArray(collection: Array<unknown>, predicate: (value: unknown, index: number, array: Array<unknown>) => unknown, forward?: boolean): unknown | undefined;
+    /**
+     * Evaluates an object with a predicate function.
+     * Returns the first truthy result from the predicate.
+     *
+     * @param {object} collection - The object to evaluate
+     * @param {(value: unknown, key: string, object: object) => unknown} predicate - Function to evaluate each property
+     * @returns {unknown|undefined} The first truthy result from the predicate, or undefined
+     * @throws {Sass} If collection is not an object or predicate is not a function
+     */
+    static evalObject(collection: object, predicate: (value: unknown, key: string, object: object) => unknown): unknown | undefined;
+    /**
+     * Evaluates a Set with a predicate function.
+     * Returns the first truthy result from the predicate.
+     *
+     * @param {Set<unknown>} collection - The Set to evaluate
+     * @param {(value: unknown, set: Set<unknown>) => unknown} predicate - Function to evaluate each element
+     * @returns {unknown|undefined} The first truthy result from the predicate, or undefined
+     * @throws {Sass} If collection is not a Set or predicate is not a function
+     */
+    static evalSet(collection: Set<unknown>, predicate: (value: unknown, set: Set<unknown>) => unknown): unknown | undefined;
+    /**
+     * Evaluates a Map with a predicate function, optionally in reverse order.
+     * Returns the first truthy result from the predicate.
+     *
+     * @param {Map<unknown, unknown>} collection - The Map to evaluate
+     * @param {(value: unknown, key: unknown, map: Map<unknown, unknown>) => unknown} predicate - Function to evaluate each entry
+     * @param {boolean} [forward] - Whether to iterate forward (true) or backward (false). Defaults to true
+     * @returns {unknown|undefined} The first truthy result from the predicate, or undefined
+     * @throws {Sass} If collection is not a Map or predicate is not a function
+     */
+    static evalMap(collection: Map<unknown, unknown>, predicate: (value: unknown, key: unknown, map: Map<unknown, unknown>) => unknown, forward?: boolean): unknown | undefined;
+    /**
+     * Zips two arrays together into an array of pairs.
+     * The resulting array length equals the shorter input array.
+     *
+     * @param {Array<unknown>} array1 - The first array
+     * @param {Array<unknown>} array2 - The second array
+     * @returns {Array<[unknown, unknown]>} Array of paired elements
+     */
+    static zip(array1: Array<unknown>, array2: Array<unknown>): Array<[unknown, unknown]>;
+    /**
+     * Unzips an array of pairs into separate arrays.
+     * Transposes a 2D array structure.
+     *
+     * @param {Array<Array<unknown>>} array - Array of arrays to unzip
+     * @returns {Array<Array<unknown>>} Array of unzipped arrays, or empty array for invalid input
+     */
+    static unzip(array: Array<Array<unknown>>): Array<Array<unknown>>;
+    /**
+     * Maps an array using an async function, processing items sequentially.
+     * Unlike Promise.all(array.map()), this processes one item at a time.
+     *
+     * @param {Array<unknown>} array - The array to map
+     * @param {(item: unknown) => Promise<unknown>} asyncFn - Async function to apply to each element
+     * @returns {Promise<Array<unknown>>} Promise resolving to the mapped array
+     * @throws {Sass} If array is not an Array or asyncFn is not a function
+     */
+    static asyncMap(array: Array<unknown>, asyncFn: (item: unknown) => Promise<unknown>): Promise<Array<unknown>>;
+    /**
+     * Checks if all elements in an array are of a specified type
+     *
+     * @param {Array<unknown>} arr - The array to check
+     * @param {string} [type] - The type to check for (optional, defaults to the type of the first element)
+     * @returns {boolean} Whether all elements are of the specified type
+     */
+    static isArrayUniform(arr: Array<unknown>, type?: string): boolean;
+    /**
+     * Checks if an array is unique
+     *
+     * @param {Array<unknown>} arr - The array of which to remove duplicates
+     * @returns {Array<unknown>} The unique elements of the array
+     */
+    static isArrayUnique(arr: Array<unknown>): Array<unknown>;
+    /**
+     * Returns the intersection of two arrays.
+     *
+     * @param {Array<unknown>} arr1 - The first array.
+     * @param {Array<unknown>} arr2 - The second array.
+     * @returns {Array<unknown>} The intersection of the two arrays.
+     */
+    static intersection(arr1: Array<unknown>, arr2: Array<unknown>): Array<unknown>;
+    /**
+     * Checks whether two arrays have any elements in common.
+     *
+     * This function returns `true` if at least one element from `arr1` exists in
+     * `arr2`, and `false` otherwise. It optimizes by iterating over the shorter
+     * array for efficiency.
+     *
+     * Example:
+     *   Collection.intersects([1, 2, 3], [3, 4, 5]) // returns true
+     *   Collection.intersects(["a", "b"], ["c", "d"]) // returns false
+     *
+     * @param {Array<unknown>} arr1 - The first array to check for intersection.
+     * @param {Array<unknown>} arr2 - The second array to check for intersection.
+     * @returns {boolean} True if any element is shared between the arrays, false otherwise.
+     */
+    static intersects(arr1: Array<unknown>, arr2: Array<unknown>): boolean;
+    /**
+     * Pads an array to a specified length with a value. This operation
+     * occurs in-place.
+     *
+     * @param {Array<unknown>} arr - The array to pad.
+     * @param {number} length - The length to pad the array to.
+     * @param {unknown} value - The value to pad the array with.
+     * @param {number} [position] - The position to pad the array at. Defaults to 0
+     * @returns {Array<unknown>} The padded array.
+     */
+    static arrayPad(arr: Array<unknown>, length: number, value: unknown, position?: number): Array<unknown>;
+    /**
+     * Filters an array asynchronously using a predicate function.
+     * Applies the predicate to all items in parallel and returns filtered results.
+     *
+     * @param {Array<unknown>} arr - The array to filter
+     * @param {(value: unknown, index: number, array: Array<unknown>) => Promise<boolean>} predicate - Async predicate function that returns a promise resolving to boolean
+     * @returns {Promise<Array<unknown>>} Promise resolving to the filtered array
+     */
+    static asyncFilter(arr: Array<unknown>, predicate: (value: unknown, index: number, array: Array<unknown>) => Promise<boolean>): Promise<Array<unknown>>;
+    /**
+     * Clones an object
+     *
+     * @param {object} obj - The object to clone
+     * @param {boolean} freeze - Whether to freeze the cloned object
+     * @returns {object} The cloned object
+     */
+    static cloneObject(obj: object, freeze?: boolean): object;
+    /**
+     * Checks if an object is empty
+     *
+     * @param {object} obj - The object to check
+     * @returns {boolean} Whether the object is empty
+     */
+    static isObjectEmpty(obj: object): boolean;
+    /**
+     * Ensures that a nested path of objects exists within the given object.
+     * Creates empty objects along the path if they don't exist.
+     *
+     * @param {object} obj - The object to check/modify
+     * @param {Array<string>} keys - Array of keys representing the path to ensure
+     * @returns {object} Reference to the deepest nested object in the path
+     */
+    static assureObjectPath(obj: object, keys: Array<string>): object;
+    /**
+     * Sets a value in a nested object structure using an array of keys; creating
+     * the structure if it does not exist.
+     *
+     * @param {object} obj - The target object to set the value in
+     * @param {Array<string>} keys - Array of keys representing the path to the target property
+     * @param {unknown} value - The value to set at the target location
+     */
+    static setNestedValue(obj: object, keys: Array<string>, value: unknown): void;
+    /**
+     * Deeply merges two or more objects. Arrays are replaced, not merged.
+     *
+     * @param {...object} sources - Objects to merge (left to right)
+     * @returns {object} The merged object
+     */
+    static mergeObject(...sources: object[]): object;
+    /**
+     * Freezes an object and all of its properties recursively.
+     *
+     * @param {object} obj The object to freeze.
+     * @returns {object} The frozen object.
+     */
+    static deepFreezeObject(obj: object): object;
+    /**
+     * Maps an object using a transformer function
+     *
+     * @param {object} original The original object
+     * @param {function(unknown): unknown} transformer The transformer function
+     * @param {boolean} mutate Whether to mutate the original object
+     * @returns {Promise<object>} The mapped object
+     */
+    static mapObject(original: object, transformer: (arg0: unknown) => unknown, mutate?: boolean): Promise<object>;
+    /**
+     * Allocates an object from a source array and a spec array or function.
+     *
+     * @param {unknown} source The source array
+     * @param {Array<unknown>|function(Array<unknown>): Promise<Array<unknown>>|Array<unknown>} spec The spec array or function
+     * @returns {Promise<object>} The allocated object
+     */
+    static allocateObject(source: unknown, spec: Array<unknown> | ((arg0: Array<unknown>) => Promise<Array<unknown>> | Array<unknown>)): Promise<object>;
+    /**
+     * Trims falsy values from both ends of an array (in-place).
+     * Optionally preserves specific falsy values.
+     *
+     * @param {Array<unknown>} arr - The array to trim
+     * @param {Array<unknown>} [except] - Values to preserve even if falsy. Defaults to empty array
+     * @returns {Array<unknown>} The trimmed array (same reference, modified in-place)
+     * @throws {Sass} If arr is not an Array or except is not an Array
+     */
+    static trimArray(arr: Array<unknown>, except?: Array<unknown>): Array<unknown>;
+    /**
+     * Trims falsy values from the right end of an array (in-place).
+     * Optionally preserves specific falsy values.
+     *
+     * @param {Array<unknown>} arr - The array to trim
+     * @param {Array<unknown>} [except] - Values to preserve even if falsy. Defaults to empty array
+     * @returns {Array<unknown>} The trimmed array (same reference, modified in-place)
+     * @throws {Sass} If arr is not an Array or except is not an Array
+     */
+    static trimArrayRight(arr: Array<unknown>, except?: Array<unknown>): Array<unknown>;
+    /**
+     * Trims falsy values from the left end of an array (in-place).
+     * Optionally preserves specific falsy values.
+     *
+     * @param {Array<unknown>} arr - The array to trim
+     * @param {Array<unknown>} [except] - Values to preserve even if falsy. Defaults to empty array
+     * @returns {Array<unknown>} The trimmed array (same reference, modified in-place)
+     * @throws {Sass} If arr is not an Array or except is not an Array
+     */
+    static trimArrayLeft(arr: Array<unknown>, except?: Array<unknown>): Array<unknown>;
+    /**
+     * Transposes an array of objects into an object of arrays.
+     * Collects values for each key across all objects into arrays.
+     *
+     * @param {Array<object>} objects - Array of plain objects to transpose
+     * @returns {object} Object with keys from input objects, values as arrays
+     * @throws {Sass} If objects is not an Array or contains non-plain objects
+     */
+    static transposeObjects(objects: Array<object>): object;
+    /**
+     * Flattens an array (or nested array) of objects and transposes them.
+     * Combines flat() and transposeObjects() operations.
+     *
+     * @param {Array<object>|Array<Array<object>>} input - Array or nested array of objects
+     * @returns {object} Transposed object with arrays of values
+     */
+    static flattenObjectArray(input: Array<object> | Array<Array<object>>): object;
+}
+//# sourceMappingURL=Collection.d.ts.map

package/src/types/lib/Collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Collection.d.ts","sourceRoot":"","sources":["../../lib/Collection.js"],"names":[],"mappings":"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"}

package/src/types/lib/Contract.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Contract represents a successful negotiation between Terms.
+ * It handles validation and compatibility checking between what
+ * one action provides and what another accepts.
+ */
+export default class Contract {
+    /**
+     * Extracts the actual schema from a terms definition
+     *
+     * @param {object} definition - Terms definition with TLD descriptor
+     * @returns {object} Extracted schema content
+     * @throws {Sass} If definition structure is invalid
+     * @private
+     */
+    private static "__#private@#extractSchemaFromTerms";
+    /**
+     * Creates a contract from terms with schema validation
+     *
+     * @param {string} name - Contract identifier
+     * @param {object} termsDefinition - The terms definition
+     * @param {import('ajv').ValidateFunction|null} [validator] - Optional AJV schema validator function with .errors property
+     * @param {import('../types.js').DebugFunction} [debug] - Debug function
+     * @returns {Contract} New contract instance
+     */
+    static fromTerms(name: string, termsDefinition: object, validator?: import("ajv").ValidateFunction | null, debug?: any): Contract;
+    /**
+     * Creates a contract by negotiating between provider and consumer terms
+     *
+     * @param {Terms} providerTerms - What the provider offers
+     * @param {Terms} consumerTerms - What the consumer expects
+     * @param {object} options - Configuration options
+     * @param {import('../types.js').DebugFunction} [options.debug] - Debug function
+     */
+    constructor(providerTerms: Terms, consumerTerms: Terms, { debug }?: {
+        debug?: any;
+    });
+    /**
+     * Validates data against this contract
+     *
+     * @param {object} data - Data to validate
+     * @returns {boolean} True if valid
+     * @throws {Sass} If validation fails or contract not negotiated
+     */
+    validate(data: object): boolean;
+    /**
+     * Check if contract negotiation was successful
+     *
+     * @returns {boolean} True if negotiated
+     */
+    get isNegotiated(): boolean;
+    /**
+     * Get the provider terms (if any)
+     *
+     * @returns {Terms|null} Provider terms
+     */
+    get providerTerms(): Terms | null;
+    /**
+     * Get the consumer terms (if any)
+     *
+     * @returns {Terms|null} Consumer terms
+     */
+    get consumerTerms(): Terms | null;
+    /**
+     * Get the contract validator
+     *
+     * @returns {(data: object) => boolean|null} The contract validator function
+     */
+    get validator(): (data: object) => boolean | null;
+    #private;
+}
+import Terms from "./Terms.js";
+//# sourceMappingURL=Contract.d.ts.map

package/src/types/lib/Contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Contract.d.ts","sourceRoot":"","sources":["../../lib/Contract.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH;IAwBE;;;;;;;OAOG;IACH,oDAgBC;IAED;;;;;;;;OAQG;IACH,uBANW,MAAM,mBACN,MAAM,cACN,OAAO,KAAK,EAAE,gBAAgB,GAAC,IAAI,gBAEjC,QAAQ,CAsBpB;IAxED;;;;;;;OAOG;IACH,2BALW,KAAK,iBACL,KAAK,cAEb;QAAsD,KAAK,GAAnD,GAAmC;KAC7C,EAQA;IA6FD;;;;;;OAMG;IACH,eAJW,MAAM,GACJ,OAAO,CAsBnB;IAsED;;;;OAIG;IACH,oBAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,qBAFa,KAAK,GAAC,IAAI,CAItB;IAED;;;;OAIG;IACH,qBAFa,KAAK,GAAC,IAAI,CAItB;IAED;;;;OAIG;IACH,iBAFa,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,GAAC,IAAI,CAI1C;;CACF;kBA9PiB,YAAY"}