mdarray-sol 0.1.0-java

data/node_modules/dc/node_modules/d3/src/color/xyz.js

@@ -0,0 +1,7 @@
+function d3_xyz_lab(x) {
+  return x > 0.008856 ? Math.pow(x, 1 / 3) : 7.787037 * x + 4 / 29;
+}
+
+function d3_xyz_rgb(r) {
+  return Math.round(255 * (r <= 0.00304 ? 12.92 * r : 1.055 * Math.pow(r, 1 / 2.4) - 0.055));
+}

data/node_modules/dc/node_modules/d3/src/compat/array.js

@@ -0,0 +1,15 @@
+import "../core/array";
+import "../core/document";
+
+// Redefine d3_array if the browser doesn’t support slice-based conversion.
+if (d3_document) {
+  try {
+    d3_array(d3_document.documentElement.childNodes)[0].nodeType;
+  } catch (e) {
+    d3_array = function(list) {
+      var i = list.length, array = new Array(i);
+      while (i--) array[i] = list[i];
+      return array;
+    };
+  }
+}

data/node_modules/dc/node_modules/d3/src/compat/date.js

@@ -0,0 +1,3 @@
+if (!Date.now) Date.now = function() {
+  return +new Date;
+};

data/node_modules/dc/node_modules/d3/src/compat/index.js

@@ -0,0 +1,3 @@
+import "array";
+import "date";
+import "style";

data/node_modules/dc/node_modules/d3/src/compat/style.js

@@ -0,0 +1,23 @@
+import "../core/document";
+
+// Redefine style.setProperty et al. if the browser doesn’t coerce arguments.
+if (d3_document) {
+  try {
+    d3_document.createElement("DIV").style.setProperty("opacity", 0, "");
+  } catch (error) {
+    var d3_element_prototype = this.Element.prototype,
+        d3_element_setAttribute = d3_element_prototype.setAttribute,
+        d3_element_setAttributeNS = d3_element_prototype.setAttributeNS,
+        d3_style_prototype = this.CSSStyleDeclaration.prototype,
+        d3_style_setProperty = d3_style_prototype.setProperty;
+    d3_element_prototype.setAttribute = function(name, value) {
+      d3_element_setAttribute.call(this, name, value + "");
+    };
+    d3_element_prototype.setAttributeNS = function(space, local, value) {
+      d3_element_setAttributeNS.call(this, space, local, value + "");
+    };
+    d3_style_prototype.setProperty = function(name, value, priority) {
+      d3_style_setProperty.call(this, name, value + "", priority);
+    };
+  }
+}

data/node_modules/dc/node_modules/d3/src/core/array.js

@@ -0,0 +1,2 @@
+var d3_arraySlice = [].slice,
+    d3_array = function(list) { return d3_arraySlice.call(list); }; // conversion for NodeLists

data/node_modules/dc/node_modules/d3/src/core/class.js

@@ -0,0 +1,8 @@
+function d3_class(ctor, properties) {
+  for (var key in properties) {
+    Object.defineProperty(ctor.prototype, key, {
+      value: properties[key],
+      enumerable: false
+    });
+  }
+}

data/node_modules/dc/node_modules/d3/src/core/document.js

@@ -0,0 +1,15 @@
+var d3_document = this.document;
+
+function d3_documentElement(node) {
+  return node
+      && (node.ownerDocument // node is a Node
+      || node.document // node is a Window
+      || node).documentElement; // node is a Document
+}
+
+function d3_window(node) {
+  return node
+      && ((node.ownerDocument && node.ownerDocument.defaultView) // node is a Node
+        || (node.document && node) // node is a Window
+        || node.defaultView); // node is a Document
+}

data/node_modules/dc/node_modules/d3/src/core/functor.js

@@ -0,0 +1,5 @@
+function d3_functor(v) {
+  return typeof v === "function" ? v : function() { return v; };
+}
+
+d3.functor = d3_functor;

data/node_modules/dc/node_modules/d3/src/core/identity.js

@@ -0,0 +1,3 @@
+function d3_identity(d) {
+  return d;
+}

data/node_modules/dc/node_modules/d3/src/core/index.js

@@ -0,0 +1,3 @@
+import "functor";
+import "ns";
+import "rebind";

