@itwin/core-bentley 4.0.0-dev.7 → 4.0.0-dev.72

package/lib/esm/Dictionary.js

@@ -1,200 +1,200 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Collections
- */
-import { lowerBound, shallowClone } from "./SortedArray";
-class DictionaryIterator {
-    constructor(keys, values) {
-        this._curIndex = -1;
-        this._keys = keys;
-        this._values = values;
-    }
-    next() {
-        if (++this._curIndex >= this._keys.length) {
-            // The ECMAScript spec states that value=undefined is valid if done=true. The TypeScript interface violates the spec hence the cast to any and back below.
-            return { done: true };
-        }
-        else {
-            return {
-                value: {
-                    key: this._keys[this._curIndex],
-                    value: this._values[this._curIndex],
-                },
-                done: false,
-            };
-        }
-    }
-}
-/**
- * Maintains a mapping of keys to values.
- * Unlike the standard Map<K, V>, a Dictionary<K, V> supports custom comparison logic for keys of object type (and for any other type).
- * The user supplies a key comparison function to the constructor, that must meet the following criteria given 'lhs' and 'rhs' of type K:
- *  - If lhs is equal to rhs, returns 0
- *  - If lhs is less than rhs, returns a negative value
- *  - If lhs is greater than rhs, returns a positive value
- *  - If compare(lhs, rhs) returns 0, then compare(rhs, lhs) must also return 0
- *  - If compare(lhs, rhs) returns a negative value, then compare(rhs, lhs) must return a positive value, and vice versa.
- *
- * Modifying a key in a way that affects the comparison function will produce unpredictable results, the
- * most likely of which is that keys will cease to map to the values with which they were initially inserted.
- * @public
- */
-export class Dictionary {
-    /**
-     * Construct a new Dictionary<K, V>.
-     * @param compareKeys The function used to compare keys within the dictionary.
-     * @param cloneKey The function invoked to clone a key for insertion into the dictionary. The default implementation simply returns its input.
-     * @param cloneValue The function invoked to clone a value for insertion into the dictionary. The default implementation simply returns its input.
-     */
-    constructor(compareKeys, cloneKey = shallowClone, cloneValue = shallowClone) {
-        this._keys = [];
-        this._values = [];
-        this._compareKeys = compareKeys;
-        this._cloneKey = cloneKey;
-        this._cloneValue = cloneValue;
-    }
-    /** The number of entries in the dictionary. */
-    get size() { return this._keys.length; }
-    /** Returns an iterator over the key-value pairs in the Dictionary suitable for use in `for-of` loops. Entries are returned in sorted order by key. */
-    [Symbol.iterator]() {
-        return new DictionaryIterator(this._keys, this._values);
-    }
-    /** Provides iteration over the keys in this Dictionary, in sorted order. */
-    keys() {
-        function* iterator(dict) {
-            for (const entry of dict)
-                yield entry.key;
-        }
-        return {
-            [Symbol.iterator]: () => iterator(this),
-        };
-    }
-    /** Provides iteration over the values in this Dictionary, in sorted order by the corresponding keys. */
-    values() {
-        function* iterator(dict) {
-            for (const entry of dict)
-                yield entry.value;
-        }
-        return {
-            [Symbol.iterator]: () => iterator(this),
-        };
-    }
-    /** Removes all entries from this dictionary */
-    clear() {
-        this._keys = [];
-        this._values = [];
-    }
-    /**
-     * Looks up a value by its key.
-     * @param key The key to search for
-     * @returns the value associated with the key, or undefined if the key is not present in the dictionary.
-     */
-    get(key) {
-        const bound = this.lowerBound(key);
-        return bound.equal ? this._values[bound.index] : undefined;
-    }
-    /**
-     * Determines if an entry exists for the specified key
-     * @param key The key to search for
-     * @returns true if an entry exists in this dictionary corresponding to the specified key.
-     */
-    has(key) {
-        return this.lowerBound(key).equal;
-    }
-    /**
-     * Deletes a value using its key.
-     * @param key The key to delete
-     * @returns true if the key was found and deleted.
-     */
-    delete(key) {
-        const bound = this.lowerBound(key);
-        if (bound.equal) {
-            this._values.splice(bound.index, 1);
-            this._keys.splice(bound.index, 1);
-            return true;
-        }
-        else {
-            return false;
-        }
-    }
-    /**
-     * Attempts to insert a new entry into the dictionary. If an entry with an equivalent key exists, the dictionary is unmodified.
-     * If the new entry is in fact inserted, both the key and value will be cloned using the functions supplied to the dictionary's constructor.
-     * @param key The key to associate with the value
-     * @param value The value to associate with the key
-     * @returns true if the new entry was inserted, false if an entry with an equivalent key already exists.
-     */
-    insert(key, value) {
-        const result = this.findOrInsert(key, value);
-        return result.inserted;
-    }
-    /** Obtains the value associated with the specified key, or inserts it if the specified key does not yet exist.
-     * @param key The key to search for.
-     * @param value The value to associate with `key` if `key` does not yet exist in the dictionary.
-     * @returns The found or inserted value and a flag indicating whether the new value was inserted.
-     */
-    findOrInsert(key, value) {
-        const bound = this.lowerBound(key);
-        if (bound.equal)
-            return { value: this._values[bound.index], inserted: false };
-        value = this._cloneValue(value);
-        this._keys.splice(bound.index, 0, this._cloneKey(key));
-        this._values.splice(bound.index, 0, this._cloneValue(value));
-        return { value, inserted: true };
-    }
-    /**
-     * Sets the value associated with the specified key in the dictionary.
-     * If no such key already exists, this is equivalent to insert(key, value); otherwise, the existing value associated with the key is replaced.
-     * In either case, the value will be cloned using the function supplied to the dictionary's constructor.
-     */
-    set(key, value) {
-        value = this._cloneValue(value);
-        const bound = this.lowerBound(key);
-        if (bound.equal) {
-            this._values[bound.index] = value;
-        }
-        else {
-            this._keys.splice(bound.index, 0, this._cloneKey(key));
-            this._values.splice(bound.index, 0, value);
-        }
-    }
-    /**
-     * Extracts the contents of this dictionary as an array of { key, value } pairs, and empties this dictionary.
-     * @returns An array of { key, value } pairs sorted by key.
-     */
-    extractPairs() {
-        const pairs = [];
-        for (let i = 0; i < this.size; i++)
-            pairs.push({ key: this._keys[i], value: this._values[i] });
-        this.clear();
-        return pairs;
-    }
-    /**
-     * Extracts the contents of this dictionary as a pair of { keys, values } arrays, and empties this dictionary.
-     * The array of keys is sorted according to the comparison criterion.
-     * The position of each value in the array of values corresponds the the position of the corresponding key in the array of keys.
-     * @returns a pair of { keys, values } arrays in which key[i] corresponds to value[i] in this dictionary and the keys are in sorted order.
-     */
-    extractArrays() {
-        const result = { keys: this._keys, values: this._values };
-        this.clear();
-        return result;
-    }
-    /** Apply a function to each (key, value) pair in the dictionary, in sorted order.
-     * @param func The function to be applied.
-     */
-    forEach(func) {
-        for (let i = 0; i < this.size; i++)
-            func(this._keys[i], this._values[i]);
-    }
-    /**
-     * Computes the position at which the specified key should be inserted to maintain sorted order.
-     * @param key The key whose position is to be computed.
-     * @returns an object with 'index' corresponding to the computed position and 'equal' set to true if an equivalent key already exists at that index.
-     */
-    lowerBound(key) { return lowerBound(key, this._keys, this._compareKeys); }
-}
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Collections
+ */
+import { lowerBound, shallowClone } from "./SortedArray";
+class DictionaryIterator {
+    constructor(keys, values) {
+        this._curIndex = -1;
+        this._keys = keys;
+        this._values = values;
+    }
+    next() {
+        if (++this._curIndex >= this._keys.length) {
+            // The ECMAScript spec states that value=undefined is valid if done=true. The TypeScript interface violates the spec hence the cast to any and back below.
+            return { done: true };
+        }
+        else {
+            return {
+                value: {
+                    key: this._keys[this._curIndex],
+                    value: this._values[this._curIndex],
+                },
+                done: false,
+            };
+        }
+    }
+}
+/**
+ * Maintains a mapping of keys to values.
+ * Unlike the standard Map<K, V>, a Dictionary<K, V> supports custom comparison logic for keys of object type (and for any other type).
+ * The user supplies a key comparison function to the constructor, that must meet the following criteria given 'lhs' and 'rhs' of type K:
+ *  - If lhs is equal to rhs, returns 0
+ *  - If lhs is less than rhs, returns a negative value
+ *  - If lhs is greater than rhs, returns a positive value
+ *  - If compare(lhs, rhs) returns 0, then compare(rhs, lhs) must also return 0
+ *  - If compare(lhs, rhs) returns a negative value, then compare(rhs, lhs) must return a positive value, and vice versa.
+ *
+ * Modifying a key in a way that affects the comparison function will produce unpredictable results, the
+ * most likely of which is that keys will cease to map to the values with which they were initially inserted.
+ * @public
+ */
+export class Dictionary {
+    /**
+     * Construct a new Dictionary<K, V>.
+     * @param compareKeys The function used to compare keys within the dictionary.
+     * @param cloneKey The function invoked to clone a key for insertion into the dictionary. The default implementation simply returns its input.
+     * @param cloneValue The function invoked to clone a value for insertion into the dictionary. The default implementation simply returns its input.
+     */
+    constructor(compareKeys, cloneKey = shallowClone, cloneValue = shallowClone) {
+        this._keys = [];
+        this._values = [];
+        this._compareKeys = compareKeys;
+        this._cloneKey = cloneKey;
+        this._cloneValue = cloneValue;
+    }
+    /** The number of entries in the dictionary. */
+    get size() { return this._keys.length; }
+    /** Returns an iterator over the key-value pairs in the Dictionary suitable for use in `for-of` loops. Entries are returned in sorted order by key. */
+    [Symbol.iterator]() {
+        return new DictionaryIterator(this._keys, this._values);
+    }
+    /** Provides iteration over the keys in this Dictionary, in sorted order. */
+    keys() {
+        function* iterator(dict) {
+            for (const entry of dict)
+                yield entry.key;
+        }
+        return {
+            [Symbol.iterator]: () => iterator(this),
+        };
+    }
+    /** Provides iteration over the values in this Dictionary, in sorted order by the corresponding keys. */
+    values() {
+        function* iterator(dict) {
+            for (const entry of dict)
+                yield entry.value;
+        }
+        return {
+            [Symbol.iterator]: () => iterator(this),
+        };
+    }
+    /** Removes all entries from this dictionary */
+    clear() {
+        this._keys = [];
+        this._values = [];
+    }
+    /**
+     * Looks up a value by its key.
+     * @param key The key to search for
+     * @returns the value associated with the key, or undefined if the key is not present in the dictionary.
+     */
+    get(key) {
+        const bound = this.lowerBound(key);
+        return bound.equal ? this._values[bound.index] : undefined;
+    }
+    /**
+     * Determines if an entry exists for the specified key
+     * @param key The key to search for
+     * @returns true if an entry exists in this dictionary corresponding to the specified key.
+     */
+    has(key) {
+        return this.lowerBound(key).equal;
+    }
+    /**
+     * Deletes a value using its key.
+     * @param key The key to delete
+     * @returns true if the key was found and deleted.
+     */
+    delete(key) {
+        const bound = this.lowerBound(key);
+        if (bound.equal) {
+            this._values.splice(bound.index, 1);
+            this._keys.splice(bound.index, 1);
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    /**
+     * Attempts to insert a new entry into the dictionary. If an entry with an equivalent key exists, the dictionary is unmodified.
+     * If the new entry is in fact inserted, both the key and value will be cloned using the functions supplied to the dictionary's constructor.
+     * @param key The key to associate with the value
+     * @param value The value to associate with the key
+     * @returns true if the new entry was inserted, false if an entry with an equivalent key already exists.
+     */
+    insert(key, value) {
+        const result = this.findOrInsert(key, value);
+        return result.inserted;
+    }
+    /** Obtains the value associated with the specified key, or inserts it if the specified key does not yet exist.
+     * @param key The key to search for.
+     * @param value The value to associate with `key` if `key` does not yet exist in the dictionary.
+     * @returns The found or inserted value and a flag indicating whether the new value was inserted.
+     */
+    findOrInsert(key, value) {
+        const bound = this.lowerBound(key);
+        if (bound.equal)
+            return { value: this._values[bound.index], inserted: false };
+        value = this._cloneValue(value);
+        this._keys.splice(bound.index, 0, this._cloneKey(key));
+        this._values.splice(bound.index, 0, this._cloneValue(value));
+        return { value, inserted: true };
+    }
+    /**
+     * Sets the value associated with the specified key in the dictionary.
+     * If no such key already exists, this is equivalent to insert(key, value); otherwise, the existing value associated with the key is replaced.
+     * In either case, the value will be cloned using the function supplied to the dictionary's constructor.
+     */
+    set(key, value) {
+        value = this._cloneValue(value);
+        const bound = this.lowerBound(key);
+        if (bound.equal) {
+            this._values[bound.index] = value;
+        }
+        else {
+            this._keys.splice(bound.index, 0, this._cloneKey(key));
+            this._values.splice(bound.index, 0, value);
+        }
+    }
+    /**
+     * Extracts the contents of this dictionary as an array of { key, value } pairs, and empties this dictionary.
+     * @returns An array of { key, value } pairs sorted by key.
+     */
+    extractPairs() {
+        const pairs = [];
+        for (let i = 0; i < this.size; i++)
+            pairs.push({ key: this._keys[i], value: this._values[i] });
+        this.clear();
+        return pairs;
+    }
+    /**
+     * Extracts the contents of this dictionary as a pair of { keys, values } arrays, and empties this dictionary.
+     * The array of keys is sorted according to the comparison criterion.
+     * The position of each value in the array of values corresponds the the position of the corresponding key in the array of keys.
+     * @returns a pair of { keys, values } arrays in which key[i] corresponds to value[i] in this dictionary and the keys are in sorted order.
+     */
+    extractArrays() {
+        const result = { keys: this._keys, values: this._values };
+        this.clear();
+        return result;
+    }
+    /** Apply a function to each (key, value) pair in the dictionary, in sorted order.
+     * @param func The function to be applied.
+     */
+    forEach(func) {
+        for (let i = 0; i < this.size; i++)
+            func(this._keys[i], this._values[i]);
+    }
+    /**
+     * Computes the position at which the specified key should be inserted to maintain sorted order.
+     * @param key The key whose position is to be computed.
+     * @returns an object with 'index' corresponding to the computed position and 'equal' set to true if an equivalent key already exists at that index.
+     */
+    lowerBound(key) { return lowerBound(key, this._keys, this._compareKeys); }
+}
 //# sourceMappingURL=Dictionary.js.map

package/lib/esm/Disposable.d.ts

@@ -1,81 +1,81 @@
-/** @packageDocumentation
- * @module Utils
- */
-/** Interface adopted by a type which has deterministic cleanup logic.
- * For example:
- *  - Most rendering-related types, such as [[RenderGraphic]] and [[Viewport]], own WebGL resources which must be explicitly released when no longer needed.
- *  - Some low-level objects like [[ECDb]] own native types defined in C++ code which must be explicitly released when no longer needed.
- *
- * A similar concept exists in languages like C++ (implemented as "destructors") and C# ("IDisposable").
- * However, because TypeScript and Javascript lack any built-in support for deterministic destruction, it is up to the programmer to ensure dispose() is called appropriately.
- * Failure to do so may result in memory leaks or leaking of other resources.
- *
- * IDisposable tends to be contagious; that is, if a type has members which implement IDisposable, that type should also implement IDisposable to dispose of those members.
- *
- * Implementations of IDisposable tend to be more "low-level" types. The disposal of such types is often handled on your behalf.
- * However, always consult the documentation for an IDisposable type to determine under what circumstances you are expected to explicitly dispose of it.
- * @public
- */
-export interface IDisposable {
-    /** Disposes of any resources owned by this object.
-     * @note The object is generally considered unusable after it has been disposed of.
-     */
-    dispose(): void;
-}
-/**
- * A type guard that checks whether the given argument implements `IDisposable` interface
- * @public
- */
-export declare function isIDisposable(obj: unknown): obj is IDisposable;
-/** Convenience function for disposing of a disposable object that may be undefined.
- * This is primarily used to simplify implementations of [[IDisposable.dispose]].
- * As a simple example:
- * ```ts
- *  class Disposable implements IDisposable {
- *    public member1?: DisposableType1;
- *    public member2?: DisposableType2;
- *
- *    public dispose() {
- *      this.member1 = dispose(this.member1); // If member1 is defined, dispose of it and set it to undefined.
- *      this.member2 = dispose(this.member2); // Likewise for member2.
- *    }
- *  }
- * ```
- * @param disposable The object to be disposed of.
- * @returns undefined
- * @public
- */
-export declare function dispose(disposable?: IDisposable): undefined;
-/** Disposes of and empties a list of disposable objects.
- * @param list The list of disposable objects.
- * @returns undefined
- * @public
- */
-export declare function disposeArray(list?: IDisposable[]): undefined;
-/** A 'using' function which is a substitution for .NET's using statement. It makes sure that 'dispose'
- * is called on the resource no matter if the func returns or throws. If func returns, the return value
- * of this function is equal to return value of func. If func throws, this function also throws (after
- * disposing the resource).
- * @public
- */
-export declare function using<T extends IDisposable, TResult>(resources: T | T[], func: (...r: T[]) => TResult): TResult;
-/** A definition of function which may be called to dispose an object
- * @public
- */
-export declare type DisposeFunc = () => void;
-/** A disposable container of disposable objects.
- * @public
- */
-export declare class DisposableList implements IDisposable {
-    private _disposables;
-    /** Creates a disposable list. */
-    constructor(disposables?: Array<IDisposable | DisposeFunc>);
-    private isDisposable;
-    /** Register an object for disposal. */
-    add(disposable: IDisposable | DisposeFunc): void;
-    /** Unregister disposable object. */
-    remove(disposable: IDisposable): void;
-    /** Disposes all registered objects. */
-    dispose(): void;
-}
+/** @packageDocumentation
+ * @module Utils
+ */
+/** Interface adopted by a type which has deterministic cleanup logic.
+ * For example:
+ *  - Most rendering-related types, such as [[RenderGraphic]] and [[Viewport]], own WebGL resources which must be explicitly released when no longer needed.
+ *  - Some low-level objects like [[ECDb]] own native types defined in C++ code which must be explicitly released when no longer needed.
+ *
+ * A similar concept exists in languages like C++ (implemented as "destructors") and C# ("IDisposable").
+ * However, because TypeScript and Javascript lack any built-in support for deterministic destruction, it is up to the programmer to ensure dispose() is called appropriately.
+ * Failure to do so may result in memory leaks or leaking of other resources.
+ *
+ * IDisposable tends to be contagious; that is, if a type has members which implement IDisposable, that type should also implement IDisposable to dispose of those members.
+ *
+ * Implementations of IDisposable tend to be more "low-level" types. The disposal of such types is often handled on your behalf.
+ * However, always consult the documentation for an IDisposable type to determine under what circumstances you are expected to explicitly dispose of it.
+ * @public
+ */
+export interface IDisposable {
+    /** Disposes of any resources owned by this object.
+     * @note The object is generally considered unusable after it has been disposed of.
+     */
+    dispose(): void;
+}
+/**
+ * A type guard that checks whether the given argument implements `IDisposable` interface
+ * @public
+ */
+export declare function isIDisposable(obj: unknown): obj is IDisposable;
+/** Convenience function for disposing of a disposable object that may be undefined.
+ * This is primarily used to simplify implementations of [[IDisposable.dispose]].
+ * As a simple example:
+ * ```ts
+ *  class Disposable implements IDisposable {
+ *    public member1?: DisposableType1;
+ *    public member2?: DisposableType2;
+ *
+ *    public dispose() {
+ *      this.member1 = dispose(this.member1); // If member1 is defined, dispose of it and set it to undefined.
+ *      this.member2 = dispose(this.member2); // Likewise for member2.
+ *    }
+ *  }
+ * ```
+ * @param disposable The object to be disposed of.
+ * @returns undefined
+ * @public
+ */
+export declare function dispose(disposable?: IDisposable): undefined;
+/** Disposes of and empties a list of disposable objects.
+ * @param list The list of disposable objects.
+ * @returns undefined
+ * @public
+ */
+export declare function disposeArray(list?: IDisposable[]): undefined;
+/** A 'using' function which is a substitution for .NET's using statement. It makes sure that 'dispose'
+ * is called on the resource no matter if the func returns or throws. If func returns, the return value
+ * of this function is equal to return value of func. If func throws, this function also throws (after
+ * disposing the resource).
+ * @public
+ */
+export declare function using<T extends IDisposable, TResult>(resources: T | T[], func: (...r: T[]) => TResult): TResult;
+/** A definition of function which may be called to dispose an object
+ * @public
+ */
+export type DisposeFunc = () => void;
+/** A disposable container of disposable objects.
+ * @public
+ */
+export declare class DisposableList implements IDisposable {
+    private _disposables;
+    /** Creates a disposable list. */
+    constructor(disposables?: Array<IDisposable | DisposeFunc>);
+    private isDisposable;
+    /** Register an object for disposal. */
+    add(disposable: IDisposable | DisposeFunc): void;
+    /** Unregister disposable object. */
+    remove(disposable: IDisposable): void;
+    /** Disposes all registered objects. */
+    dispose(): void;
+}
 //# sourceMappingURL=Disposable.d.ts.map

package/lib/esm/Disposable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Disposable.d.ts","sourceRoot":"","sources":["../../src/Disposable.ts"],"names":[],"mappings":"AAIA;;GAEG;AAEH;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,OAAO,IAAI,IAAI,CAAC;CACjB;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,WAAW,CAG9D;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,OAAO,CAAC,UAAU,CAAC,EAAE,WAAW,GAAG,SAAS,CAI3D;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,CAAC,EAAE,WAAW,EAAE,GAAG,SAAS,CAS5D;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,WAAW,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,KAAK,OAAO,GAAG,OAAO,CAkB/G;AAED;;GAEG;AACH,oBAAY,WAAW,GAAG,MAAM,IAAI,CAAC;AAQrC;;GAEG;AACH,qBAAa,cAAe,YAAW,WAAW;IAChD,OAAO,CAAC,YAAY,CAAgB;IAEpC,iCAAiC;gBACrB,WAAW,GAAE,KAAK,CAAC,WAAW,GAAG,WAAW,CAAM;IAO9D,OAAO,CAAC,YAAY;IAIpB,uCAAuC;IAChC,GAAG,CAAC,UAAU,EAAE,WAAW,GAAG,WAAW;IAOhD,oCAAoC;IAC7B,MAAM,CAAC,UAAU,EAAE,WAAW,GAAG,IAAI;IAM5C,uCAAuC;IAChC,OAAO,IAAI,IAAI;CAIvB"}
+{"version":3,"file":"Disposable.d.ts","sourceRoot":"","sources":["../../src/Disposable.ts"],"names":[],"mappings":"AAIA;;GAEG;AAEH;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,OAAO,IAAI,IAAI,CAAC;CACjB;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,WAAW,CAG9D;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,OAAO,CAAC,UAAU,CAAC,EAAE,WAAW,GAAG,SAAS,CAI3D;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,CAAC,EAAE,WAAW,EAAE,GAAG,SAAS,CAS5D;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,WAAW,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,KAAK,OAAO,GAAG,OAAO,CAkB/G;AAED;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC;AAQrC;;GAEG;AACH,qBAAa,cAAe,YAAW,WAAW;IAChD,OAAO,CAAC,YAAY,CAAgB;IAEpC,iCAAiC;gBACrB,WAAW,GAAE,KAAK,CAAC,WAAW,GAAG,WAAW,CAAM;IAO9D,OAAO,CAAC,YAAY;IAIpB,uCAAuC;IAChC,GAAG,CAAC,UAAU,EAAE,WAAW,GAAG,WAAW;IAOhD,oCAAoC;IAC7B,MAAM,CAAC,UAAU,EAAE,WAAW,GAAG,IAAI;IAM5C,uCAAuC;IAChC,OAAO,IAAI,IAAI;CAIvB"}