@furystack/utils 7.0.2 → 8.0.1

package/src/using-async.spec.ts

@@ -0,0 +1,93 @@
+import { describe, expect, it, vi } from 'vitest'
+import { usingAsync } from './using-async.js'
+import { MockDisposable } from './using.spec.js'
+
+export class MockAsyncDisposable implements AsyncDisposable {
+  private disposed = false
+  public isDisposed = () => this.disposed
+  /**
+   * Disposes the MockDisposable instance, calls the dispose callback
+   */
+  public async [Symbol.asyncDispose]() {
+    this.disposed = true
+    this.disposeCallback && this.disposeCallback()
+  }
+
+  /**
+   * Mock to throw an error
+   */
+  public whooops() {
+    throw Error('Whooops')
+  }
+
+  /**
+   * Defines the callback that will be called on dispose
+   */
+  public disposeCallback!: () => void
+}
+
+/**
+ * Unit tests for disposables
+ */
+describe('usingAsync()', () => {
+  it('dispose should be called with usingAsync()', async () => {
+    const callbackMethod = vi.fn()
+    await usingAsync(new MockAsyncDisposable(), async (d) => {
+      d.disposeCallback = () => {
+        callbackMethod()
+      }
+      return new Promise((resolve) => {
+        setTimeout(resolve, 1)
+      })
+    })
+    expect(callbackMethod).toBeCalled()
+  })
+
+  it('dispose should be called when async fails', async () => {
+    const callbackMethod = vi.fn()
+    try {
+      await usingAsync(new MockAsyncDisposable(), async (d) => {
+        d.disposeCallback = () => {
+          callbackMethod()
+        }
+        return new Promise((_resolve, reject) => {
+          setTimeout(reject, 1)
+        })
+      })
+    } catch (error) {
+      /** ignore */
+    }
+    expect(callbackMethod).toBeCalled()
+  })
+
+  it('should await dispose for asyncs with usingAsync()', async () => {
+    class AsyncDispose implements AsyncDisposable {
+      /** flag */
+      public isDisposed = false
+      /** set isDisposed with a timeout */
+      public async [Symbol.asyncDispose]() {
+        await new Promise<void>((resolve) =>
+          setTimeout(() => {
+            this.isDisposed = true
+            resolve()
+          }, 10),
+        )
+      }
+    }
+
+    const asyncDispose = new AsyncDispose()
+    await usingAsync(asyncDispose, async () => {
+      /** */
+    })
+    expect(asyncDispose.isDisposed).toBe(true)
+  })
+
+  it('Should dispose a non-async disposable object as well', async () => {
+    const createdResource = await usingAsync(new MockDisposable(), async (mock) => {
+      expect(mock).toBeInstanceOf(MockDisposable)
+      return mock
+    })
+
+    expect(createdResource.isDisposed()).toBe(true)
+  })
+})

package/src/using-async.ts

@@ -0,0 +1,24 @@
+import { isAsyncDisposable } from './is-async-disposable.js'
+import { isDisposable } from './is-disposable.js'
+
+/**
+ * Method that accepts an IDisposable resource that will be disposed after the callback
+ * @param resource The resource that is used in the callback and will be disposed afterwards
+ * @param callback The callback that will be executed asynchrounously before the resource will be disposed
+ * @returns A promise that will be resolved with a return value after the resource is disposed
+ */
+export const usingAsync = async <T extends Disposable | AsyncDisposable, TReturns>(
+  resource: T,
+  callback: (r: T) => Promise<TReturns>,
+) => {
+  try {
+    return await callback(resource)
+  } finally {
+    if (isAsyncDisposable(resource)) {
+      await resource[Symbol.asyncDispose]()
+    }
+    if (isDisposable(resource)) {
+      resource[Symbol.dispose]()
+    }
+  }
+}

