passenger 5.0.21 → 5.0.22

data/src/nodejs_supportlib/vendor-copy/continuation-local-storage/node_modules/async-listener/node_modules/shimmer/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "shimmer",
+  "version": "1.0.0",
+  "description": "Safe(r) monkeypatching for JavaScript.",
+  "main": "index.js",
+  "scripts": {
+    "test": "tap test/*.tap.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/othiym23/shimmer.git"
+  },
+  "keywords": [
+    "monkeypatch",
+    "swizzle",
+    "wrapping",
+    "danger",
+    "hmm",
+    "shim"
+  ],
+  "author": {
+    "name": "Forrest L Norvell",
+    "email": "ogd@aoaioxxysz.net"
+  },
+  "license": "BSD",
+  "devDependencies": {
+    "tap": "~0.4.3",
+    "sinon": "~1.7.2"
+  },
+  "readme": "## Safer monkeypatching for Node.js\n\n`shimmer` does a bunch of the work necessary to wrap other methods in\na wrapper you provide:\n\n```javascript\nvar http = require('http');\nvar shimmer = require('shimmer');\n\nshimmer.wrap(http, 'request', function (original) {\n  return function () {\n    console.log(\"Starting request!\");\n    var returned = original.apply(this, arguments)\n    console.log(\"Done setting up request -- OH YEAH!\");\n    return returned;\n  };\n});\n```\n\n### Mandatory disclaimer\n\nThere are times when it's necessary to monkeypatch default behavior in\nJavaScript and Node. However, changing the behavior of the runtime on the fly\nis rarely a good idea, and you should be using this module because you need to,\nnot because it seems like fun.\n\n### API\n\nAll monkeypatched functions have an attribute, `__wrapped`, set to true on\nthem.\n\n#### shimmer(options)\n\nIf you pass in an options object containing a function labeled `logger`,\n`shimmer` will use it instead of the logger, which defaults to `console.error`.\n`shimmer` is built to be as unobtrusive as possible and has no need to run\nasynchronously, so it defaults to logging when things fail, instead of\nthrowing.\n\n#### shimmer.wrap(nodule, name, wrapper)\n\n`shimmer` monkeypatches in place, so it expects to be passed an object.\nIt accepts either instances, prototypes, or the results of calling\n`require`. `name` must be the string key for the field's name on the\nobject.\n\n`wrapper` is a function that takes a single parameter, which is the original\nfunction to be monkeypatched. `shimmer` assumes that you're adding behavior\nto the original method, and not replacing it outright. If you *are* replacing\nthe original function, feel free to ignore the passed-in function.\n\nIf you *aren't* discarding the original, remember these tips:\n\n* call the original with something like `original.apply(this, arguments)`,\n  unless your reason for monkeypatching is to transform the arguments.\n* always capture and return the return value coming from the original function.\n  Today's null-returning callback is tomorrow's error-code returning callback.\n* Don't make an asynchronous function synchronous and vice versa.\n\n#### shimmer.massWrap(nodules, names, wrapper)\n\nJust like `wrap`, with the addition that you can wrap multiple methods on\nmultiple modules. Note that this function expects the list of functions to be\nmonkeypatched on all of the modules to be the same.\n\n#### shimmer.unwrap(nodule, name)\n\nA convenience function for restoring the function back the way it was before\nyou started. Won't unwrap if somebody else has monkeypatched the function after\nyou (but will log in that case). Won't throw if you try to double-unwrap a\nfunction (but will log).\n\n#### shimmer.wrapEmitter(emitter, mark, prepare)\n\nWrap an EventEmitter's event listeners. Each listener will be passed to\n`mark` when it is registered with `.addListener()` or `.on()`, and then\neach listener is passed to `prepare` to be wrapped before it's called\nby the `.emit()` call. `wrapListener` deals with the single listener\nvs array of listeners logic, and also ensures that edge cases like\n`.removeListener()` being called from within an `.emit()` for the same\nevent type is handled properly.\n\nThe wrapped EE can be restored to its pristine state by using\nemitter.__unwrap(), but this should only be used if you *really* know\nwhat you're doing.\n",
+  "readmeFilename": "README.md",
+  "bugs": {
+    "url": "https://github.com/othiym23/shimmer/issues"
+  },
+  "homepage": "https://github.com/othiym23/shimmer",
+  "_id": "shimmer@1.0.0",
+  "_shasum": "49c2d71c678360b802be18b278382d1cbb805c39",
+  "_from": "shimmer@1.0.0",
+  "_resolved": "https://registry.npmjs.org/shimmer/-/shimmer-1.0.0.tgz"
+}