data/node_modules/dc/node_modules/d3/src/core/noop.js

@@ -0,0 +1 @@
+function d3_noop() {}

data/node_modules/dc/node_modules/d3/src/core/ns.js

@@ -0,0 +1,18 @@
+var d3_nsXhtml = "http://www.w3.org/1999/xhtml";
+
+var d3_nsPrefix = {
+  svg: "http://www.w3.org/2000/svg",
+  xhtml: d3_nsXhtml,
+  xlink: "http://www.w3.org/1999/xlink",
+  xml: "http://www.w3.org/XML/1998/namespace",
+  xmlns: "http://www.w3.org/2000/xmlns/"
+};
+
+d3.ns = {
+  prefix: d3_nsPrefix,
+  qualify: function(name) {
+    var i = name.indexOf(":"), prefix = name;
+    if (i >= 0 && (prefix = name.slice(0, i)) !== "xmlns") name = name.slice(i + 1);
+    return d3_nsPrefix.hasOwnProperty(prefix) ? {space: d3_nsPrefix[prefix], local: name} : name;
+  }
+};

data/node_modules/dc/node_modules/d3/src/core/rebind.js

@@ -0,0 +1,16 @@
+// Copies a variable number of methods from source to target.
+d3.rebind = function(target, source) {
+  var i = 1, n = arguments.length, method;
+  while (++i < n) target[method = arguments[i]] = d3_rebind(target, source, source[method]);
+  return target;
+};
+
+// Method is assumed to be a standard D3 getter-setter:
+// If passed with no arguments, gets the value.
+// If passed with arguments, sets the value and returns the target.
+function d3_rebind(target, source, method) {
+  return function() {
+    var value = method.apply(source, arguments);
+    return value === source ? target : value;
+  };
+}

data/node_modules/dc/node_modules/d3/src/core/source.js

@@ -0,0 +1,3 @@
+function d3_source(d) {
+  return d.source;
+}

data/node_modules/dc/node_modules/d3/src/core/subclass.js

@@ -0,0 +1,11 @@
+var d3_subclass = {}.__proto__?
+
+// Until ECMAScript supports array subclassing, prototype injection works well.
+function(object, prototype) {
+  object.__proto__ = prototype;
+}:
+
+// And if your browser doesn't support __proto__, we'll use direct extension.
+function(object, prototype) {
+  for (var property in prototype) object[property] = prototype[property];
+};

data/node_modules/dc/node_modules/d3/src/core/target.js

@@ -0,0 +1,3 @@
+function d3_target(d) {
+  return d.target;
+}

data/node_modules/dc/node_modules/d3/src/core/true.js

@@ -0,0 +1,3 @@
+function d3_true() {
+  return true;
+}

data/node_modules/dc/node_modules/d3/src/core/vendor.js

@@ -0,0 +1,10 @@
+function d3_vendorSymbol(object, name) {
+  if (name in object) return name;
+  name = name.charAt(0).toUpperCase() + name.slice(1);
+  for (var i = 0, n = d3_vendorPrefixes.length; i < n; ++i) {
+    var prefixName = d3_vendorPrefixes[i] + name;
+    if (prefixName in object) return prefixName;
+  }
+}
+
+var d3_vendorPrefixes = ["webkit", "ms", "moz", "Moz", "o", "O"];

data/node_modules/dc/node_modules/d3/src/core/zero.js

@@ -0,0 +1,3 @@
+function d3_zero() {
+  return 0;
+}

data/node_modules/dc/node_modules/d3/src/d3.js

@@ -0,0 +1,23 @@
+import "start";
+import "compat/";
+
+import "arrays/";
+import "behavior/";
+import "color/";
+import "core/";
+import "dsv/";
+import "event/";
+import "format/";
+import "geo/";
+import "geom/";
+import "interpolate/";
+import "layout/";
+import "math/";
+import "scale/";
+import "selection/";
+import "svg/";
+import "time/";
+import "transition/";
+import "xhr/";
+
+import "end";

data/node_modules/dc/node_modules/d3/src/dsv/csv.js

@@ -0,0 +1,3 @@
+import "dsv";
+
+d3.csv = d3.dsv(",", "text/csv");

data/node_modules/dc/node_modules/d3/src/dsv/dsv.js