package/src/using.spec.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it, vi } from 'vitest'
+import { using } from './using.js'
+
+export class MockDisposable implements Disposable {
+  private disposed = false
+  public isDisposed = () => this.disposed
+  /**
+   * Disposes the MockDisposable instance, calls the dispose callback
+   */
+  public [Symbol.dispose]() {
+    this.disposed = true
+    this.disposeCallback && this.disposeCallback()
+  }
+
+  /**
+   * Mock to throw an error
+   */
+  public whooops() {
+    throw Error('Whooops')
+  }
+
+  /**
+   * Defines the callback that will be called on dispose
+   */
+  public disposeCallback!: () => void
+}
+
+describe('Using', () => {
+  it('Can be constructed', () => {
+    using(new MockDisposable(), (d) => {
+      expect(d).toBeInstanceOf(MockDisposable)
+    })
+  })
+
+  it('Should return a value from a callback', () => {
+    const returned = using(new MockDisposable(), () => {
+      return 1
+    })
+    expect(returned).toBe(1)
+  })
+
+  describe('isDisposed', () => {
+    it('should return a correct value before and after disposition', () => {
+      const d = new MockDisposable()
+      expect(d.isDisposed()).toBe(false)
+      d[Symbol.dispose]()
+      expect(d.isDisposed()).toBe(true)
+    })
+  })
+
+  describe('dispose()', () => {
+    it('should be called on error', () => {
+      const callbackMethod = vi.fn()
+      try {
+        using(new MockDisposable(), (d) => {
+          d.disposeCallback = () => {
+            callbackMethod()
+          }
+          d.whooops()
+        })
+      } catch {
+        /** ignore */
+      }
+      expect(callbackMethod).toBeCalled()
+    })
+  })
+})

package/src/using.ts

@@ -0,0 +1,13 @@
+/**
+ * Method that accepts an IDisposable resource that will be disposed after the callback
+ * @param resource The resource that is used in the callback and will be disposed afterwards
+ * @param callback The callback that will be executed synchrounously before the resource will be disposed
+ * @returns the value that will be returned by the callback method
+ */
+export const using = <T extends Disposable, TReturns>(resource: T, callback: (r: T) => TReturns) => {
+  try {
+    return callback(resource)
+  } finally {
+    resource[Symbol.dispose]()
+  }
+}

package/src/value-observer.ts

