@leofcoin/chain 1.5.39 → 1.5.41

package/exports/browser/{index-34c93510-db72e006.js → index-7dedefe5-b92d7eab.js}

@@ -1,5 +1,5 @@
-import { M as MultiWallet, e as encrypt, b as base58$1 } from './node-browser-e7da3b14.js';
-import './index-526fd466.js';
+import { M as MultiWallet, e as encrypt, b as base58$1 } from './node-browser-ccc3409e.js';
+import './index-c3bd3090.js';
 
 /**
  * @params {String} network

package/exports/browser/{index-526fd466.js → index-c3bd3090.js}

@@ -12630,4 +12630,4 @@ class RawTransactionMessage extends FormatInterface {
     }
 }
 
-export { BigNumber as B, ContractMessage as C, Logger as L, RawTransactionMessage as R, TransactionMessage as T, ValidatorMessage as V, arrayify as a, isBytes as b, BlockMessage as c, BWMessage as d, BWRequestMessage as e, hexZeroPad as h, isBigNumberish as i, toBase58 as t, version as v };
+export { BigNumber as B, ContractMessage as C, Logger as L, RawTransactionMessage as R, TransactionMessage as T, ValidatorMessage as V, arrayify as a, isBytes as b, BlockMessage as c, BWMessage as d, BWRequestMessage as e, getDefaultExportFromCjs as g, hexZeroPad as h, isBigNumberish as i, toBase58 as t, version as v };

package/exports/browser/{messages-b7f41cba-61105b71.js → messages-7cab2a51-aba26369.js}

@@ -1,5 +1,5 @@
-import { F as FormatInterface } from './node-browser-e7da3b14.js';
-import './index-526fd466.js';
+import { F as FormatInterface } from './node-browser-ccc3409e.js';
+import './index-c3bd3090.js';
 
 var proto$b = {
   data: new Uint8Array(),

package/exports/browser/{node-browser-e7da3b14.js → node-browser-ccc3409e.js}

@@ -1,4 +1,4 @@
-import { C as ContractMessage, T as TransactionMessage, c as BlockMessage, d as BWMessage, e as BWRequestMessage, V as ValidatorMessage } from './index-526fd466.js';
+import { C as ContractMessage, T as TransactionMessage, c as BlockMessage, d as BWMessage, e as BWRequestMessage, V as ValidatorMessage } from './index-c3bd3090.js';
 
 var nodeConfig = async (config = {
     network: 'leofcoin:peach',
@@ -27178,7 +27178,7 @@ class Identity {
             this.selectedAccount = new TextDecoder().decode(selected);
         }
         else {
-            const importee = await import(/* webpackChunkName: "generate-account" */ './index-34c93510-db72e006.js');
+            const importee = await import(/* webpackChunkName: "generate-account" */ './index-7dedefe5-b92d7eab.js');
             const { identity, accounts } = await importee.default(password, this.network);
             await globalThis.accountStore.put('public', JSON.stringify({ walletId: identity.walletId }));
             await globalThis.walletStore.put('version', String(1));