@@ -0,0 +1,136 @@
+import "../arrays/set";
+import "../xhr/xhr";
+
+d3.dsv = function(delimiter, mimeType) {
+  var reFormat = new RegExp("[\"" + delimiter + "\n]"),
+      delimiterCode = delimiter.charCodeAt(0);
+
+  function dsv(url, row, callback) {
+    if (arguments.length < 3) callback = row, row = null;
+    var xhr = d3_xhr(url, mimeType, row == null ? response : typedResponse(row), callback);
+
+    xhr.row = function(_) {
+      return arguments.length
+          ? xhr.response((row = _) == null ? response : typedResponse(_))
+          : row;
+    };
+
+    return xhr;
+  }
+
+  function response(request) {
+    return dsv.parse(request.responseText);
+  }
+
+  function typedResponse(f) {
+    return function(request) {
+      return dsv.parse(request.responseText, f);
+    };
+  }
+
+  dsv.parse = function(text, f) {
+    var o;
+    return dsv.parseRows(text, function(row, i) {
+      if (o) return o(row, i - 1);
+      var a = new Function("d", "return {" + row.map(function(name, i) {
+        return JSON.stringify(name) + ": d[" + i + "]";
+      }).join(",") + "}");
+      o = f ? function(row, i) { return f(a(row), i); } : a;
+    });
+  };
+
+  dsv.parseRows = function(text, f) {
+    var EOL = {}, // sentinel value for end-of-line
+        EOF = {}, // sentinel value for end-of-file
+        rows = [], // output rows
+        N = text.length,
+        I = 0, // current character index
+        n = 0, // the current line number
+        t, // the current token
+        eol; // is the current token followed by EOL?
+
+    function token() {
+      if (I >= N) return EOF; // special case: end of file
+      if (eol) return eol = false, EOL; // special case: end of line
+
+      // special case: quotes
+      var j = I;
+      if (text.charCodeAt(j) === 34) {
+        var i = j;
+        while (i++ < N) {
+          if (text.charCodeAt(i) === 34) {
+            if (text.charCodeAt(i + 1) !== 34) break;
+            ++i;
+          }
+        }
+        I = i + 2;
+        var c = text.charCodeAt(i + 1);
+        if (c === 13) {
+          eol = true;
+          if (text.charCodeAt(i + 2) === 10) ++I;
+        } else if (c === 10) {
+          eol = true;
+        }
+        return text.slice(j + 1, i).replace(/""/g, "\"");
+      }
+
+      // common case: find next delimiter or newline
+      while (I < N) {
+        var c = text.charCodeAt(I++), k = 1;
+        if (c === 10) eol = true; // \n
+        else if (c === 13) { eol = true; if (text.charCodeAt(I) === 10) ++I, ++k; } // \r|\r\n
+        else if (c !== delimiterCode) continue;
+        return text.slice(j, I - k);
+      }
+
+      // special case: last token before EOF
+      return text.slice(j);
+    }
+
+    while ((t = token()) !== EOF) {
+      var a = [];
+      while (t !== EOL && t !== EOF) {
+        a.push(t);
+        t = token();
+      }
+      if (f && (a = f(a, n++)) == null) continue;
+      rows.push(a);
+    }
+
+    return rows;
+  };
+
+  dsv.format = function(rows) {
+    if (Array.isArray(rows[0])) return dsv.formatRows(rows); // deprecated; use formatRows
+    var fieldSet = new d3_Set, fields = [];
+
+    // Compute unique fields in order of discovery.
+    rows.forEach(function(row) {
+      for (var field in row) {
+        if (!fieldSet.has(field)) {
+          fields.push(fieldSet.add(field));
+        }
+      }
+    });
+
+    return [fields.map(formatValue).join(delimiter)].concat(rows.map(function(row) {
+      return fields.map(function(field) {
+        return formatValue(row[field]);
+      }).join(delimiter);
+    })).join("\n");
+  };
+
+  dsv.formatRows = function(rows) {
+    return rows.map(formatRow).join("\n");
+  };
+
+  function formatRow(row) {
+    return row.map(formatValue).join(delimiter);
+  }
+
+  function formatValue(text) {
+    return reFormat.test(text) ? "\"" + text.replace(/\"/g, "\"\"") + "\"" : text;
+  }
+
+  return dsv;
+};