data/src/nodejs_supportlib/vendor-copy/continuation-local-storage/node_modules/async-listener/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "async-listener",
+  "version": "0.5.6",
+  "description": "Polyfill exporting trevnorris's 0.11+ asyncListener API.",
+  "author": {
+    "name": "Forrest L Norvell",
+    "email": "ogd@aoaioxxysz.net"
+  },
+  "contributors": [
+    {
+      "name": "Tim Caswell",
+      "email": "tim@creationix.com"
+    },
+    {
+      "name": "Forrest L Norvell",
+      "email": "ogd@aoaioxxysz.net"
+    }
+  ],
+  "main": "index.js",
+  "scripts": {
+    "test": "tap test/*.tap.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/othiym23/async-listener.git"
+  },
+  "keywords": [
+    "polyfill",
+    "shim",
+    "zesty",
+    "crazed",
+    "experimental"
+  ],
+  "license": "BSD-2-Clause",
+  "bugs": {
+    "url": "https://github.com/othiym23/async-listener/issues"
+  },
+  "engines": {
+    "node": "<=0.11.8 || >0.11.10"
+  },
+  "dependencies": {
+    "shimmer": "1.0.0"
+  },
+  "devDependencies": {
+    "tap": "^0.7.1"
+  },
+  "readme": "[![NPM](https://nodei.co/npm/async-listener.png?downloads=true&stars=true)](https://nodei.co/npm/async-listener/)\n\n# process.addAsyncListener polyfill\n\nThis is an implementation of Trevor Norris's\nprocess.{addAsyncListener,removeAsyncListener} API for adding behavior to async\ncalls. You can see his implementation (currently a work in progress) on\n[Node.js core pull request #6011](https://github.com/joyent/node/pull/6011).\nThis polyfill / shim is intended for use in versions of Node prior to whatever\nversion of Node in which Trevor's changes finally land (anticipated at the time\nof this writing as 0.11.7).\n\nHere's his documentation of the intended API, which will probably get cleaned up\nhere later:\n\n## createAsyncListener(callbacks[, initialStorage])\n\n* `callbacks` {Object}\n* `initialStorage` {Value}\n\nReturns a constructed `AsyncListener` object. Which can then be passed to\n`process.addAsyncListener()` and `process.removeAsyncListener()`. Each\nfunction parameter is as follows:\n\n1. `callbacks`: An `Object` which may contain four optional fields:\n   * `create`: A `function (storage)` that is called when an asynchronous event\n     is queued. Recives the `storage` attached to the listner. `storage` can be\n     created by passing an `initialStorage` argument during costruction, or by\n     returning a `Value` from `create` which will be attached to the listner\n     and overwrite the `initialStorage`.\n   * `before`: A `function (context, storage)` that is called immediately\n     before the asynchronous callback is about to run. It will be passed both\n     the `context` (i.e. `this`) of the calling function and the `storage`.\n   * `after`: A `function (context, storage)` called immediately after the\n     asynchronous event's callback is run. Note that if the event's callback\n     throws during execution this will not be called.\n   * `error`: A `function (storage, error)` called if the event's callback\n     threw. If `error` returns `true` then Node will assume the error has been\n     properly handled and resume execution normally.\n1. `initialStorage`: A `Value` (i.e. anything) that will be, by default,\n   attached to all new event instances. This will be overwritten if a `Value`\n   is returned by `create()`.\n\n\n## addAsyncListener(callbacks[, initialStorage])\n## addAsyncListener(asyncListener)\n\nReturns a constructed `AsyncListener` object and immediately adds it to the\nlistening queue.\n\n## removeAsyncListener(asyncListener)\n\nRemoves the `asyncListener` from the listening queue.\n",
+  "readmeFilename": "README.md",
+  "homepage": "https://github.com/othiym23/async-listener",
+  "_id": "async-listener@0.5.6",
+  "_shasum": "0c5f7dfb7d5ba657098f3ca5d7be693f720e09f9",
+  "_from": "async-listener@^0.5.0",
+  "_resolved": "https://registry.npmjs.org/async-listener/-/async-listener-0.5.6.tgz"
+}