@@ -27254,17 +27254,18 @@ class Peernet {
     autoStart = true;
     #starting = false;
     #started = false;
-    #connections = {};
     requestProtos = {};
     _messageHandler;
     _peerHandler;
     protos;
+    version;
     /**
      * @access public
      * @param {Object} options
      * @param {String} options.network - desired network
      * @param {String} options.stars - star list for selected network (these should match, don't mix networks)
      * @param {String} options.root - path to root directory
+     * @param {String} options.version - path to root directory
      * @param {String} options.storePrefix - prefix for datatores (lfc)
      *
      * @return {Promise} instance of Peernet
@@ -27279,6 +27280,7 @@ class Peernet {
         this.network = options.network || 'leofcoin';
         this.autoStart = options.autoStart === undefined ? true : options.autoStart;
         this.stars = options.stars;
+        this.version = options.version;
         const parts = this.network.split(':');
         this.networkVersion = options.networkVersion || parts.length > 1 ? parts[1] : 'mainnet';
         if (!options.storePrefix)
@@ -27343,13 +27345,10 @@ class Peernet {
      * @return {Array} peerId
      */
     get peers() {
-        return Object.entries(this.#connections);
+        return Object.entries(this.client?.connections);
     }
     get connections() {
-        return Object.values(this.#connections);
-    }
-    get peerEntries() {
-        return Object.values(this.#connections);
+        return this.client?.connections || {};
     }
     /**
      * @return {String} id - peerId
@@ -27370,7 +27369,7 @@ class Peernet {
         this.root = options.root;
         const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile
         // FolderMessageResponse
-         } = await import(/* webpackChunkName: "messages" */ './messages-b7f41cba-61105b71.js');
+         } = await import(/* webpackChunkName: "messages" */ './messages-7cab2a51-aba26369.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -27404,80 +27403,321 @@ class Peernet {
         await this.identity.load(password);
         this._peerHandler = new PeerDiscovery(this.id);
         this.peerId = this.id;
-        this.addRequestHandler('handshake', () => {
-            return new peernet.protos['peernet-response']({
-                response: { peerId: this.id }
-            });
-        });
-        pubsub.subscribe('peer:discovered', async (peer) => {
-            // console.log(peer);
-            if (this.requestProtos['version']) {
-                let data = await new globalThis.peernet.protos['peernet-request']({
-                    request: 'version'
-                });
-                let node = await globalThis.peernet.prepareMessage(data);
-                let response = await peer.request(node.encoded);
-                response = await new globalThis.peernet.protos['peernet-response'](new Uint8Array(Object.values(response)));
-                peer.version = response.decoded.response.version;
-            }
-            let data = await new globalThis.peernet.protos['peernet-request']({
-                request: 'handshake'
-            });
-            let node = await globalThis.peernet.prepareMessage(data);
-            let response = await peer.request(node.encoded);
-            response = await new globalThis.peernet.protos['peernet-response'](new Uint8Array(Object.values(response)));
-            // todo: response.decoded should be the response and not response.peerId
-            this.#connections[response.decoded.response.peerId] = peer;
-            pubsub.publish('peer:connected', peer);
-            // todo: cleanup discovered
-        });
-        pubsub.subscribe('peer:left', this.#peerLeft.bind(this));
+        // this.addRequestHandler('handshake', () => {
+        //   return new peernet.protos['peernet-response']({
+        //     response: { peerId: this.id }
+        //   })
+        // })
+        // pubsub.subscribe('peer:discovered', async (peer) => {
+        //   // console.log(peer);
+        //   if (this.requestProtos['version'] && !peer.version) {
+        //     let data = await new globalThis.peernet.protos['peernet-request']({
+        //       request: 'version'
+        //     })
+        //     let node = await globalThis.peernet.prepareMessage(data)
+        //     let response = await peer.request(node.encoded)
+        //     response = await new globalThis.peernet.protos['peernet-response'](new Uint8Array(Object.values(response)))
+        //     peer.version = response.decoded.response.version
+        //   }
+        //   if (!peer.peerId) {
+        //     let data = await new globalThis.peernet.protos['peernet-request']({
+        //       request: 'handshake'
+        //     })
+        //     let node = await globalThis.peernet.prepareMessage(data)
+        //     let response = await peer.request(node.encoded)
+        //     response = await new globalThis.peernet.protos['peernet-response'](new Uint8Array(Object.values(response)))
+        //     // todo: response.decoded should be the response and not response.peerId
+        //     // todo: ignore above and remove discover completly
+        //     response.decoded.response.peerId
+        //   }
+        // this.connections[peer.peerId] = peer
+        // pubsub.publish('peer:connected', peer)
+        // todo: cleanup discovered
+        // })
+        // pubsub.subscribe('peer:left', this.#peerLeft.bind(this))
         /**
          * converts data -> message -> proto
          * @see DataHandler
          */
         pubsub.subscribe('peer:data', dataHandler);
+        // // todo: remove below, already handles in the swarm
+        // if (globalThis.navigator) {
+        //   globalThis.addEventListener('beforeunload', async () => this.client.close())
+        // } else {
+        //   process.on('SIGTERM', async () => {
+        //     process.stdin.resume()
+        //     try {
+        //       await this.client.close()
+        //     } catch (error) {
+        //       // @ts-ignore
+        //       await this.client.close()
+        //     }
+        //     process.exit()
+        //   })
+        // }
+        if (this.autoStart)
+            await this.start();
+        return this;
+    }
+    async start() {
+        if (this.#starting || this.#started)
+            return;
+        this.#starting = true;
+        const importee = class Client {
+    #peerId;
+    #connections = {};
+    #stars = {};
+    #connectEvent = 'peer:connected';
+    id;
+    networkVersion;
+    starsConfig;
+    socketClient;
+    messageSize = 262144;
+    version;
+    #messagesToHandle = {};
+    get peerId() {
+        return this.#peerId;
+    }
+    get connections() {
+        return { ...this.#connections };
+    }
+    get peers() {
+        return Object.entries(this.#connections);
+    }
+    getPeer(peerId) {
+        return this.#connections[peerId];
+    }
+    /**
+     *
+     * @param options {object}
+     * @param options.peerId {string}
+     * @param options.networkVersion {string}
+     * @param options.version {string}
+     * @param options.stars {string[]}
+     * @param options.connectEvent {string} defaults to peer:connected, can be renamed to handle different protocols, like peer:discovered (setup peer props before fireing the connect event)
+     */
+    constructor(options) {
+        const { peerId, networkVersion, version, connectEvent, stars } = {
+            ...defaultOptions,
+            ...options
+        };
+        this.#peerId = peerId;
+        this.networkVersion = networkVersion;
+        this.version = version;
+        this.#connectEvent = connectEvent;
+        this.starsConfig = stars;
+        this._init();
+    }
+    async _init() {
+        // reconnectJob()
+        if (!globalThis.RTCPeerConnection)
+            globalThis.wrtc = (await import('./browser-2c73e2ef-2c73e2ef.js').then(function (n) { return n.b; })).default;
+        for (const star of this.starsConfig) {
+            try {
+                const client = new SocketRequestClient(star, this.networkVersion);
+                this.#stars[star] = await client.init();
+                this.setupStarListeners(this.#stars[star]);
+                this.#stars[star].send({
+                    url: 'join',
+                    params: { version: this.version, peerId: this.peerId }
+                });
+            }
+            catch (e) {
+                if (this.starsConfig.indexOf(star) === this.starsConfig.length - 1 &&
+                    !this.socketClient)
+                    throw new Error(`No star available to connect`);
+            }
+        }
         if (globalThis.navigator) {
-            globalThis.addEventListener('beforeunload', async () => this.client.destroy());
+            globalThis.addEventListener('beforeunload', async () => this.close());
         }
         else {
-            process.on('SIGTERM', async () => {
+            process.on('SIGINT', async () => {
                 process.stdin.resume();
-                try {
-                    await this.client.destroy();
-                }
-                catch (error) {
-                    // @ts-ignore
-                    await this.client.close();
-                }
+                await this.close();
                 process.exit();
             });
         }
-        if (this.autoStart)
-            await this.start();
-        return this;
     }
-    async start() {
-        if (this.#starting || this.#started)
+    setupStarListeners(star) {
+        star.pubsub.subscribe('peer:joined', (id) => this.#peerJoined(id, star));
+        star.pubsub.subscribe('peer:left', (id) => this.#peerLeft(id, star));
+        star.pubsub.subscribe('star:joined', this.#starJoined);
+        star.pubsub.subscribe('star:left', this.#starLeft);
+        star.pubsub.subscribe('signal', (message) => this.#inComingSignal(message, star));
+    }
+    #starJoined = (id) => {
+        if (this.#stars[id]) {
+            this.#stars[id].close(0);
+            delete this.#stars[id];
+        }
+        console.log(`star ${id} joined`);
+    };
+    #starLeft = async (id) => {
+        if (this.#stars[id]) {
+            this.#stars[id].close(0);
+            delete this.#stars[id];
+        }
+        if (Object.keys(this.#stars).length === 0) {
+            for (const star of this.starsConfig) {
+                try {
+                    const socketClient = await new SocketRequestClient(star, this.networkVersion).init();
+                    if (!socketClient?.client?.OPEN)
+                        return;
+                    this.#stars[star] = socketClient;
+                    this.#stars[star].send({
+                        url: 'join',
+                        params: { peerId: this.peerId, version: this.version }
+                    });
+                    this.setupStarListeners(socketClient);
+                }
+                catch (e) {
+                    if (this.starsConfig.indexOf(star) === this.starsConfig.length - 1)
+                        throw new Error(`No star available to connect`);
+                }
+            }
+        }
+        globalThis.debug(`star ${id} left`);
+    };
+    #peerLeft(peer, star) {
+        const id = peer.peerId || peer;
+        if (this.#connections[id]) {
+            this.#connections[id].destroy();
+            delete this.#connections[id];
+        }
+        globalThis.debug(`peer ${id} left`);
+    }
+    #createRTCPeerConnection = (peerId, star, version, initiator = false) => {
+        const peer = new Peer({
+            initiator: initiator,
+            from: this.peerId,
+            to: peerId,
+            version
+        });
+        peer.on('signal', (signal) => this.#peerSignal(peer, signal, star));
+        peer.on('connect', () => this.#peerConnect(peer));
+        peer.on('close', () => this.#peerClose(peer));
+        peer.on('data', (data) => this.#peerData(peer, data));
+        peer.on('error', (error) => this.#peerError(peer, error));
+        this.#connections[peerId] = peer;
+    };
+    #peerJoined = async ({ peerId, version }, star) => {
+        // check if peer rejoined before the previous connection closed
+        if (this.#connections[peerId]) {
+            if (this.#connections[peerId].connected)
+                this.#connections[peerId].destroy();
+            delete this.#connections[peerId];
+        }
+        // RTCPeerConnection
+        this.#createRTCPeerConnection(peerId, star, version, true);
+        globalThis.debug(`peer ${peerId} joined`);
+    };
+    #inComingSignal = async ({ from, signal, channelName, version }, star) => {
+        if (version !== this.version) {
+            console.warn(`${from} joined using the wrong version.\nexpected: ${this.version} but got:${version}`);
             return;
-        this.#starting = true;
-        const importee = await import('./client-493cbd83-493cbd83.js');
+        }
+        let peer = this.#connections[from];
+        if (!peer) {
+            this.#createRTCPeerConnection(from, star, version);
+            peer = this.#connections[from];
+        }
+        if (String(peer.channelName) !== String(channelName))
+            console.warn(`channelNames don't match: got ${peer.channelName}, expected: ${channelName}`);
+        peer.signal(signal);
+    };
+    #peerSignal = (peer, signal, star) => {
+        let client = this.#stars[star];
+        if (!client)
+            client = this.#stars[Object.keys(this.#stars)[0]];
+        client.send({
+            url: 'signal',
+            params: {
+                from: this.peerId,
+                to: peer.peerId,
+                channelName: peer.channelName,
+                version: this.version,
+                signal
+            }
+        });
+    };
+    #peerClose = (peer) => {
+        if (this.#connections[peer.peerId]) {
+            this.#connections[peer.peerId].destroy();
+            delete this.#connections[peer.peerId];
+        }
+        globalThis.debug(`closed ${peer.peerId}'s connection`);
+    };
+    #peerConnect = (peer) => {
+        globalThis.debug(`${peer.peerId} connected`);
+        globalThis.pubsub.publish(this.#connectEvent, peer.peerId);
+    };
+    #noticeMessage = (message, id) => {
+        if (globalThis.pubsub.subscribers[id]) {
+            globalThis.pubsub.publish(id, new Uint8Array(message));
+        }
+        else {
+            globalThis.pubsub.publish('peer:data', new Uint8Array(message));
+        }
+    };
+    #peerData = (peer, data) => {
+        const { id, size, chunk } = JSON.parse(new TextDecoder().decode(data));
+        peer.bw.down += size;
+        if (size <= MAX_MESSAGE_SIZE) {
+            this.#noticeMessage(chunk, id);
+        }
+        else {
+            if (!this.#messagesToHandle[id])
+                this.#messagesToHandle[id] = [];
+            this.#messagesToHandle[id] = [
+                ...this.#messagesToHandle[id],
+                ...Object.values(chunk)
+            ];
+            if (this.#messagesToHandle[id].length === Number(size)) {
+                this.#noticeMessage(this.#messagesToHandle[id], id);
+                delete this.#messagesToHandle[id];
+            }
+        }
+    };
+    #peerError = (peer, error) => {
+        console.warn(`Connection error: ${error.message}`);
+        peer.destroy();
+    };
+    async close() {
+        for (const star in this.#stars) {
+            if (this.#stars[star].connectionState() === 'open')
+                await this.#stars[star].send({ url: 'leave', params: this.peerId });
+        }
+        const promises = [
+            Object.values(this.#connections).map((connection) => connection.destroy()),
+            Object.values(this.#stars).map((connection) => connection.close(0))
+        ];
+        await Promise.allSettled(promises);
+    }
+};
         /**
          * @access public
          * @type {PeernetClient}
          */
-        this.client = new importee.default(this.id, this.networkVersion, this.stars);
+        console.log(this.stars);
+        this.client = new importee.default({
+            peerId: this.id,
+            networkVersion: this.networkVersion,
+            version: this.version,
+            stars: this.stars
+        });
         this.#started = true;
         this.#starting = false;
     }
-    #peerLeft(peer) {
-        for (const [id, _peer] of Object.entries(this.#connections)) {
-            if (_peer.id === peer.id && this.#connections[id] && !this.#connections[id].connected) {
-                delete this.#connections[id];
-                this.removePeer(_peer);
-            }
-        }
-    }
+    // todo: remove, handled in swarm now
+    // #peerLeft(peer: SwarmPeer) {
+    //   for (const [id, _peer] of Object.entries(this.connections)) {
+    //     if (_peer.id === peer.id && this.connections[id] && !this.connections[id].connected) {
+    //       delete this.connections[id]
+    //       this.removePeer(_peer)
+    //     }
+    //   }
+    // }
     addRequestHandler(name, method) {
         this.requestProtos[name] = method;
     }
@@ -27581,7 +27821,7 @@ class Peernet {
                 this.dht.addProvider(peerInfo, proto.decoded.hash);
         };
         let walks = [];
-        for (const [peerId, peer] of Object.entries(this.#connections)) {
+        for (const [peerId, peer] of Object.entries(this.connections)) {
             if (peerId !== this.id) {
                 walks.push(walk(peer, peerId));
             }
@@ -27648,7 +27888,7 @@ class Peernet {
         if (!closestPeer || !closestPeer.id)
             return this.requestData(hash, store?.name || store);
         const id = closestPeer.id;
-        const peer = this.#connections[id];
+        const peer = this.connections[id];
         if (peer?.connected) {
             let data = await new globalThis.peernet.protos['peernet-data']({
                 hash,
@@ -27662,7 +27902,7 @@ class Peernet {
                 const promises = [];
                 const providers = await this.providersFor(hash, store);
                 for (const provider of Object.values(providers)) {
-                    const peer = this.#connections[provider.id];
+                    const peer = this.connections[provider.id];
                     if (peer)
                         promises.push(peer.request(node.encoded));
                 }
@@ -27876,7 +28116,7 @@ class Peernet {
         // globalSub.publish(topic, data)
         const id = Math.random().toString(36).slice(-12);
         data = await new globalThis.peernet.protos['peernet-ps']({ data, topic });
-        for (const [peerId, peer] of Object.entries(this.#connections)) {
+        for (const [peerId, peer] of Object.entries(this.connections)) {
             if (peerId !== this.id) {
                 const node = await this.prepareMessage(data);
                 this.sendMessage(peer, id, node.encoded);
@@ -27898,16 +28138,15 @@ class Peernet {
     }
     async removePeer(peer) {
         console.log('removepeer', peer.id);
-        const id = peer.id;
-        await this.client._removePeer(peer);
-        if (this.client.peers[id]) {
-            for (const connection of Object.keys(this.client.peers[id])) {
-                // if (this.client.peers[id][connection].connected === false) delete this.client.peers[id][connection]
-                // @ts-ignore
-                if (this.client.peers[id][connection].connected)
-                    return this.client.emit('peerconnect', connection);
-            }
-        }
+        peer.id;
+        // await this.client.connections(peer)
+        // if (this.client.peers[id]) {
+        //   for (const connection of Object.keys(this.client.peers[id])) {
+        //     // if (this.client.peers[id][connection].connected === false) delete this.client.peers[id][connection]
+        //     // @ts-ignore
+        //     if (this.client.peers[id][connection].connected) return this.client.emit('peerconnect', connection)
+        //   }
+        // }
     }
     get Buffer() {
         return Buffer;
@@ -27949,6 +28188,7 @@ class Node {
         network: 'leofcoin:peach',
         networkName: 'leofcoin:peach',
         networkVersion: 'peach',
+        version: '1.2.0',
         stars: networks.leofcoin.peach.stars
     }, password) {
         this.#node = globalThis.Peernet

package/exports/browser/node-browser.js

@@ -1,2 +1,2 @@
-export { N as default } from './node-browser-e7da3b14.js';
-import './index-526fd466.js';
+export { N as default } from './node-browser-ccc3409e.js';
+import './index-c3bd3090.js';

package/exports/chain.js

@@ -2,6 +2,7 @@ import { formatBytes, BigNumber, formatUnits, parseUnits } from '@leofcoin/utils
 import { TransactionMessage, BlockMessage, ContractMessage, BWMessage, BWRequestMessage } from '@leofcoin/messages';
 import addresses, { contractFactory, nativeToken, validators, nameService } from '@leofcoin/addresses';
 import { calculateFee, createContractMessage, signTransaction, contractFactoryMessage, nativeTokenMessage, validatorsMessage, nameServiceMessage } from '@leofcoin/lib';
+import semver from 'semver';
 import { randombytes } from '@leofcoin/crypto';
 import EasyWorker from '@vandeurenglenn/easy-worker';
 import { ContractDeploymentError, ExecutionError, isResolveError, ResolveError, isExecutionError } from '@leofcoin/errors';
@@ -1106,9 +1107,13 @@ class VersionControl extends State {
     constructor(config) {
         super(config);
     }
+    #currentVersion;
+    async #setCurrentVersion() {
+        this.version = this.#currentVersion;
+        await globalThis.chainStore.put('version', this.version);
+    }
     async init() {
         super.init && (await super.init());
-        console.log('init');
         try {
             const version = await globalThis.chainStore.get('version');
             this.version = new TextDecoder().decode(version);
@@ -1119,18 +1124,16 @@ class VersionControl extends State {
              * in the future we want newer nodes to handle the new changes and still confirm old version transactions
              * unless there is a security issue!
              */
-            if (this.version !== '1.1.1') {
-                this.version = '1.1.1';
-                await this.clearAll();
-                await globalThis.chainStore.put('version', this.version);
+            if (semver.compare(this.#currentVersion, this.version) === 1) {
+                // await this.clearAll()
+                this.#setCurrentVersion();
             }
             // if (version)
         }
         catch (e) {
             console.log(e);
-            this.version = '1.1.1';
-            await this.clearAll();
-            await globalThis.chainStore.put('version', this.version);
+            // await this.clearAll()
+            this.#setCurrentVersion();
         }
     }
 }
@@ -1469,7 +1472,7 @@ class Chain extends VersionControl {
         //   }
         // }, [])
         const peers = {};
-        for (const entry of globalThis.peernet.peerEntries) {
+        for (const entry of globalThis.peernet.peers) {
             peers[entry[0]] = entry[1];
         }
         for (const validator of Object.keys(validators)) {

package/exports/node-browser.d.ts

@@ -5,6 +5,7 @@ export default class Node {
         network: string;
         networkName: string;
         networkVersion: string;
+        version: string;
         stars: string[];
     }, password: string): Promise<this>;
 }

package/exports/node.d.ts

@@ -5,6 +5,7 @@ export default class Node {
         network: string;
         networkName: string;
         networkVersion: string;
+        version: string;
         stars: string[];
         autoStart: boolean;
     }, password: any): Promise<this>;

package/exports/node.js

@@ -13,6 +13,7 @@ class Node {
         network: 'leofcoin:peach',
         networkName: 'leofcoin:peach',
         networkVersion: 'peach',
+        version: '1.2.0',
         stars: networks.leofcoin.peach.stars,
         autoStart: false
     }, password) {

package/exports/version-control.d.ts

@@ -1,5 +1,6 @@
 import State from './state.js';
 export declare class VersionControl extends State {
+    #private;
     constructor(config: any);
     init(): Promise<void>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/chain",
-  "version": "1.5.39",
+  "version": "1.5.41",
   "description": "Official javascript implementation",
   "exports": {
     "./node": {