react-websocket 3.3.0 → 3.6.0

package/dist/core.d.cts

@@ -111,14 +111,42 @@ interface SendOptions {
   volatile?: boolean;
   /**
    * Keep only the newest queued message with this key. Sending again with the same key
-   * while disconnected replaces the earlier one, which moves to the back of the queue.
+   * while disconnected replaces the earlier one, which moves to the back of the queue
+   * (or of the `priority` messages, for a priority one).
    * For state where only the latest value matters, such as "my position is now (x, y)".
    */
   key?: string;
+  /**
+   * Queue this message ahead of every message queued without `priority`, after earlier
+   * priority messages. For control messages that must not wait behind a backlog, such as
+   * cancel, interrupt or a token refresh. Messages sent from `open` listeners still go first.
+   *
+   * It only matters while the socket isn't open: once a message is handed to the browser,
+   * nothing can overtake it. To keep that buffer short, send bulky streams with `maxBuffered`.
+   * @default false
+   */
+  priority?: boolean;
+  /**
+   * Drop the message instead of sending it while more than this many bytes are already
+   * waiting in the browser's send buffer (`socket.bufferedAmount`). For high-rate streams on
+   * a slow link, such as audio frames or per-tick input, where a late message is worse than
+   * none. `send()` returns `false`, and `onDrop` isn't called.
+   *
+   * Only checked while the socket is open: a message queued while disconnected is sent on
+   * open regardless. `bufferedAmount` includes what you sent earlier in the same task, so set
+   * it well above one burst of messages.
+   *
+   * @example
+   * ```ts
+   * voice.send(frame, { volatile: true, maxBuffered: 64 * 1024 });
+   * ```
+   */
+  maxBuffered?: number;
   /**
    * Called if the message is dropped from the queue without being sent: replaced by a
    * newer message with the same `key`, or evicted by `queue.limit`. Not called when the
-   * queue is cleared because the client closed or gave up.
+   * queue is cleared because the client closed or gave up, or when `send()` drops the
+   * message right away (`volatile` while not open, or `maxBuffered`) and returns `false`.
    */
   onDrop?: () => void;
 }