data/src/nodejs_supportlib/vendor-copy/continuation-local-storage/node_modules/emitter-listener/listener.js

@@ -0,0 +1,160 @@
+'use strict';
+
+var shimmer = require('shimmer');
+var wrap    = shimmer.wrap;
+var unwrap  = shimmer.unwrap;
+
+// Default to complaining loudly when things don't go according to plan.
+// dunderscores are boring
+var SYMBOL = 'wrap@before';
+
+function _process(self, listeners) {
+  var l = listeners.length;
+  for (var p = 0; p < l; p++) {
+    var listener = listeners[p];
+    // set up the listener so that onEmit can do whatever it needs
+    var before = self[SYMBOL];
+    if (typeof before === 'function') {
+      before(listener);
+    }
+    else if (Array.isArray(before)) {
+      var length = before.length;
+      for (var i = 0; i < length; i++) before[i](listener);
+    }
+  }
+}
+
+function _listeners(self, event) {
+  var listeners;
+  listeners = self._events && self._events[event];
+  if (!Array.isArray(listeners)) {
+    if (listeners) {
+      listeners = [listeners];
+    }
+    else {
+      listeners = [];
+    }
+  }
+
+  return listeners;
+}
+
+function _findAndProcess(self, event, before) {
+  var after = _listeners(self, event);
+  var unprocessed = after.filter(function(fn) { return before.indexOf(fn) === -1; });
+  if (unprocessed.length > 0) _process(self, unprocessed);
+}
+
+function _wrap(unwrapped, visit) {
+  if (!unwrapped) return;
+
+  var wrapped = unwrapped;
+  if (typeof unwrapped === 'function') {
+    wrapped = visit(unwrapped);
+  }
+  else if (Array.isArray(unwrapped)) {
+    wrapped = [];
+    for (var i = 0; i < unwrapped.length; i++) {
+      wrapped[i] = visit(unwrapped[i]);
+    }
+  }
+  return wrapped;
+}
+
+module.exports = function wrapEmitter(emitter, onAddListener, onEmit) {
+  if (!emitter || !emitter.on || !emitter.addListener ||
+      !emitter.removeListener || !emitter.emit) {
+    throw new Error("can only wrap real EEs");
+  }
+
+  if (!onAddListener) throw new Error("must have function to run on listener addition");
+  if (!onEmit) throw new Error("must have function to wrap listeners when emitting");
+
+  /* Attach a context to a listener, and make sure that this hook stays
+   * attached to the emitter forevermore.
+   */
+  function adding(on) {
+    return function added(event, listener) {
+      var existing = _listeners(this, event);
+
+      try {
+        var returned = on.call(this, event, listener);
+        _findAndProcess(this, event, existing);
+        return returned;
+      }
+      finally {
+        // old-style streaming overwrites .on and .addListener, so rewrap
+        if (!this.on.__wrapped) wrap(this, 'on', adding);
+        if (!this.addListener.__wrapped) wrap(this, 'addListener', adding);
+      }
+    };
+  }
+
+  function emitting(emit) {
+    return function emitted(event) {
+      if (!this._events || !this._events[event]) return emit.apply(this, arguments);
+
+      var unwrapped = this._events[event];
+
+      /* Ensure that if removeListener gets called, it's working with the
+       * unwrapped listeners.
+       */
+      function remover(removeListener) {
+        return function removed() {
+          this._events[event] = unwrapped;
+          try {
+            return removeListener.apply(this, arguments);
+          }
+          finally {
+            unwrapped = this._events[event];
+            this._events[event] = _wrap(unwrapped, onEmit);
+          }
+        };
+      }
+      wrap(this, 'removeListener', remover);
+
+      try {
+        /* At emit time, ensure that whatever else is going on, removeListener will
+         * still work while at the same time running whatever hooks are necessary to
+         * make sure the listener is run in the correct context.
+         */
+        this._events[event] = _wrap(unwrapped, onEmit);
+        return emit.apply(this, arguments);
+      }
+      finally {
+        /* Ensure that regardless of what happens when preparing and running the
+         * listeners, the status quo ante is restored before continuing.
+         */
+        unwrap(this, 'removeListener');
+        this._events[event] = unwrapped;
+      }
+    };
+  }
+
+  // support multiple onAddListeners
+  if (!emitter[SYMBOL]) {
+    emitter[SYMBOL] = onAddListener;
+  }
+  else if (typeof emitter[SYMBOL] === 'function') {
+    emitter[SYMBOL] = [emitter[SYMBOL], onAddListener];
+  }
+  else if (Array.isArray(emitter[SYMBOL])) {
+    emitter[SYMBOL].push(onAddListener);
+  }
+
+  // only wrap the core functions once
+  if (!emitter.__wrapped) {
+    wrap(emitter, 'addListener', adding);
+    wrap(emitter, 'on',          adding);
+    wrap(emitter, 'emit',        emitting);
+
+    emitter.__unwrap = function () {
+      unwrap(emitter, 'addListener');
+      unwrap(emitter, 'on');
+      unwrap(emitter, 'emit');
+      delete emitter[SYMBOL];
+      delete emitter.__wrapped;
+    };
+    emitter.__wrapped = true;
+  }
+};

