@game_ryo/lsji 0.3.0 → 1.0.0

package/src/server/ui/node_modules/socket.io-client/build/esm/url.d.ts

@@ -0,0 +1,33 @@
+type ParsedUrl = {
+    source: string;
+    protocol: string;
+    authority: string;
+    userInfo: string;
+    user: string;
+    password: string;
+    host: string;
+    port: string;
+    relative: string;
+    path: string;
+    directory: string;
+    file: string;
+    query: string;
+    anchor: string;
+    pathNames: Array<string>;
+    queryKey: {
+        [key: string]: string;
+    };
+    id: string;
+    href: string;
+};
+/**
+ * URL parser.
+ *
+ * @param uri - url
+ * @param path - the request path of the connection
+ * @param loc - An object meant to mimic window.location.
+ *        Defaults to window.location.
+ * @public
+ */
+export declare function url(uri: string | ParsedUrl, path?: string, loc?: Location): ParsedUrl;
+export {};

package/src/server/ui/node_modules/socket.io-client/build/esm/url.js

@@ -0,0 +1,59 @@
+import { parse } from "engine.io-client";
+/**
+ * URL parser.
+ *
+ * @param uri - url
+ * @param path - the request path of the connection
+ * @param loc - An object meant to mimic window.location.
+ *        Defaults to window.location.
+ * @public
+ */
+export function url(uri, path = "", loc) {
+    let obj = uri;
+    // default to window.location
+    loc = loc || (typeof location !== "undefined" && location);
+    if (null == uri)
+        uri = loc.protocol + "//" + loc.host;
+    // relative path support
+    if (typeof uri === "string") {
+        if ("/" === uri.charAt(0)) {
+            if ("/" === uri.charAt(1)) {
+                uri = loc.protocol + uri;
+            }
+            else {
+                uri = loc.host + uri;
+            }
+        }
+        if (!/^(https?|wss?):\/\//.test(uri)) {
+            if ("undefined" !== typeof loc) {
+                uri = loc.protocol + "//" + uri;
+            }
+            else {
+                uri = "https://" + uri;
+            }
+        }
+        // parse
+        obj = parse(uri);
+    }
+    // make sure we treat `localhost:80` and `localhost` equally
+    if (!obj.port) {
+        if (/^(http|ws)$/.test(obj.protocol)) {
+            obj.port = "80";
+        }
+        else if (/^(http|ws)s$/.test(obj.protocol)) {
+            obj.port = "443";
+        }
+    }
+    obj.path = obj.path || "/";
+    const ipv6 = obj.host.indexOf(":") !== -1;
+    const host = ipv6 ? "[" + obj.host + "]" : obj.host;
+    // define unique id
+    obj.id = obj.protocol + "://" + host + ":" + obj.port + path;
+    // define href
+    obj.href =
+        obj.protocol +
+            "://" +
+            host +
+            (loc && loc.port === obj.port ? "" : ":" + obj.port);
+    return obj;
+}

package/src/server/ui/node_modules/socket.io-client/build/esm-debug/browser-entrypoint.d.ts

@@ -0,0 +1,2 @@
+import { io } from "./index.js";
+export default io;

package/src/server/ui/node_modules/socket.io-client/build/esm-debug/browser-entrypoint.js

@@ -0,0 +1,2 @@
+import { io } from "./index.js";
+export default io;

package/src/server/ui/node_modules/socket.io-client/build/esm-debug/contrib/backo2.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Initialize backoff timer with `opts`.
+ *
+ * - `min` initial timeout in milliseconds [100]
+ * - `max` max timeout [10000]
+ * - `jitter` [0]
+ * - `factor` [2]
+ *
+ * @param {Object} opts
+ * @api public
+ */
+export declare function Backoff(opts: any): void;

package/src/server/ui/node_modules/socket.io-client/build/esm-debug/contrib/backo2.js