@@ -1,4 +1,3 @@
-import type { Disposable } from './disposable.js'
 import type { ObservableValue, ValueChangeCallback } from './observable-value.js'
 
 export type ValueObserverOptions<T> = {
@@ -21,9 +20,9 @@ export type ValueObserverOptions<T> = {
  * // To update the value
  * observableValue.setValue(Math.random());
  * // if you want to dispose a single observer
- * observer.dispose();
+ * observer[Symbol.dispose]();
  * // if you want to dispose the whole observableValue with all of its observers:
- * observableValue.dispose();
+ * observableValue[Symbol.dispose]();
  * ```
  * @param T This type parameter is the value type to observe
  */
@@ -31,7 +30,7 @@ export class ValueObserver<T> implements Disposable {
   /**
    * Disposes the ValueObserver instance. Unsubscribes from the observable
    */
-  public dispose() {
+  public [Symbol.dispose]() {
     this.observable.unsubscribe(this)
   }
 

package/esm/disposable.d.ts

@@ -1,49 +0,0 @@
-/**
- *
- * You can implement *IDisposable* resources and use them with a *using()* or *usingAsync()* syntax.
- *
- * Usage example:
- *
- * ```ts
- * class Resource implements IDisposable{
- *       dispose(){
- *           // cleanup logics
- *      }
- * }
- *
- *
- * using(new Resource(), (resource)=>{
- *      // do something with the resource
- * })
- *
- * usingAsync(new Resource(), async (resource)=>{
- *      // do something with the resource, allows awaiting promises
- * })
- * ```
- */
-/** */
-/**
- * Resources in using an usingAsync should implement this interface
- *
- */
-export interface Disposable {
-    /**
-     * Method called when the IDisposable is disposed.
-     */
-    dispose: () => void | Promise<void>;
-}
-/**
- * Method that accepts an IDisposable resource that will be disposed after the callback
- * @param resource The resource that is used in the callback and will be disposed afterwards
- * @param callback The callback that will be executed synchrounously before the resource will be disposed
- * @returns the value that will be returned by the callback method
- */
-export declare const using: <T extends Disposable, TReturns>(resource: T, callback: (r: T) => TReturns) => TReturns;
-/**
- * Method that accepts an IDisposable resource that will be disposed after the callback
- * @param resource The resource that is used in the callback and will be disposed afterwards
- * @param callback The callback that will be executed asynchrounously before the resource will be disposed
- * @returns A promise that will be resolved with a return value after the resource is disposed
- */
-export declare const usingAsync: <T extends Disposable, TReturns>(resource: T, callback: (r: T) => Promise<TReturns>) => Promise<TReturns>;
-//# sourceMappingURL=disposable.d.ts.map

package/esm/disposable.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"disposable.d.ts","sourceRoot":"","sources":["../src/disposable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM;AAEN;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB;;OAEG;IACH,OAAO,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACpC;AAED;;;;;GAKG;AACH,eAAO,MAAM,KAAK,6CAA8C,CAAC,YAAY,CAAC,CAAC,EAAE,CAAC,KAAK,QAAQ,aAM9F,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,UAAU,6CACX,CAAC,YACD,CAAC,CAAC,EAAE,CAAC,KAAK,QAAQ,QAAQ,CAAC,sBAUtC,CAAA"}

package/esm/disposable.js

@@ -1,56 +0,0 @@
-/**
- *
- * You can implement *IDisposable* resources and use them with a *using()* or *usingAsync()* syntax.
- *
- * Usage example:
- *
- * ```ts
- * class Resource implements IDisposable{
- *       dispose(){
- *           // cleanup logics
- *      }
- * }
- *
- *
- * using(new Resource(), (resource)=>{
- *      // do something with the resource
- * })
- *
- * usingAsync(new Resource(), async (resource)=>{
- *      // do something with the resource, allows awaiting promises
- * })
- * ```
- */
-/** */
-/**
- * Method that accepts an IDisposable resource that will be disposed after the callback
- * @param resource The resource that is used in the callback and will be disposed afterwards
- * @param callback The callback that will be executed synchrounously before the resource will be disposed
- * @returns the value that will be returned by the callback method
- */
-export const using = (resource, callback) => {
-    try {
-        return callback(resource);
-    }
-    finally {
-        resource.dispose();
-    }
-};
-/**
- * Method that accepts an IDisposable resource that will be disposed after the callback
- * @param resource The resource that is used in the callback and will be disposed afterwards
- * @param callback The callback that will be executed asynchrounously before the resource will be disposed
- * @returns A promise that will be resolved with a return value after the resource is disposed
- */
-export const usingAsync = async (resource, callback) => {
-    try {
-        return await callback(resource);
-    }
-    finally {
-        const disposeResult = resource.dispose();
-        if (disposeResult instanceof Promise) {
-            await disposeResult;
-        }
-    }
-};
-//# sourceMappingURL=disposable.js.map

package/esm/disposable.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"disposable.js","sourceRoot":"","sources":["../src/disposable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM;AAaN;;;;;GAKG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,CAAiC,QAAW,EAAE,QAA4B,EAAE,EAAE;IACjG,IAAI,CAAC;QACH,OAAO,QAAQ,CAAC,QAAQ,CAAC,CAAA;IAC3B,CAAC;YAAS,CAAC;QACT,QAAQ,CAAC,OAAO,EAAE,CAAA;IACpB,CAAC;AACH,CAAC,CAAA;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,KAAK,EAC7B,QAAW,EACX,QAAqC,EACrC,EAAE;IACF,IAAI,CAAC;QACH,OAAO,MAAM,QAAQ,CAAC,QAAQ,CAAC,CAAA;IACjC,CAAC;YAAS,CAAC;QACT,MAAM,aAAa,GAAG,QAAQ,CAAC,OAAO,EAAE,CAAA;QACxC,IAAI,aAAa,YAAY,OAAO,EAAE,CAAC;YACrC,MAAM,aAAa,CAAA;QACrB,CAAC;IACH,CAAC;AACH,CAAC,CAAA"}

package/esm/disposable.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"disposable.spec.d.ts","sourceRoot":"","sources":["../src/disposable.spec.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAGjD,qBAAa,cAAe,YAAW,UAAU;IAC/C,OAAO,CAAC,QAAQ,CAAQ;IACjB,UAAU,gBAAsB;IACvC;;OAEG;IACI,OAAO,aAGb;IAED;;OAEG;IACI,OAAO;IAId;;OAEG;IACI,eAAe,EAAG,MAAM,IAAI,CAAA;CACpC;AAED;;GAEG;AACH,eAAO,MAAM,eAAe,qCAkG1B,CAAA"}

package/esm/disposable.spec.js

@@ -1,118 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { using, usingAsync } from './disposable.js';
-export class MockDisposable {
-    disposed = false;
-    isDisposed = () => this.disposed;
-    /**
-     * Disposes the MockDisposable instance, calls the dispose callback
-     */
-    dispose = () => {
-        this.disposed = true;
-        this.disposeCallback && this.disposeCallback();
-    };
-    /**
-     * Mock to throw an error
-     */
-    whooops() {
-        throw Error('Whooops');
-    }
-    /**
-     * Defines the callback that will be called on dispose
-     */
-    disposeCallback;
-}
-/**
- * Unit tests for disposables
- */
-export const disposableTests = describe('Disposable', () => {
-    it('Can be constructed', () => {
-        using(new MockDisposable(), (d) => {
-            expect(d).toBeInstanceOf(MockDisposable);
-        });
-    });
-    it('Should return a value from a callback', () => {
-        const returned = using(new MockDisposable(), () => {
-            return 1;
-        });
-        expect(returned).toBe(1);
-    });
-    it('Should return a value from an async callback', async () => {
-        const returned = await usingAsync(new MockDisposable(), async () => {
-            return 2;
-        });
-        expect(returned).toBe(2);
-    });
-    describe('isDisposed', () => {
-        it('should return a correct value before and after disposition', () => {
-            const d = new MockDisposable();
-            expect(d.isDisposed()).toBe(false);
-            d.dispose();
-            expect(d.isDisposed()).toBe(true);
-        });
-    });
-    describe('dispose()', () => {
-        it('should be called on error', () => {
-            const callbackMethod = vi.fn();
-            try {
-                using(new MockDisposable(), (d) => {
-                    d.disposeCallback = () => {
-                        callbackMethod();
-                    };
-                    d.whooops();
-                });
-            }
-            catch {
-                /** ignore */
-            }
-            expect(callbackMethod).toBeCalled();
-        });
-        it('should be called with usingAsync()', async () => {
-            const callbackMethod = vi.fn();
-            await usingAsync(new MockDisposable(), async (d) => {
-                d.disposeCallback = () => {
-                    callbackMethod();
-                };
-                return new Promise((resolve) => {
-                    setTimeout(resolve, 1);
-                });
-            });
-            expect(callbackMethod).toBeCalled();
-        });
-        it('should be called when async fails', async () => {
-            const callbackMethod = vi.fn();
-            try {
-                await usingAsync(new MockDisposable(), async (d) => {
-                    d.disposeCallback = () => {
-                        callbackMethod();
-                    };
-                    return new Promise((_resolve, reject) => {
-                        setTimeout(reject, 1);
-                    });
-                });
-            }
-            catch (error) {
-                /** ignore */
-            }
-            expect(callbackMethod).toBeCalled();
-        });
-        it('should await dispose for asyncs with usingAsync()', async () => {
-            class AsyncDispose {
-                /** flag */
-                isDisposed = false;
-                /** set isDisposed with a timeout */
-                async dispose() {
-                    await new Promise((resolve) => setTimeout(() => {
-                        this.isDisposed = true;
-                        resolve();
-                    }, 10));
-                }
-            }
-            const asyncDispose = new AsyncDispose();
-            await usingAsync(asyncDispose, async () => {
-                /** */
-            });
-            expect(asyncDispose.isDisposed).toBe(true);
-        });
-    });
-});
-//# sourceMappingURL=disposable.spec.js.map

package/esm/disposable.spec.js.map

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

package/esm/trace.d.ts

@@ -1,119 +0,0 @@
-import type { Disposable } from './disposable.js';
-import { ObservableValue } from './observable-value.js';
-/**
- * Options object for tracing method calls
- */
-export interface TraceMethodOptions<T, TMethod extends (...args: TArgs) => unknown, TArgs extends unknown[]> {
-    /**
-     * The context object. Can be an instance or a constructor for static methods
-     */
-    object: T;
-    /**
-     * The method reference that needs to be traced
-     */
-    method: TMethod;
-    /**
-     * Callback that will be called right before executing the method
-     */
-    onCalled?: (newValue: TraceMethodCall<TArgs>) => void;
-    /**
-     * Callback that will be called right after the method returns
-     */
-    onFinished?: (newValue: TraceMethodFinished<ReturnType<TMethod>, TArgs>) => void;
-    /**
-     * Callback that will be called when a method throws an error
-     */
-    onError?: (newValue: TraceMethodError<TArgs>) => void;
-    /**
-     * The method execution will be awaited if set
-     */
-    isAsync?: boolean;
-}
-/**
- * Defines a trace method call object
- */
-export interface TraceMethodCall<TArgs extends any[]> {
-    /**
-     * The timestamp when the event occured
-     */
-    startDateTime: Date;
-    /**
-     * The provided arguments for the call
-     */
-    methodArguments: TArgs;
-}
-/**
- * Defines a trace event when a method call has been finished
- */
-export interface TraceMethodFinished<TReturns, TArgs extends any[]> extends TraceMethodCall<TArgs> {
-    returned: TReturns;
-    finishedDateTime: Date;
-}
-/**
- * Defines a trace event when an error was thrown during a method call
- */
-export interface TraceMethodError<TArgs extends any[]> extends TraceMethodCall<TArgs> {
-    error: any;
-    errorDateTime: Date;
-}
-/**
- * Defines a method mapping object
- */
-export interface MethodMapping<TReturns, TArgs extends any[]> {
-    /**
-     * The original method instance
-     */
-    originalMethod: (...args: TArgs) => TReturns;
-    /**
-     * An observable for distributing the events
-     */
-    callObservable: ObservableValue<TraceMethodCall<TArgs>>;
-    finishedObservable: ObservableValue<TraceMethodFinished<any, TArgs>>;
-    errorObservable: ObservableValue<TraceMethodError<TArgs>>;
-}
-/**
- * Defines an Object Trace mapping
- */
-export interface ObjectTrace {
-    /**
-     * Map about the already wrapped methods
-     */
-    methodMappings: Map<string, MethodMapping<any, any[]>>;
-}
-/**
- * Helper class that can be used to trace method calls programmatically
- *
- * Usage example:
- * ```ts
- * const methodTracer: IDisposable = Trace.method({
- *     object: myObjectInstance,           // You can define an object constructor for static methods as well
- *     method: myObjectInstance.method,    // The method to be tracked
- *     isAsync: true,                      // if you set to async, method finished will be *await*-ed
- *     onCalled: (traceData) => {
- *         console.log("Method called:", traceData)
- *     },
- *     onFinished: (traceData) => {
- *         console.log("Method call finished:", traceData)
- *     },
- *     onError: (traceData) => {
- *         console.log("Method throwed an error:", traceData)
- *     }
- * });
- * ```
- */
-export declare class Trace {
-    private static objectTraces;
-    private static getMethodTrace;
-    private static traceStart;
-    private static traceFinished;
-    private static traceError;
-    private static callMethod;
-    private static callMethodAsync;
-    /**
-     * Creates an observer that will be observe method calls, finishes and errors
-     * @param options The options object for the trace
-     * @returns the trace object that can be disposed after usage
-     */
-    static method<T extends object, TMethod extends (...args: TArgs) => any, TArgs extends any[]>(options: TraceMethodOptions<T, TMethod, TArgs>): Disposable;
-}
-//# sourceMappingURL=trace.d.ts.map

package/esm/trace.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"trace.d.ts","sourceRoot":"","sources":["../src/trace.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAEvD;;GAEG;AACH,MAAM,WAAW,kBAAkB,CAAC,CAAC,EAAE,OAAO,SAAS,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,OAAO,EAAE,KAAK,SAAS,OAAO,EAAE;IACzG;;OAEG;IACH,MAAM,EAAE,CAAC,CAAA;IACT;;OAEG;IACH,MAAM,EAAE,OAAO,CAAA;IACf;;OAEG;IACH,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,eAAe,CAAC,KAAK,CAAC,KAAK,IAAI,CAAA;IACrD;;OAEG;IACH,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,mBAAmB,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,KAAK,CAAC,KAAK,IAAI,CAAA;IAChF;;OAEG;IACH,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,gBAAgB,CAAC,KAAK,CAAC,KAAK,IAAI,CAAA;IAErD;;OAEG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe,CAAC,KAAK,SAAS,GAAG,EAAE;IAClD;;OAEG;IACH,aAAa,EAAE,IAAI,CAAA;IAEnB;;OAEG;IACH,eAAe,EAAE,KAAK,CAAA;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB,CAAC,QAAQ,EAAE,KAAK,SAAS,GAAG,EAAE,CAAE,SAAQ,eAAe,CAAC,KAAK,CAAC;IAChG,QAAQ,EAAE,QAAQ,CAAA;IAClB,gBAAgB,EAAE,IAAI,CAAA;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB,CAAC,KAAK,SAAS,GAAG,EAAE,CAAE,SAAQ,eAAe,CAAC,KAAK,CAAC;IACnF,KAAK,EAAE,GAAG,CAAA;IACV,aAAa,EAAE,IAAI,CAAA;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa,CAAC,QAAQ,EAAE,KAAK,SAAS,GAAG,EAAE;IAC1D;;OAEG;IACH,cAAc,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,QAAQ,CAAA;IAC5C;;OAEG;IACH,cAAc,EAAE,eAAe,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAAA;IAEvD,kBAAkB,EAAE,eAAe,CAAC,mBAAmB,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAA;IACpE,eAAe,EAAE,eAAe,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,CAAA;CAC1D;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAA;CACvD;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,KAAK;IAChB,OAAO,CAAC,MAAM,CAAC,YAAY,CAAsC;IAEjE,OAAO,CAAC,MAAM,CAAC,cAAc;IAQ7B,OAAO,CAAC,MAAM,CAAC,UAAU;IAazB,OAAO,CAAC,MAAM,CAAC,aAAa;IAe5B,OAAO,CAAC,MAAM,CAAC,UAAU;IAgBzB,OAAO,CAAC,MAAM,CAAC,UAAU;mBAiBJ,eAAe;IAiBpC;;;;OAIG;WACW,MAAM,CAAC,CAAC,SAAS,MAAM,EAAE,OAAO,SAAS,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,GAAG,EAAE,KAAK,SAAS,GAAG,EAAE,EACjG,OAAO,EAAE,kBAAkB,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,GAC7C,UAAU;CAuDd"}