Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →
json-wire-protocol
Advanced tools
json-wire-protocol - npm Package Compare versions
Comparing version 0.2.0 to 0.2.1
@@ -564,4 +564,4 @@ ;!function(exports, undefined) { | ||
| var SEPERATOR_CODE = 58; // UTF8 / ASCII value for : | ||
| var SEPERATOR = ':'; | ||
| var SEPARATOR = ':'; | ||
| var SEPARATOR_CODE = SEPARATOR.charCodeAt(0); | ||
| var EventEmitter = | ||
@@ -592,800 +592,5 @@ global.EventEmitter2 || | ||
| do { | ||
| if (buffer[index] === SEPERATOR_CODE) | ||
| if (buffer[index] === SEPARATOR_CODE) | ||
| return index; | ||
| } while( | ||
| ++index && index + 1 < length | ||
| ); | ||
| return -1; | ||
| } | ||
| /** | ||
| * Wrapper for creating either a buffer or ArrayBuffer. | ||
| */ | ||
| function createByteContainer() { | ||
| if (HAS_BUFFER) | ||
| return new Buffer(0); | ||
| return new Uint8Array(); | ||
| } | ||
| /** | ||
| * Join the contents of byte container a and b returning c. | ||
| */ | ||
| function concatByteContainers(a, b) { | ||
| if (HAS_BUFFER) | ||
| return Buffer.concat([a, b]); | ||
| // make sure everything is unit8 | ||
| if (a instanceof ArrayBuffer) | ||
| a = new Uint8Array(a); | ||
| if (b instanceof ArrayBuffer) | ||
| b = new Uint8Array(b); | ||
| // sizes of originals | ||
| var aLen = a.length; | ||
| var bLen = b.length; | ||
| var array = new Uint8Array(aLen + bLen); | ||
| array.set(a); | ||
| array.set(b, aLen); | ||
| // return new byte container | ||
| return array; | ||
| } | ||
| function sliceByteContainers(container, start, end) { | ||
| start = start || 0; | ||
| end = end || byteLength(container); | ||
| if (HAS_BUFFER) | ||
| return container.slice(start, end); | ||
| return container.subarray(start, end); | ||
| } | ||
| /** | ||
| * Like Buffer.byteLength but works on ArrayBuffers too. | ||
| */ | ||
| function byteLength(input) { | ||
| if (typeof input === 'string') { | ||
| if (HAS_BUFFER) { | ||
| return Buffer.byteLength(input); | ||
| } | ||
| var encoder = new TextEncoder(); | ||
| var out = encoder.encode(input); | ||
| return out.length; | ||
| } | ||
| return input.length; | ||
| } | ||
| function bytesToUtf8(container, start, end) { | ||
| if (!start) | ||
| start = 0; | ||
| if (!end) | ||
| end = byteLength(container); | ||
| if (HAS_BUFFER) | ||
| return container.toString('utf8', start, end); | ||
| var decoder = new TextDecoder(); | ||
| var array = container.subarray(start, end); | ||
| return decoder.decode(array); | ||
| } | ||
| /** | ||
| * converts an object to a string representation suitable for storage on disk. | ||
| * Its very important to note that the length in the string refers to the utf8 | ||
| * size of the json content in bytes (as utf8) not the JS string length. | ||
| * | ||
| * @param {Object} object to stringify. | ||
| * @return {String} serialized object. | ||
| */ | ||
| function stringify(object) { | ||
| var json = JSON.stringify(object); | ||
| var len = byteLength(json); | ||
| return len + SEPERATOR + json; | ||
| } | ||
| /** | ||
| * attempts to parse a given buffer or string. | ||
| * | ||
| * @param {Uint8Array|Buffer} input in byteLength:{json..} format | ||
| * @return {Objec} JS object. | ||
| */ | ||
| function parse(input) { | ||
| var stream = new Stream(); | ||
| var result; | ||
| stream.once('data', function(data) { | ||
| result = data; | ||
| }); | ||
| stream.write(input); | ||
| if (!result) { | ||
| throw new Error( | ||
| 'no command available from parsing:' + input | ||
| ); | ||
| } | ||
| return result; | ||
| } | ||
| function Stream() { | ||
| EventEmitter.call(this); | ||
| this._pendingLength = null; | ||
| // zero length buffer so we can concat later | ||
| // this is always a unit8 array or a buffer. | ||
| this._buffer = createByteContainer(); | ||
| } | ||
| Stream.prototype = { | ||
| __proto__: EventEmitter.prototype, | ||
| _findLength: function() { | ||
| if (this._pendingLength === null) { | ||
| var idx = indexInBuffer(this._buffer, SEPERATOR); | ||
| if (idx === -1) | ||
| return; | ||
| // mark the length to read out of the rolling buffer. | ||
| this._pendingLength = parseInt( | ||
| bytesToUtf8(this._buffer, 0, idx), | ||
| 10 | ||
| ); | ||
| this._buffer = sliceByteContainers(this._buffer, idx + 1); | ||
| } | ||
| }, | ||
| _readBuffer: function() { | ||
| // if the buffer.length is < then we pendingLength need to buffer | ||
| // more data. | ||
| if (!this._pendingLength || this._buffer.length < this._pendingLength) | ||
| return false; | ||
| // extract remainder and parse json | ||
| var message = sliceByteContainers(this._buffer, 0, this._pendingLength); | ||
| this._buffer = sliceByteContainers(this._buffer, this._pendingLength); | ||
| this._pendingLength = null; | ||
| var result; | ||
| try { | ||
| message = bytesToUtf8(message); | ||
| result = JSON.parse(message); | ||
| } catch (e) { | ||
| this.emit('error', e); | ||
| return false; | ||
| } | ||
| this.emit('data', result); | ||
| return true; | ||
| }, | ||
| write: function (buffer) { | ||
| // append new buffer to whatever we have. | ||
| this._buffer = concatByteContainers(this._buffer, buffer); | ||
| do { | ||
| // attempt to find length of next message. | ||
| this._findLength(); | ||
| } while ( | ||
| // keep repeating while there are messages | ||
| this._readBuffer() | ||
| ); | ||
| } | ||
| }; | ||
| exports.parse = parse; | ||
| exports.stringify = stringify; | ||
| exports.Stream = Stream; | ||
| }).apply( | ||
| null, | ||
| typeof window === 'undefined' ? | ||
| [global, module.exports] : | ||
| [window, window.jsonWireProtocol = {}] | ||
| ) | ||
| ;!function(exports, undefined) { | ||
| var isArray = Array.isArray ? Array.isArray : function _isArray(obj) { | ||
| return Object.prototype.toString.call(obj) === "[object Array]"; | ||
| }; | ||
| var defaultMaxListeners = 10; | ||
| function init() { | ||
| this._events = {}; | ||
| if (this._conf) { | ||
| configure.call(this, this._conf); | ||
| } | ||
| } | ||
| function configure(conf) { | ||
| if (conf) { | ||
| this._conf = conf; | ||
| conf.delimiter && (this.delimiter = conf.delimiter); | ||
| conf.maxListeners && (this._events.maxListeners = conf.maxListeners); | ||
| conf.wildcard && (this.wildcard = conf.wildcard); | ||
| conf.newListener && (this.newListener = conf.newListener); | ||
| if (this.wildcard) { | ||
| this.listenerTree = {}; | ||
| } | ||
| } | ||
| } | ||
| function EventEmitter(conf) { | ||
| this._events = {}; | ||
| this.newListener = false; | ||
| configure.call(this, conf); | ||
| } | ||
| // | ||
| // Attention, function return type now is array, always ! | ||
| // It has zero elements if no any matches found and one or more | ||
| // elements (leafs) if there are matches | ||
| // | ||
| function searchListenerTree(handlers, type, tree, i) { | ||
| if (!tree) { | ||
| return []; | ||
| } | ||
| var listeners=[], leaf, len, branch, xTree, xxTree, isolatedBranch, endReached, | ||
| typeLength = type.length, currentType = type[i], nextType = type[i+1]; | ||
| if (i === typeLength && tree._listeners) { | ||
| // | ||
| // If at the end of the event(s) list and the tree has listeners | ||
| // invoke those listeners. | ||
| // | ||
| if (typeof tree._listeners === 'function') { | ||
| handlers && handlers.push(tree._listeners); | ||
| return [tree]; | ||
| } else { | ||
| for (leaf = 0, len = tree._listeners.length; leaf < len; leaf++) { | ||
| handlers && handlers.push(tree._listeners[leaf]); | ||
| } | ||
| return [tree]; | ||
| } | ||
| } | ||
| if ((currentType === '*' || currentType === '**') || tree[currentType]) { | ||
| // | ||
| // If the event emitted is '*' at this part | ||
| // or there is a concrete match at this patch | ||
| // | ||
| if (currentType === '*') { | ||
| for (branch in tree) { | ||
| if (branch !== '_listeners' && tree.hasOwnProperty(branch)) { | ||
| listeners = listeners.concat(searchListenerTree(handlers, type, tree[branch], i+1)); | ||
| } | ||
| } | ||
| return listeners; | ||
| } else if(currentType === '**') { | ||
| endReached = (i+1 === typeLength || (i+2 === typeLength && nextType === '*')); | ||
| if(endReached && tree._listeners) { | ||
| // The next element has a _listeners, add it to the handlers. | ||
| listeners = listeners.concat(searchListenerTree(handlers, type, tree, typeLength)); | ||
| } | ||
| for (branch in tree) { | ||
| if (branch !== '_listeners' && tree.hasOwnProperty(branch)) { | ||
| if(branch === '*' || branch === '**') { | ||
| if(tree[branch]._listeners && !endReached) { | ||
| listeners = listeners.concat(searchListenerTree(handlers, type, tree[branch], typeLength)); | ||
| } | ||
| listeners = listeners.concat(searchListenerTree(handlers, type, tree[branch], i)); | ||
| } else if(branch === nextType) { | ||
| listeners = listeners.concat(searchListenerTree(handlers, type, tree[branch], i+2)); | ||
| } else { | ||
| // No match on this one, shift into the tree but not in the type array. | ||
| listeners = listeners.concat(searchListenerTree(handlers, type, tree[branch], i)); | ||
| } | ||
| } | ||
| } | ||
| return listeners; | ||
| } | ||
| listeners = listeners.concat(searchListenerTree(handlers, type, tree[currentType], i+1)); | ||
| } | ||
| xTree = tree['*']; | ||
| if (xTree) { | ||
| // | ||
| // If the listener tree will allow any match for this part, | ||
| // then recursively explore all branches of the tree | ||
| // | ||
| searchListenerTree(handlers, type, xTree, i+1); | ||
| } | ||
| xxTree = tree['**']; | ||
| if(xxTree) { | ||
| if(i < typeLength) { | ||
| if(xxTree._listeners) { | ||
| // If we have a listener on a '**', it will catch all, so add its handler. | ||
| searchListenerTree(handlers, type, xxTree, typeLength); | ||
| } | ||
| // Build arrays of matching next branches and others. | ||
| for(branch in xxTree) { | ||
| if(branch !== '_listeners' && xxTree.hasOwnProperty(branch)) { | ||
| if(branch === nextType) { | ||
| // We know the next element will match, so jump twice. | ||
| searchListenerTree(handlers, type, xxTree[branch], i+2); | ||
| } else if(branch === currentType) { | ||
| // Current node matches, move into the tree. | ||
| searchListenerTree(handlers, type, xxTree[branch], i+1); | ||
| } else { | ||
| isolatedBranch = {}; | ||
| isolatedBranch[branch] = xxTree[branch]; | ||
| searchListenerTree(handlers, type, { '**': isolatedBranch }, i+1); | ||
| } | ||
| } | ||
| } | ||
| } else if(xxTree._listeners) { | ||
| // We have reached the end and still on a '**' | ||
| searchListenerTree(handlers, type, xxTree, typeLength); | ||
| } else if(xxTree['*'] && xxTree['*']._listeners) { | ||
| searchListenerTree(handlers, type, xxTree['*'], typeLength); | ||
| } | ||
| } | ||
| return listeners; | ||
| } | ||
| function growListenerTree(type, listener) { | ||
| type = typeof type === 'string' ? type.split(this.delimiter) : type.slice(); | ||
| // | ||
| // Looks for two consecutive '**', if so, don't add the event at all. | ||
| // | ||
| for(var i = 0, len = type.length; i+1 < len; i++) { | ||
| if(type[i] === '**' && type[i+1] === '**') { | ||
| return; | ||
| } | ||
| } | ||
| var tree = this.listenerTree; | ||
| var name = type.shift(); | ||
| while (name) { | ||
| if (!tree[name]) { | ||
| tree[name] = {}; | ||
| } | ||
| tree = tree[name]; | ||
| if (type.length === 0) { | ||
| if (!tree._listeners) { | ||
| tree._listeners = listener; | ||
| } | ||
| else if(typeof tree._listeners === 'function') { | ||
| tree._listeners = [tree._listeners, listener]; | ||
| } | ||
| else if (isArray(tree._listeners)) { | ||
| tree._listeners.push(listener); | ||
| if (!tree._listeners.warned) { | ||
| var m = defaultMaxListeners; | ||
| if (typeof this._events.maxListeners !== 'undefined') { | ||
| m = this._events.maxListeners; | ||
| } | ||
| if (m > 0 && tree._listeners.length > m) { | ||
| tree._listeners.warned = true; | ||
| console.error('(node) warning: possible EventEmitter memory ' + | ||
| 'leak detected. %d listeners added. ' + | ||
| 'Use emitter.setMaxListeners() to increase limit.', | ||
| tree._listeners.length); | ||
| console.trace(); | ||
| } | ||
| } | ||
| } | ||
| return true; | ||
| } | ||
| name = type.shift(); | ||
| } | ||
| return true; | ||
| }; | ||
| // By default EventEmitters will print a warning if more than | ||
| // 10 listeners are added to it. This is a useful default which | ||
| // helps finding memory leaks. | ||
| // | ||
| // Obviously not all Emitters should be limited to 10. This function allows | ||
| // that to be increased. Set to zero for unlimited. | ||
| EventEmitter.prototype.delimiter = '.'; | ||
| EventEmitter.prototype.setMaxListeners = function(n) { | ||
| this._events || init.call(this); | ||
| this._events.maxListeners = n; | ||
| if (!this._conf) this._conf = {}; | ||
| this._conf.maxListeners = n; | ||
| }; | ||
| EventEmitter.prototype.event = ''; | ||
| EventEmitter.prototype.once = function(event, fn) { | ||
| this.many(event, 1, fn); | ||
| return this; | ||
| }; | ||
| EventEmitter.prototype.many = function(event, ttl, fn) { | ||
| var self = this; | ||
| if (typeof fn !== 'function') { | ||
| throw new Error('many only accepts instances of Function'); | ||
| } | ||
| function listener() { | ||
| if (--ttl === 0) { | ||
| self.off(event, listener); | ||
| } | ||
| fn.apply(this, arguments); | ||
| }; | ||
| listener._origin = fn; | ||
| this.on(event, listener); | ||
| return self; | ||
| }; | ||
| EventEmitter.prototype.emit = function() { | ||
| this._events || init.call(this); | ||
| var type = arguments[0]; | ||
| if (type === 'newListener' && !this.newListener) { | ||
| if (!this._events.newListener) { return false; } | ||
| } | ||
| // Loop through the *_all* functions and invoke them. | ||
| if (this._all) { | ||
| var l = arguments.length; | ||
| var args = new Array(l - 1); | ||
| for (var i = 1; i < l; i++) args[i - 1] = arguments[i]; | ||
| for (i = 0, l = this._all.length; i < l; i++) { | ||
| this.event = type; | ||
| this._all[i].apply(this, args); | ||
| } | ||
| } | ||
| // If there is no 'error' event listener then throw. | ||
| if (type === 'error') { | ||
| if (!this._all && | ||
| !this._events.error && | ||
| !(this.wildcard && this.listenerTree.error)) { | ||
| if (arguments[1] instanceof Error) { | ||
| throw arguments[1]; // Unhandled 'error' event | ||
| } else { | ||
| throw new Error("Uncaught, unspecified 'error' event."); | ||
| } | ||
| return false; | ||
| } | ||
| } | ||
| var handler; | ||
| if(this.wildcard) { | ||
| handler = []; | ||
| var ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice(); | ||
| searchListenerTree.call(this, handler, ns, this.listenerTree, 0); | ||
| } | ||
| else { | ||
| handler = this._events[type]; | ||
| } | ||
| if (typeof handler === 'function') { | ||
| this.event = type; | ||
| if (arguments.length === 1) { | ||
| handler.call(this); | ||
| } | ||
| else if (arguments.length > 1) | ||
| switch (arguments.length) { | ||
| case 2: | ||
| handler.call(this, arguments[1]); | ||
| break; | ||
| case 3: | ||
| handler.call(this, arguments[1], arguments[2]); | ||
| break; | ||
| // slower | ||
| default: | ||
| var l = arguments.length; | ||
| var args = new Array(l - 1); | ||
| for (var i = 1; i < l; i++) args[i - 1] = arguments[i]; | ||
| handler.apply(this, args); | ||
| } | ||
| return true; | ||
| } | ||
| else if (handler) { | ||
| var l = arguments.length; | ||
| var args = new Array(l - 1); | ||
| for (var i = 1; i < l; i++) args[i - 1] = arguments[i]; | ||
| var listeners = handler.slice(); | ||
| for (var i = 0, l = listeners.length; i < l; i++) { | ||
| this.event = type; | ||
| listeners[i].apply(this, args); | ||
| } | ||
| return (listeners.length > 0) || this._all; | ||
| } | ||
| else { | ||
| return this._all; | ||
| } | ||
| }; | ||
| EventEmitter.prototype.on = function(type, listener) { | ||
| if (typeof type === 'function') { | ||
| this.onAny(type); | ||
| return this; | ||
| } | ||
| if (typeof listener !== 'function') { | ||
| throw new Error('on only accepts instances of Function'); | ||
| } | ||
| this._events || init.call(this); | ||
| // To avoid recursion in the case that type == "newListeners"! Before | ||
| // adding it to the listeners, first emit "newListeners". | ||
| this.emit('newListener', type, listener); | ||
| if(this.wildcard) { | ||
| growListenerTree.call(this, type, listener); | ||
| return this; | ||
| } | ||
| if (!this._events[type]) { | ||
| // Optimize the case of one listener. Don't need the extra array object. | ||
| this._events[type] = listener; | ||
| } | ||
| else if(typeof this._events[type] === 'function') { | ||
| // Adding the second element, need to change to array. | ||
| this._events[type] = [this._events[type], listener]; | ||
| } | ||
| else if (isArray(this._events[type])) { | ||
| // If we've already got an array, just append. | ||
| this._events[type].push(listener); | ||
| // Check for listener leak | ||
| if (!this._events[type].warned) { | ||
| var m = defaultMaxListeners; | ||
| if (typeof this._events.maxListeners !== 'undefined') { | ||
| m = this._events.maxListeners; | ||
| } | ||
| if (m > 0 && this._events[type].length > m) { | ||
| this._events[type].warned = true; | ||
| console.error('(node) warning: possible EventEmitter memory ' + | ||
| 'leak detected. %d listeners added. ' + | ||
| 'Use emitter.setMaxListeners() to increase limit.', | ||
| this._events[type].length); | ||
| console.trace(); | ||
| } | ||
| } | ||
| } | ||
| return this; | ||
| }; | ||
| EventEmitter.prototype.onAny = function(fn) { | ||
| if(!this._all) { | ||
| this._all = []; | ||
| } | ||
| if (typeof fn !== 'function') { | ||
| throw new Error('onAny only accepts instances of Function'); | ||
| } | ||
| // Add the function to the event listener collection. | ||
| this._all.push(fn); | ||
| return this; | ||
| }; | ||
| EventEmitter.prototype.addListener = EventEmitter.prototype.on; | ||
| EventEmitter.prototype.off = function(type, listener) { | ||
| if (typeof listener !== 'function') { | ||
| throw new Error('removeListener only takes instances of Function'); | ||
| } | ||
| var handlers,leafs=[]; | ||
| if(this.wildcard) { | ||
| var ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice(); | ||
| leafs = searchListenerTree.call(this, null, ns, this.listenerTree, 0); | ||
| } | ||
| else { | ||
| // does not use listeners(), so no side effect of creating _events[type] | ||
| if (!this._events[type]) return this; | ||
| handlers = this._events[type]; | ||
| leafs.push({_listeners:handlers}); | ||
| } | ||
| for (var iLeaf=0; iLeaf<leafs.length; iLeaf++) { | ||
| var leaf = leafs[iLeaf]; | ||
| handlers = leaf._listeners; | ||
| if (isArray(handlers)) { | ||
| var position = -1; | ||
| for (var i = 0, length = handlers.length; i < length; i++) { | ||
| if (handlers[i] === listener || | ||
| (handlers[i].listener && handlers[i].listener === listener) || | ||
| (handlers[i]._origin && handlers[i]._origin === listener)) { | ||
| position = i; | ||
| break; | ||
| } | ||
| } | ||
| if (position < 0) { | ||
| return this; | ||
| } | ||
| if(this.wildcard) { | ||
| leaf._listeners.splice(position, 1) | ||
| } | ||
| else { | ||
| this._events[type].splice(position, 1); | ||
| } | ||
| if (handlers.length === 0) { | ||
| if(this.wildcard) { | ||
| delete leaf._listeners; | ||
| } | ||
| else { | ||
| delete this._events[type]; | ||
| } | ||
| } | ||
| } | ||
| else if (handlers === listener || | ||
| (handlers.listener && handlers.listener === listener) || | ||
| (handlers._origin && handlers._origin === listener)) { | ||
| if(this.wildcard) { | ||
| delete leaf._listeners; | ||
| } | ||
| else { | ||
| delete this._events[type]; | ||
| } | ||
| } | ||
| } | ||
| return this; | ||
| }; | ||
| EventEmitter.prototype.offAny = function(fn) { | ||
| var i = 0, l = 0, fns; | ||
| if (fn && this._all && this._all.length > 0) { | ||
| fns = this._all; | ||
| for(i = 0, l = fns.length; i < l; i++) { | ||
| if(fn === fns[i]) { | ||
| fns.splice(i, 1); | ||
| return this; | ||
| } | ||
| } | ||
| } else { | ||
| this._all = []; | ||
| } | ||
| return this; | ||
| }; | ||
| EventEmitter.prototype.removeListener = EventEmitter.prototype.off; | ||
| EventEmitter.prototype.removeAllListeners = function(type) { | ||
| if (arguments.length === 0) { | ||
| !this._events || init.call(this); | ||
| return this; | ||
| } | ||
| if(this.wildcard) { | ||
| var ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice(); | ||
| var leafs = searchListenerTree.call(this, null, ns, this.listenerTree, 0); | ||
| for (var iLeaf=0; iLeaf<leafs.length; iLeaf++) { | ||
| var leaf = leafs[iLeaf]; | ||
| leaf._listeners = null; | ||
| } | ||
| } | ||
| else { | ||
| if (!this._events[type]) return this; | ||
| this._events[type] = null; | ||
| } | ||
| return this; | ||
| }; | ||
| EventEmitter.prototype.listeners = function(type) { | ||
| if(this.wildcard) { | ||
| var handlers = []; | ||
| var ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice(); | ||
| searchListenerTree.call(this, handlers, ns, this.listenerTree, 0); | ||
| return handlers; | ||
| } | ||
| this._events || init.call(this); | ||
| if (!this._events[type]) this._events[type] = []; | ||
| if (!isArray(this._events[type])) { | ||
| this._events[type] = [this._events[type]]; | ||
| } | ||
| return this._events[type]; | ||
| }; | ||
| EventEmitter.prototype.listenersAny = function() { | ||
| if(this._all) { | ||
| return this._all; | ||
| } | ||
| else { | ||
| return []; | ||
| } | ||
| }; | ||
| if (typeof define === 'function' && define.amd) { | ||
| define(function() { | ||
| return EventEmitter; | ||
| }); | ||
| } else { | ||
| exports.EventEmitter2 = EventEmitter; | ||
| } | ||
| }(typeof process !== 'undefined' && typeof process.title !== 'undefined' && typeof exports !== 'undefined' ? exports : window); | ||
| (function(global, exports) { | ||
| var HAS_BUFFER = typeof Buffer !== 'undefined'; | ||
| var SEPERATOR_CODE = 58; // UTF8 / ASCII value for : | ||
| var SEPERATOR = ':'; | ||
| var EventEmitter = | ||
| global.EventEmitter2 || | ||
| require('eventemitter2').EventEmitter2; | ||
| /** | ||
| * First ocurrence of where string occurs in a buffer. | ||
| * | ||
| * NOTE: this is not UTF8 safe generally we expect to find the correct | ||
| * char fairly quickly unless the buffer is incorrectly formatted. | ||
| * | ||
| * @param {Buffer} buffer haystack. | ||
| * @param {String} string needle. | ||
| * @return {Numeric} -1 if not found index otherwise. | ||
| */ | ||
| function indexInBuffer(buffer, string) { | ||
| if (typeof buffer === 'string') | ||
| return buffer.indexOf(string); | ||
| if (buffer.length === 0) | ||
| return -1; | ||
| var index = 0; | ||
| var length = buffer.length; | ||
| do { | ||
| if (buffer[index] === SEPERATOR_CODE) | ||
| return index; | ||
| } while ( | ||
@@ -1488,3 +693,3 @@ ++index && index + 1 < length | ||
| return len + SEPERATOR + json; | ||
| return len + SEPARATOR + json; | ||
| } | ||
@@ -1532,3 +737,3 @@ | ||
| if (this._pendingLength === null) { | ||
| var idx = indexInBuffer(this._buffer, SEPERATOR); | ||
| var idx = indexInBuffer(this._buffer, SEPARATOR); | ||
| if (idx === -1) | ||
@@ -1589,2 +794,3 @@ return; | ||
| exports.Stream = Stream; | ||
| exports.separator = SEPARATOR; | ||
| }).apply( | ||
@@ -1591,0 +797,0 @@ null, |
| { | ||
| "name": "json-wire-protocol", | ||
| "version": "0.2.0", | ||
| "version": "0.2.1", | ||
| "main": "index.js", | ||
@@ -5,0 +5,0 @@ "description": "JSON wire protocol parser/writer (used in mozilla debugger protocol)", |
Sorry, the diff of this file is not supported yet
New alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Fixed alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Worsened metrics
- Total package byte prevSize
- decreased by-37.39%
36518
- Lines of code
- decreased by-39.21%
1014
No dependency changes