data/node_modules/dc/node_modules/d3/src/dsv/index.js

@@ -0,0 +1,3 @@
+import "dsv";
+import "csv";
+import "tsv";

data/node_modules/dc/node_modules/d3/src/dsv/tsv.js

@@ -0,0 +1,3 @@
+import "dsv";
+
+d3.tsv = d3.dsv("\t", "text/tab-separated-values");

data/node_modules/dc/node_modules/d3/src/end.js

@@ -0,0 +1,4 @@
+  if (typeof define === "function" && define.amd) this.d3 = d3, define(d3);
+  else if (typeof module === "object" && module.exports) module.exports = d3;
+  else this.d3 = d3;
+}();

data/node_modules/dc/node_modules/d3/src/event/dispatch.js

@@ -0,0 +1,69 @@
+import "../arrays/map";
+
+d3.dispatch = function() {
+  var dispatch = new d3_dispatch,
+      i = -1,
+      n = arguments.length;
+  while (++i < n) dispatch[arguments[i]] = d3_dispatch_event(dispatch);
+  return dispatch;
+};
+
+function d3_dispatch() {}
+
+d3_dispatch.prototype.on = function(type, listener) {
+  var i = type.indexOf("."),
+      name = "";
+
+  // Extract optional namespace, e.g., "click.foo"
+  if (i >= 0) {
+    name = type.slice(i + 1);
+    type = type.slice(0, i);
+  }
+
+  if (type) return arguments.length < 2
+      ? this[type].on(name)
+      : this[type].on(name, listener);
+
+  if (arguments.length === 2) {
+    if (listener == null) for (type in this) {
+      if (this.hasOwnProperty(type)) this[type].on(name, null);
+    }
+    return this;
+  }
+};
+
+function d3_dispatch_event(dispatch) {
+  var listeners = [],
+      listenerByName = new d3_Map;
+
+  function event() {
+    var z = listeners, // defensive reference
+        i = -1,
+        n = z.length,
+        l;
+    while (++i < n) if (l = z[i].on) l.apply(this, arguments);
+    return dispatch;
+  }
+
+  event.on = function(name, listener) {
+    var l = listenerByName.get(name),
+        i;
+
+    // return the current listener, if any
+    if (arguments.length < 2) return l && l.on;
+
+    // remove the old listener, if any (with copy-on-write)
+    if (l) {
+      l.on = null;
+      listeners = listeners.slice(0, i = listeners.indexOf(l)).concat(listeners.slice(i + 1));
+      listenerByName.remove(name);
+    }
+
+    // add the new listener, if any
+    if (listener) listeners.push(listenerByName.set(name, {on: listener}));
+
+    return dispatch;
+  };
+
+  return event;
+}

data/node_modules/dc/node_modules/d3/src/event/drag.js

@@ -0,0 +1,36 @@
+import "../core/document";
+import "../core/vendor";
+import "../selection/on";
+
+var d3_event_dragSelect,
+    d3_event_dragId = 0;
+
+function d3_event_dragSuppress(node) {
+  var name = ".dragsuppress-" + ++d3_event_dragId,
+      click = "click" + name,
+      w = d3.select(d3_window(node))
+          .on("touchmove" + name, d3_eventPreventDefault)
+          .on("dragstart" + name, d3_eventPreventDefault)
+          .on("selectstart" + name, d3_eventPreventDefault);
+
+  if (d3_event_dragSelect == null) {
+    d3_event_dragSelect = "onselectstart" in node ? false
+        : d3_vendorSymbol(node.style, "userSelect");
+  }
+
+  if (d3_event_dragSelect) {
+    var style = d3_documentElement(node).style,
+        select = style[d3_event_dragSelect];
+    style[d3_event_dragSelect] = "none";
+  }
+
+  return function(suppressClick) {
+    w.on(name, null);
+    if (d3_event_dragSelect) style[d3_event_dragSelect] = select;
+    if (suppressClick) { // suppress the next click, but only if it’s immediate
+      var off = function() { w.on(click, null); };
+      w.on(click, function() { d3_eventPreventDefault(); off(); }, true);
+      setTimeout(off, 0);
+    }
+  };
+}