@@ -126,7 +154,7 @@ interface SendOptions {
 interface QueueOptions {
   /**
    * Maximum number of messages held while not connected. When full, the oldest
-   * message is dropped.
+   * message is dropped, skipping `priority` messages unless nothing else is queued.
    * @default Infinity
    */
   limit?: number;
@@ -309,12 +337,14 @@ interface WebSocketClient<In = unknown, Out = unknown> {
    * Send a message (encoded with `serialize`/`json` if configured). If the socket isn't
    * open, the message is queued and sent on open (see the `queue` option), unless
    * `options.volatile` is set.
-   * @returns `true` if it was sent immediately, `false` if it was queued or dropped.
+   * @returns `true` if it was sent immediately, `false` if it was queued or dropped
+   *   (`volatile` while not open, or `maxBuffered` while open).
    *
    * @example
    * ```ts
    * game.send({ type: 'input', dx, dy }, { volatile: true }); // never replayed after a reconnect
    * game.send({ type: 'position', x, y }, { key: 'position' }); // only the newest is queued
+   * game.send({ type: 'leave' }, { priority: true }); // ahead of everything already queued
    * ```
    */
   send(message: Out, options?: SendOptions): boolean;
@@ -457,20 +487,36 @@ interface WebSocketRequestsOptions<Req, In, Out> {
   reply: (message: In) => number | string | null | undefined;
   /**
    * Called on a reply. Return something other than `undefined` to reject the request with
-   * it instead of resolving, e.g. for a server-side error reply.
+   * it instead of resolving, e.g. for a server-side error reply. A stream throws it.
    */
   error?: (message: In) => unknown;
   /**
-   * Default time to wait for a reply, in ms. `Infinity` waits forever.
+   * Whether a reply is the last one of a stream. `stream()` needs it. That reply is yielded
+   * too, then the stream ends.
+   */
+  done?: (message: In) => boolean;
+  /**
+   * Build the message that tells the server to stop working on request `id`. Sent when this
+   * side gives up: the request's `signal` aborts, it times out, a loop over a stream exits
+   * early, or the manager is disposed. Not sent after the last reply, an error reply, a lost
+   * connection or `close()`.
+   */
+  cancel?: (id: number) => Out;
+  /**
+   * Default time to wait for a reply, in ms. For a stream, the time to wait for each reply,
+   * including the first. `Infinity` waits forever.
    * @default 10000
    */
   timeout?: number;
 }
-/** Per-call options for {@link WebSocketRequests.request}. */
+/** Per-call options for {@link WebSocketRequests.request} and {@link WebSocketRequests.stream}. */
 interface RequestOptions extends SendOptions {
-  /** Time to wait for a reply, in ms. Overrides the manager's `timeout`. */
+  /**
+   * Time to wait for a reply (for a stream, for each reply), in ms. Overrides the manager's
+   * `timeout`.
+   */
   timeout?: number;
-  /** Abort the request. It rejects with `signal.reason`. A late reply is ignored. */
+  /** Abort the request. It rejects (a stream throws) with `signal.reason`. A late reply is ignored. */
   signal?: AbortSignal;
 }
 /** Request/response over one client. Create with {@link createWebSocketRequests}. */
@@ -487,7 +533,26 @@ interface WebSocketRequests<Req, In> {
    * queue (replaced by a newer request with the same `key`, or evicted by `queue.limit`).
    */
   request(message: Req, options?: RequestOptions): Promise<In>;
-  /** Number of requests waiting for a reply. */
+  /**
+   * Send a request and iterate over its replies, up to and including the one `done` matches.
+   * Holds the connection until the stream ends. Needs the `done` option.
+   *
+   * `timeout` is the time to wait for each reply. Replies that arrive before the loop reads
+   * them are buffered. The stream is one-shot: iterate it once.
+   *
+   * Fails where `request()` rejects, with the same errors, after yielding the replies already
+   * received. Aborting `signal` throws `signal.reason` right away and discards them. Leaving
+   * the loop early, aborting and timing out send `cancel`.
+   *
+   * @example
+   * ```ts
+   * for await (const reply of rpc.stream({ type: 'ask', prompt }, { signal })) {
+   *   text += reply.delta;
+   * }
+   * ```
+   */
+  stream(message: Req, options?: RequestOptions): AsyncIterableIterator<In>;
+  /** Number of requests and streams waiting for a reply. */
   pending(): number;
   /** Reject every pending request and stop listening. Only needed for managers created dynamically. */
   dispose(): void;
@@ -649,6 +714,85 @@ interface WebSocketResponder<P = unknown, R = unknown> {
  */
 export declare function createWebSocketResponder<Q extends RequestFields, R, In, const Out>(client: WebSocketClient<In, Out>, options: WebSocketResponderOptions<Q, R, NoInfer<In>, NoInfer<Out>>): WebSocketResponder<ParamsOf<Q>, R>;
 //#endregion
+//#region src/sendrate.d.ts
+/** Options for {@link createWebSocketSendRate}. */
+interface WebSocketSendRateOptions {
+  /**
+   * Ticks per second while the connection keeps up.
+   * @default 30
+   */
+  maxRate?: number;
+  /**
+   * The rate never drops below this, in ticks per second.
+   * @default 5
+   */
+  minRate?: number;
+  /**
+   * Bytes waiting in the browser's send buffer (`socket.bufferedAmount`) above which a tick
+   * sends nothing and the rate halves.
+   * @default 1024
+   */
+  maxBuffered?: number;
+  /**
+   * Measurements from `createWebSocketLatency` on the same client. With them, a round-trip time
+   * that rises also lowers the rate. Without them, only the send buffer is watched.
+   */
+  latency?: Pick<WebSocketLatency, 'getSnapshot'>;
+  /**
+   * How far `rtt` may rise above the lowest one measured on this connection before the rate
+   * halves, in ms. A steady high ping keeps the full rate; only a rising one counts.
+   * @default 100
+   */
+  maxRttIncrease?: number;
+}
+/** The current send rate. A new object is created on every change. */
+interface SendRate {
+  /** Ticks per second, rounded. */
+  readonly rate: number;
+  /**
+   * Whether the last tick found the link congested: the send buffer above `maxBuffered`, or
+   * `rtt` risen more than `maxRttIncrease`.
+   */
+  readonly congested: boolean;
+}
+/** Keyed sends coalesced at a rate that adapts to the link. Create with {@link createWebSocketSendRate}. */
+interface WebSocketSendRate<Out> {
+  /** The client the messages are sent on. */
+  readonly client: WebSocketClient<any, Out>;
+  /**
+   * Send `message` at the next tick. A message with the same `key` still waiting for it is
+   * replaced, so only the newest one goes out. Sent with `volatile`.
+   */
+  send(message: Out, key: string): void;
+  /** Send everything waiting now, e.g. right before a one-shot action that must carry the latest aim. */
+  flush(): void;
+  /** The current {@link SendRate}. Returns the same object until it changes. */
+  getSnapshot(): SendRate;
+  /** Called whenever the rate or `congested` changes. Compatible with `useSyncExternalStore`. */
+  subscribe(listener: () => void): () => void;
+  /** Stop sending and listening. Only needed for instances created dynamically. */
+  dispose(): void;
+}
+/**
+ * Send high-rate state, such as aim, cursor or position, at a rate that adapts to the
+ * connection. Messages are coalesced per key between ticks. The rate drops by half when the
+ * send buffer fills up or the round trip grows, and climbs back one tick per second at a time
+ * when the link keeps up, so players on a poor connection degrade smoothly instead of building
+ * up lag.
+ *
+ * Ticks run only while the socket is open and something is waiting. Messages waiting during a
+ * reconnect go out after it; `close()` drops them. It doesn't open the connection by itself.
+ *
+ * @example
+ * ```ts
+ * export const stream = createWebSocketSendRate(game, { latency, maxRate: 30 });
+ *
+ * // On every pointer move: at most 30 a second, fewer on a congested link.
+ * stream.send({ type: 'aim', angle }, 'aim');
+ * ```
+ */
+export declare function createWebSocketSendRate<Out>(client: WebSocketClient<any, Out>, options?: WebSocketSendRateOptions): WebSocketSendRate<Out>;
+//#endregion
 //#region src/state.d.ts
 /** Options for {@link createWebSocketState}. */
 interface WebSocketStateOptions<S, In> {
@@ -659,6 +803,17 @@ interface WebSocketStateOptions<S, In> {
    * change, or the same `state` to ignore the message (subscribers aren't notified).
    */
   reduce: (state: S, message: In) => S;
+  /**
+   * `'frame'`: notify subscribers at most once per animation frame instead of once per
+   * message, so a fast stream (tokens, tickers, game state) renders once per frame.
+   * `getState()` is always current; only notifications wait. `setState` and `reset` still
+   * notify right away.
+   *
+   * Browsers pause animation frames in background tabs: the state keeps up, and subscribers
+   * hear about it when the tab is visible again. Without `requestAnimationFrame` (Node, some
+   * workers), it waits about 16 ms instead.
+   */
+  batch?: 'frame';
 }
 /**
  * State derived from a client's messages. Read it with `useWebSocketState(store, selector)`,
@@ -748,5 +903,5 @@ interface WebSocketTopics {
  */
 export declare function createWebSocketTopics<const Out>(client: WebSocketClient<any, Out>, options: WebSocketTopicsOptions<NoInfer<Out>>): WebSocketTopics;
 //#endregion
-export type { CloseInfo, EventMap, HeartbeatOptions, IncomingRequest, Latency, QueueOptions, ReconnectOptions, RequestHandler, RequestOptions, SendData, SendOptions, Snapshot, StandardSchemaV1, Status, UrlSource, WebSocketClient, WebSocketLatency, WebSocketLatencyOptions, WebSocketOptions, WebSocketRequests, WebSocketRequestsOptions, WebSocketResponder, WebSocketResponderOptions, WebSocketState, WebSocketStateOptions, WebSocketTopics, WebSocketTopicsOptions };
+export type { CloseInfo, EventMap, HeartbeatOptions, IncomingRequest, Latency, QueueOptions, ReconnectOptions, RequestHandler, RequestOptions, SendData, SendOptions, SendRate, Snapshot, StandardSchemaV1, Status, UrlSource, WebSocketClient, WebSocketLatency, WebSocketLatencyOptions, WebSocketOptions, WebSocketRequests, WebSocketRequestsOptions, WebSocketResponder, WebSocketResponderOptions, WebSocketSendRate, WebSocketSendRateOptions, WebSocketState, WebSocketStateOptions, WebSocketTopics, WebSocketTopicsOptions };
 //# sourceMappingURL=core.d.cts.map

package/dist/core.d.ts

@@ -111,14 +111,42 @@ interface SendOptions {
   volatile?: boolean;
   /**
    * Keep only the newest queued message with this key. Sending again with the same key
-   * while disconnected replaces the earlier one, which moves to the back of the queue.
+   * while disconnected replaces the earlier one, which moves to the back of the queue
+   * (or of the `priority` messages, for a priority one).
    * For state where only the latest value matters, such as "my position is now (x, y)".
    */
   key?: string;
+  /**
+   * Queue this message ahead of every message queued without `priority`, after earlier
+   * priority messages. For control messages that must not wait behind a backlog, such as
+   * cancel, interrupt or a token refresh. Messages sent from `open` listeners still go first.
+   *
+   * It only matters while the socket isn't open: once a message is handed to the browser,
+   * nothing can overtake it. To keep that buffer short, send bulky streams with `maxBuffered`.
+   * @default false
+   */
+  priority?: boolean;
+  /**
+   * Drop the message instead of sending it while more than this many bytes are already
+   * waiting in the browser's send buffer (`socket.bufferedAmount`). For high-rate streams on
+   * a slow link, such as audio frames or per-tick input, where a late message is worse than
+   * none. `send()` returns `false`, and `onDrop` isn't called.
+   *
+   * Only checked while the socket is open: a message queued while disconnected is sent on
+   * open regardless. `bufferedAmount` includes what you sent earlier in the same task, so set
+   * it well above one burst of messages.
+   *
+   * @example
+   * ```ts
+   * voice.send(frame, { volatile: true, maxBuffered: 64 * 1024 });
+   * ```
+   */
+  maxBuffered?: number;
   /**
    * Called if the message is dropped from the queue without being sent: replaced by a
    * newer message with the same `key`, or evicted by `queue.limit`. Not called when the
-   * queue is cleared because the client closed or gave up.
+   * queue is cleared because the client closed or gave up, or when `send()` drops the
+   * message right away (`volatile` while not open, or `maxBuffered`) and returns `false`.
    */
   onDrop?: () => void;
 }
@@ -126,7 +154,7 @@ interface SendOptions {
 interface QueueOptions {
   /**
    * Maximum number of messages held while not connected. When full, the oldest
-   * message is dropped.
+   * message is dropped, skipping `priority` messages unless nothing else is queued.
    * @default Infinity
    */
   limit?: number;
@@ -309,12 +337,14 @@ interface WebSocketClient<In = unknown, Out = unknown> {
    * Send a message (encoded with `serialize`/`json` if configured). If the socket isn't
    * open, the message is queued and sent on open (see the `queue` option), unless
    * `options.volatile` is set.
-   * @returns `true` if it was sent immediately, `false` if it was queued or dropped.
+   * @returns `true` if it was sent immediately, `false` if it was queued or dropped
+   *   (`volatile` while not open, or `maxBuffered` while open).
    *
    * @example
    * ```ts
    * game.send({ type: 'input', dx, dy }, { volatile: true }); // never replayed after a reconnect
    * game.send({ type: 'position', x, y }, { key: 'position' }); // only the newest is queued
+   * game.send({ type: 'leave' }, { priority: true }); // ahead of everything already queued
    * ```
    */
   send(message: Out, options?: SendOptions): boolean;
@@ -457,20 +487,36 @@ interface WebSocketRequestsOptions<Req, In, Out> {
   reply: (message: In) => number | string | null | undefined;
   /**
    * Called on a reply. Return something other than `undefined` to reject the request with
-   * it instead of resolving, e.g. for a server-side error reply.
+   * it instead of resolving, e.g. for a server-side error reply. A stream throws it.
    */
   error?: (message: In) => unknown;
   /**
-   * Default time to wait for a reply, in ms. `Infinity` waits forever.
+   * Whether a reply is the last one of a stream. `stream()` needs it. That reply is yielded
+   * too, then the stream ends.
+   */
+  done?: (message: In) => boolean;
+  /**
+   * Build the message that tells the server to stop working on request `id`. Sent when this
+   * side gives up: the request's `signal` aborts, it times out, a loop over a stream exits
+   * early, or the manager is disposed. Not sent after the last reply, an error reply, a lost
+   * connection or `close()`.
+   */
+  cancel?: (id: number) => Out;
+  /**
+   * Default time to wait for a reply, in ms. For a stream, the time to wait for each reply,
+   * including the first. `Infinity` waits forever.
    * @default 10000
    */
   timeout?: number;
 }
-/** Per-call options for {@link WebSocketRequests.request}. */
+/** Per-call options for {@link WebSocketRequests.request} and {@link WebSocketRequests.stream}. */
 interface RequestOptions extends SendOptions {
-  /** Time to wait for a reply, in ms. Overrides the manager's `timeout`. */
+  /**
+   * Time to wait for a reply (for a stream, for each reply), in ms. Overrides the manager's
+   * `timeout`.
+   */
   timeout?: number;
-  /** Abort the request. It rejects with `signal.reason`. A late reply is ignored. */
+  /** Abort the request. It rejects (a stream throws) with `signal.reason`. A late reply is ignored. */
   signal?: AbortSignal;
 }
 /** Request/response over one client. Create with {@link createWebSocketRequests}. */
@@ -487,7 +533,26 @@ interface WebSocketRequests<Req, In> {
    * queue (replaced by a newer request with the same `key`, or evicted by `queue.limit`).
    */
   request(message: Req, options?: RequestOptions): Promise<In>;
-  /** Number of requests waiting for a reply. */
+  /**
+   * Send a request and iterate over its replies, up to and including the one `done` matches.
+   * Holds the connection until the stream ends. Needs the `done` option.
+   *
+   * `timeout` is the time to wait for each reply. Replies that arrive before the loop reads
+   * them are buffered. The stream is one-shot: iterate it once.
+   *
+   * Fails where `request()` rejects, with the same errors, after yielding the replies already
+   * received. Aborting `signal` throws `signal.reason` right away and discards them. Leaving
+   * the loop early, aborting and timing out send `cancel`.
+   *
+   * @example
+   * ```ts
+   * for await (const reply of rpc.stream({ type: 'ask', prompt }, { signal })) {
+   *   text += reply.delta;
+   * }
+   * ```
+   */
+  stream(message: Req, options?: RequestOptions): AsyncIterableIterator<In>;
+  /** Number of requests and streams waiting for a reply. */
   pending(): number;
   /** Reject every pending request and stop listening. Only needed for managers created dynamically. */
   dispose(): void;
@@ -649,6 +714,85 @@ interface WebSocketResponder<P = unknown, R = unknown> {
  */
 export declare function createWebSocketResponder<Q extends RequestFields, R, In, const Out>(client: WebSocketClient<In, Out>, options: WebSocketResponderOptions<Q, R, NoInfer<In>, NoInfer<Out>>): WebSocketResponder<ParamsOf<Q>, R>;
 //#endregion
+//#region src/sendrate.d.ts
+/** Options for {@link createWebSocketSendRate}. */
+interface WebSocketSendRateOptions {
+  /**
+   * Ticks per second while the connection keeps up.
+   * @default 30
+   */
+  maxRate?: number;
+  /**
+   * The rate never drops below this, in ticks per second.
+   * @default 5
+   */
+  minRate?: number;
+  /**
+   * Bytes waiting in the browser's send buffer (`socket.bufferedAmount`) above which a tick
+   * sends nothing and the rate halves.
+   * @default 1024
+   */
+  maxBuffered?: number;
+  /**
+   * Measurements from `createWebSocketLatency` on the same client. With them, a round-trip time
+   * that rises also lowers the rate. Without them, only the send buffer is watched.
+   */
+  latency?: Pick<WebSocketLatency, 'getSnapshot'>;
+  /**
+   * How far `rtt` may rise above the lowest one measured on this connection before the rate
+   * halves, in ms. A steady high ping keeps the full rate; only a rising one counts.
+   * @default 100
+   */
+  maxRttIncrease?: number;
+}
+/** The current send rate. A new object is created on every change. */
+interface SendRate {
+  /** Ticks per second, rounded. */
+  readonly rate: number;
+  /**
+   * Whether the last tick found the link congested: the send buffer above `maxBuffered`, or
+   * `rtt` risen more than `maxRttIncrease`.
+   */
+  readonly congested: boolean;
+}
+/** Keyed sends coalesced at a rate that adapts to the link. Create with {@link createWebSocketSendRate}. */
+interface WebSocketSendRate<Out> {
+  /** The client the messages are sent on. */
+  readonly client: WebSocketClient<any, Out>;
+  /**
+   * Send `message` at the next tick. A message with the same `key` still waiting for it is
+   * replaced, so only the newest one goes out. Sent with `volatile`.
+   */
+  send(message: Out, key: string): void;
+  /** Send everything waiting now, e.g. right before a one-shot action that must carry the latest aim. */
+  flush(): void;
+  /** The current {@link SendRate}. Returns the same object until it changes. */
+  getSnapshot(): SendRate;
+  /** Called whenever the rate or `congested` changes. Compatible with `useSyncExternalStore`. */
+  subscribe(listener: () => void): () => void;
+  /** Stop sending and listening. Only needed for instances created dynamically. */
+  dispose(): void;
+}
+/**
+ * Send high-rate state, such as aim, cursor or position, at a rate that adapts to the
+ * connection. Messages are coalesced per key between ticks. The rate drops by half when the
+ * send buffer fills up or the round trip grows, and climbs back one tick per second at a time
+ * when the link keeps up, so players on a poor connection degrade smoothly instead of building
+ * up lag.
+ *
+ * Ticks run only while the socket is open and something is waiting. Messages waiting during a
+ * reconnect go out after it; `close()` drops them. It doesn't open the connection by itself.
+ *
+ * @example
+ * ```ts
+ * export const stream = createWebSocketSendRate(game, { latency, maxRate: 30 });
+ *
+ * // On every pointer move: at most 30 a second, fewer on a congested link.
+ * stream.send({ type: 'aim', angle }, 'aim');
+ * ```
+ */
+export declare function createWebSocketSendRate<Out>(client: WebSocketClient<any, Out>, options?: WebSocketSendRateOptions): WebSocketSendRate<Out>;
+//#endregion
 //#region src/state.d.ts
 /** Options for {@link createWebSocketState}. */
 interface WebSocketStateOptions<S, In> {
@@ -659,6 +803,17 @@ interface WebSocketStateOptions<S, In> {
    * change, or the same `state` to ignore the message (subscribers aren't notified).
    */
   reduce: (state: S, message: In) => S;
+  /**
+   * `'frame'`: notify subscribers at most once per animation frame instead of once per
+   * message, so a fast stream (tokens, tickers, game state) renders once per frame.
+   * `getState()` is always current; only notifications wait. `setState` and `reset` still
+   * notify right away.
+   *
+   * Browsers pause animation frames in background tabs: the state keeps up, and subscribers
+   * hear about it when the tab is visible again. Without `requestAnimationFrame` (Node, some
+   * workers), it waits about 16 ms instead.
+   */
+  batch?: 'frame';
 }
 /**
  * State derived from a client's messages. Read it with `useWebSocketState(store, selector)`,
@@ -748,5 +903,5 @@ interface WebSocketTopics {
  */
 export declare function createWebSocketTopics<const Out>(client: WebSocketClient<any, Out>, options: WebSocketTopicsOptions<NoInfer<Out>>): WebSocketTopics;
 //#endregion
-export type { CloseInfo, EventMap, HeartbeatOptions, IncomingRequest, Latency, QueueOptions, ReconnectOptions, RequestHandler, RequestOptions, SendData, SendOptions, Snapshot, StandardSchemaV1, Status, UrlSource, WebSocketClient, WebSocketLatency, WebSocketLatencyOptions, WebSocketOptions, WebSocketRequests, WebSocketRequestsOptions, WebSocketResponder, WebSocketResponderOptions, WebSocketState, WebSocketStateOptions, WebSocketTopics, WebSocketTopicsOptions };
+export type { CloseInfo, EventMap, HeartbeatOptions, IncomingRequest, Latency, QueueOptions, ReconnectOptions, RequestHandler, RequestOptions, SendData, SendOptions, SendRate, Snapshot, StandardSchemaV1, Status, UrlSource, WebSocketClient, WebSocketLatency, WebSocketLatencyOptions, WebSocketOptions, WebSocketRequests, WebSocketRequestsOptions, WebSocketResponder, WebSocketResponderOptions, WebSocketSendRate, WebSocketSendRateOptions, WebSocketState, WebSocketStateOptions, WebSocketTopics, WebSocketTopicsOptions };
 //# sourceMappingURL=core.d.ts.map