data/src/nodejs_supportlib/vendor-copy/continuation-local-storage/node_modules/emitter-listener/node_modules/shimmer/index.js

@@ -0,0 +1,90 @@
+'use strict';
+
+function isFunction(funktion) {
+  return funktion && {}.toString.call(funktion) === '[object Function]';
+}
+
+// Default to complaining loudly when things don't go according to plan.
+var logger = console.error.bind(console);
+
+// Keep initialization idempotent.
+function shimmer(options) {
+  if (options && options.logger) {
+    if (!isFunction(options.logger)) logger("new logger isn't a function, not replacing");
+    else logger = options.logger;
+  }
+}
+
+function wrap(nodule, name, wrapper) {
+  if (!nodule || !nodule[name]) {
+    logger("no original function " + name + " to wrap");
+    return;
+  }
+
+  if (!wrapper) {
+    logger("no wrapper function");
+    logger((new Error()).stack);
+    return;
+  }
+
+  if (!isFunction(nodule[name]) || !isFunction(wrapper)) {
+    logger("original object and wrapper must be functions");
+    return;
+  }
+
+  var original = nodule[name]
+    , wrapped = wrapper(original)
+    ;
+
+  wrapped.__original = original;
+  wrapped.__unwrap = function () {
+    if (nodule[name] === wrapped) nodule[name] = original;
+  };
+  wrapped.__wrapped = true;
+
+  nodule[name] = wrapped;
+
+  return wrapped;
+}
+
+function massWrap(nodules, names, wrapper) {
+  if (!nodules) {
+    logger("must provide one or more modules to patch");
+    logger((new Error()).stack);
+    return;
+  } else if (!Array.isArray(nodules)) {
+    nodules = [nodules];
+  }
+
+  if (!(names && Array.isArray(names))) {
+    logger("must provide one or more functions to wrap on modules");
+    return;
+  }
+
+  nodules.forEach(function (nodule) {
+    names.forEach(function (name) {
+      wrap(nodule, name, wrapper);
+    });
+  });
+}
+
+function unwrap(nodule, name) {
+  if (!nodule || !nodule[name]) {
+    logger("no function to unwrap.");
+    logger((new Error()).stack);
+    return;
+  }
+
+  if (!nodule[name].__unwrap) {
+    logger("no original to unwrap to -- has " + name + " already been unwrapped?");
+  }
+  else {
+    return nodule[name].__unwrap();
+  }
+}
+
+shimmer.wrap = wrap;
+shimmer.massWrap = massWrap;
+shimmer.unwrap = unwrap;
+
+module.exports = shimmer;

