deku 0.1.0

data/deps/node_modules/deku/node_modules/fast.js/map.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var mapArray = require('./array/map'),
+    mapObject = require('./object/map');
+
+/**
+ * # Map
+ *
+ * A fast `.map()` implementation.
+ *
+ * @param  {Array|Object} subject     The array or object to map over.
+ * @param  {Function}     fn          The mapper function.
+ * @param  {Object}       thisContext The context for the mapper.
+ * @return {Array|Object}             The array or object containing the results.
+ */
+module.exports = function fastMap (subject, fn, thisContext) {
+  if (subject instanceof Array) {
+    return mapArray(subject, fn, thisContext);
+  }
+  else {
+    return mapObject(subject, fn, thisContext);
+  }
+};

data/deps/node_modules/deku/node_modules/fast.js/object/assign.js

@@ -0,0 +1,34 @@
+'use strict';
+
+/**
+ * Analogue of Object.assign().
+ * Copies properties from one or more source objects to
+ * a target object. Existing keys on the target object will be overwritten.
+ *
+ * > Note: This differs from spec in some important ways:
+ * > 1. Will throw if passed non-objects, including `undefined` or `null` values.
+ * > 2. Does not support the curious Exception handling behavior, exceptions are thrown immediately.
+ * > For more details, see:
+ * > https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
+ *
+ *
+ *
+ * @param  {Object} target      The target object to copy properties to.
+ * @param  {Object} source, ... The source(s) to copy properties from.
+ * @return {Object}             The updated target object.
+ */
+module.exports = function fastAssign (target) {
+  var totalArgs = arguments.length,
+      source, i, totalKeys, keys, key, j;
+
+  for (i = 1; i < totalArgs; i++) {
+    source = arguments[i];
+    keys = Object.keys(source);
+    totalKeys = keys.length;
+    for (j = 0; j < totalKeys; j++) {
+      key = keys[j];
+      target[key] = source[key];
+    }
+  }
+  return target;
+};

data/deps/node_modules/deku/node_modules/fast.js/object/clone.js

@@ -0,0 +1,25 @@
+'use strict';
+
+/**
+ * # Clone Object
+ *
+ * Shallow clone a simple object.
+ *
+ * > Note: Prototypes and non-enumerable properties will not be copied!
+ *
+ * @param  {Object} input The object to clone.
+ * @return {Object}       The cloned object.
+ */
+module.exports = function fastCloneObject (input) {
+  var keys = Object.keys(input),
+      total = keys.length,
+      cloned = {},
+      i, key;
+
+  for (i = 0; i < total; i++) {
+    key = keys[i];
+    cloned[key] = input[key];
+  }
+
+  return cloned;
+};

data/deps/node_modules/deku/node_modules/fast.js/object/filter.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var bindInternal3 = require('../function/bindInternal3');
+
+/**
+ * # Filter
+ *
+ * A fast object `.filter()` implementation.
+ *
+ * @param  {Object}   subject     The object to filter.
+ * @param  {Function} fn          The filter function.
+ * @param  {Object}   thisContext The context for the filter.
+ * @return {Object}               The new object containing the filtered results.
+ */
+module.exports = function fastFilterObject (subject, fn, thisContext) {
+  var keys = Object.keys(subject),
+      length = keys.length,
+      result = {},
+      iterator = thisContext !== undefined ? bindInternal3(fn, thisContext) : fn,
+      i, key;
+  for (i = 0; i < length; i++) {
+    key = keys[i];
+    if (iterator(subject[key], key, subject)) {
+      result[key] = subject[key];
+    }
+  }
+  return result;
+};

data/deps/node_modules/deku/node_modules/fast.js/object/forEach.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var bindInternal3 = require('../function/bindInternal3');
+
+/**
+ * # For Each
+ *
+ * A fast object `.forEach()` implementation.
+ *
+ * @param  {Object}   subject     The object to iterate over.
+ * @param  {Function} fn          The visitor function.
+ * @param  {Object}   thisContext The context for the visitor.
+ */
+module.exports = function fastForEachObject (subject, fn, thisContext) {
+  var keys = Object.keys(subject),
+      length = keys.length,
+      iterator = thisContext !== undefined ? bindInternal3(fn, thisContext) : fn,
+      key, i;
+  for (i = 0; i < length; i++) {
+    key = keys[i];
+    iterator(subject[key], key, subject);
+  }
+};

