@soundworks/core 3.6.0 → 4.0.0-alpha.0

package/types/server/PluginManager.d.ts

@@ -0,0 +1,91 @@
+export default PluginManager;
+export namespace server {
+    /**
+     * ~onStateChangeCallback
+     */
+    type PluginManager = (: object, initiator: server.Plugin | null) => any;
+}
+/**
+ * Callback executed when a plugin internal state is updated.
+ *
+ * @callback server.PluginManager~onStateChangeCallback
+ * @param {object<server.Plugin#id, server.Plugin>} fullState - List of all plugins.
+ * @param {server.Plugin|null} initiator - Plugin that initiated the update or `null`
+ *  if the change was initiated by the state manager (i.e. when the initialization
+ *  of the plugins starts).
+ */
+/**
+ * Delete the registered {@link server.PluginManager~onStateChangeCallback}.
+ *
+ * @callback server.PluginManager~deleteOnStateChangeCallback
+ */
+/**
+ * The `PluginManager` allows to register and retrieve `soundworks` plugins.
+ *
+ * Plugins should always be registered both client-side and server-side,
+ * and before {@link client.Client#start} or {@link server.Server#start}
+ * are called for proper initialization.
+ *
+ * In some sitautions, you might want to register the same plugin factory several times
+ * using different ids (e.g. for watching several parts of the file system, etc.).
+ *
+ * Refer to the plugins' documentation for more precise examples, and the specific API
+ * they expose. See [https://soundworks.dev/guide/ecosystem](https://soundworks.dev/guide/ecosystem)
+ * for more informations on the available plugins.
+ *
+ * ```
+ * import { Server } from '@soundworks/core/server.js';
+ * import platformPlugin from '@soundworks/plugin-sync/server.js';
+ *
+ * const server = new Server(config);
+ * // register the plugin before `server.start()`
+ * server.pluginManager.register('sync', pluginSync);
+ *
+ * await server.start();
+ *
+ * const sync = await server.pluginManager.get('sync');
+ *
+ * setInterval(() => {
+ *   // log the estimated global synced clock alongside the local clock.
+ *   console.log(sync.getSyncTime(), sync.getLocalTime());
+ * }, 1000);
+ * ```
+ *
+ * @memberof server
+ * @extends BasePluginManager
+ * @inheritdoc
+ * @hideconstructor
+ */
+declare class PluginManager extends BasePluginManager {
+    register(id: any, factory?: any, options?: {}, deps?: any[]): void;
+    /**
+     * Retrieve an fully started instance of a registered plugin.
+     *
+     * Be aware that the `get` method resolves only when the plugin is fully 'started',
+     * which is what we want 99.99% of the time. As such, and to prevent the application
+     * to be stuck in some kind of Promise dead lock, this method will throw if
+     * used before `server.init()` (or `server.start()`).
+     *
+     * To handle the remaining 0.01% cases and access plugin instances during their
+     * initialization (e.g. to display initialization screen, etc.), you should rely
+     * on the `onStateChange` method.
+     *
+     * _Note: the async API is designed to enable the dynamic creation of plugins (hopefully
+     * without brealing changes) in a future release._
+     *
+     * @param {server.Plugin#id} id - Id of the plugin as defined when registered.
+     * @returns {server.Plugin}
+     * @see {@link server.PluginManager#onStateChange}
+     *
+     * @private
+     */
+    private get;
+    /** private */
+    checkRegisteredPlugins(registeredPlugins: any): void;
+    /** @private */
+    private addClient;
+    /** @private */
+    private removeClient;
+}
+import BasePluginManager from "../common/BasePluginManager.js";
+//# sourceMappingURL=PluginManager.d.ts.map

package/types/server/PluginManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PluginManager.d.ts","sourceRoot":"","sources":["../../src/server/PluginManager.js"],"names":[],"mappings":";;;;;4BAQW,MAAM,aACN,gBAAc,IAAI;;AAL7B;;;;;;;;GAQG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH;IASE,mEAQC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,YAMC;IAID,cAAc;IACd,qDAYC;IAED,eAAe;IACf,kBAUC;IAED,eAAe;IACf,qBAUC;CACF"}

package/types/server/Server.d.ts