data/src/nodejs_supportlib/vendor-copy/continuation-local-storage/node_modules/emitter-listener/node_modules/shimmer/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "shimmer",
+  "version": "1.0.0",
+  "description": "Safe(r) monkeypatching for JavaScript.",
+  "main": "index.js",
+  "scripts": {
+    "test": "tap test/*.tap.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/othiym23/shimmer.git"
+  },
+  "keywords": [
+    "monkeypatch",
+    "swizzle",
+    "wrapping",
+    "danger",
+    "hmm",
+    "shim"
+  ],
+  "author": {
+    "name": "Forrest L Norvell",
+    "email": "ogd@aoaioxxysz.net"
+  },
+  "license": "BSD",
+  "devDependencies": {
+    "tap": "~0.4.3",
+    "sinon": "~1.7.2"
+  },
+  "readme": "## Safer monkeypatching for Node.js\n\n`shimmer` does a bunch of the work necessary to wrap other methods in\na wrapper you provide:\n\n```javascript\nvar http = require('http');\nvar shimmer = require('shimmer');\n\nshimmer.wrap(http, 'request', function (original) {\n  return function () {\n    console.log(\"Starting request!\");\n    var returned = original.apply(this, arguments)\n    console.log(\"Done setting up request -- OH YEAH!\");\n    return returned;\n  };\n});\n```\n\n### Mandatory disclaimer\n\nThere are times when it's necessary to monkeypatch default behavior in\nJavaScript and Node. However, changing the behavior of the runtime on the fly\nis rarely a good idea, and you should be using this module because you need to,\nnot because it seems like fun.\n\n### API\n\nAll monkeypatched functions have an attribute, `__wrapped`, set to true on\nthem.\n\n#### shimmer(options)\n\nIf you pass in an options object containing a function labeled `logger`,\n`shimmer` will use it instead of the logger, which defaults to `console.error`.\n`shimmer` is built to be as unobtrusive as possible and has no need to run\nasynchronously, so it defaults to logging when things fail, instead of\nthrowing.\n\n#### shimmer.wrap(nodule, name, wrapper)\n\n`shimmer` monkeypatches in place, so it expects to be passed an object.\nIt accepts either instances, prototypes, or the results of calling\n`require`. `name` must be the string key for the field's name on the\nobject.\n\n`wrapper` is a function that takes a single parameter, which is the original\nfunction to be monkeypatched. `shimmer` assumes that you're adding behavior\nto the original method, and not replacing it outright. If you *are* replacing\nthe original function, feel free to ignore the passed-in function.\n\nIf you *aren't* discarding the original, remember these tips:\n\n* call the original with something like `original.apply(this, arguments)`,\n  unless your reason for monkeypatching is to transform the arguments.\n* always capture and return the return value coming from the original function.\n  Today's null-returning callback is tomorrow's error-code returning callback.\n* Don't make an asynchronous function synchronous and vice versa.\n\n#### shimmer.massWrap(nodules, names, wrapper)\n\nJust like `wrap`, with the addition that you can wrap multiple methods on\nmultiple modules. Note that this function expects the list of functions to be\nmonkeypatched on all of the modules to be the same.\n\n#### shimmer.unwrap(nodule, name)\n\nA convenience function for restoring the function back the way it was before\nyou started. Won't unwrap if somebody else has monkeypatched the function after\nyou (but will log in that case). Won't throw if you try to double-unwrap a\nfunction (but will log).\n\n#### shimmer.wrapEmitter(emitter, mark, prepare)\n\nWrap an EventEmitter's event listeners. Each listener will be passed to\n`mark` when it is registered with `.addListener()` or `.on()`, and then\neach listener is passed to `prepare` to be wrapped before it's called\nby the `.emit()` call. `wrapListener` deals with the single listener\nvs array of listeners logic, and also ensures that edge cases like\n`.removeListener()` being called from within an `.emit()` for the same\nevent type is handled properly.\n\nThe wrapped EE can be restored to its pristine state by using\nemitter.__unwrap(), but this should only be used if you *really* know\nwhat you're doing.\n",
+  "readmeFilename": "README.md",
+  "bugs": {
+    "url": "https://github.com/othiym23/shimmer/issues"
+  },
+  "homepage": "https://github.com/othiym23/shimmer",
+  "_id": "shimmer@1.0.0",
+  "_shasum": "49c2d71c678360b802be18b278382d1cbb805c39",
+  "_from": "shimmer@1.0.0",
+  "_resolved": "https://registry.npmjs.org/shimmer/-/shimmer-1.0.0.tgz"
+}