@@ -0,0 +1,66 @@
+/**
+ * Initialize backoff timer with `opts`.
+ *
+ * - `min` initial timeout in milliseconds [100]
+ * - `max` max timeout [10000]
+ * - `jitter` [0]
+ * - `factor` [2]
+ *
+ * @param {Object} opts
+ * @api public
+ */
+export function Backoff(opts) {
+    opts = opts || {};
+    this.ms = opts.min || 100;
+    this.max = opts.max || 10000;
+    this.factor = opts.factor || 2;
+    this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter : 0;
+    this.attempts = 0;
+}
+/**
+ * Return the backoff duration.
+ *
+ * @return {Number}
+ * @api public
+ */
+Backoff.prototype.duration = function () {
+    var ms = this.ms * Math.pow(this.factor, this.attempts++);
+    if (this.jitter) {
+        var rand = Math.random();
+        var deviation = Math.floor(rand * this.jitter * ms);
+        ms = (Math.floor(rand * 10) & 1) == 0 ? ms - deviation : ms + deviation;
+    }
+    return Math.min(ms, this.max) | 0;
+};
+/**
+ * Reset the number of attempts.
+ *
+ * @api public
+ */
+Backoff.prototype.reset = function () {
+    this.attempts = 0;
+};
+/**
+ * Set the minimum duration
+ *
+ * @api public
+ */
+Backoff.prototype.setMin = function (min) {
+    this.ms = min;
+};
+/**
+ * Set the maximum duration
+ *
+ * @api public
+ */
+Backoff.prototype.setMax = function (max) {
+    this.max = max;
+};
+/**
+ * Set the jitter
+ *
+ * @api public
+ */
+Backoff.prototype.setJitter = function (jitter) {
+    this.jitter = jitter;
+};

package/src/server/ui/node_modules/socket.io-client/build/esm-debug/index.d.ts

@@ -0,0 +1,29 @@
+import { Manager, ManagerOptions } from "./manager.js";
+import { DisconnectDescription, Socket, SocketOptions } from "./socket.js";
+/**
+ * Looks up an existing `Manager` for multiplexing.
+ * If the user summons:
+ *
+ *   `io('http://localhost/a');`
+ *   `io('http://localhost/b');`
+ *
+ * We reuse the existing instance based on same scheme/port/host,
+ * and we initialize sockets for each namespace.
+ *
+ * @public
+ */
+declare function lookup(opts?: Partial<ManagerOptions & SocketOptions>): Socket;
+declare function lookup(uri?: string, opts?: Partial<ManagerOptions & SocketOptions>): Socket;
+/**
+ * Protocol version.
+ *
+ * @public
+ */
+export { protocol } from "socket.io-parser";
+/**
+ * Expose constructors for standalone build.
+ *
+ * @public
+ */
+export { DisconnectDescription, Manager, ManagerOptions, Socket, SocketOptions, lookup as io, lookup as connect, lookup as default, };
+export { Fetch, NodeXHR, XHR, NodeWebSocket, WebSocket, WebTransport, } from "engine.io-client";

package/src/server/ui/node_modules/socket.io-client/build/esm-debug/index.js

@@ -0,0 +1,62 @@
+import { url } from "./url.js";
+import { Manager } from "./manager.js";
+import { Socket } from "./socket.js";
+import debugModule from "debug"; // debug()
+const debug = debugModule("socket.io-client"); // debug()
+/**
+ * Managers cache.
+ */
+const cache = {};
+function lookup(uri, opts) {
+    if (typeof uri === "object") {
+        opts = uri;
+        uri = undefined;
+    }
+    opts = opts || {};
+    const parsed = url(uri, opts.path || "/socket.io");
+    const source = parsed.source;
+    const id = parsed.id;
+    const path = parsed.path;
+    const sameNamespace = cache[id] && path in cache[id]["nsps"];
+    const newConnection = opts.forceNew ||
+        opts["force new connection"] ||
+        false === opts.multiplex ||
+        sameNamespace;
+    let io;
+    if (newConnection) {
+        debug("ignoring socket cache for %s", source);
+        io = new Manager(source, opts);
+    }
+    else {
+        if (!cache[id]) {
+            debug("new io instance for %s", source);
+            cache[id] = new Manager(source, opts);
+        }
+        io = cache[id];
+    }
+    if (parsed.query && !opts.query) {
+        opts.query = parsed.queryKey;
+    }
+    return io.socket(parsed.path, opts);
+}
+// so that "lookup" can be used both as a function (e.g. `io(...)`) and as a
+// namespace (e.g. `io.connect(...)`), for backward compatibility
+Object.assign(lookup, {
+    Manager,
+    Socket,
+    io: lookup,
+    connect: lookup,
+});
+/**
+ * Protocol version.
+ *
+ * @public
+ */
+export { protocol } from "socket.io-parser";
+/**
+ * Expose constructors for standalone build.
+ *
+ * @public
+ */
+export { Manager, Socket, lookup as io, lookup as connect, lookup as default, };
+export { Fetch, NodeXHR, XHR, NodeWebSocket, WebSocket, WebTransport, } from "engine.io-client";