data/deps/node_modules/deku/node_modules/fast.js/object/index.js

@@ -0,0 +1,11 @@
+'use strict';
+
+exports.assign = require('./assign');
+exports.clone = require('./clone');
+exports.filter = require('./filter');
+exports.forEach = require('./forEach');
+exports.map = require('./map');
+exports.reduce = require('./reduce');
+exports.reduceRight = require('./reduceRight');
+exports.keys = require('./keys');
+exports.values = require('./values');

data/deps/node_modules/deku/node_modules/fast.js/object/keys.js

@@ -0,0 +1,17 @@
+'use strict';
+
+/**
+ * Object.keys() shim for ES3 environments.
+ *
+ * @param  {Object} obj The object to get keys for.
+ * @return {Array}      The array of keys.
+ */
+module.exports = typeof Object.keys === "function" ? Object.keys : /* istanbul ignore next */ function fastKeys (obj) {
+  var keys = [];
+  for (var key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      keys.push(key);
+    }
+  }
+  return keys;
+};

data/deps/node_modules/deku/node_modules/fast.js/object/map.js

@@ -0,0 +1,26 @@
+'use strict';
+
+var bindInternal3 = require('../function/bindInternal3');
+
+/**
+ * # Map
+ *
+ * A fast object `.map()` implementation.
+ *
+ * @param  {Object}   subject     The object to map over.
+ * @param  {Function} fn          The mapper function.
+ * @param  {Object}   thisContext The context for the mapper.
+ * @return {Object}               The new object containing the results.
+ */
+module.exports = function fastMapObject (subject, fn, thisContext) {
+  var keys = Object.keys(subject),
+      length = keys.length,
+      result = {},
+      iterator = thisContext !== undefined ? bindInternal3(fn, thisContext) : fn,
+      i, key;
+  for (i = 0; i < length; i++) {
+    key = keys[i];
+    result[key] = iterator(subject[key], key, subject);
+  }
+  return result;
+};

data/deps/node_modules/deku/node_modules/fast.js/object/reduce.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var bindInternal4 = require('../function/bindInternal4');
+
+/**
+ * # Reduce
+ *
+ * A fast object `.reduce()` implementation.
+ *
+ * @param  {Object}   subject      The object to reduce over.
+ * @param  {Function} fn           The reducer function.
+ * @param  {mixed}    initialValue The initial value for the reducer, defaults to subject[0].
+ * @param  {Object}   thisContext  The context for the reducer.
+ * @return {mixed}                 The final result.
+ */
+module.exports = function fastReduceObject (subject, fn, initialValue, thisContext) {
+  var keys = Object.keys(subject),
+      length = keys.length,
+      iterator = thisContext !== undefined ? bindInternal4(fn, thisContext) : fn,
+      i, key, result;
+
+  if (initialValue === undefined) {
+    i = 1;
+    result = subject[keys[0]];
+  }
+  else {
+    i = 0;
+    result = initialValue;
+  }
+
+  for (; i < length; i++) {
+    key = keys[i];
+    result = iterator(result, subject[key], key, subject);
+  }
+
+  return result;
+};

data/deps/node_modules/deku/node_modules/fast.js/object/reduceRight.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var bindInternal4 = require('../function/bindInternal4');
+
+/**
+ * # Reduce
+ *
+ * A fast object `.reduce()` implementation.
+ *
+ * @param  {Object}   subject      The object to reduce over.
+ * @param  {Function} fn           The reducer function.
+ * @param  {mixed}    initialValue The initial value for the reducer, defaults to subject[0].
+ * @param  {Object}   thisContext  The context for the reducer.
+ * @return {mixed}                 The final result.
+ */
+module.exports = function fastReduceRightObject (subject, fn, initialValue, thisContext) {
+  var keys = Object.keys(subject),
+      length = keys.length,
+      iterator = thisContext !== undefined ? bindInternal4(fn, thisContext) : fn,
+      i, key, result;
+
+  if (initialValue === undefined) {
+    i = length - 2;
+    result = subject[keys[length - 1]];
+  }
+  else {
+    i = length - 1;
+    result = initialValue;
+  }
+
+  for (; i >= 0; i--) {
+    key = keys[i];
+    result = iterator(result, subject[key], key, subject);
+  }
+
+  return result;
+};