@@ -0,0 +1,223 @@
+export default Server;
+/**
+ * Server side entry point for a `soundworks` application.
+ *
+ * This object hosts configuration informations, as well as methods to
+ * initialize and start the application. It is also responsible for creating
+ * the static file (http) server as well as the socket server.
+ *
+ * @memberof server
+ *
+ * @param {server.ServerConfig} config
+ * @example
+ * import { Server } from '@soundworks/core/server';
+ * const server = new Server({
+ *   app: {
+ *     name: 'my-example-app',
+ *     clients: { myClient: { target: 'node' } },
+ *   },
+ *   env: {
+ *     port: 8888,
+ *   },
+ * });
+ * await server.init();
+ * await server.start();
+ */
+declare class Server {
+    constructor(config: any);
+    /**
+     * Configuration informations.
+     * Defaults to:
+     * ```
+     * {
+     *   env: {
+     *     type: 'development',
+     *     port: 8000,
+     *     subfolder: '',
+     *     useHttps: false,
+     *     httpsInfos: null,
+     *   },
+     *   app: {
+     *     name: 'soundworks',
+     *     clients: {},
+     *   },
+     * }
+     * ```
+     */
+    config: any;
+    /**
+     * Router. Internally use polka.
+     * (cf. {@link https://github.com/lukeed/polka})
+     */
+    router: any;
+    /**
+     * Http(s) server instance. The node `http` or `https` module instance
+     * (cf. {@link https://nodejs.org/api/http.html})
+     */
+    httpServer: any;
+    /**
+     * Key / value storage with Promise based Map API
+     * basically a wrapper around kvey (cf. {@link https://github.com/lukechilds/keyv})
+     * @private
+     */
+    private db;
+    /**
+     * The {@link server.Sockets} instance. A small wrapper around
+     * [`ws`](https://github.com/websockets/ws) server.
+     * @see {@link server.Sockets}
+     * @type {server.Sockets}
+     */
+    sockets: server.Sockets;
+    /**
+     * The {@link server.PluginManager} instance.
+     * @see {@link server.PluginManager}
+     * @type {server.PluginManager}
+     */
+    pluginManager: server.PluginManager;
+    /**
+     * The {@link server.StateManager} instance.
+     * @see {@link server.StateManager}
+     * @type {server.StateManager}
+     */
+    stateManager: server.StateManager;
+    /**
+     * The {@link server.ContextManager} instance.
+     *
+     */
+    contextManager: ContextManager;
+    /**
+     * If https is required, will contain informations about the certificates
+     * (self-signed, validity dates, etc.)
+     */
+    httpsInfos: {
+        selfSigned: boolean;
+        CN: any;
+        altNames: any;
+        validFrom: any;
+        validTo: any;
+        isValid: boolean;
+        daysRemaining: number;
+    } | {
+        selfSigned: boolean;
+        CN?: undefined;
+        altNames?: undefined;
+        validFrom?: undefined;
+        validTo?: undefined;
+        isValid?: undefined;
+        daysRemaining?: undefined;
+    } | {
+        selfSigned: boolean;
+        CN?: undefined;
+        altNames?: undefined;
+        validFrom?: undefined;
+        validTo?: undefined;
+        isValid?: undefined;
+        daysRemaining?: undefined;
+    };
+    /**
+     * Current status of the server ['idle', 'inited', 'started']
+     */
+    status: string;
+    /** @private */
+    private _applicationTemplateConfig;
+    /** @private */
+    private _onStatusChangeCallbacks;
+    /** @private */
+    private _auditState;
+    /**
+     * Method to be called before `start` in the initialization lifecycle of the
+     * soundworks server. Note that if `init()`` is not explicitely called, `start()`
+     *  will call it implicitely.
+     *
+     * What it does:
+     * - create the audit state
+     * - prepapre http(s) server and routing according to the informations
+     * declared in `config.app.clients`
+     * - starts all registered plugins
+     *
+     * After `await server.init()`, you can safely use the StateManager, as well
+     * as any registered Plugins.
+     *
+     * @example
+     * const server = new Server(config);
+     * await server.init();
+     * await server.start();
+     * // or implicitly called by start
+     * const server = new Server(config);
+     * await server.start(); // init is called implicitely
+     */
+    init(): Promise<void>;
+    /**
+     * Method to be called when `init` step is done in the initialization
+     * lifecycle of the soundworks server. If `server.init()` has not been called
+     * explicitely, `server.start()` will call it automatically.
+     *
+     * What it does:
+     * - starts all registered contexts (context are automatically registered
+     * when instantiated)
+     * - start the web socket server
+     * - launch the HTTP server on given port
+     *
+     * After `await server.start()` the server is ready to accept incoming connexions
+     */
+    start(): Promise<any>;
+    /**
+     * Stop the server, close all existing WebSocket connections.
+     * Mainly usefull for test.
+     */
+    stop(): Promise<void>;
+    /**
+     * Open the route for a given client.
+     * @private
+     */
+    private _openClientRoute;
+    /**
+     * Socket connection callback.
+     * @private
+     */
+    private _onSocketConnection;
+    /**
+     * Create namespaced databases for core and plugins
+     * (kind of experimental API do not expose in doc for now)
+     *
+     * @note - introduced in v3.1.0-beta.1
+     * @note - used by core and plugin-audio-streams
+     * @private
+     */
+    private createNamespacedDb;
+    onStatusChange(callback: any): () => boolean;
+    /** @private */
+    private _dispatchStatus;
+    /**
+     * Configure the server to work out-of-the box with the soundworks-template
+     * directory tree structure.
+     *
+     * - uses [template-literal](https://www.npmjs.com/package/template-literal) package
+     * as html templateEngine
+     * - define `.build/server/tmpl` as the directory in which html template can be
+     * found
+     * - define the `clientConfigFunction` function that return client compliant
+     * config object to be injected in the html template.
+     *
+     * Also expose two public directory:
+     * - the `public` directory which is exposed behind the root path
+     * - the `./.build/public` directory which is exposed behind the `build` path
+     */
+    setDefaultTemplateConfig(): void;
+    /**
+     * Define your own template path, template engine, and clientConfig function.
+     * This method is for very advanced use-cases and only be used if you know what
+     * you are doing. As such its behavior could probably be improved a lot...
+     *
+     * If you end up using this, please contact me to explain your use-case :)
+     */
+    setCustomTemplateConfig(options: any): void;
+    /**
+     * Get the global audit state of the application.
+     *
+     * @throws Will throw if called before `server.init()`
+     */
+    getAuditState(): Promise<any>;
+}
+import ContextManager from "./ContextManager.js";
+//# sourceMappingURL=Server.d.ts.map