data/src/nodejs_supportlib/vendor-copy/continuation-local-storage/node_modules/emitter-listener/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "emitter-listener",
+  "version": "1.0.1",
+  "description": "(Meta)observability for EventEmitters.",
+  "main": "listener.js",
+  "directories": {
+    "test": "test"
+  },
+  "scripts": {
+    "test": "tap test/*.tap.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/othiym23/emitter-listener.git"
+  },
+  "keywords": [
+    "wow",
+    "such",
+    "introspection",
+    "amaze",
+    "listener",
+    "so",
+    "observe"
+  ],
+  "author": {
+    "name": "Forrest L Norvell",
+    "email": "ogd@aoaioxxysz.net"
+  },
+  "license": "BSD-2-Clause",
+  "bugs": {
+    "url": "https://github.com/othiym23/emitter-listener/issues"
+  },
+  "homepage": "https://github.com/othiym23/emitter-listener",
+  "devDependencies": {
+    "tap": "~0.4.6"
+  },
+  "dependencies": {
+    "shimmer": "1.0.0"
+  },
+  "readme": "## Add dynamic instrumentation to emitters\n\n`shimmer` does a bunch of the work necessary to wrap other methods in\na wrapper you provide:\n\n```javascript\nvar EventEmitter = require('events').EventEmitter;\nvar wrapEmitter = require('emitter-listener');\n\nvar ee = new EventEmitter();\n\nvar id = 0;\n\nwrapEmitter(\n  ee,\n  function mark(listener) {\n    listener.id = id++;\n  },\n  function prepare(listener) {\n    console.log('listener id is %d', listener.id);\n  }\n);\n```\n\n### Mandatory disclaimer\n\nThere are times when it's necessary to monkeypatch default behavior in\nJavaScript and Node. However, changing the behavior of the runtime on the fly\nis rarely a good idea, and you should be using this module because you need to,\nnot because it seems like fun.\n\n#### wrapEmitter(emitter, mark, prepare)\n\nWrap an EventEmitter's event listeners. Each listener will be passed to\n`mark` when it is registered with `.addListener()` or `.on()`, and then\neach listener is passed to `prepare` to be wrapped before it's called\nby the `.emit()` call. `wrapListener` deals with the single listener\nvs array of listeners logic, and also ensures that edge cases like\n`.removeListener()` being called from within an `.emit()` for the same\nevent type is handled properly.\n\nThe wrapped EE can be restored to its pristine state by using\nemitter.__unwrap(), but this should only be used if you *really* know\nwhat you're doing.\n",
+  "readmeFilename": "README.md",
+  "_id": "emitter-listener@1.0.1",
+  "_shasum": "b2499ea6e58230a52c268d5df261eecd9f10fe97",
+  "_from": "emitter-listener@^1.0.1",
+  "_resolved": "https://registry.npmjs.org/emitter-listener/-/emitter-listener-1.0.1.tgz"
+}