data/deps/node_modules/deku/node_modules/fast.js/object/values.js

@@ -0,0 +1,20 @@
+'use strict';
+
+/**
+ * # Values
+ * Return all the (enumerable) property values for an object.
+ * Like Object.keys() but for values.
+ *
+ * @param  {Object} obj The object to retrieve values from.
+ * @return {Array}      An array containing property values.
+ */
+module.exports = function fastValues (obj) {
+  var keys = Object.keys(obj),
+      length = keys.length,
+      values = new Array(length);
+
+  for (var i = 0; i < length; i++) {
+    values[i] = obj[keys[i]];
+  }
+  return values;
+};

data/deps/node_modules/deku/node_modules/fast.js/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "fast.js",
+  "version": "0.1.1",
+  "description": "Faster user-land reimplementations of native functions with extra helpers.",
+  "main": "index.js",
+  "scripts": {
+    "jshint": "jshint ./",
+    "pretest": "npm run jshint",
+    "test": "mocha",
+    "bench": "node ./bench/index.js",
+    "coverage": "./node_modules/istanbul/lib/cli.js cover ./node_modules/mocha/bin/_mocha",
+    "install-sm": "wget http://ftp.mozilla.org/pub/mozilla.org/firefox/nightly/latest-trunk/jsshell-linux-x86_64.zip -O ./ci/environments/sm/sm.zip; unzip -o -d ./ci/environments/sm ./ci/environments/sm/sm.zip",
+    "bench-sm": "browserify ./bench/index.js | cat ./ci/sm-shim.js - > ./ci/environments/sm/bench.js; ./ci/environments/sm/js -f ./ci/environments/sm/bench.js",
+    "install-v8": "sh ./ci/environments/v8/install.sh",
+    "bench-v8": "browserify ./bench/index.js | cat ./ci/v8-shim.js - > ./ci/environments/v8/bench.js; ./ci/environments/v8/v8-git-mirror/out/native/shell ./ci/environments/v8/bench.js",
+    "dist": "npm run dist-browser; npm run dist-minify; npm run dist-bench",
+    "dist-browser": "browserify -o dist/fast.js -s fast ./index.js",
+    "dist-minify": "uglifyjs -o ./dist/fast.min.js ./dist/fast.js --mangle --compress warnings=false",
+    "dist-bench": "browserify -o ./dist/bench.js ./bench/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "http://github.com/codemix/fast.js"
+  },
+  "keywords": [
+    "fast",
+    "native"
+  ],
+  "author": {
+    "name": "Charles Pick",
+    "email": "charles@codemix.com"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/codemix/fast.js/issues"
+  },
+  "homepage": "https://github.com/codemix/fast.js",
+  "devDependencies": {
+    "expect.js": "~0.3.1",
+    "should": "~4.0.4",
+    "mocha": "~1.20.1",
+    "benchmark": "~1.0.0",
+    "microtime": "~0.6.0",
+    "istanbul": "~0.2.11",
+    "jshint": "~2.5.1",
+    "underscore": "git://github.com/jashkenas/underscore.git#master",
+    "lodash": "git://github.com/lodash/lodash.git#master",
+    "browserify": "~4.1.11",
+    "uglifyjs": "~2.3.6"
+  },
+  "gitHead": "46556d8e4dc9b8825b039f6d5532a90ccd2a4379",
+  "_id": "fast.js@0.1.1",
+  "_shasum": "7c024d55ae144882fbcee44b79005fe2dcabd9fe",
+  "_from": "fast.js@>=0.1.1 <0.2.0",
+  "_npmVersion": "1.4.28",
+  "_npmUser": {
+    "name": "codemix",
+    "email": "charles@codemix.com"
+  },
+  "maintainers": [
+    {
+      "name": "codemix",
+      "email": "charles@codemix.com"
+    }
+  ],
+  "dist": {
+    "shasum": "7c024d55ae144882fbcee44b79005fe2dcabd9fe",
+    "tarball": "http://registry.npmjs.org/fast.js/-/fast.js-0.1.1.tgz"
+  },
+  "directories": {},
+  "_resolved": "https://registry.npmjs.org/fast.js/-/fast.js-0.1.1.tgz",
+  "readme": "ERROR: No README data found!"
+}