package/types/server/Server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Server.d.ts","sourceRoot":"","sources":["../../src/server/Server.js"],"names":[],"mappings":";AA2EA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IACE,yBA2IC;IAvIC;;;;;;;;;;;;;;;;;;OAkBG;IACH,YAA+C;IAuC/C;;;OAGG;IACH,YAAuB;IAIvB;;;OAGG;IACH,gBAAsB;IAEtB;;;;OAIG;IACH,WAAyC;IAEzC;;;;;OAKG;IACH,wBAA4B;IAE5B;;;;OAIG;IACH,oCAA4C;IAE5C;;;;OAIG;IACH,kCAAsC;IAEtC;;;OAGG;IACH,+BAA8C;IAE9C;;;OAGG;IACH;;;;;;;;;;;;;;;;;;;;;;;;MAAsB;IAEtB;;OAEG;IACH,eAAoB;IAEpB,eAAe;IACf,mCAIC;IAED,eAAe;IACf,iCAAyC;IACzC,eAAe;IACf,oBAAuB;IASzB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,sBAwMC;IAED;;;;;;;;;;;;OAYG;IACH,sBAoFC;IAGD;;;OAGG;IACH,sBAgBC;IAED;;;OAGG;IACH,yBAgEC;IAED;;;OAGG;IACH,4BAmEC;IAED;;;;;;;OAOG;IACH,2BAmBC;IAED,6CAIC;IAED,eAAe;IACf,wBAgBC;IAED;;;;;;;;;;;;;;OAcG;IACH,iCAsBC;IAED;;;;;;OAMG;IACH,4CAEC;IAED;;;;OAIG;IACH,8BAMC;CACF"}

package/types/server/SharedState.d.ts

