{"_id":"cable","_rev":"38-70d3ed793e7fa7bfd0ab12d58e0da9b8","name":"cable","description":"Cable is a fast and simple binary request/response protocol stream for Node.js","dist-tags":{"latest":"1.3.0"},"versions":{"0.1.0":{"name":"cable","version":"0.1.0","dependencies":{},"repository":{"type":"git","url":"git://github.com/mafintosh/cable.git"},"description":"Cable is JSON requests over TCP with pipelining","keywords":["request","json","tcp","pipeline"],"author":{"name":"Mathias Buus Madsen","email":"mathiasbuus@gmail.com"},"_npmUser":{"name":"mafintosh","email":"mathiasbuus@gmail.com"},"_id":"cable@0.1.0","scripts":{"start":"node server.js"},"devDependencies":{},"optionalDependencies":{},"engines":{"node":"*"},"_engineSupported":true,"_npmVersion":"1.1.24","_nodeVersion":"v0.6.19","_defaultsLoaded":true,"dist":{"shasum":"5a4cdd074d2fac3aa19d8b1a1b5764b7e8844627","tarball":"https://registry.npmjs.org/cable/-/cable-0.1.0.tgz","integrity":"sha512-y0ki/Rgo1keDZ673BmJaJzBNEpfcm/HsErY5bpfOZGBB6ufOI5EJk50iAAj1pC1Q/rcqab1/8cFS28s18xCnfw==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIBHgb3FTQNgB9fN8qGQGaxgEcccYuWBwFq5MjJLLtKyYAiEAytpucBrsgKURf6o6UGdpLVu0X4JGkJEXfze2KeHAI7I="}]},"readme":"","maintainers":[{"name":"mafintosh","email":"mathiasbuus@gmail.com"}],"directories":{}},"0.1.1":{"name":"cable","version":"0.1.1","dependencies":{},"repository":{"type":"git","url":"git://github.com/mafintosh/cable.git"},"description":"Cable is JSON requests over TCP with pipelining","keywords":["request","json","tcp","pipeline"],"author":{"name":"Mathias Buus Madsen","email":"mathiasbuus@gmail.com"},"_npmUser":{"name":"mafintosh","email":"mathiasbuus@gmail.com"},"_id":"cable@0.1.1","scripts":{"start":"node server.js"},"devDependencies":{},"optionalDependencies":{},"engines":{"node":"*"},"_engineSupported":true,"_npmVersion":"1.1.24","_nodeVersion":"v0.6.19","_defaultsLoaded":true,"dist":{"shasum":"cf2059a877f3bed523003984fa68316a0c23cb87","tarball":"https://registry.npmjs.org/cable/-/cable-0.1.1.tgz","integrity":"sha512-oBlSHoMymYxQbCPPwPvRpIzFKgKb5QzE/II0woWpu4hX+rFfk5AP6It++hNf+gYc6XGBfZq+dcmzgV4z6UCpdQ==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEQCICaGi6taaLKcHFtRMO7qS1j4FrHaZFrNCyFLhSTm2YyCAiA+gPp3U+ue1OEHUYZ1qqD1LMGBpcO6kFLIiD3r+zouXw=="}]},"readme":"# Cable\n\nCable is incredibly fast JSON requests over TCP in Node.js with pipelining support.  \nIt's available through npm:\n\n\tnpm install cable\n\n## Usage\n\nCable is especially useful for fast communication between processes and servers.\nUsage is simple:\n\nYou can start a server:\n\n``` js\nvar cable = require('cable');\n\nvar server = cable.listen(8080); // if you omit 8080 here you'll get a random port\n\nserver.on('request', function(message, callback) {\n\t// lets just echo\n\tcallback(null, {echo:message});\n});\nserver.ready(function(addr) {\n\tconsole.log('concact me here: '+addr);\n});\n```\n\nOr do a request:\n\n``` js\ncable('localhost:8080', {hello:'world'}, function(err, message) {\n\tconsole.log(message);\n});\n```\n\nTo get an idea of the speed of cable you can try and run the [benchmark](https://github.com/mafintosh/cable/blob/master/bench.js)\n\n## Pipelining\n\nWhen you do a request `cable('localhost:8080',...)` cable opens up a TCP connection to the host and waits for the request to finish. If a new request is made to the same host in the meantime cable will just use the same TCP connection and pipeline the request minimizing latency. When all requests to a host are finished cable will close the connection to avoid tricky timeout issues.\n\n## License\n\n**This software is licensed under \"MIT\"**\n\n> Copyright (c) 2012 Mathias Buus Madsen <mathiasbuus@gmail.com>\n> \n> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n> \n> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\n> \n> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.","maintainers":[{"name":"mafintosh","email":"mathiasbuus@gmail.com"}],"directories":{}},"0.1.3":{"name":"cable","version":"0.1.3","dependencies":{"request-stream":"0.1.x","network-address":"0.0.x"},"repository":{"type":"git","url":"git://github.com/mafintosh/cable"},"description":"Cable is JSON requests over TCP with pipelining","keywords":["request","json","tcp","pipeline"],"author":{"name":"Mathias Buus Madsen","email":"mathiasbuus@gmail.com"},"readme":"# Cable\n\nCable is incredibly fast JSON requests over TCP in Node.js with pipelining support.  \nIt's available through npm:\n\n\tnpm install cable\n\n## Usage\n\nCable is especially useful for fast communication between processes and servers.\nUsage is simple:\n\nYou can start a server:\n\n``` js\nvar cable = require('cable');\n\nvar server = cable.listen(8080); // if you omit 8080 here you'll get a random port\n\nserver.on('request', function(message, callback) {\n\t// lets just echo\n\tcallback(null, {echo:message});\n});\nserver.ready(function(addr) {\n\tconsole.log('contact me here: '+addr);\n});\n```\n\nOr do a request:\n\n``` js\ncable('localhost:8080', {hello:'world'}, function(err, message) {\n\tconsole.log(message);\n});\n```\n\nTo get an idea of the speed of cable you can try and run the [benchmark](https://github.com/mafintosh/cable/blob/master/bench.js)\n\n## Pipelining\n\nWhen you do a request `cable('localhost:8080',...)` cable opens up a TCP connection to the host and waits for the request to finish. If a new request is made to the same host in the meantime cable will just use the same TCP connection and pipeline the request minimizing latency. When all requests to a host are finished cable will close the connection to avoid tricky timeout issues.\n\n## License\n\n**This software is licensed under \"MIT\"**\n\n> Copyright (c) 2012 Mathias Buus Madsen <mathiasbuus@gmail.com>\n> \n> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n> \n> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\n> \n> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.","readmeFilename":"README.md","_id":"cable@0.1.3","dist":{"shasum":"e1f0341cc9288cec681d2bf4e4fe0edcee01f5d7","tarball":"https://registry.npmjs.org/cable/-/cable-0.1.3.tgz","integrity":"sha512-XOLJKaiY6YrNKRi70i9egyGdjRybdwyGuT4qENcnwVs3ZO+QONmXJN4rD433FPC+ONjbVL4PT9prT7elt03IDQ==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIQCwnRstk+wuL1fjqAA57DME/GMbshy/SZilyL/g1NWzewIgFkMvPhZZ+QHaf4kymifr4IvWtTBrcmX/C0VDY1Pw7Ro="}]},"_npmVersion":"1.1.65","_npmUser":{"name":"mafintosh","email":"mathiasbuus@gmail.com"},"maintainers":[{"name":"mafintosh","email":"mathiasbuus@gmail.com"}],"directories":{}},"0.1.4":{"name":"cable","version":"0.1.4","dependencies":{"request-stream":"0.1.x","network-address":"0.0.x"},"repository":{"type":"git","url":"git://github.com/mafintosh/cable"},"description":"Cable is JSON requests over TCP with pipelining","keywords":["request","json","tcp","pipeline","server"],"author":{"name":"Mathias Buus Madsen","email":"mathiasbuus@gmail.com"},"readme":"# Cable\n\nCable is incredibly fast JSON requests over TCP in Node.js with pipelining support.  \nIt's available through npm:\n\n\tnpm install cable\n\n## Usage\n\nCable is especially useful for fast communication between processes and servers.\nUsage is simple:\n\nYou can start a server:\n\n``` js\nvar cable = require('cable');\n\nvar server = cable.listen(8080); // if you omit 8080 here you'll get a random port\n\nserver.on('request', function(message, callback) {\n\t// lets just echo\n\tcallback(null, {echo:message});\n});\nserver.ready(function(addr) {\n\tconsole.log('contact me here: '+addr);\n});\n```\n\nOr do a request:\n\n``` js\ncable('localhost:8080', {hello:'world'}, function(err, message) {\n\tconsole.log(message);\n});\n```\n\nTo get an idea of the speed of cable you can try and run the [benchmark](https://github.com/mafintosh/cable/blob/master/bench.js)\n\n## Pipelining\n\nWhen you do a request `cable('localhost:8080',...)` cable opens up a TCP connection to the host and waits for the request to finish. If a new request is made to the same host in the meantime cable will just use the same TCP connection and pipeline the request minimizing latency. When all requests to a host are finished cable will close the connection to avoid tricky timeout issues.\n\n## License\n\n**This software is licensed under \"MIT\"**\n\n> Copyright (c) 2012 Mathias Buus Madsen <mathiasbuus@gmail.com>\n> \n> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n> \n> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\n> \n> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.","readmeFilename":"README.md","_id":"cable@0.1.4","dist":{"shasum":"31b57aac47e71b616f021f6a8541231b17586071","tarball":"https://registry.npmjs.org/cable/-/cable-0.1.4.tgz","integrity":"sha512-RSfTRVjYxgh3hI2V5clS8SDoYspnxWpyepPxeFo9KFaOM64iQiAcwS6xEfKgsnI/sX6ajDN/B0+lwWCa1lk4Ig==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEQCIDLsjbw01ju5DGDfacol8Ece1boijU0DEGgEXy6I3GBDAiBJxBgADLWPLLVpDM9ztU6DRZzLNlLd1iS4tMZOVqs/4g=="}]},"_npmVersion":"1.1.65","_npmUser":{"name":"mafintosh","email":"mathiasbuus@gmail.com"},"maintainers":[{"name":"mafintosh","email":"mathiasbuus@gmail.com"}]},"0.1.5":{"name":"cable","version":"0.1.5","dependencies":{"conversation-stream":"0.1.x","network-address":"0.0.x"},"repository":{"type":"git","url":"git://github.com/mafintosh/cable"},"description":"Cable is JSON requests over TCP with pipelining","keywords":["request","json","tcp","pipeline","server"],"author":{"name":"Mathias Buus Madsen","email":"mathiasbuus@gmail.com"},"readme":"# Cable\n\nCable is incredibly fast JSON requests over TCP in Node.js with pipelining support.  \nIt's available through npm:\n\n\tnpm install cable\n\n## Usage\n\nCable is especially useful for fast communication between processes and servers.\nUsage is simple:\n\nYou can start a server:\n\n``` js\nvar cable = require('cable');\n\nvar server = cable.listen(8080); // if you omit 8080 here you'll get a random port\n\nserver.on('request', function(message, callback) {\n\t// lets just echo\n\tcallback(null, {echo:message});\n});\nserver.ready(function(addr) {\n\tconsole.log('contact me here: '+addr);\n});\n```\n\nOr do a request:\n\n``` js\ncable('localhost:8080', {hello:'world'}, function(err, message) {\n\tconsole.log(message);\n});\n```\n\nTo get an idea of the speed of cable you can try and run the [benchmark](https://github.com/mafintosh/cable/blob/master/bench.js)\n\n## Pipelining\n\nWhen you do a request `cable('localhost:8080',...)` cable opens up a TCP connection to the host and waits for the request to finish. If a new request is made to the same host in the meantime cable will just use the same TCP connection and pipeline the request minimizing latency. When all requests to a host are finished cable will close the connection to avoid tricky timeout issues.\n\n## License\n\n**This software is licensed under \"MIT\"**\n\n> Copyright (c) 2012 Mathias Buus Madsen <mathiasbuus@gmail.com>\n> \n> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n> \n> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\n> \n> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.","readmeFilename":"README.md","_id":"cable@0.1.5","dist":{"shasum":"85cd271e2afbea99c1186374aa0f97c301fc3496","tarball":"https://registry.npmjs.org/cable/-/cable-0.1.5.tgz","integrity":"sha512-/EoPJ366NghxpIZK9H+Cn2rVx6iEKup9aUUua8hokKrZWserkaxnMMMRYykaU3AF5c8l93tikTzqvmWjMHqO6g==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEYCIQDmivdPlE1sG45XpyKgrvtsqqdWFCtVeDps0oMun845eAIhAO7jHbg6euORrk+MJCQYZFFK39EQuoRJtG9P7GWcvTy5"}]},"_npmVersion":"1.1.66","_npmUser":{"name":"mafintosh","email":"mathiasbuus@gmail.com"},"maintainers":[{"name":"mafintosh","email":"mathiasbuus@gmail.com"}]},"1.0.0":{"name":"cable","version":"1.0.0","dependencies":{"fifo":"~0.2.0"},"repository":{"type":"git","url":"git://github.com/mafintosh/cable.git"},"description":"Cable is incredibly fast binary encoded JSON requests over a stream in Node.js with pipelining support","keywords":["request","json","pipeline","server"],"author":{"name":"Mathias Buus Madsen","email":"mathiasbuus@gmail.com"},"scripts":{"test":"node test.js"},"readme":"# Cable\n\nCable is incredibly fast binary encoded JSON requests over a stream in Node.js with pipelining support.\nIt's available through npm:\n\n\tnpm install cable\n\n## Usage\n\nCable is especially useful for fast communication between processes and servers. All JSON messages\nare sent with a 5 byte header that descripes the type and length of a message. This allows for extremely\neasy and fast parsing.\n\nUsage is simple. Start a server:\n\n``` js\nvar net = require('net');\nvar cable = require('cable');\n\nvar server = net.createServer(function(socket) {\n\tvar c = cable();\n\n\tc.on('message', function(message, callback) {\n\t\t// lets just echo\n\t\tcallback(null, {echo:message});\n\t});\n\n\tsocket.pipe(c).pipe(socket); // setup the pipe chain\n});\n\nserver.listen(8080);\n```\n\nDo a request:\n\n``` js\nvar socket = net.connect(8080);\nvar c = cable();\n\nsocket.pipe(c).pipe(socket);\n\nc.send({hello:'world'}, function(err, message) {\n\tconsole.log(message); // prints echo\n});\n\nc.send({hello:'verden'}, function(err, message) {\n\tconsole.log(message); // prints echo again\n});\n```\n\n## Pipelining\n\nWhen you do a request `c.send(message, [cb])` cable sends the message and pushes the callback to a response stack. If a new request is made to the same stream in the meantime cable will just send that right away and pipeline the request to minimize latency. Omit the callback to not wait for a response.\n\n## Full API\n\n* `cable() -> c` instantiate a new cable duplex stream\n\n* `c.send(message, [cb])` send a message. add the callback if you want a response\n\n* `c.on('message', message, cb)` emitted when a message is received. `cb` is noop if no callback was used in `send`\n\n* `c.destroy()` destroy the stream. calls all missing callbacks with an error\n\n## License\n\nMIT","readmeFilename":"README.md","bugs":{"url":"https://github.com/mafintosh/cable/issues"},"homepage":"https://github.com/mafintosh/cable","_id":"cable@1.0.0","dist":{"shasum":"8f95481edb06c73fa7ddf34e4307bb17f977d989","tarball":"https://registry.npmjs.org/cable/-/cable-1.0.0.tgz","integrity":"sha512-SrwS7uyqKVLJ6G7QkjMvLFYp/kFANTRGwCh34BeIOOuSFfuX7VK8DkQA/36fAed5AUR8UW392BeSbOB/v8GBfA==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEYCIQDNqSabyM2JeSeTmy7EO8xKnzKwZ0dhGNhv0MfAJg2srQIhAN43uiZz3FcK4BgGPdjMTstOClUaSBzEME1e2JjOkJEh"}]},"_from":".","_npmVersion":"1.3.17","_npmUser":{"name":"mafintosh","email":"mathiasbuus@gmail.com"},"maintainers":[{"name":"mafintosh","email":"mathiasbuus@gmail.com"}]},"1.0.1":{"name":"cable","version":"1.0.1","dependencies":{"fifo":"~0.2.0"},"repository":{"type":"git","url":"git://github.com/mafintosh/cable.git"},"description":"Cable is incredibly fast binary encoded JSON requests over a stream in Node.js with pipelining support","keywords":["request","json","pipeline","server"],"author":{"name":"Mathias Buus Madsen","email":"mathiasbuus@gmail.com"},"scripts":{"test":"node test.js"},"readme":"# Cable\n\nCable is incredibly fast binary encoded JSON requests over a stream in Node.js with pipelining support.\nIt's available through npm:\n\n\tnpm install cable\n\n## Usage\n\nCable is especially useful for fast communication between processes and servers. All JSON messages\nare sent with a 5 byte header that descripes the type and length of a message. This allows for extremely\neasy and fast parsing.\n\nUsage is simple. Start a server:\n\n``` js\nvar net = require('net');\nvar cable = require('cable');\n\nvar server = net.createServer(function(socket) {\n\tvar c = cable();\n\n\tc.on('message', function(message, callback) {\n\t\t// lets just echo\n\t\tcallback(null, {echo:message});\n\t});\n\n\tsocket.pipe(c).pipe(socket); // setup the pipe chain\n});\n\nserver.listen(8080);\n```\n\nDo a request:\n\n``` js\nvar socket = net.connect(8080);\nvar c = cable();\n\nsocket.pipe(c).pipe(socket);\n\nc.send({hello:'world'}, function(err, message) {\n\tconsole.log(message); // prints echo\n});\n\nc.send({hello:'verden'}, function(err, message) {\n\tconsole.log(message); // prints echo again\n});\n```\n\n## Pipelining\n\nWhen you do a request `c.send(message, [cb])` cable sends the message and pushes the callback to a response stack. If a new request is made to the same stream in the meantime cable will just send that right away and pipeline the request to minimize latency. Omit the callback to not wait for a response.\n\n## Full API\n\n* `cable() -> c` instantiate a new cable duplex stream\n\n* `c.send(message, [cb])` send a message. add the callback if you want a response\n\n* `c.on('message', message, cb)` emitted when a message is received. `cb` is noop if no callback was used in `send`\n\n* `c.destroy()` destroy the stream. calls all missing callbacks with an error\n\n## License\n\nMIT","readmeFilename":"README.md","bugs":{"url":"https://github.com/mafintosh/cable/issues"},"homepage":"https://github.com/mafintosh/cable","_id":"cable@1.0.1","dist":{"shasum":"bda2920884e74e31ff41e8a9fdb22184bd97b6a6","tarball":"https://registry.npmjs.org/cable/-/cable-1.0.1.tgz","integrity":"sha512-xxhA5ZSisbAD57EVOYW2Wlw6YOJ9t9l/wMwpcLptrSR7eTsZLVpmNM02YxO/HQ6T+XabxKjA5lF8Mp4ZSyPlMg==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIQCe0mT/eqPFZDwvQOWTZV/4s0D3ffsGnY15j6su6U2AUAIgB3wUhTBu18SWlPMIMKu05JTJ43oPiW3wMGpHRasnWpw="}]},"_from":".","_npmVersion":"1.3.17","_npmUser":{"name":"mafintosh","email":"mathiasbuus@gmail.com"},"maintainers":[{"name":"mafintosh","email":"mathiasbuus@gmail.com"}]},"1.0.2":{"name":"cable","version":"1.0.2","dependencies":{"fifo":"~0.2.0"},"repository":{"type":"git","url":"git://github.com/mafintosh/cable.git"},"description":"Cable is incredibly fast binary encoded JSON requests over a stream in Node.js with pipelining support","keywords":["request","json","pipeline","server"],"author":{"name":"Mathias Buus Madsen","email":"mathiasbuus@gmail.com"},"scripts":{"test":"node test.js"},"readme":"# Cable\n\nCable is incredibly fast binary encoded JSON requests over a stream in Node.js with pipelining support.\nIt's available through npm:\n\n\tnpm install cable\n\n## Usage\n\nCable is especially useful for fast communication between processes and servers. All JSON messages\nare sent with a 5 byte header that descripes the type and length of a message. This allows for extremely\neasy and fast parsing.\n\nUsage is simple. Start a server:\n\n``` js\nvar net = require('net');\nvar cable = require('cable');\n\nvar server = net.createServer(function(socket) {\n\tvar c = cable();\n\n\tc.on('message', function(message, callback) {\n\t\t// lets just echo\n\t\tcallback(null, {echo:message});\n\t});\n\n\tsocket.pipe(c).pipe(socket); // setup the pipe chain\n});\n\nserver.listen(8080);\n```\n\nDo a request:\n\n``` js\nvar socket = net.connect(8080);\nvar c = cable();\n\nsocket.pipe(c).pipe(socket);\n\nc.send({hello:'world'}, function(err, message) {\n\tconsole.log(message); // prints echo\n});\n\nc.send({hello:'verden'}, function(err, message) {\n\tconsole.log(message); // prints echo again\n});\n```\n\n## Pipelining\n\nWhen you do a request `c.send(message, [cb])` cable sends the message and pushes the callback to a response stack. If a new request is made to the same stream in the meantime cable will just send that right away and pipeline the request to minimize latency. Omit the callback to not wait for a response.\n\n## Full API\n\n* `cable() -> c` instantiate a new cable duplex stream\n\n* `c.send(message, [cb])` send a message. add the callback if you want a response\n\n* `c.on('message', message, cb)` emitted when a message is received. `cb` is noop if no callback was used in `send`\n\n* `c.destroy()` destroy the stream. calls all missing callbacks with an error\n\n* `c.ping(cb)` send a ping.\n\n## License\n\nMIT","readmeFilename":"README.md","bugs":{"url":"https://github.com/mafintosh/cable/issues"},"homepage":"https://github.com/mafintosh/cable","_id":"cable@1.0.2","dist":{"shasum":"250a77d02841a820b71a1b558d428adf889dce2c","tarball":"https://registry.npmjs.org/cable/-/cable-1.0.2.tgz","integrity":"sha512-zQe/BB5rtCBLQkLhOgRzYew+F+bZLBie6Cw4rSPNDwsrQbV/e6W4fF5sckiyhPmjLU9ciSqQEb+RLTJuo7niZw==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEQCIBgxuiFIPoaTy2nkaFxOB0tF+klvvKccYt5C9S7TOjEtAiBEP4JJca1qcPjW1Butgzx378D0kx7Kk06hnXMrPTMu2Q=="}]},"_from":".","_npmVersion":"1.3.17","_npmUser":{"name":"mafintosh","email":"mathiasbuus@gmail.com"},"maintainers":[{"name":"mafintosh","email":"mathiasbuus@gmail.com"}]},"1.1.0":{"name":"cable","version":"1.1.0","dependencies":{},"repository":{"type":"git","url":"git://github.com/mafintosh/cable.git"},"description":"Cable is incredibly fast binary encoded JSON requests over a stream in Node.js with pipelining support","keywords":["request","json","pipeline","server"],"author":{"name":"Mathias Buus Madsen","email":"mathiasbuus@gmail.com"},"scripts":{"test":"node test.js"},"readme":"# Cable\n\nCable is incredibly fast binary encoded JSON requests over a stream in Node.js with pipelining support.\nIt's available through npm:\n\n\tnpm install cable\n\n## Usage\n\nCable is especially useful for fast communication between processes and servers. All JSON messages\nare sent with a 5 byte header that descripes the type and length of a message. This allows for extremely\neasy and fast parsing.\n\nUsage is simple. Start a server:\n\n``` js\nvar net = require('net');\nvar cable = require('cable');\n\nvar server = net.createServer(function(socket) {\n\tvar c = cable();\n\n\tc.on('message', function(message, callback) {\n\t\t// lets just echo\n\t\tcallback(null, {echo:message});\n\t});\n\n\tsocket.pipe(c).pipe(socket); // setup the pipe chain\n});\n\nserver.listen(8080);\n```\n\nDo a request:\n\n``` js\nvar socket = net.connect(8080);\nvar c = cable();\n\nsocket.pipe(c).pipe(socket);\n\nc.send({hello:'world'}, function(err, message) {\n\tconsole.log(message); // prints echo\n});\n\nc.send({hello:'verden'}, function(err, message) {\n\tconsole.log(message); // prints echo again\n});\n```\n\n## Pipelining\n\nWhen you do a request `c.send(message, [cb])` cable sends the message and pushes the callback to a response stack. If a new request is made to the same stream in the meantime cable will just send that right away and pipeline the request to minimize latency. Omit the callback to not wait for a response.\n\n## Full API\n\n* `cable() -> c` instantiate a new cable duplex stream\n\n* `c.send(message, [cb])` send a message. add the callback if you want a response\n\n* `c.on('message', message, cb)` emitted when a message is received. `cb` is noop if no callback was used in `send`\n\n* `c.destroy()` destroy the stream. calls all missing callbacks with an error\n\n* `c.ping(cb)` send a ping.\n\n## License\n\nMIT","readmeFilename":"README.md","bugs":{"url":"https://github.com/mafintosh/cable/issues"},"homepage":"https://github.com/mafintosh/cable","_id":"cable@1.1.0","dist":{"shasum":"1a7a8726d6bee8247a256f618fa1e27480004f60","tarball":"https://registry.npmjs.org/cable/-/cable-1.1.0.tgz","integrity":"sha512-N/Q0OeD0XhwhLnhaeDp6+JtECeLfJMrT9jNlS+T4LbsqM34EvkOxkwz3u36DmR2Mgy9I13uvXynCEBIQHFznag==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCICj6l0V/31NpOYoQ/zG4kU04+HqhDEnXqksquf+U5pSxAiEAooWeWnLGgc3KedDklWxpva0Css0Sne3Q6eZxjLVrrOM="}]},"_from":".","_npmVersion":"1.3.17","_npmUser":{"name":"mafintosh","email":"mathiasbuus@gmail.com"},"maintainers":[{"name":"mafintosh","email":"mathiasbuus@gmail.com"}]},"1.2.0":{"name":"cable","version":"1.2.0","dependencies":{},"repository":{"type":"git","url":"git://github.com/mafintosh/cable.git"},"description":"Cable is a fast and simple binary request/response protocol stream for Node.js","keywords":["request","json","pipeline","server"],"author":{"name":"Mathias Buus Madsen","email":"mathiasbuus@gmail.com"},"scripts":{"test":"node test.js"},"readme":"# Cable\n\nCable is a fast and simple binary request/response protocol stream for Node.js. It features an easy to use api, pipelining and optional encodings.\nIt's available through npm:\n\n\tnpm install cable\n\n## Usage\n\nCable is especially useful for fast communication between processes and servers. All messages\nare sent with a 7 byte header that descripes the id and length of a message. This allows for extremely\neasy and fast parsing.\n\nUsage is simple. Start a server:\n\n``` js\nvar net = require('net');\nvar cable = require('cable');\n\nvar server = net.createServer(function(socket) {\n\tvar c = cable();\n\n\tc.on('message', function(message, callback) {\n\t\t// lets just echo\n\t\tcallback(null, message);\n\t});\n\n\tsocket.pipe(c).pipe(socket); // setup the pipe chain\n});\n\nserver.listen(8080);\n```\n\nDo a request:\n\n``` js\nvar socket = net.connect(8080);\nvar c = cable();\n\nsocket.pipe(c).pipe(socket);\n\nc.send(new Buffer('hello'), function(err, message) {\n\tconsole.log(message); // prints 'hello' as a buffer\n});\n\nc.send(new Buffer('world'), function(err, message) {\n\tconsole.log(message); // prints 'world' as a buffer\n});\n```\n\nTo send JSON either encode/decode the messages yourself or use the encoding option\n\n``` js\nvar c = cable({encoding:'json'});\n\ns.send({hello:'world'}, function(err, doc) {\n\tconsole.log(doc); // doc will also be JSON\n});\n```\n\n## Pipelining\n\nWhen you do a request `c.send(message, [cb])` cable sends the message and remembers the callback. If a new request is made to the same stream in the meantime cable will just send that right away and pipeline the request to minimize latency. If you do not care about the response then don't pass a callback.\n\n## Full API\n\n* `cable({encoding:null|json|utf-8}) -> c` instantiate a new cable duplex stream. select an optional message encoding\n\n* `c.send(message, [cb])` send a message. add the callback if you want a response\n\n* `c.on('message', message, cb)` emitted when a message is received. `cb` is noop if no callback was used in `send`\n\n* `c.destroy()` destroy the stream. calls all missing callbacks with an error\n\n* `c.ping(cb)` send a ping. useful to check if the connection is still alive\n\n## Protocol\n\nAll messages are prefixed with the following header and looks like this\n\n```\n ----------------------------------------------------------------------------------\n|  1 byte type  |  16 byte message id  |  32 byte uint message length  |  message  |\n ----------------------------------------------------------------------------------\n```\n\nThe type byte can be:\n\n* `0` this message does not expect a response\n* `1` this message expects a response with the same id\n* `2` this is a response to the message with same id\n* `3` this message is an error response to the message with the same id (message body is a utf-8 encoding error message)\n\nMessage ids should be safe to reuse after a response has been received.\n\n## License\n\nMIT\n","readmeFilename":"README.md","bugs":{"url":"https://github.com/mafintosh/cable/issues"},"homepage":"https://github.com/mafintosh/cable","_id":"cable@1.2.0","dist":{"shasum":"0fd3eef9117ca3198d03c99a059e9d824591f49d","tarball":"https://registry.npmjs.org/cable/-/cable-1.2.0.tgz","integrity":"sha512-lrLwNKmFf9+MjFCEOhjWY4aBMNUSPeCeZCbzedl5iy7THudMgiqTBIHsVThTfoCiAGP9GJEVaIfIa1eWoRu/Bw==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIHVWoKtt1nX5J/UICdBic50nw1bJcIEu/c09VfL0V1zzAiEAzZ06i+/yQKqb9qis44y72vlKhZc50GFP0FPwtPCMKNY="}]},"_from":".","_npmVersion":"1.3.17","_npmUser":{"name":"mafintosh","email":"mathiasbuus@gmail.com"},"maintainers":[{"name":"mafintosh","email":"mathiasbuus@gmail.com"}]},"1.2.1":{"name":"cable","version":"1.2.1","dependencies":{},"repository":{"type":"git","url":"git://github.com/mafintosh/cable.git"},"description":"Cable is a fast and simple binary request/response protocol stream for Node.js","keywords":["request","json","pipeline","server"],"author":{"name":"Mathias Buus Madsen","email":"mathiasbuus@gmail.com"},"scripts":{"test":"node test.js"},"readme":"# Cable\n\nCable is a fast and simple binary request/response protocol stream for Node.js. It features an easy to use api, pipelining and optional encodings.\nIt's available through npm:\n\n\tnpm install cable\n\n## Usage\n\nCable is especially useful for fast communication between processes and servers. All messages\nare sent with a 7 byte header that descripes the id and length of a message. This allows for extremely\neasy and fast parsing.\n\nUsage is simple. Start a server:\n\n``` js\nvar net = require('net');\nvar cable = require('cable');\n\nvar server = net.createServer(function(socket) {\n\tvar c = cable();\n\n\tc.on('message', function(message, callback) {\n\t\t// lets just echo\n\t\tcallback(null, message);\n\t});\n\n\tsocket.pipe(c).pipe(socket); // setup the pipe chain\n});\n\nserver.listen(8080);\n```\n\nDo a request:\n\n``` js\nvar socket = net.connect(8080);\nvar c = cable();\n\nsocket.pipe(c).pipe(socket);\n\nc.send(new Buffer('hello'), function(err, message) {\n\tconsole.log(message); // prints 'hello' as a buffer\n});\n\nc.send(new Buffer('world'), function(err, message) {\n\tconsole.log(message); // prints 'world' as a buffer\n});\n```\n\nTo send JSON either encode/decode the messages yourself or use the encoding option\n\n``` js\nvar c = cable({encoding:'json'});\n\ns.send({hello:'world'}, function(err, doc) {\n\tconsole.log(doc); // doc will also be JSON\n});\n```\n\n## Pipelining\n\nWhen you do a request `c.send(message, [cb])` cable sends the message and remembers the callback. If a new request is made to the same stream in the meantime cable will just send that right away and pipeline the request to minimize latency. If you do not care about the response then don't pass a callback.\n\n## Full API\n\n* `cable({encoding:null|json|utf-8}) -> c` instantiate a new cable duplex stream. select an optional message encoding\n\n* `c.send(message, [cb])` send a message. add the callback if you want a response\n\n* `c.on('message', message, cb)` emitted when a message is received. `cb` is noop if no callback was used in `send`\n\n* `c.destroy()` destroy the stream. calls all missing callbacks with an error\n\n* `c.ping(cb)` send a ping. useful to check if the connection is still alive\n\n## Protocol\n\nAll messages are prefixed with the following header and looks like this\n\n```\n ----------------------------------------------------------------------------------\n|  1 byte type  |  2 byte message id  |  4 byte uint message length  |  message  |\n ----------------------------------------------------------------------------------\n```\n\nThe type byte can be:\n\n* `0` this message does not expect a response\n* `1` this message expects a response with the same id\n* `2` this is a response to the message with same id\n* `3` this message is an error response to the message with the same id (message body is a utf-8 encoding error message)\n\nMessage ids should be safe to reuse after a response has been received.\n\n## License\n\nMIT\n","readmeFilename":"README.md","bugs":{"url":"https://github.com/mafintosh/cable/issues"},"homepage":"https://github.com/mafintosh/cable","_id":"cable@1.2.1","dist":{"shasum":"ac5d654cd2c3ca8e384f309d586809f0796af0ba","tarball":"https://registry.npmjs.org/cable/-/cable-1.2.1.tgz","integrity":"sha512-RbMfWOi7XToj+Vg6i2ResH4s3SIaTRHhiTuzhoXJLkqvSQI4Xsy1RwOOe/t0b5JFxtygGc+Cu6Hh6WeRCULyrA==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEYCIQCWg8ad+8ByD/hRRnhUZjajma7ewoVtFFokMKJyaB2x8QIhAKVsreaCqJLKU6izAyL/yT80lWVYde8Q9Yu68037KXlT"}]},"_from":".","_npmVersion":"1.3.17","_npmUser":{"name":"mafintosh","email":"mathiasbuus@gmail.com"},"maintainers":[{"name":"mafintosh","email":"mathiasbuus@gmail.com"}]},"1.2.2":{"name":"cable","version":"1.2.2","dependencies":{},"repository":{"type":"git","url":"git://github.com/mafintosh/cable.git"},"description":"Cable is a fast and simple binary request/response protocol stream for Node.js","keywords":["request","json","pipeline","server"],"author":{"name":"Mathias Buus Madsen","email":"mathiasbuus@gmail.com"},"scripts":{"test":"node test.js"},"readme":"# Cable\n\nCable is a fast and simple binary request/response protocol stream for Node.js. It features an easy to use api, pipelining and optional encodings.\nIt's available through npm:\n\n\tnpm install cable\n\n## Usage\n\nCable is especially useful for fast communication between processes and servers. All messages\nare sent with a 7 byte header that descripes the id and length of a message. This allows for extremely\neasy and fast parsing.\n\nUsage is simple. Start a server:\n\n``` js\nvar net = require('net');\nvar cable = require('cable');\n\nvar server = net.createServer(function(socket) {\n\tvar c = cable();\n\n\tc.on('message', function(message, callback) {\n\t\t// lets just echo\n\t\tcallback(null, message);\n\t});\n\n\tsocket.pipe(c).pipe(socket); // setup the pipe chain\n});\n\nserver.listen(8080);\n```\n\nDo a request:\n\n``` js\nvar socket = net.connect(8080);\nvar c = cable();\n\nsocket.pipe(c).pipe(socket);\n\nc.send(new Buffer('hello'), function(err, message) {\n\tconsole.log(message); // prints 'hello' as a buffer\n});\n\nc.send(new Buffer('world'), function(err, message) {\n\tconsole.log(message); // prints 'world' as a buffer\n});\n```\n\nTo send JSON either encode/decode the messages yourself or use the encoding option\n\n``` js\nvar c = cable({encoding:'json'});\n\ns.send({hello:'world'}, function(err, doc) {\n\tconsole.log(doc); // doc will also be JSON\n});\n```\n\n## Pipelining\n\nWhen you do a request `c.send(message, [cb])` cable sends the message and remembers the callback. If a new request is made to the same stream in the meantime cable will just send that right away and pipeline the request to minimize latency. If you do not care about the response then don't pass a callback.\n\n## Full API\n\n* `cable({encoding:null|json|utf-8}) -> c` instantiate a new cable duplex stream. select an optional message encoding\n\n* `c.send(message, [cb])` send a message. add the callback if you want a response\n\n* `c.on('message', message, cb)` emitted when a message is received. `cb` is noop if no callback was used in `send`\n\n* `c.destroy()` destroy the stream. calls all missing callbacks with an error\n\n* `c.ping(cb)` send a ping. useful to check if the connection is still alive\n\n## Protocol\n\nAll messages are prefixed with the following header and looks like this\n\n```\n --------------------------------------------------------------------------------\n|  1 byte type  |  2 byte message id  |  4 byte uint message length  |  message  |\n --------------------------------------------------------------------------------\n```\n\nThe type byte can be:\n\n* `0` this message does not expect a response\n* `1` this message expects a response with the same id\n* `2` this is a response to the message with same id\n* `3` this message is an error response to the message with the same id (message body is a utf-8 encoding error message)\n\nMessage ids should be safe to reuse after a response has been received.\n\n## License\n\nMIT\n","readmeFilename":"README.md","bugs":{"url":"https://github.com/mafintosh/cable/issues"},"homepage":"https://github.com/mafintosh/cable","_id":"cable@1.2.2","dist":{"shasum":"f8fa11d69fd5285a4fad55f06207c1aa916e3467","tarball":"https://registry.npmjs.org/cable/-/cable-1.2.2.tgz","integrity":"sha512-Z6yWf9M+6Z/2ky26WJoUPW16T1vMOI7mVfqJJ21+vpGPdvyQxooFomCWw5OdxvfTnas4wFSUyVm0LmSMll6lKw==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIC6pjL5ps9tjVt56wj4yj2BbLvaN9chBhyHKQsCaoou8AiEA3n8g2N8ftna46XSTGDXnmWVupUc+l+fKuluZ1GP6U68="}]},"_from":".","_npmVersion":"1.3.17","_npmUser":{"name":"mafintosh","email":"mathiasbuus@gmail.com"},"maintainers":[{"name":"mafintosh","email":"mathiasbuus@gmail.com"}]},"1.3.0":{"name":"cable","version":"1.3.0","dependencies":{},"repository":{"type":"git","url":"git://github.com/mafintosh/cable.git"},"description":"Cable is a fast and simple binary request/response protocol stream for Node.js","keywords":["request","json","pipeline","server"],"author":{"name":"Mathias Buus Madsen","email":"mathiasbuus@gmail.com"},"scripts":{"test":"tap test/*.js"},"devDependencies":{"tap":"~0.4.6"},"readme":"# Cable\n\nCable is a fast and simple binary request/response protocol stream for Node.js. It features an easy to use api, pipelining and optional encodings.\nIt's available through npm:\n\n\tnpm install cable\n\n[![build status](https://secure.travis-ci.org/mafintosh/cable.png)](http://travis-ci.org/mafintosh/cable)\n\n## Usage\n\nCable is especially useful for fast communication between processes and servers. All messages\nare sent with a 7 byte header that descripes the id and length of a message. This allows for extremely\neasy and fast parsing.\n\nUsage is simple. Start a server:\n\n``` js\nvar net = require('net');\nvar cable = require('cable');\n\nvar server = net.createServer(function(socket) {\n\tvar c = cable();\n\n\tc.on('message', function(message, callback) {\n\t\t// lets just echo\n\t\tcallback(null, message);\n\t});\n\n\tsocket.pipe(c).pipe(socket); // setup the pipe chain\n});\n\nserver.listen(8080);\n```\n\nDo a request:\n\n``` js\nvar socket = net.connect(8080);\nvar c = cable();\n\nsocket.pipe(c).pipe(socket);\n\nc.send(new Buffer('hello'), function(err, message) {\n\tconsole.log(message); // prints 'hello' as a buffer\n});\n\nc.send(new Buffer('world'), function(err, message) {\n\tconsole.log(message); // prints 'world' as a buffer\n});\n```\n\nTo send JSON either encode/decode the messages yourself or use the encoding option\n\n``` js\nvar c = cable({encoding:'json'});\n\ns.send({hello:'world'}, function(err, doc) {\n\tconsole.log(doc); // doc will also be JSON\n});\n```\n\n## Pipelining\n\nWhen you do a request `c.send(message, [cb])` cable sends the message and remembers the callback. If a new request is made to the same stream in the meantime cable will just send that right away and pipeline the request to minimize latency. If you do not care about the response then don't pass a callback.\n\n## Full API\n\n* `cable({encoding:null|json|utf-8}) -> c` instantiate a new cable duplex stream. select an optional message encoding\n\n* `c.send(message, [cb])` send a message. add the callback if you want a response\n\n* `c.on('message', message, cb)` emitted when a message is received. `cb` is noop if no callback was used in `send`\n\n* `c.destroy()` destroy the stream. calls all missing callbacks with an error\n\n* `c.ping(cb)` send a ping. useful to check if the connection is still alive\n\n## Protocol\n\nAll messages are prefixed with the following header and looks like this\n\n```\n --------------------------------------------------------------------------------\n|  1 byte type  |  2 byte message id  |  4 byte uint message length  |  message  |\n --------------------------------------------------------------------------------\n```\n\nThe type byte can be:\n\n* `0` this message does not expect a response\n* `1` this message expects a response with the same id\n* `2` this is a response to the message with same id\n* `3` this message is an error response to the message with the same id (message body is a utf-8 encoding error message)\n\nMessage ids should be safe to reuse after a response has been received.\n\n## License\n\nMIT\n","readmeFilename":"README.md","bugs":{"url":"https://github.com/mafintosh/cable/issues"},"homepage":"https://github.com/mafintosh/cable","_id":"cable@1.3.0","dist":{"shasum":"5ace5d494a0882f92be52503c4eb6f9e299ef3b6","tarball":"https://registry.npmjs.org/cable/-/cable-1.3.0.tgz","integrity":"sha512-B4LWqsNOTC620f72zsHhcikoUr2dSnMygQvpLcE6ZgiqB7g9WaCd4FPoW5ptDk7db1TUl3kJOhdHeXsTqx6RwA==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEYCIQC9DP6LH9ymqkT44uIHajIltM3yJ6vIHaNddowDPUINAAIhAPhkxZF3UzAJF8MTxd6hQrVdQWBM9CBm8GUvjx6y5D3a"}]},"_from":".","_npmVersion":"1.3.17","_npmUser":{"name":"mafintosh","email":"mathiasbuus@gmail.com"},"maintainers":[{"name":"mafintosh","email":"mathiasbuus@gmail.com"}]}},"readme":"","maintainers":[{"name":"mafintosh","email":"mathiasbuus@gmail.com"}],"time":{"modified":"2022-06-13T05:22:56.636Z","created":"2012-07-24T18:20:57.569Z","0.1.0":"2012-07-24T18:21:07.726Z","0.1.1":"2012-07-24T18:43:36.717Z","0.1.2":"2012-08-03T12:38:56.830Z","0.1.3":"2012-11-19T00:09:28.506Z","0.1.4":"2012-11-19T00:21:18.186Z","0.1.5":"2012-12-11T19:46:30.007Z","1.0.0":"2013-12-29T02:00:14.444Z","1.0.1":"2013-12-29T09:43:28.757Z","1.0.2":"2013-12-29T14:27:09.607Z","1.1.0":"2013-12-30T02:23:46.274Z","1.2.0":"2014-01-01T01:07:27.763Z","1.2.1":"2014-01-01T01:08:40.185Z","1.2.2":"2014-01-01T07:49:31.322Z","1.3.0":"2014-01-01T18:34:27.131Z"},"author":{"name":"Mathias Buus Madsen","email":"mathiasbuus@gmail.com"},"repository":{"type":"git","url":"git://github.com/mafintosh/cable.git"},"users":{"fgribreau":true}}