@bikky/replication 1.0.13 → 1.0.14

package/Networking.js

@@ -1,768 +0,0 @@
-import { SmartArray } from "@bikky/smart-collections";
-import { Replicable } from "./Replicatable.js";
-import { IDPool } from "./IDPool.js";
-import { isPrimitiveValue } from "./Constants/SerialisationTypes.js";
-var InstanceByProxy = new Map();
-var LocalTime;
-let lastUpdate = Date.now();
-var Connections;
-(function (Connections) {
-    Connections.RemotesByID = new Map();
-    Connections.Remotes = new SmartArray();
-    Connections.Interfaces = new Map();
-    Connections.disconnectHandlers = new Map();
-    /**
-     * There's one RemoteConnection per remote PC. All instances reference the RemoteConnection.
-     * The RemoteConnection handles batching as well as keeping track of the ping of clients and
-     * how far behind they are.
-     */
-    class RemoteConnection {
-        constructor(id, connection) {
-            this.ping = -1;
-            this.pingHistory = [];
-            this.time = -1;
-            this.messages = [];
-            this.id = id;
-            this.socket = connection;
-            if ("on" in this.socket) {
-                this.socket.on("message", (body) => {
-                    var data = JSON.parse(body);
-                    if ("request" in data && data.request == "id") {
-                        //Ignore connection requests, they're handled in AddRemoteConnection.
-                        return;
-                    }
-                    this.recieveMessages(data, id);
-                });
-                this.socket.on("close", (code, reason) => {
-                    this.handleDisconnect();
-                });
-            }
-            else {
-                this.socket.onmessage = (event) => {
-                    var body = event.data;
-                    var data = JSON.parse(body);
-                    if ("request" in data && data.request == "id") {
-                        //Ignore connection requests, they're handled in AddRemoteConnection.
-                        return;
-                    }
-                    this.recieveMessages(data, id);
-                };
-                this.socket.onclose = (event) => {
-                    this.handleDisconnect();
-                };
-            }
-            Connections.disconnectHandlers.set(id, []);
-            Connections.RemotesByID.set(id, this);
-            Connections.Remotes.push(this);
-        }
-        handleDisconnect() {
-            for (var handler of Connections.disconnectHandlers.get(this.id)) {
-                handler();
-            }
-            Connections.RemotesByID.delete(this.id);
-            Connections.Remotes.remove(this);
-            for (var remoteInterface of Connections.Interfaces.values()) {
-                remoteInterface.removeConnection(this.id, this);
-            }
-            Connections.disconnectHandlers.delete(this.id);
-        }
-        recieveMessages(data, remoteID) {
-            this.ping = data.time - this.time;
-            this.pingHistory.unshift(this.ping);
-            if (this.pingHistory.length > 5) {
-                this.pingHistory.pop();
-            }
-            this.time = data.time;
-            if (!Messenger.isServer) {
-                //TODO: Add ping to this calculation, but ping should be calculated based on the messages' clientTime not serverTime.
-                LocalTime = data.time; // + this.ping / 2;
-                lastUpdate = Date.now();
-            }
-            for (var message of data.messages) {
-                var target = Connections.Interfaces.get(message.id);
-                if (target) {
-                    target.recieveMessage(message, remoteID);
-                }
-                else {
-                    console.error("Remote tried to send a message to", message.id, "but no interface by that id exists");
-                }
-            }
-        }
-        queueMessage(obj) {
-            this.messages.push(obj);
-        }
-        sendMessages() {
-            try {
-                if ("send" in this.socket) {
-                    this.socket.send(JSON.stringify({
-                        time: LocalTime,
-                        messages: this.messages
-                    }));
-                }
-                this.messages = [];
-            }
-            catch (e) {
-                console.log("------------------------------------------------");
-                console.log(e);
-                console.log("Failed to send message batch");
-                console.log("------------------------------------------------");
-            }
-        }
-    }
-    Connections.RemoteConnection = RemoteConnection;
-    //This has the traps for the proxy to send messages over the network.
-    class RemoteInstance {
-        constructor(remoteID, connection, remoteInterface) {
-            this.propertyMap = new Map();
-            this.remoteID = remoteID;
-            this.connection = connection;
-            this.interface = remoteInterface;
-        }
-        send(message) {
-            try {
-                this.connection.queueMessage(message);
-            }
-            catch (e) {
-                console.log("------------------------------------------------");
-                console.log(e);
-                console.log(message);
-                console.log("------------------------------------------------");
-            }
-        }
-        get(target, property) {
-            if (typeof property === "symbol") {
-                //this can be triggered by console logging a proxy so we should handle it nicely.
-                console.error("Can't invoke symbol on remote!");
-                return "This is a proxy";
-            }
-            var send = (property, ...args) => {
-                var key;
-                var promise = new Promise((resolve, reject) => {
-                    key = this.interface.addCompletion(resolve);
-                });
-                var data = {
-                    id: this.interface.objectID,
-                    property: property,
-                    args: args.map((e) => {
-                        if (Replicable.CanReference(e) && !isPrimitiveValue(e)) {
-                            return Replicable.Reference(e);
-                        }
-                        return ["Plain", e];
-                    }),
-                    key: key,
-                    from: Connections.LocalID,
-                    tick: LocalTime
-                };
-                this.send(data);
-                return promise;
-            };
-            if (typeof property === "string") {
-                var result = this.propertyMap.get(property);
-                if (result) {
-                    return result;
-                }
-                //Proxy has to wrap a function to be callable.
-                var proxy = new Proxy(() => { }, new PropertyProxy([property], send));
-                this.propertyMap.set(property, proxy);
-                return proxy;
-            }
-            else {
-                return (...args) => send(property, ...args);
-            }
-        }
-        //A trap for setting property values.
-        set(target, property, value, receiver) {
-            throw new Error("Don't set properties on remote objects directly, use the set function!");
-            //return false;
-        }
-        //A trap for a direct function call (not a method).
-        apply(...args) {
-            var key;
-            var promise = new Promise((resolve, reject) => {
-                key = this.interface.addCompletion(resolve);
-            });
-            var data = {
-                id: this.interface.objectID,
-                function: true,
-                args: args.map((e) => {
-                    if (Replicable.CanReference(e) && !isPrimitiveValue(e)) {
-                        return Replicable.Reference(e);
-                    }
-                    return ["Plain", e];
-                }),
-                key: key,
-                from: Connections.LocalID,
-                tick: LocalTime
-            };
-            this.send(data);
-            return promise;
-        }
-        //A trap for the new operator.
-        construct(target, args, newTarget) {
-            throw new Error("Construct Trap Not Implemented");
-            //return {};
-        }
-    }
-    Connections.RemoteInstance = RemoteInstance;
-    //This class allows you to send messages to property's functions. E.g. remote.property.foo.
-    //It was coded at midnight and in a rush, so it's poorly typed and named.
-    class PropertyProxy {
-        constructor(propertyPath, send) {
-            this.propertyMap = new Map();
-            this.propertyPath = propertyPath;
-            this.parentSend = send;
-        }
-        //A trap for getting property values.
-        get(target, property) {
-            if (typeof property === "symbol") {
-                //this can be triggered by console logging a proxy so we should handle it nicely.
-                console.error("Can't invoke symbol on remote!");
-                return "This is a proxy";
-            }
-            else {
-                if (typeof property === "string") {
-                    var result = this.propertyMap.get(property);
-                    if (result) {
-                        return result;
-                    }
-                    //Proxy has to wrap a function to be callable.
-                    var proxy = new Proxy(() => { }, new PropertyProxy([...this.propertyPath, property], this.parentSend));
-                    this.propertyMap.set(property, proxy);
-                    return proxy;
-                }
-                else {
-                    //property can be a number here, but I didn't want to update the typings everywhere.
-                    return (...args) => {
-                        return this.parentSend([...this.propertyPath, property], ...args);
-                    };
-                }
-            }
-        }
-        //A trap for setting property values.
-        set(target, property, value, receiver) {
-            throw new Error("Don't set properties on remote objects directly, use the set function!");
-            //return false;
-        }
-        //A trap for a direct function call (not a method).
-        apply(target, thisArg, args) {
-            return this.parentSend(this.propertyPath, ...args);
-        }
-    }
-    //This can hold one remote for client stuff (the server) or many remotes for server stuff (one for each client)
-    // and the user won't know the difference.
-    class RemoteInterface {
-        constructor(objectID, local) {
-            this.remotes = new Map();
-            this.nextKey = 0;
-            this.completions = new Map();
-            //Allows users to access sub-properties via getters.
-            this.propertyMap = new Map();
-            this.objectID = objectID;
-            this.local = local;
-            Connections.Interfaces.set(this.objectID, this);
-        }
-        divertMessages(newLocal) {
-            if (!this.oldLocal) {
-                this.oldLocal = this.local;
-            }
-            this.local = newLocal;
-        }
-        restoreMessageRecipient() {
-            if (this.oldLocal) {
-                this.local = this.oldLocal;
-                delete this.oldLocal;
-            }
-        }
-        getNewKey() {
-            var key = this.nextKey;
-            this.nextKey++;
-            return key;
-        }
-        addCompletion(resolver) {
-            var key = this.getNewKey();
-            this.completions.set(key, resolver);
-            return key;
-        }
-        addConnection(remoteID, connection) {
-            var remoteInstance = new RemoteInstance(remoteID, connection, this);
-            remoteInstance.proxy = new Proxy({}, remoteInstance);
-            InstanceByProxy.set(remoteInstance.proxy, remoteInstance);
-            this.remotes.set(remoteID, remoteInstance);
-        }
-        removeConnection(remoteID, connection) {
-            var instance = this.remotes.get(remoteID);
-            this.remotes.delete(remoteID);
-            return instance;
-        }
-        recieveMessage(data, remoteID) {
-            var remote = this.remotes.get(remoteID);
-            if (!remote) {
-                return;
-            }
-            if ("completion" in data) {
-                var completion = this.completions.get(data.key);
-                if (completion) {
-                    this.completions.delete(data.key);
-                    completion(data.result);
-                    return;
-                }
-                else {
-                    //throw new Error("Got a message for a completion that's already been completed");
-                    console.error("Got a message for a completion that's already been completed", data);
-                    return;
-                }
-            }
-            if (data.property) {
-                var objectID = this.objectID;
-                function sendResponse(result) {
-                    var response = {
-                        id: objectID,
-                        property: data.property,
-                        completion: true, //the function has finished being called.
-                        key: data.key,
-                        result: result,
-                        from: Connections.LocalID,
-                        tick: LocalTime
-                    };
-                    remote.send(response);
-                }
-                let args = data.args.map((e) => {
-                    if (Array.isArray(e) && e[0] === "Plain") {
-                        return e[1];
-                    }
-                    if (Replicable.IsReference(e)) {
-                        return Replicable.Dereference(e);
-                    }
-                    return e;
-                });
-                args.push({ connection: remote.proxy, id: data.from, tick: data.tick });
-                var target = this.local;
-                var prop = data.property;
-                if (Array.isArray(prop)) {
-                    for (var i = 0; i < prop.length - 1; i++) {
-                        target = target[prop[i]];
-                    }
-                    //Store the last one.
-                    prop = prop[i];
-                }
-                var returned = target[prop].apply(target, args);
-                if (returned instanceof Promise) {
-                    returned.then(sendResponse.bind(this));
-                }
-                else {
-                    sendResponse.call(this, returned);
-                }
-            }
-            if (data.function) {
-                let args = data.args.map((e) => {
-                    if (Array.isArray(e) && e[0] === "Plain") {
-                        return e[1];
-                    }
-                    if (Replicable.IsReference(e)) {
-                        return Replicable.Dereference(e);
-                    }
-                    return e;
-                });
-                args.push({ connection: remote.proxy, id: data.from, tick: data.tick });
-                this.local
-                    .apply(this.local, args)
-                    .then((result) => {
-                    var response = {
-                        id: this.objectID,
-                        property: data.property,
-                        completion: true, //the function has finished being called.
-                        key: data.key,
-                        result: result,
-                        from: Connections.LocalID,
-                        tick: LocalTime
-                    };
-                    remote.send(response);
-                });
-            }
-        }
-        //A trap for getting property values.
-        get(target, property) {
-            if (typeof property === "symbol") {
-                //this can be triggered by console logging a proxy so we should handle it nicely.
-                console.error("Can't invoke symbol on remote!");
-                return "This is a proxy";
-            }
-            else {
-                var send = (property, ...args) => {
-                    if (Messenger.isServer) {
-                        var promises = [];
-                        for (var remote of this.remotes.values()) {
-                            let remoteFunction = remote.get(target, property);
-                            promises.push(remoteFunction.apply(remote, args));
-                        }
-                        //Don't return results from every client - as this is probably unintentional.
-                        return new Promise((res, rej) => {
-                            Promise.all(promises)
-                                .then(() => res())
-                                .catch(rej);
-                        });
-                    }
-                    else {
-                        for (var remote of this.remotes.values()) {
-                            let remoteFunction = remote.get(target, property);
-                            return remoteFunction.apply(remote, args);
-                        }
-                    }
-                };
-                if (typeof property === "string") {
-                    var result = this.propertyMap.get(property);
-                    if (result) {
-                        return result;
-                    }
-                    //Proxy has to wrap a function to be callable.
-                    var proxy = new Proxy(() => { }, new PropertyProxy([property], send));
-                    this.propertyMap.set(property, proxy);
-                    return proxy;
-                }
-                else {
-                    return (...args) => send(property, ...args);
-                }
-            }
-        }
-        //A trap for setting property values.
-        set(target, property, value, receiver) {
-            throw new Error("Don't set properties on remote objects directly, use the set function!");
-            //return false;
-        }
-        //A trap for a direct function call (not a method).
-        apply(...args) {
-            return (...args) => {
-                if (Messenger.isServer) {
-                    var promises = [];
-                    for (var remote of this.remotes.values()) {
-                        promises.push(remote.apply(remote, args));
-                    }
-                    //Don't return results from every client - as this is probably unintentional.
-                    return new Promise((res, rej) => {
-                        Promise.all(promises)
-                            .then(() => res())
-                            .catch(rej);
-                    });
-                }
-                else {
-                    for (var remote of this.remotes.values()) {
-                        return remote.apply(remote, args);
-                    }
-                }
-            };
-        }
-        //A trap for the new operator.
-        construct(target, args, newTarget) {
-            throw new Error("Construct Trap Not Implemented");
-            //return {};
-        }
-    }
-    Connections.RemoteInterface = RemoteInterface;
-})(Connections || (Connections = {}));
-export var Messenger;
-(function (Messenger) {
-    var InterfaceByProxy = new Map();
-    Messenger.isConnected = false;
-    var resolveConnectPromise;
-    Messenger.connect = new Promise((resolve) => (resolveConnectPromise = resolve));
-    let serverID = null;
-    function prepareIPCLikeWebsocket(connectionToServer) {
-        if ("ipc" in connectionToServer) {
-            // IPCRenderer.
-            let socket = connectionToServer;
-            connectionToServer = {
-                send: (data) => {
-                    socket.send("message", data);
-                },
-                on: (channel, handler) => {
-                    socket.ipc.on(channel, (...args) => {
-                        if (args[1]) {
-                            return handler(args[1]);
-                        }
-                        else {
-                            return handler(args[0]);
-                        }
-                    });
-                },
-                once: (channel, handler) => {
-                    socket.ipc.once(channel, (...args) => {
-                        if (args[1]) {
-                            return handler(args[1]);
-                        }
-                        else {
-                            return handler(args[0]);
-                        }
-                    });
-                }
-            };
-        }
-        if ("emit" in connectionToServer) {
-            // IPCMain for a specific window.
-            let socket = connectionToServer;
-            connectionToServer = {
-                send: (data) => {
-                    socket.send("message", data);
-                },
-                on: (channel, handler) => {
-                    socket.on(channel, (...args) => {
-                        if (args[1]) {
-                            return handler(args[1]);
-                        }
-                        else {
-                            return handler(args[0]);
-                        }
-                    });
-                },
-                once: (channel, handler) => {
-                    socket.once(channel, (...args) => {
-                        if (args[1]) {
-                            return handler(args[1]);
-                        }
-                        else {
-                            return handler(args[0]);
-                        }
-                    });
-                }
-            };
-        }
-        return connectionToServer;
-    }
-    function initialise(isTheServer, connectionToServer) {
-        Messenger.isServer = isTheServer;
-        Messenger.isConnected = Messenger.isServer;
-        if (Messenger.isServer) {
-            LocalTime = 0;
-            lastUpdate = Date.now();
-            serverID = IDPool.useUUID();
-            Connections.LocalID = serverID;
-            resolveConnectPromise();
-        }
-        else {
-            if (!connectionToServer) {
-                throw new Error("Can't initialise client without a connection to the server");
-            }
-            connectionToServer = prepareIPCLikeWebsocket(connectionToServer);
-            let res;
-            let promise = new Promise((resolve) => res = resolve);
-            var initialised = false;
-            /**
-             * Because websockets don't connect until the client sends a message, we start up the client
-             * and send a pre-emptive message to the server. The return message should initialise the
-             * client with its own unique ID as well as the server's time.
-             */
-            function initClient(data) {
-                var message = JSON.parse(data);
-                initialised = true;
-                LocalTime = message.time;
-                Connections.LocalID = message.id;
-                Messenger.addRemoteConnection(message.serverID, connectionToServer);
-                setTimeout(async () => {
-                    res();
-                }, 1);
-            }
-            if ("once" in connectionToServer && connectionToServer.once) {
-                connectionToServer.once("message", initClient);
-            }
-            else if ("on" in connectionToServer) {
-                connectionToServer.on("message", (data) => {
-                    if (!initialised) {
-                        initClient(data);
-                    }
-                });
-            }
-            else {
-                connectionToServer.onmessage = (event) => {
-                    if (!initialised) {
-                        initClient(event.data);
-                    }
-                };
-            }
-            connectionToServer.send(JSON.stringify({ request: "id" }));
-            lastUpdate = Date.now();
-            return promise;
-        }
-    }
-    Messenger.initialise = initialise;
-    //var lastMessage = 0;
-    function tick() {
-        let nextUpdate = Date.now();
-        LocalTime += nextUpdate - lastUpdate;
-        lastUpdate = nextUpdate;
-        sendMessages();
-    }
-    Messenger.tick = tick;
-    function sendMessages() {
-        for (var conn of Connections.Remotes) {
-            conn.sendMessages();
-        }
-    }
-    Messenger.sendMessages = sendMessages;
-    function getLocalTime() {
-        return LocalTime;
-    }
-    Messenger.getLocalTime = getLocalTime;
-    function onDisconnect(id, handler) {
-        if (Connections.disconnectHandlers.has(id)) {
-            Connections.disconnectHandlers.get(id).push(handler);
-            return;
-        }
-        throw new Error("Can't add handler for connection that doesn't exist");
-    }
-    Messenger.onDisconnect = onDisconnect;
-    //Connection is any because it throws an error during compile on the server - WebSocket the type isn't defined on the server.
-    function addRemoteConnection(id, connection) {
-        let websocket = prepareIPCLikeWebsocket(connection);
-        let resolve;
-        let ready = new Promise((res) => resolve = res);
-        if (!Messenger.isServer) {
-            serverID = id;
-            var remote = new Connections.RemoteConnection(id, websocket);
-            for (var remoteInterface of Connections.Interfaces.values()) {
-                remoteInterface.addConnection(id, remote);
-            }
-            resolveConnectPromise();
-            resolve(remote);
-        }
-        else {
-            if ("on" in websocket) {
-                websocket.on("message", (data) => {
-                    var message = JSON.parse(data);
-                    if (message.request == "id") {
-                        var remote = new Connections.RemoteConnection(id, websocket);
-                        for (var remoteInterface of Connections.Interfaces.values()) {
-                            remoteInterface.addConnection(id, remote);
-                        }
-                        websocket.send(JSON.stringify({ response: "id", id: id, serverID: serverID, time: Messenger.getLocalTime() }));
-                        resolve(remote);
-                    }
-                });
-            }
-            else {
-                websocket.onmessage = (event) => {
-                    var message = JSON.parse(event.data);
-                    if (message.request == "id") {
-                        var remote = new Connections.RemoteConnection(id, websocket);
-                        for (var remoteInterface of Connections.Interfaces.values()) {
-                            remoteInterface.addConnection(id, remote);
-                        }
-                        websocket.send(JSON.stringify({ response: "id", id: id, serverID: serverID, time: Messenger.getLocalTime() }));
-                        resolve(remote);
-                    }
-                };
-            }
-        }
-        return ready;
-    }
-    Messenger.addRemoteConnection = addRemoteConnection;
-    //Local will usually be different to type even though they represent the same object/entity,
-    // because usually the server will have different functions to the client.
-    function newRemoteInterface(name, object) {
-        var remoteInterface = new Connections.RemoteInterface(name, object);
-        Connections.Interfaces.set(name, remoteInterface);
-        var proxy = new Proxy({}, remoteInterface);
-        InterfaceByProxy.set(proxy, remoteInterface);
-        for (var [id, connection] of Connections.RemotesByID.entries()) {
-            remoteInterface.addConnection(id, connection);
-        }
-        console.info("Made new interface", name, "for", object.__proto__.constructor.name, object.name || "");
-        return proxy;
-    }
-    Messenger.newRemoteInterface = newRemoteInterface;
-    function getInstanceForID(remoteInterface, id) {
-        var trueRemoteInterface = InterfaceByProxy.get(remoteInterface);
-        if (trueRemoteInterface) {
-            var remote = trueRemoteInterface.remotes.get(id);
-            if (remote) {
-                return remote.proxy;
-            }
-        }
-        return null;
-    }
-    Messenger.getInstanceForID = getInstanceForID;
-    function getAllInstancesExceptID(remoteInterface, id) {
-        var trueRemoteInterface = InterfaceByProxy.get(remoteInterface);
-        if (trueRemoteInterface) {
-            var instances = [];
-            for (var remote of trueRemoteInterface.remotes.values()) {
-                if (remote.remoteID !== id) {
-                    instances.push(remote.proxy);
-                }
-            }
-            return instances;
-        }
-        return null;
-    }
-    Messenger.getAllInstancesExceptID = getAllInstancesExceptID;
-    function getAllInstancesExcept(remoteInterface, remoteInstance) {
-        var trueRemoteInterface = InterfaceByProxy.get(remoteInterface);
-        if (trueRemoteInterface) {
-            var instances = [];
-            for (var remote of trueRemoteInterface.remotes.values()) {
-                if (remote.proxy != remoteInstance) {
-                    instances.push(remote.proxy);
-                }
-            }
-            return instances;
-        }
-        return null;
-    }
-    Messenger.getAllInstancesExcept = getAllInstancesExcept;
-    function getRemoteTime(id) {
-        return Connections.RemotesByID.get(id)?.time ?? null;
-    }
-    Messenger.getRemoteTime = getRemoteTime;
-    function getRemotePing(id) {
-        return Connections.RemotesByID.get(id)?.ping ?? null;
-    }
-    Messenger.getRemotePing = getRemotePing;
-    function getRemoteAvgPing(id) {
-        var remote = Connections.RemotesByID.get(id);
-        if (!remote)
-            return null;
-        return remote.pingHistory.reduce((a, b) => a + b) / remote.pingHistory.length;
-    }
-    Messenger.getRemoteAvgPing = getRemoteAvgPing;
-    function getIDForInstance(remoteInterface, remoteInstance) {
-        var trueRemoteInterface = InterfaceByProxy.get(remoteInterface);
-        if (trueRemoteInterface) {
-            for (var remote of trueRemoteInterface.remotes.values()) {
-                if (remote.proxy == remoteInstance) {
-                    return remote.remoteID;
-                }
-            }
-        }
-        return null;
-    }
-    Messenger.getIDForInstance = getIDForInstance;
-    function isRemoteProxy(remote) {
-        return InterfaceByProxy.has(remote) || InstanceByProxy.has(remote);
-    }
-    Messenger.isRemoteProxy = isRemoteProxy;
-    function getLocalID() {
-        return Connections.LocalID;
-    }
-    Messenger.getLocalID = getLocalID;
-    /**
-     * Will return the local id if on the server. Assumes that only the server connects to clients.
-     */
-    function getServerID() {
-        if (serverID === null) {
-            throw new Error(`Cannot get remote ID before server has connected/initialised.`);
-        }
-        return serverID;
-    }
-    Messenger.getServerID = getServerID;
-    //Diverts messages from their original target to a new target. Good for proxies.
-    function divertMessages(remote, newTarget) {
-        var rInterface = InterfaceByProxy.get(remote);
-        rInterface.divertMessages(newTarget);
-    }
-    Messenger.divertMessages = divertMessages;
-    //Restores diverted messages to their original target.
-    function restoreMessages(remote) {
-        var rInterface = InterfaceByProxy.get(remote);
-        rInterface.restoreMessageRecipient();
-    }
-    Messenger.restoreMessages = restoreMessages;
-})(Messenger || (Messenger = {}));
-//# sourceMappingURL=Networking.js.map