@@ -0,0 +1,86 @@
+export default SharedState;
+export namespace server {
+    /**
+     * ~onUpdateCallback
+     */
+    type SharedState = (newValues: any, oldValues: any, context?: Mixed) => any;
+}
+/**
+ * @callback server.SharedState~onUpdateCallback
+ * @param {Object} newValues - Key / value pairs of the updates that have been
+ *  applied to the state.
+ * @param {Object} oldValues - Key / value pairs of the updated params before
+ *  the updates has been applied to the state.
+ * @param {Mixed} [context=null] - Optionnal context object that has been passed
+ *  with the values updates in the `set` call.
+ */
+/**
+ * Delete the registered {@link server.SharedState~onUpdateCallback}.
+ *
+ * @callback server.SharedState~deleteOnUpdateCallback
+ */
+/**
+ * The `SharedState` is one of the most important and versatile abstraction provided
+ * by `soundworks`. It represents a set of parameters that are synchronized accross
+ * every nodes of the application (clients and server) that declared some interest
+ * to the shared state.
+ *
+ * A `SharedState` is created according to a "schema" (in the sense of a database
+ * schema) that must be declared and registered server-side. Any number of `SharedState`s
+ * can be created from a single schema.
+ *
+ * A shared state can be created both by the clients or by the server (in which case
+ * it is generally considered as a global state of the application). Similarly any
+ * node of the application (clients or server) can declare interest and "attach" to
+ * a state created by another node. All node attached to a state can modify its values
+ * and/or react to the modifications applied by other nodes.
+ *
+ * Tutorial: {@link https://soundworks.dev/guide/state-manager.html}
+ *
+ * ```
+ * // server-side
+ * import { Server } from '@soundworks/server/index.js';
+ *
+ * const server = new Server(config);
+ * // declare and register the schema of a shared state.
+ * server.stateManager.registerSchema('some-global-state', {
+ *   myRandom: {
+ *     type: 'float',
+ *     default: 0,
+ *   }
+ * });
+ *
+ * await server.start();
+ *
+ * // create a global state server-side
+ * const globalState = await server.stateManager.create('some-global-state');
+ * // listen and react to the changes made by the clients
+ * globalState.onUpdate(updates => console.log(updates));
+ * ```
+ *
+ * ```
+ * // client-side
+ * import { Client } from '@soundworks/client.index.js';
+ *
+ * const client = new Client(config);
+ * await client.start();
+ *
+ * // attach to the global state created by the server
+ * const globalState = await client.stateManager.attach('some-global-state');
+ *
+ * // update the value of a `myRandom` parameter every seconds
+ * setInterval(() => {
+ *   globalState.set({ myRandom: Math.random() });
+ * }, 1000);
+ * ``
+ *
+ * @memberof server
+ * @extends BaseSharedState
+ * @inheritdoc
+ * @hideconstructor
+ * @see {server.StateManager}
+ */
+declare class SharedState extends BaseSharedState {
+}
+import BaseSharedState from "../common/BaseSharedState.js";
+//# sourceMappingURL=SharedState.d.ts.map

package/types/server/SharedState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SharedState.d.ts","sourceRoot":"","sources":["../../src/server/SharedState.js"],"names":[],"mappings":";;;;;;;AAIA;;;;;;;;GAQG;AAEH;;;;GAIG;AAGH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH;CAA4C"}

package/types/server/Socket.d.ts

