Salvaged what could be salvaged.

.babelrc

@@ -0,0 +1,10 @@
+{
+  "stage": 0,
+  "sourceMaps": true,
+  "optional": [
+    "runtime"
+  ],
+  "ignore": [
+    "node_modules/**/*"
+  ]
+}

.gitignore

@@ -0,0 +1,7 @@
+node_modules
+.tmp
+/boolean
+/function
+/iterable
+/number
+/value

.travis.yml

@@ -0,0 +1,5 @@
+language: node_js
+node_js:
+  - "0.10"
+after_success:
+ - npm run-script coveralls

package.json

@@ -0,0 +1,33 @@
+{
+  "name": "trine",
+  "version": "0.0.0",
+  "description": "The library modern JS doesn't deserve, but needs right now.",
+  "main": "index.js",
+  "scripts": {
+    "prepublish": "./scripts/build.bash",
+    "testsuite": "./scripts/testsuite.bash",
+    "test": "./scripts/test.bash",
+    "coveralls": "cat ./.tmp/coverage/lcov.info | COVERALLS_SERVICE_NAME=\"travis-ci\" coveralls"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/jussi-kalliokoski/trine.git"
+  },
+  "author": "Jussi Kalliokoski <jussi.kallikoski@gmail.com> (http://juss.in)",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/jussi-kalliokoski/trine/issues"
+  },
+  "homepage": "https://github.com/jussi-kalliokoski/trine#readme",
+  "devDependencies": {
+    "babel": "^5.5.6",
+    "babel-runtime": "^5.5.6",
+    "chai": "^3.0.0",
+    "coveralls": "^2.11.2",
+    "isparta": "^3.0.3",
+    "mocha": "^2.2.5",
+    "node-babel": "^0.1.2",
+    "sinon": "^1.14.1",
+    "sinon-chai": "^2.8.0"
+  }
+}

scripts/build.bash

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+
+set -e

scripts/test.bash

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+
+set -e
+npm run testsuite

scripts/testsuite.bash

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+
+set -e
+
+coverage_directory="./.tmp/coverage"
+test_directory="./test"
+
+babel-node node_modules/.bin/isparta cover \
+    --dir "$coverage_directory" \
+    node_modules/.bin/_mocha \
+    -- \
+    -R spec \
+    "$test_directory/_init.js" \
+    "$test_directory/spec/**/*Spec.js" \
+

src/boolean/and.js

@@ -0,0 +1,17 @@
+"use strict"
+
+/**
+ * Returns true if both operands are true.
+ *
+ * @example Basic Usage
+ *
+ * ```javascript
+ * true::and(true) // true
+ * true::and(false) // false
+ * false::and(true) // false
+ * false::and(false) // false
+ * ```
+*/
+export function and (
+) {
+};

src/boolean/equals.js

@@ -0,0 +1,15 @@
+"use strict"
+
+/**
+ * Returns the strict equality of the two operands.
+ *
+ * @example Basic Usage
+ *
+ * ```javascript
+ * "foo"::equals("bar") // false
+ * "bar"::equals("bar") // true
+ * ```
+*/
+export function equals (
+) {
+};

src/boolean/not.js

@@ -0,0 +1,15 @@
+"use strict"
+
+/**
+ * Returns the negation of the boolean.
+ *
+ * @example Basic Usage
+ *
+ * ```javascript
+ * true::not() // false
+ * false::not() // true
+ * ```
+*/
+export function not (
+) {
+};

src/boolean/or.js

@@ -0,0 +1,17 @@
+"use strict"
+
+/**
+ * Returns true if either of the operands is true.
+ *
+ * @example Basic Usage
+ *
+ * ```javascript
+ * true::or(true) // true
+ * true::or(false) // true
+ * false::or(true) // true
+ * false::or(false) // false
+ * ```
+*/
+export function or (
+) {
+};

src/boolean/xor.js

@@ -0,0 +1,17 @@
+"use strict"
+
+/**
+ * Returns true if one and only one of the conditions is true.
+ *
+ * @example Basic Usage
+ *
+ * ```javascript
+ * true::and(true) // false
+ * true::and(false) // true
+ * false::and(true) // true
+ * false::and(false) // false
+ * ```
+*/
+export function xor (
+) {
+};

src/function/partial.js

@@ -0,0 +1,47 @@
+"use strict"
+
+/**
+ * Returns a version of the function that has given parameters prefilled and passes given parameters through to the original, denoted by placeholders.
+ *
+ * @example Unary <code>parseInt</code>
+ *
+ * ```javascript
+ * parseInt
+ * ```
+ *
+ * @example Hexadecimal <code>parseInt</code>
+ *
+ * ```javascript
+ * parseInt
+ * ```
+ *
+ * @example Fill Only the Second Argument
+ *
+ * ```javascript
+ * function foo (a, b, c, d) {
+ *   console.log(a, b, c, d);
+ * }
+ *
+ * foo::partial(_, 2, ___)(1, 3, 4) // logs "1 2 3 4"
+ * ```
+ *
+ * @example Fill Only the Second Last Argument
+ *
+ * ```javascript
+ * function foo (a, b, c, d) {
+ *   console.log(a, b, c, d);
+ * }
+ *
+ * foo::partial(___, 3, _)(1, 2, 4) // logs "1 2 3 4"
+ * ```
+ *
+ * @example Compose a Prototype Method
+ *
+ * ```javascript
+ * const slice1 = Array.prototype.slice::partial(1, ___);
+ * [1, 2, 3, 4]::slice1() // [2, 3, 4]
+ * ```
+*/
+export function partial (
+) {
+};

