add lisp packages

lisp/emacs-application-framework/app/mermaid/node_modules/d3-array/src/array.js

@@ -0,0 +1,4 @@
+var array = Array.prototype;
+
+export var slice = array.slice;
+export var map = array.map;

lisp/emacs-application-framework/app/mermaid/node_modules/d3-array/src/ascending.js

@@ -0,0 +1,3 @@
+export default function(a, b) {
+  return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-array/src/bisect.js

@@ -0,0 +1,7 @@
+import ascending from "./ascending";
+import bisector from "./bisector";
+
+var ascendingBisect = bisector(ascending);
+export var bisectRight = ascendingBisect.right;
+export var bisectLeft = ascendingBisect.left;
+export default bisectRight;

lisp/emacs-application-framework/app/mermaid/node_modules/d3-array/src/bisector.js

@@ -0,0 +1,33 @@
+import ascending from "./ascending";
+
+export default function(compare) {
+  if (compare.length === 1) compare = ascendingComparator(compare);
+  return {
+    left: function(a, x, lo, hi) {
+      if (lo == null) lo = 0;
+      if (hi == null) hi = a.length;
+      while (lo < hi) {
+        var mid = lo + hi >>> 1;
+        if (compare(a[mid], x) < 0) lo = mid + 1;
+        else hi = mid;
+      }
+      return lo;
+    },
+    right: function(a, x, lo, hi) {
+      if (lo == null) lo = 0;
+      if (hi == null) hi = a.length;
+      while (lo < hi) {
+        var mid = lo + hi >>> 1;
+        if (compare(a[mid], x) > 0) hi = mid;
+        else lo = mid + 1;
+      }
+      return lo;
+    }
+  };
+}
+
+function ascendingComparator(f) {
+  return function(d, x) {
+    return ascending(f(d), x);
+  };
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-array/src/constant.js

@@ -0,0 +1,5 @@
+export default function(x) {
+  return function() {
+    return x;
+  };
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-array/src/cross.js

@@ -0,0 +1,21 @@
+import {pair} from "./pairs";
+
+export default function(values0, values1, reduce) {
+  var n0 = values0.length,
+      n1 = values1.length,
+      values = new Array(n0 * n1),
+      i0,
+      i1,
+      i,
+      value0;
+
+  if (reduce == null) reduce = pair;
+
+  for (i0 = i = 0; i0 < n0; ++i0) {
+    for (value0 = values0[i0], i1 = 0; i1 < n1; ++i1, ++i) {
+      values[i] = reduce(value0, values1[i1]);
+    }
+  }
+
+  return values;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-array/src/descending.js

@@ -0,0 +1,3 @@
+export default function(a, b) {
+  return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-array/src/deviation.js

@@ -0,0 +1,6 @@
+import variance from "./variance";
+
+export default function(array, f) {
+  var v = variance(array, f);
+  return v ? Math.sqrt(v) : v;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-array/src/extent.js

@@ -0,0 +1,37 @@
+export default function(values, valueof) {
+  var n = values.length,
+      i = -1,
+      value,
+      min,
+      max;
+
+  if (valueof == null) {
+    while (++i < n) { // Find the first comparable value.
+      if ((value = values[i]) != null && value >= value) {
+        min = max = value;
+        while (++i < n) { // Compare the remaining values.
+          if ((value = values[i]) != null) {
+            if (min > value) min = value;
+            if (max < value) max = value;
+          }
+        }
+      }
+    }
+  }
+
+  else {
+    while (++i < n) { // Find the first comparable value.
+      if ((value = valueof(values[i], i, values)) != null && value >= value) {
+        min = max = value;
+        while (++i < n) { // Compare the remaining values.
+          if ((value = valueof(values[i], i, values)) != null) {
+            if (min > value) min = value;
+            if (max < value) max = value;
+          }
+        }
+      }
+    }
+  }
+
+  return [min, max];
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-array/src/histogram.js

@@ -0,0 +1,75 @@
+import {slice} from "./array";
+import bisect from "./bisect";
+import constant from "./constant";
+import extent from "./extent";
+import identity from "./identity";
+import range from "./range";
+import {tickStep} from "./ticks";
+import sturges from "./threshold/sturges";
+
+export default function() {
+  var value = identity,
+      domain = extent,
+      threshold = sturges;
+
+  function histogram(data) {
+    var i,
+        n = data.length,
+        x,
+        values = new Array(n);
+
+    for (i = 0; i < n; ++i) {
+      values[i] = value(data[i], i, data);
+    }
+
+    var xz = domain(values),
+        x0 = xz[0],
+        x1 = xz[1],
+        tz = threshold(values, x0, x1);
+
+    // Convert number of thresholds into uniform thresholds.
+    if (!Array.isArray(tz)) {
+      tz = tickStep(x0, x1, tz);
+      tz = range(Math.ceil(x0 / tz) * tz, x1, tz); // exclusive
+    }
+
+    // Remove any thresholds outside the domain.
+    var m = tz.length;
+    while (tz[0] <= x0) tz.shift(), --m;
+    while (tz[m - 1] > x1) tz.pop(), --m;
+
+    var bins = new Array(m + 1),
+        bin;
+
+    // Initialize bins.
+    for (i = 0; i <= m; ++i) {
+      bin = bins[i] = [];
+      bin.x0 = i > 0 ? tz[i - 1] : x0;
+      bin.x1 = i < m ? tz[i] : x1;
+    }
+
+    // Assign data to bins by value, ignoring any outside the domain.
+    for (i = 0; i < n; ++i) {
+      x = values[i];
+      if (x0 <= x && x <= x1) {
+        bins[bisect(tz, x, 0, m)].push(data[i]);
+      }
+    }
+
+    return bins;
+  }
+
+  histogram.value = function(_) {
+    return arguments.length ? (value = typeof _ === "function" ? _ : constant(_), histogram) : value;
+  };
+
+  histogram.domain = function(_) {
+    return arguments.length ? (domain = typeof _ === "function" ? _ : constant([_[0], _[1]]), histogram) : domain;
+  };
+
+  histogram.thresholds = function(_) {
+    return arguments.length ? (threshold = typeof _ === "function" ? _ : Array.isArray(_) ? constant(slice.call(_)) : constant(_), histogram) : threshold;
+  };
+
+  return histogram;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-array/src/identity.js

@@ -0,0 +1,3 @@
+export default function(x) {
+  return x;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-array/src/index.js

@@ -0,0 +1,27 @@
+export {default as bisect, bisectRight, bisectLeft} from "./bisect";
+export {default as ascending} from "./ascending";
+export {default as bisector} from "./bisector";
+export {default as cross} from "./cross";
+export {default as descending} from "./descending";
+export {default as deviation} from "./deviation";
+export {default as extent} from "./extent";
+export {default as histogram} from "./histogram";
+export {default as thresholdFreedmanDiaconis} from "./threshold/freedmanDiaconis";
+export {default as thresholdScott} from "./threshold/scott";
+export {default as thresholdSturges} from "./threshold/sturges";
+export {default as max} from "./max";
+export {default as mean} from "./mean";
+export {default as median} from "./median";
+export {default as merge} from "./merge";
+export {default as min} from "./min";
+export {default as pairs} from "./pairs";
+export {default as permute} from "./permute";
+export {default as quantile} from "./quantile";
+export {default as range} from "./range";
+export {default as scan} from "./scan";
+export {default as shuffle} from "./shuffle";
+export {default as sum} from "./sum";
+export {default as ticks, tickIncrement, tickStep} from "./ticks";
+export {default as transpose} from "./transpose";
+export {default as variance} from "./variance";
+export {default as zip} from "./zip";

lisp/emacs-application-framework/app/mermaid/node_modules/d3-array/src/max.js

@@ -0,0 +1,34 @@
+export default function(values, valueof) {
+  var n = values.length,
+      i = -1,
+      value,
+      max;
+
+  if (valueof == null) {
+    while (++i < n) { // Find the first comparable value.
+      if ((value = values[i]) != null && value >= value) {
+        max = value;
+        while (++i < n) { // Compare the remaining values.
+          if ((value = values[i]) != null && value > max) {
+            max = value;
+          }
+        }
+      }
+    }
+  }
+
+  else {
+    while (++i < n) { // Find the first comparable value.
+      if ((value = valueof(values[i], i, values)) != null && value >= value) {
+        max = value;
+        while (++i < n) { // Compare the remaining values.
+          if ((value = valueof(values[i], i, values)) != null && value > max) {
+            max = value;
+          }
+        }
+      }
+    }
+  }
+
+  return max;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-array/src/mean.js

@@ -0,0 +1,25 @@
+import number from "./number";
+
+export default function(values, valueof) {
+  var n = values.length,
+      m = n,
+      i = -1,
+      value,
+      sum = 0;
+
+  if (valueof == null) {
+    while (++i < n) {
+      if (!isNaN(value = number(values[i]))) sum += value;
+      else --m;
+    }
+  }
+
+  else {
+    while (++i < n) {
+      if (!isNaN(value = number(valueof(values[i], i, values)))) sum += value;
+      else --m;
+    }
+  }
+
+  if (m) return sum / m;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-array/src/median.js

@@ -0,0 +1,28 @@
+import ascending from "./ascending";
+import number from "./number";
+import quantile from "./quantile";
+
+export default function(values, valueof) {
+  var n = values.length,
+      i = -1,
+      value,
+      numbers = [];
+
+  if (valueof == null) {
+    while (++i < n) {
+      if (!isNaN(value = number(values[i]))) {
+        numbers.push(value);
+      }
+    }
+  }
+
+  else {
+    while (++i < n) {
+      if (!isNaN(value = number(valueof(values[i], i, values)))) {
+        numbers.push(value);
+      }
+    }
+  }
+
+  return quantile(numbers.sort(ascending), 0.5);
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-array/src/merge.js

@@ -0,0 +1,21 @@
+export default function(arrays) {
+  var n = arrays.length,
+      m,
+      i = -1,
+      j = 0,
+      merged,
+      array;
+
+  while (++i < n) j += arrays[i].length;
+  merged = new Array(j);
+
+  while (--n >= 0) {
+    array = arrays[n];
+    m = array.length;
+    while (--m >= 0) {
+      merged[--j] = array[m];
+    }
+  }
+
+  return merged;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-array/src/min.js

@@ -0,0 +1,34 @@
+export default function(values, valueof) {
+  var n = values.length,
+      i = -1,
+      value,
+      min;
+
+  if (valueof == null) {
+    while (++i < n) { // Find the first comparable value.
+      if ((value = values[i]) != null && value >= value) {
+        min = value;
+        while (++i < n) { // Compare the remaining values.
+          if ((value = values[i]) != null && min > value) {
+            min = value;
+          }
+        }
+      }
+    }
+  }
+
+  else {
+    while (++i < n) { // Find the first comparable value.
+      if ((value = valueof(values[i], i, values)) != null && value >= value) {
+        min = value;
+        while (++i < n) { // Compare the remaining values.
+          if ((value = valueof(values[i], i, values)) != null && min > value) {
+            min = value;
+          }
+        }
+      }
+    }
+  }
+
+  return min;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-array/src/number.js

@@ -0,0 +1,3 @@
+export default function(x) {
+  return x === null ? NaN : +x;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-array/src/pairs.js

@@ -0,0 +1,10 @@
+export default function(array, f) {
+  if (f == null) f = pair;
+  var i = 0, n = array.length - 1, p = array[0], pairs = new Array(n < 0 ? 0 : n);
+  while (i < n) pairs[i] = f(p, p = array[++i]);
+  return pairs;
+}
+
+export function pair(a, b) {
+  return [a, b];
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-array/src/permute.js

@@ -0,0 +1,5 @@
+export default function(array, indexes) {
+  var i = indexes.length, permutes = new Array(i);
+  while (i--) permutes[i] = array[indexes[i]];
+  return permutes;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-array/src/quantile.js

@@ -0,0 +1,14 @@
+import number from "./number";
+
+export default function(values, p, valueof) {
+  if (valueof == null) valueof = number;
+  if (!(n = values.length)) return;
+  if ((p = +p) <= 0 || n < 2) return +valueof(values[0], 0, values);
+  if (p >= 1) return +valueof(values[n - 1], n - 1, values);
+  var n,
+      i = (n - 1) * p,
+      i0 = Math.floor(i),
+      value0 = +valueof(values[i0], i0, values),
+      value1 = +valueof(values[i0 + 1], i0 + 1, values);
+  return value0 + (value1 - value0) * (i - i0);
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-array/src/range.js

@@ -0,0 +1,13 @@
+export default function(start, stop, step) {
+  start = +start, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step;
+
+  var i = -1,
+      n = Math.max(0, Math.ceil((stop - start) / step)) | 0,
+      range = new Array(n);
+
+  while (++i < n) {
+    range[i] = start + i * step;
+  }
+
+  return range;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-array/src/scan.js

@@ -0,0 +1,20 @@
+import ascending from "./ascending";
+
+export default function(values, compare) {
+  if (!(n = values.length)) return;
+  var n,
+      i = 0,
+      j = 0,
+      xi,
+      xj = values[j];
+
+  if (compare == null) compare = ascending;
+
+  while (++i < n) {
+    if (compare(xi = values[i], xj) < 0 || compare(xj, xj) !== 0) {
+      xj = xi, j = i;
+    }
+  }
+
+  if (compare(xj, xj) === 0) return j;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-array/src/shuffle.js

@@ -0,0 +1,14 @@
+export default function(array, i0, i1) {
+  var m = (i1 == null ? array.length : i1) - (i0 = i0 == null ? 0 : +i0),
+      t,
+      i;
+
+  while (m) {
+    i = Math.random() * m-- | 0;
+    t = array[m + i0];
+    array[m + i0] = array[i + i0];
+    array[i + i0] = t;
+  }
+
+  return array;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-array/src/sum.js

@@ -0,0 +1,20 @@
+export default function(values, valueof) {
+  var n = values.length,
+      i = -1,
+      value,
+      sum = 0;
+
+  if (valueof == null) {
+    while (++i < n) {
+      if (value = +values[i]) sum += value; // Note: zero and null are equivalent.
+    }
+  }
+
+  else {
+    while (++i < n) {
+      if (value = +valueof(values[i], i, values)) sum += value;
+    }
+  }
+
+  return sum;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-array/src/threshold/freedmanDiaconis.js

@@ -0,0 +1,9 @@
+import {map} from "../array";
+import ascending from "../ascending";
+import number from "../number";
+import quantile from "../quantile";
+
+export default function(values, min, max) {
+  values = map.call(values, number).sort(ascending);
+  return Math.ceil((max - min) / (2 * (quantile(values, 0.75) - quantile(values, 0.25)) * Math.pow(values.length, -1 / 3)));
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-array/src/threshold/scott.js

@@ -0,0 +1,5 @@
+import deviation from "../deviation";
+
+export default function(values, min, max) {
+  return Math.ceil((max - min) / (3.5 * deviation(values) * Math.pow(values.length, -1 / 3)));
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-array/src/threshold/sturges.js

@@ -0,0 +1,3 @@
+export default function(values) {
+  return Math.ceil(Math.log(values.length) / Math.LN2) + 1;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-array/src/ticks.js

@@ -0,0 +1,51 @@
+var e10 = Math.sqrt(50),
+    e5 = Math.sqrt(10),
+    e2 = Math.sqrt(2);
+
+export default function(start, stop, count) {
+  var reverse,
+      i = -1,
+      n,
+      ticks,
+      step;
+
+  stop = +stop, start = +start, count = +count;
+  if (start === stop && count > 0) return [start];
+  if (reverse = stop < start) n = start, start = stop, stop = n;
+  if ((step = tickIncrement(start, stop, count)) === 0 || !isFinite(step)) return [];
+
+  if (step > 0) {
+    start = Math.ceil(start / step);
+    stop = Math.floor(stop / step);
+    ticks = new Array(n = Math.ceil(stop - start + 1));
+    while (++i < n) ticks[i] = (start + i) * step;
+  } else {
+    start = Math.floor(start * step);
+    stop = Math.ceil(stop * step);
+    ticks = new Array(n = Math.ceil(start - stop + 1));
+    while (++i < n) ticks[i] = (start - i) / step;
+  }
+
+  if (reverse) ticks.reverse();
+
+  return ticks;
+}
+
+export function tickIncrement(start, stop, count) {
+  var step = (stop - start) / Math.max(0, count),
+      power = Math.floor(Math.log(step) / Math.LN10),
+      error = step / Math.pow(10, power);
+  return power >= 0
+      ? (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1) * Math.pow(10, power)
+      : -Math.pow(10, -power) / (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1);
+}
+
+export function tickStep(start, stop, count) {
+  var step0 = Math.abs(stop - start) / Math.max(0, count),
+      step1 = Math.pow(10, Math.floor(Math.log(step0) / Math.LN10)),
+      error = step0 / step1;
+  if (error >= e10) step1 *= 10;
+  else if (error >= e5) step1 *= 5;
+  else if (error >= e2) step1 *= 2;
+  return stop < start ? -step1 : step1;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-array/src/transpose.js

@@ -0,0 +1,15 @@
+import min from "./min";
+
+export default function(matrix) {
+  if (!(n = matrix.length)) return [];
+  for (var i = -1, m = min(matrix, length), transpose = new Array(m); ++i < m;) {
+    for (var j = -1, n, row = transpose[i] = new Array(n); ++j < n;) {
+      row[j] = matrix[j][i];
+    }
+  }
+  return transpose;
+}
+
+function length(d) {
+  return d.length;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-array/src/variance.js

@@ -0,0 +1,33 @@
+import number from "./number";
+
+export default function(values, valueof) {
+  var n = values.length,
+      m = 0,
+      i = -1,
+      mean = 0,
+      value,
+      delta,
+      sum = 0;
+
+  if (valueof == null) {
+    while (++i < n) {
+      if (!isNaN(value = number(values[i]))) {
+        delta = value - mean;
+        mean += delta / ++m;
+        sum += delta * (value - mean);
+      }
+    }
+  }
+
+  else {
+    while (++i < n) {
+      if (!isNaN(value = number(valueof(values[i], i, values)))) {
+        delta = value - mean;
+        mean += delta / ++m;
+        sum += delta * (value - mean);
+      }
+    }
+  }
+
+  if (m > 1) return sum / (m - 1);
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-array/src/zip.js

@@ -0,0 +1,5 @@
+import transpose from "./transpose";
+
+export default function() {
+  return transpose(arguments);
+}