@@ -0,0 +1,128 @@
+export default Socket;
+/**
+ * Simple wrapper with simple pubsub system built on top of `ws` sockets.
+ * The abstraction contains two different socket:
+ * - one configured for string (JSON compatible) messages
+ * - one configured with `binaryType=arraybuffer` for streaming data more
+ *   efficiently.
+ *
+ * @see https://github.com/websockets/ws
+ *
+ * @memberof server
+ */
+declare class Socket {
+    constructor(ws: any, binaryWs: any, rooms: any, sockets: any, options?: {});
+    /**
+     * Reference to the sockets object, is mainly dedicated to allow
+     * broadcasting from a given socket instance.
+     * @type {server.Sockets}
+     * @example
+     * socket.sockets.broadcast('my-room', this, 'update-value', 1);
+     */
+    sockets: server.Sockets;
+    /**
+     * `ws` socket instance configured with `binaryType=blob` (string)
+     * @private
+     * @type {Object}
+     */
+    private ws;
+    /**
+     * `ws` socket instance configured with `binaryType=arraybuffer` (TypedArray)
+     * @private
+     * @type {Object}
+     */
+    private binaryWs;
+    /**
+     * `ws` socket instance configured with `binaryType=arraybuffer` (TypedArray)
+     * @private
+     * @type {Map}
+     */
+    private rooms;
+    /**
+     * Configuration object
+     * @type {Object}
+     */
+    config: any;
+    _stringListeners: Map<any, any>;
+    _binaryListeners: Map<any, any>;
+    _isAlive: boolean;
+    _intervalId: NodeJS.Timeout;
+    /**
+     * Called when the string socket closes (aka client reload).
+     */
+    /** @private */
+    private terminate;
+    /** @private */
+    private _emit;
+    /** @private */
+    private _addListener;
+    /** @private */
+    private _removeListener;
+    /** @private */
+    private _removeAllListeners;
+    /**
+     * Add the socket to a room
+     * @param {String} roomId - Id of the room
+     */
+    addToRoom(roomId: string): void;
+    /**
+     * Remove the socket from a room
+     * @param {String} roomId - Id of the room
+     */
+    removeFromRoom(roomId: string): void;
+    /**
+     * Sends JSON compatible messages on a given channel
+     *
+     * @param {String} channel - Channel of the message
+     * @param {...*} args - Arguments of the message (as many as needed, of any type)
+     */
+    send(channel: string, ...args: any[]): void;
+    /**
+     * Listen JSON compatible messages on a given channel
+     *
+     * @param {String} channel - Channel of the message
+     * @param {Function} callback - Callback to execute when a message is received
+     */
+    addListener(channel: string, callback: Function): void;
+    /**
+     * Remove a listener from JSON compatible messages on a given channel
+     *
+     * @param {String} channel - Channel of the message
+     * @param {Function} callback - Callback to cancel
+     */
+    removeListener(channel: string, callback: Function): void;
+    /**
+     * Remove all listeners from JSON compatible messages on a given channel
+     *
+     * @param {String} channel - Channel of the message
+     */
+    removeAllListeners(channel: string): void;
+    /**
+     * Sends binary messages on a given channel
+     *
+     * @param {String} channel - Channel of the message
+     * @param {TypedArray} typedArray - Data to send
+     */
+    sendBinary(channel: string, typedArray: TypedArray): void;
+    /**
+     * Listen binary messages on a given channel
+     *
+     * @param {String} channel - Channel of the message
+     * @param {Function} callback - Callback to execute when a message is received
+     */
+    addBinaryListener(channel: string, callback: Function): void;
+    /**
+     * Remove a listener from binary compatible messages on a given channel
+     *
+     * @param {String} channel - Channel of the message
+     * @param {Function} callback - Callback to cancel
+     */
+    removeBinaryListener(channel: string, callback: Function): void;
+    /**
+     * Remove all listeners from binary compatible messages on a given channel
+     *
+     * @param {String} channel - Channel of the message
+     */
+    removeAllBinaryListeners(channel: string): void;
+}
+//# sourceMappingURL=Socket.d.ts.map

package/types/server/Socket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Socket.d.ts","sourceRoot":"","sources":["../../src/server/Socket.js"],"names":[],"mappings":";AAcA;;;;;;;;;;GAUG;AACH;IACE,4EA2HC;IAzHC;;;;;;OAMG;IACH,wBAAsB;IAEtB;;;;OAIG;IACH,WAAY;IAEZ;;;;OAIG;IACH,iBAAwB;IAExB;;;;OAIG;IACH,cAAkB;IAElB;;;OAGG;IACH,YAGC;IAED,gCAAiC;IACjC,gCAAiC;IAoDjC,kBAAoB;IAiBpB,4BAW4B;IAG9B;;OAEG;IACH,eAAe;IACf,kBAmCC;IAED,eAAe;IACf,cAOC;IAED,eAAe;IACf,qBAOC;IAED,eAAe;IACf,wBASC;IAED,eAAe;IACf,4BAIC;IAED;;;OAGG;IACH,gCAOC;IAED;;;OAGG;IACH,qCAKC;IAED;;;;;OAKG;IACH,4CAcC;IAED;;;;;OAKG;IACH,uDAEC;IAED;;;;;OAKG;IACH,0DAEC;IAED;;;;OAIG;IACH,0CAEC;IAED;;;;;OAKG;IACH,0DAQC;IAED;;;;;OAKG;IACH,6DAEC;IAED;;;;;OAKG;IACH,gEAEC;IAED;;;;OAIG;IACH,gDAEC;CACF"}