src/iterable/aggregate.js

@@ -0,0 +1,18 @@
+"use strict"
+
+/**
+ * Yields all the accumulations of the iterator with a given accumulator method.
+ *
+ * @ntime O(n)
+ * @dspace O(1)
+ * @example Basic Usage
+ *
+ * ```javascript
+ * [1,2,3]::aggregate(function (b) {
+ *   return this + b;
+ * }, 0) // yields 0, 1, 3, 6
+ * ```
+*/
+export function aggregate (
+) {
+};

src/iterable/convolve.js

@@ -0,0 +1,19 @@
+"use strict"
+
+/**
+ * Maps the iterator with the additional tail of <code>k</code> previous items.
+ * <code>k</code> is determined by the number of items in the accumulation iterator.
+ *
+ * @ntime O(n)
+ * @dspace O(k)
+ * @example Basic Usage
+ *
+ * ```javascript
+ * [1,2,3].convolve(function (tail) {
+ *   return [...tail, this].reduce(add);
+ * }, [0, -1]) // yields 0, 3, 6
+ * ```
+*/
+export function convolve (
+) {
+};

src/iterable/count.js

@@ -0,0 +1,16 @@
+"use strict"
+
+/**
+ * Yields the number of items in the iterator.
+ *
+ * @ntime O(n)
+ * @dspace O(1)
+ * @example Basic Usage
+ *
+ * ```javascript
+ * [1,2,3]::count() // yields 3
+ * ```
+*/
+export function count (
+) {
+};

src/iterable/difference.js

@@ -0,0 +1,18 @@
+"use strict"
+
+/**
+ * Yields the sorted difference iterator of two sorted iterators.
+ *
+ * @ntime O(n+m)
+ * @dspace O(2)
+ * @example Basic Usage
+ *
+ * ```javascript
+ * [1,2,4]::difference([2,3,4,5], function (b) {
+ *   return this - b;
+ * }); // yields 1,3,5
+ * ```
+*/
+export function difference (
+) {
+};

src/iterable/drop.js

@@ -0,0 +1,18 @@
+"use strict"
+
+/**
+ * Yields the items that don't qualify the condition.
+ *
+ * @ntime O(n)
+ * @dspace O(1)
+ * @example Basic Usage
+ *
+ * ```javascript
+ * [1,2,3,4]::drop(function () {
+ *   return this % 2 === 0;
+ * }) // yields 1, 3
+ * ```
+*/
+export function drop (
+) {
+};

src/iterable/dropWhile.js

@@ -0,0 +1,18 @@
+"use strict"
+
+/**
+ * Yields the first item that matches condition, and all the items after that.
+ *
+ * @ntime O(n)
+ * @dspace O(1)
+ * @example Basic Usage
+ *
+ * ```javascript
+ * [1,2,3,4,1,2,3,4]::dropWhile(function () {
+ *   return this < 4;
+ * }) // yields 4, 1, 2, 3, 4
+ * ```
+*/
+export function dropWhile (
+) {
+};

src/iterable/find.js

@@ -0,0 +1,18 @@
+"use strict"
+
+/**
+ * Yields the first item that qualifies the condition.
+ *
+ * @ntime O(n)
+ * @dspace O(1)
+ * @example Basic Usage
+ *
+ * ```javascript
+ * [{id:2,x:1}, {id:3,x:2}, {id:4,x:4}, {id:3,x:5}]::find(function () {
+ *   return this.id === 3;
+ * }) // yields { id: 3, x: 2 }
+ * ```
+*/
+export function find (
+) {
+};

src/iterable/first.js

@@ -0,0 +1,19 @@
+"use strict"
+
+/**
+ * Yields the k-th item of the iterator.
+ *
+ * @ntime O(k)
+ * @dspace O(1)
+ * @example Basic Usage
+ *
+ * ```javascript
+ * [1,2,3]::first(0) // yields 1
+ * [1,2,3]::first(1) // yields 2
+ * [1,2,3]::first(2) // yields 3
+ * [1,2,3]::first(3) // yields nothing
+ * ```
+*/
+export function first (
+) {
+};

src/iterable/fork.js

@@ -0,0 +1,19 @@
+"use strict"
+
+/**
+ * Forks the iterator and yields the forks.
+ *
+ * @example Basic Usage
+ *
+ * ```javascript
+ * const source = [1,2,3]::map(function () { return this * 2});
+ * const forks = source::fork();
+ * const a = forks.next().value;
+ * const b = forks.next().value;
+ * [...a] // [1,2,3]
+ * [...b] // [1,2,3]
+ * ```
+*/
+export function fork (
+) {
+};