data/src/nodejs_supportlib/vendor-copy/continuation-local-storage/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "continuation-local-storage",
+  "version": "3.1.4",
+  "description": "userland implementation of https://github.com/joyent/node/issues/5243",
+  "main": "context.js",
+  "directories": {
+    "test": "test"
+  },
+  "scripts": {
+    "test": "tap test/*.tap.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/othiym23/node-continuation-local-storage.git"
+  },
+  "keywords": [
+    "threading",
+    "shared",
+    "context",
+    "domains",
+    "tracing",
+    "logging"
+  ],
+  "author": {
+    "name": "Forrest L Norvell",
+    "email": "ogd@aoaioxxysz.net"
+  },
+  "contributors": [
+    {
+      "name": "Tim Caswell",
+      "email": "tim@creationix.com"
+    },
+    {
+      "name": "Forrest L Norvell",
+      "email": "ogd@aoaioxxysz.net"
+    }
+  ],
+  "license": "BSD",
+  "devDependencies": {
+    "tap": "^0.7.1"
+  },
+  "dependencies": {
+    "async-listener": "^0.5.0",
+    "emitter-listener": "^1.0.1"
+  },
+  "readme": "[![NPM](https://nodei.co/npm/continuation-local-storage.png?downloads=true&stars=true)](https://nodei.co/npm/continuation-local-storage/)\n\n# Continuation-Local Storage\n\nContinuation-local storage works like thread-local storage in threaded\nprogramming, but is based on chains of Node-style callbacks instead of threads.\nThe standard Node convention of functions calling functions is very similar to\nsomething called [\"continuation-passing style\"][cps] in functional programming,\nand the name comes from the way this module allows you to set and get values\nthat are scoped to the lifetime of these chains of function calls.\n\nSuppose you're writing a module that fetches a user and adds it to a session\nbefore calling a function passed in by a user to continue execution:\n\n```javascript\n// setup.js\n\nvar createNamespace = require('continuation-local-storage').createNamespace;\nvar session = createNamespace('my session');\n\nvar db = require('./lib/db.js');\n\nfunction start(options, next) {\n  db.fetchUserById(options.id, function (error, user) {\n    if (error) return next(error);\n\n    session.set('user', user);\n\n    next();\n  });\n}\n```\n\nLater on in the process of turning that user's data into an HTML page, you call\nanother function (maybe defined in another module entirely) that wants to fetch\nthe value you set earlier:\n\n```javascript\n// send_response.js\n\nvar getNamespace = require('continuation-local-storage').getNamespace;\nvar session = getNamespace('my session');\n\nvar render = require('./lib/render.js')\n\nfunction finish(response) {\n  var user = session.get('user');\n  render({user: user}).pipe(response);\n}\n```\n\nWhen you set values in continuation-local storage, those values are accessible\nuntil all functions called from the original function – synchronously or\nasynchronously – have finished executing. This includes callbacks passed to\n`process.nextTick` and the [timer functions][] ([setImmediate][],\n[setTimeout][], and [setInterval][]), as well as callbacks passed to\nasynchronous functions that call native functions (such as those exported from\nthe `fs`, `dns`, `zlib` and `crypto` modules).\n\nA simple rule of thumb is anywhere where you might have set a property on the\n`request` or `response` objects in an HTTP handler, you can (and should) now\nuse continuation-local storage. This API is designed to allow you extend the\nscope of a variable across a sequence of function calls, but with values\nspecific to each sequence of calls.\n\nValues are grouped into namespaces, created with `createNamespace()`. Sets of\nfunction calls are grouped together by calling them within the function passed\nto `.run()` on the namespace object. Calls to `.run()` can be nested, and each\nnested context this creates has its own copy of the set of values from the\nparent context. When a function is making multiple asynchronous calls, this\nallows each child call to get, set, and pass along its own context without\noverwriting the parent's.\n\nA simple, annotated example of how this nesting behaves:\n\n```javascript\nvar createNamespace = require('contination-local-storage').createNamespace;\n\nvar writer = createNamespace('writer');\nwriter.run(function () {\n  writer.set('value', 0);\n\n  requestHandler();\n});\n\nfunction requestHandler() {\n  writer.run(function(outer) {\n    // writer.get('value') returns 0\n    // outer.value is 0\n    writer.set('value', 1);\n    // writer.get('value') returns 1\n    // outer.value is 1\n    process.nextTick(function() {\n      // writer.get('value') returns 1\n      // outer.value is 1\n      writer.run(function(inner) {\n        // writer.get('value') returns 1\n        // outer.value is 1\n        // inner.value is 1\n        writer.set('value', 2);\n        // writer.get('value') returns 2\n        // outer.value is 1\n        // inner.value is 2\n      });\n    });\n  });\n\n  setTimeout(function() {\n    // runs with the default context, because nested contexts have ended\n    console.log(writer.get('value')); // prints 0\n  }, 1000);\n}\n```\n\n## cls.createNamespace(name)\n\n* return: {Namespace}\n\nEach application wanting to use continuation-local values should create its own\nnamespace. Reading from (or, more significantly, writing to) namespaces that\ndon't belong to you is a faux pas.\n\n## cls.getNamespace(name)\n\n* return: {Namespace}\n\nLook up an existing namespace.\n\n## cls.destroyNamespace(name)\n\nDispose of an existing namespace. WARNING: be sure to dispose of any references\nto destroyed namespaces in your old code, as contexts associated with them will\nno longer be propagated.\n\n## cls.reset()\n\nCompletely reset all continuation-local storage namespaces. WARNING: while this\nwill stop the propagation of values in any existing namespaces, if there are\nremaining references to those namespaces in code, the associated storage will\nstill be reachable, even though the associated state is no longer being updated.\nMake sure you clean up any references to destroyed namespaces yourself.\n\n## process.namespaces\n\n* return: dictionary of {Namespace} objects\n\nContinuation-local storage has a performance cost, and so it isn't enabled\nuntil the module is loaded for the first time. Once the module is loaded, the\ncurrent set of namespaces is available in `process.namespaces`, so library code\nthat wants to use continuation-local storage only when it's active should test\nfor the existence of `process.namespaces`.\n\n## Class: Namespace\n\nApplication-specific namespaces group values local to the set of functions\nwhose calls originate from a callback passed to `namespace.run()` or\n`namespace.bind()`.\n\n### namespace.active\n\n* return: the currently active context on a namespace\n\n### namespace.set(key, value)\n\n* return: `value`\n\nSet a value on the current continuation context. Must be set within an active\ncontinuation chain started with `namespace.run()` or `namespace.bind()`.\n\n### namespace.get(key)\n\n* return: the requested value, or `undefined`\n\nLook up a value on the current continuation context. Recursively searches from\nthe innermost to outermost nested continuation context for a value associated\nwith a given key. Must be set within an active continuation chain started with\n`namespace.run()` or `namespace.bind()`.\n\n### namespace.run(callback)\n\n* return: the context associated with that callback\n\nCreate a new context on which values can be set or read. Run all the functions\nthat are called (either directly, or indirectly through asynchronous functions\nthat take callbacks themselves) from the provided callback within the scope of\nthat namespace. The new context is passed as an argument to the callback\nwhen it's called.\n\n### namespace.bind(callback, [context])\n\n* return: a callback wrapped up in a context closure\n\nBind a function to the specified namespace. Works analogously to\n`Function.bind()` or `domain.bind()`. If context is omitted, it will default to\nthe currently active context in the namespace, or create a new context if none\nis currently defined.\n\n### namespace.bindEmitter(emitter)\n\nBind an EventEmitter to a namespace. Operates similarly to `domain.add`, with a\nless generic name and the additional caveat that unlike domains, namespaces\nnever implicitly bind EventEmitters to themselves when they're created within\nthe context of an active namespace.\n\nThe most likely time you'd want to use this is when you're using Express or\nConnect and want to make sure your middleware execution plays nice with CLS, or\nare doing other things with HTTP listeners:\n\n```javascript\nhttp.createServer(function (req, res) {\n  writer.add(req);\n  writer.add(res);\n\n  // do other stuff, some of which is asynchronous\n});\n```\n\n### namespace.createContext()\n\n* return: a context cloned from the currently active context\n\nUse this with `namespace.bind()`, if you want to have a fresh context at invocation time,\nas opposed to binding time:\n\n```javascript\nfunction doSomething(p) {\n  console.log(\"%s = %s\", p, ns.get(p));\n}\n\nfunction bindLater(callback) {\n  return writer.bind(callback, writer.createContext());\n}\n\nsetInterval(function () {\n  var bound = bindLater(doSomething);\n  bound('test');\n}, 100);\n```\n\n## context\n\nA context is a plain object created using the enclosing context as its prototype.\n\n[timer functions]: timers.html\n[setImmediate]:    timers.html#timers_setimmediate_callback_arg\n[setTimeout]:      timers.html#timers_settimeout_callback_delay_arg\n[setInterval]:     timers.html#timers_setinterval_callback_delay_arg\n[cps]:             http://en.wikipedia.org/wiki/Continuation-passing_style\n",
+  "readmeFilename": "README.md",
+  "bugs": {
+    "url": "https://github.com/othiym23/node-continuation-local-storage/issues"
+  },
+  "homepage": "https://github.com/othiym23/node-continuation-local-storage",
+  "_id": "continuation-local-storage@3.1.4",
+  "_shasum": "cd9d604853ef17b4527d006f7b906e3e7375a2e1",
+  "_from": "continuation-local-storage@^3.1.4",
+  "_resolved": "https://registry.npmjs.org/continuation-local-storage/-/continuation-local-storage-3.1.4.tgz"
+}