package/types/server/Sockets.d.ts

@@ -0,0 +1,73 @@
+export default Sockets;
+/**
+ * Websocket server that creates and host all {@link server.Socket} instance.
+ * Most of the time, you shouldn't have to use this class instance directely, but
+ * it could be usefull in some situations, for broadcasting messages, creating rooms, etc.
+ *
+ * @memberof server
+ */
+declare class Sockets {
+    /** @private */
+    private _wss;
+    /** @private */
+    private _rooms;
+    /** @private */
+    private _initializationCache;
+    /** @private */
+    private _latencyStatsWorker;
+    /** @private */
+    private _auditState;
+    /**
+     * Initialize sockets, all sockets are added by default added to two rooms:
+     * - to the room corresponding to the client `role`
+     * - to the '*' that holds all connected sockets
+     *
+     * @private
+     */
+    private start;
+    /** @protected */
+    protected terminate(): void;
+    /** @private */
+    private _broadcast;
+    /**
+     * Add a socket to a room
+     *
+     * @param {server.Socket} socket - Socket to add to the room.
+     * @param {String} roomId - Id of the room
+     */
+    addToRoom(socket: server.Socket, roomId: string): void;
+    /**
+     * Remove a socket from a room
+     *
+     * @param {server.Socket} socket - Socket to remove from the room.
+     * @param {String} [roomId=null] - Id of the room
+     */
+    removeFromRoom(socket: server.Socket, roomId?: string): void;
+    /**
+     * Send a string message to all client of given room(s). If no room
+     * not specified, the message is sent to all clients
+     *
+     * @param {String|Array} roomsIds - Ids of the rooms that must receive
+     *  the message. If null the message is sent to all clients
+     * @param {server.Socket} excludeSocket - Optionnal
+     *  socket to ignore when broadcasting the message, typically the client
+     *  at the origin of the message
+     * @param {String} channel - Channel of the message
+     * @param {...*} args - Arguments of the message (as many as needed, of any type)
+     */
+    broadcast(roomIds: any, excludeSocket: server.Socket, channel: string, ...args: any[]): void;
+    /**
+     * Send a binary message (TypedArray) to all client of given room(s). If no room
+     * not specified, the message is sent to all clients
+     *
+     * @param {String|Array} roomsIds - Ids of the rooms that must receive
+     *  the message. If null the message is sent to all clients
+     * @param {server.Socket} excludeSocket - Optionnal
+     *  socket to ignore when broadcasting the message, typically the client
+     *  at the origin of the message
+     * @param {String} channel - Channel of the message
+     * @param {...*} args - Arguments of the message (as many as needed, of any type)
+     */
+    broadcastBinary(roomIds: any, excludeSocket: server.Socket, channel: string, typedArray: any): void;
+}
+//# sourceMappingURL=Sockets.d.ts.map

package/types/server/Sockets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sockets.d.ts","sourceRoot":"","sources":["../../src/server/Sockets.js"],"names":[],"mappings":";AAYA;;;;;;GAMG;AACH;IAEI,eAAe;IACf,aAAgB;IAChB,eAAe;IACf,eAAuB;IAGvB,eAAe;IACf,6BAAqC;IAErC,eAAe;IACf,4BAA+B;IAC/B,eAAe;IACf,oBAAuB;IAIzB;;;;;;OAMG;IACH,cAwDC;IAED,iBAAiB;IACjB,4BAMC;IAED,eAAe;IACf,mBA8BC;IAED;;;;;OAKG;IACH,uDAEC;IAED;;;;;OAKG;IACH,6DAEC;IAED;;;;;;;;;;;OAWG;IACH,6FAEC;IAED;;;;;;;;;;;OAWG;IACH,oGAEC;CACF"}