package/src/server/ui/node_modules/socket.io-client/build/esm-debug/manager.d.ts

@@ -0,0 +1,295 @@
+import { Socket as Engine, SocketOptions as EngineOptions } from "engine.io-client";
+import { Socket, SocketOptions, DisconnectDescription } from "./socket.js";
+import { Packet } from "socket.io-parser";
+import { DefaultEventsMap, EventsMap, Emitter } from "@socket.io/component-emitter";
+export interface ManagerOptions extends EngineOptions {
+    /**
+     * Should we force a new Manager for this connection?
+     * @default false
+     */
+    forceNew: boolean;
+    /**
+     * Should we multiplex our connection (reuse existing Manager) ?
+     * @default true
+     */
+    multiplex: boolean;
+    /**
+     * The path to get our client file from, in the case of the server
+     * serving it
+     * @default '/socket.io'
+     */
+    path: string;
+    /**
+     * Should we allow reconnections?
+     * @default true
+     */
+    reconnection: boolean;
+    /**
+     * How many reconnection attempts should we try?
+     * @default Infinity
+     */
+    reconnectionAttempts: number;
+    /**
+     * The time delay in milliseconds between reconnection attempts
+     * @default 1000
+     */
+    reconnectionDelay: number;
+    /**
+     * The max time delay in milliseconds between reconnection attempts
+     * @default 5000
+     */
+    reconnectionDelayMax: number;
+    /**
+     * Used in the exponential backoff jitter when reconnecting
+     * @default 0.5
+     */
+    randomizationFactor: number;
+    /**
+     * The timeout in milliseconds for our connection attempt
+     * @default 20000
+     */
+    timeout: number;
+    /**
+     * Should we automatically connect?
+     * @default true
+     */
+    autoConnect: boolean;
+    /**
+     * the parser to use. Defaults to an instance of the Parser that ships with socket.io.
+     */
+    parser: any;
+}
+interface ManagerReservedEvents {
+    open: () => void;
+    error: (err: Error) => void;
+    ping: () => void;
+    packet: (packet: Packet) => void;
+    close: (reason: string, description?: DisconnectDescription) => void;
+    reconnect_failed: () => void;
+    reconnect_attempt: (attempt: number) => void;
+    reconnect_error: (err: Error) => void;
+    reconnect: (attempt: number) => void;
+}
+export declare class Manager<ListenEvents extends EventsMap = DefaultEventsMap, EmitEvents extends EventsMap = ListenEvents> extends Emitter<{}, {}, ManagerReservedEvents> {
+    /**
+     * The Engine.IO client instance
+     *
+     * @public
+     */
+    engine: Engine;
+    /**
+     * @private
+     */
+    _autoConnect: boolean;
+    /**
+     * @private
+     */
+    _readyState: "opening" | "open" | "closed";
+    /**
+     * @private
+     */
+    _reconnecting: boolean;
+    private readonly uri;
+    opts: Partial<ManagerOptions>;
+    private nsps;
+    private subs;
+    private backoff;
+    private setTimeoutFn;
+    private clearTimeoutFn;
+    private _reconnection;
+    private _reconnectionAttempts;
+    private _reconnectionDelay;
+    private _randomizationFactor;
+    private _reconnectionDelayMax;
+    private _timeout;
+    private encoder;
+    private decoder;
+    private skipReconnect;
+    /**
+     * `Manager` constructor.
+     *
+     * @param uri - engine instance or engine uri/opts
+     * @param opts - options
+     * @public
+     */
+    constructor(opts: Partial<ManagerOptions>);
+    constructor(uri?: string, opts?: Partial<ManagerOptions>);
+    constructor(uri?: string | Partial<ManagerOptions>, opts?: Partial<ManagerOptions>);
+    /**
+     * Sets the `reconnection` config.
+     *
+     * @param {Boolean} v - true/false if it should automatically reconnect
+     * @return {Manager} self or value
+     * @public
+     */
+    reconnection(v: boolean): this;
+    reconnection(): boolean;
+    reconnection(v?: boolean): this | boolean;
+    /**
+     * Sets the reconnection attempts config.
+     *
+     * @param {Number} v - max reconnection attempts before giving up
+     * @return {Manager} self or value
+     * @public
+     */
+    reconnectionAttempts(v: number): this;
+    reconnectionAttempts(): number;
+    reconnectionAttempts(v?: number): this | number;
+    /**
+     * Sets the delay between reconnections.
+     *
+     * @param {Number} v - delay
+     * @return {Manager} self or value
+     * @public
+     */
+    reconnectionDelay(v: number): this;
+    reconnectionDelay(): number;
+    reconnectionDelay(v?: number): this | number;
+    /**
+     * Sets the randomization factor
+     *
+     * @param v - the randomization factor
+     * @return self or value
+     * @public
+     */
+    randomizationFactor(v: number): this;
+    randomizationFactor(): number;
+    randomizationFactor(v?: number): this | number;
+    /**
+     * Sets the maximum delay between reconnections.
+     *
+     * @param v - delay
+     * @return self or value
+     * @public
+     */
+    reconnectionDelayMax(v: number): this;
+    reconnectionDelayMax(): number;
+    reconnectionDelayMax(v?: number): this | number;
+    /**
+     * Sets the connection timeout. `false` to disable
+     *
+     * @param v - connection timeout
+     * @return self or value
+     * @public
+     */
+    timeout(v: number | boolean): this;
+    timeout(): number | boolean;
+    timeout(v?: number | boolean): this | number | boolean;
+    /**
+     * Starts trying to reconnect if reconnection is enabled and we have not
+     * started reconnecting yet
+     *
+     * @private
+     */
+    private maybeReconnectOnOpen;
+    /**
+     * Sets the current transport `socket`.
+     *
+     * @param {Function} fn - optional, callback
+     * @return self
+     * @public
+     */
+    open(fn?: (err?: Error) => void): this;
+    /**
+     * Alias for open()
+     *
+     * @return self
+     * @public
+     */
+    connect(fn?: (err?: Error) => void): this;
+    /**
+     * Called upon transport open.
+     *
+     * @private
+     */
+    private onopen;
+    /**
+     * Called upon a ping.
+     *
+     * @private
+     */
+    private onping;
+    /**
+     * Called with data.
+     *
+     * @private
+     */
+    private ondata;
+    /**
+     * Called when parser fully decodes a packet.
+     *
+     * @private
+     */
+    private ondecoded;
+    /**
+     * Called upon socket error.
+     *
+     * @private
+     */
+    private onerror;
+    /**
+     * Creates a new socket for the given `nsp`.
+     *
+     * @return {Socket}
+     * @public
+     */
+    socket(nsp: string, opts?: Partial<SocketOptions>): Socket;
+    /**
+     * Called upon a socket close.
+     *
+     * @param socket
+     * @private
+     */
+    _destroy(socket: Socket): void;
+    /**
+     * Writes a packet.
+     *
+     * @param packet
+     * @private
+     */
+    _packet(packet: Partial<Packet & {
+        query: string;
+        options: any;
+    }>): void;
+    /**
+     * Clean up transport subscriptions and packet buffer.
+     *
+     * @private
+     */
+    private cleanup;
+    /**
+     * Close the current socket.
+     *
+     * @private
+     */
+    _close(): void;
+    /**
+     * Alias for close()
+     *
+     * @private
+     */
+    private disconnect;
+    /**
+     * Called when:
+     *
+     * - the low-level engine is closed
+     * - the parser encountered a badly formatted packet
+     * - all sockets are disconnected
+     *
+     * @private
+     */
+    private onclose;
+    /**
+     * Attempt a reconnection.
+     *
+     * @private
+     */
+    private reconnect;
+    /**
+     * Called upon successful reconnect.
+     *
+     * @private
+     */
+    private onreconnect;
+}
+export {};