data/deps/node_modules/deku/node_modules/fast.js/reduce.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var reduceArray = require('./array/reduce'),
+    reduceObject = require('./object/reduce');
+
+/**
+ * # Reduce
+ *
+ * A fast `.reduce()` implementation.
+ *
+ * @param  {Array|Object} subject      The array or object to reduce over.
+ * @param  {Function}     fn           The reducer function.
+ * @param  {mixed}        initialValue The initial value for the reducer, defaults to subject[0].
+ * @param  {Object}       thisContext  The context for the reducer.
+ * @return {Array|Object}              The array or object containing the results.
+ */
+module.exports = function fastReduce (subject, fn, initialValue, thisContext) {
+  if (subject instanceof Array) {
+    return reduceArray(subject, fn, initialValue, thisContext);
+  }
+  else {
+    return reduceObject(subject, fn, initialValue, thisContext);
+  }
+};

data/deps/node_modules/deku/node_modules/fast.js/reduceRight.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var reduceRightArray = require('./array/reduceRight'),
+    reduceRightObject = require('./object/reduceRight');
+
+/**
+ * # Reduce Right
+ *
+ * A fast `.reduceRight()` implementation.
+ *
+ * @param  {Array|Object} subject      The array or object to reduce over.
+ * @param  {Function}     fn           The reducer function.
+ * @param  {mixed}        initialValue The initial value for the reducer, defaults to subject[0].
+ * @param  {Object}       thisContext  The context for the reducer.
+ * @return {Array|Object}              The array or object containing the results.
+ */
+module.exports = function fastReduceRight (subject, fn, initialValue, thisContext) {
+  if (subject instanceof Array) {
+    return reduceRightArray(subject, fn, initialValue, thisContext);
+  }
+  else {
+    return reduceRightObject(subject, fn, initialValue, thisContext);
+  }
+};

data/deps/node_modules/deku/node_modules/fast.js/string/index.js

@@ -0,0 +1,3 @@
+'use strict';
+
+exports.intern = require('./intern');

data/deps/node_modules/deku/node_modules/fast.js/string/intern.js

@@ -0,0 +1,56 @@
+'use strict';
+
+// Compilers such as V8 use string interning to make string comparison very fast and efficient,
+// as efficient as comparing two references to the same object.
+//
+//
+// V8 does its best to intern strings automatically where it can, for instance:
+// ```js
+//   var greeting = "hello world";
+// ```
+// With this, comparison will be very fast:
+// ```js
+//   if (greeting === "hello world") {}
+// ```
+// However, there are several cases where V8 cannot intern the string, and instead
+// must resort to byte-wise comparison. This can be signficantly slower for long strings.
+// The most common example is string concatenation:
+// ```js
+//   function subject () { return "world"; };
+//   var greeting = "hello " + subject();
+// ```
+// In this case, V8 cannot intern the string. So this comparison is *much* slower:
+// ```js
+//  if (greeting === "hello world") {}
+// ```
+
+
+
+// At the moment, the fastest, safe way of interning a string is to
+// use it as a key in an object, and then use that key.
+//
+// Note: This technique comes courtesy of Petka Antonov - http://jsperf.com/istrn/11
+//
+// We create a container object in hash mode.
+// Most strings being interned will not be valid fast property names,
+// so we ensure hash mode now to avoid transitioning the object mode at runtime.
+var container = {'- ': true};
+delete container['- '];
+
+
+/**
+ * Intern a string to make comparisons faster.
+ *
+ * > Note: This is a relatively expensive operation, you
+ * shouldn't usually do the actual interning at runtime, instead
+ * use this at compile time to make future work faster.
+ *
+ * @param  {String} string The string to intern.
+ * @return {String}        The interned string.
+ */
+module.exports = function fastIntern (string) {
+  container[string] = true;
+  var interned = Object.keys(container)[0];
+  delete container[interned];
+  return interned;
+};