mdarray-sol 0.1.0-java

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

@@ -0,0 +1,9 @@
+import "selection";
+
+d3_selectionPrototype.insert = function(name, before) {
+  name = d3_selection_creator(name);
+  before = d3_selection_selector(before);
+  return this.select(function() {
+    return this.insertBefore(name.apply(this, arguments), before.apply(this, arguments) || null);
+  });
+};

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

@@ -0,0 +1,27 @@
+// import "../transition/transition";
+import "selection";
+
+// TODO Interrupt transitions for all namespaces?
+d3_selectionPrototype.interrupt = function(name) {
+  return this.each(name == null
+      ? d3_selection_interrupt
+      : d3_selection_interruptNS(d3_transitionNamespace(name)));
+};
+
+var d3_selection_interrupt = d3_selection_interruptNS(d3_transitionNamespace());
+
+function d3_selection_interruptNS(ns) {
+  return function() {
+    var lock,
+        activeId,
+        active;
+    if ((lock = this[ns]) && (active = lock[activeId = lock.active])) {
+      active.timer.c = null;
+      active.timer.t = NaN;
+      if (--lock.count) delete lock[activeId];
+      else delete this[ns];
+      lock.active += 0.5;
+      active.event && active.event.interrupt.call(this, this.__data__, active.index);
+    }
+  };
+}

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

@@ -0,0 +1,11 @@
+import "selection";
+
+d3_selectionPrototype.node = function() {
+  for (var j = 0, m = this.length; j < m; j++) {
+    for (var group = this[j], i = 0, n = group.length; i < n; i++) {
+      var node = group[i];
+      if (node) return node;
+    }
+  }
+  return null;
+};

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

@@ -0,0 +1,106 @@
+import "../arrays/map";
+import "../core/array";
+import "../core/document";
+import "../core/noop";
+import "../event/event";
+import "../format/requote";
+import "selection";
+
+d3_selectionPrototype.on = function(type, listener, capture) {
+  var n = arguments.length;
+  if (n < 3) {
+
+    // For on(object) or on(object, boolean), the object specifies the event
+    // types and listeners to add or remove. The optional boolean specifies
+    // whether the listener captures events.
+    if (typeof type !== "string") {
+      if (n < 2) listener = false;
+      for (capture in type) this.each(d3_selection_on(capture, type[capture], listener));
+      return this;
+    }
+
+    // For on(string), return the listener for the first node.
+    if (n < 2) return (n = this.node()["__on" + type]) && n._;
+
+    // For on(string, function), use the default capture.
+    capture = false;
+  }
+
+  // Otherwise, a type, listener and capture are specified, and handled as below.
+  return this.each(d3_selection_on(type, listener, capture));
+};
+
+function d3_selection_on(type, listener, capture) {
+  var name = "__on" + type,
+      i = type.indexOf("."),
+      wrap = d3_selection_onListener;
+
+  if (i > 0) type = type.slice(0, i);
+  var filter = d3_selection_onFilters.get(type);
+  if (filter) type = filter, wrap = d3_selection_onFilter;
+
+  function onRemove() {
+    var l = this[name];
+    if (l) {
+      this.removeEventListener(type, l, l.$);
+      delete this[name];
+    }
+  }
+
+  function onAdd() {
+    var l = wrap(listener, d3_array(arguments));
+    onRemove.call(this);
+    this.addEventListener(type, this[name] = l, l.$ = capture);
+    l._ = listener;
+  }
+
+  function removeAll() {
+    var re = new RegExp("^__on([^.]+)" + d3.requote(type) + "$"),
+        match;
+    for (var name in this) {
+      if (match = name.match(re)) {
+        var l = this[name];
+        this.removeEventListener(match[1], l, l.$);
+        delete this[name];
+      }
+    }
+  }
+
+  return i
+      ? listener ? onAdd : onRemove
+      : listener ? d3_noop : removeAll;
+}
+
+var d3_selection_onFilters = d3.map({
+  mouseenter: "mouseover",
+  mouseleave: "mouseout"
+});
+
+if (d3_document) {
+  d3_selection_onFilters.forEach(function(k) {
+    if ("on" + k in d3_document) d3_selection_onFilters.remove(k);
+  });
+}
+
+function d3_selection_onListener(listener, argumentz) {
+  return function(e) {
+    var o = d3.event; // Events can be reentrant (e.g., focus).
+    d3.event = e;
+    argumentz[0] = this.__data__;
+    try {
+      listener.apply(this, argumentz);
+    } finally {
+      d3.event = o;
+    }
+  };
+}
+
+function d3_selection_onFilter(listener, argumentz) {
+  var l = d3_selection_onListener(listener, argumentz);
+  return function(e) {
+    var target = this, related = e.relatedTarget;
+    if (!related || (related !== target && !(related.compareDocumentPosition(target) & 8))) {
+      l.call(target, e);
+    }
+  };
+}

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

@@ -0,0 +1,13 @@
+import "selection";
+
+d3_selectionPrototype.order = function() {
+  for (var j = -1, m = this.length; ++j < m;) {
+    for (var group = this[j], i = group.length - 1, next = group[i], node; --i >= 0;) {
+      if (node = group[i]) {
+        if (next && next !== node.nextSibling) next.parentNode.insertBefore(node, next);
+        next = node;
+      }
+    }
+  }
+  return this;
+};

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

@@ -0,0 +1,43 @@
+import "selection";
+
+d3_selectionPrototype.property = function(name, value) {
+  if (arguments.length < 2) {
+
+    // For property(string), return the property value for the first node.
+    if (typeof name === "string") return this.node()[name];
+
+    // For property(object), the object specifies the names and values of the
+    // properties to set or remove. The values may be functions that are
+    // evaluated for each element.
+    for (value in name) this.each(d3_selection_property(value, name[value]));
+    return this;
+  }
+
+  // Otherwise, both a name and a value are specified, and are handled as below.
+  return this.each(d3_selection_property(name, value));
+};
+
+function d3_selection_property(name, value) {
+
+  // For property(name, null), remove the property with the specified name.
+  function propertyNull() {
+    delete this[name];
+  }
+
+  // For property(name, string), set the property with the specified name.
+  function propertyConstant() {
+    this[name] = value;
+  }
+
+  // For property(name, function), evaluate the function for each element, and
+  // set or remove the property as appropriate.
+  function propertyFunction() {
+    var x = value.apply(this, arguments);
+    if (x == null) delete this[name];
+    else this[name] = x;
+  }
+
+  return value == null
+      ? propertyNull : (typeof value === "function"
+      ? propertyFunction : propertyConstant);
+}

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

@@ -0,0 +1,13 @@
+import "selection";
+
+// TODO remove(selector)?
+// TODO remove(node)?
+// TODO remove(function)?
+d3_selectionPrototype.remove = function() {
+  return this.each(d3_selectionRemove);
+};
+
+function d3_selectionRemove() {
+  var parent = this.parentNode;
+  if (parent) parent.removeChild(this);
+}

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

@@ -0,0 +1,32 @@
+import "selection";
+
+d3_selectionPrototype.select = function(selector) {
+  var subgroups = [],
+      subgroup,
+      subnode,
+      group,
+      node;
+
+  selector = d3_selection_selector(selector);
+
+  for (var j = -1, m = this.length; ++j < m;) {
+    subgroups.push(subgroup = []);
+    subgroup.parentNode = (group = this[j]).parentNode;
+    for (var i = -1, n = group.length; ++i < n;) {
+      if (node = group[i]) {
+        subgroup.push(subnode = selector.call(node, node.__data__, i, j));
+        if (subnode && "__data__" in node) subnode.__data__ = node.__data__;
+      } else {
+        subgroup.push(null);
+      }
+    }
+  }
+
+  return d3_selection(subgroups);
+};
+
+function d3_selection_selector(selector) {
+  return typeof selector === "function" ? selector : function() {
+    return d3_select(selector, this);
+  };
+}

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

@@ -0,0 +1,27 @@
+import "../core/array";
+import "selection";
+
+d3_selectionPrototype.selectAll = function(selector) {
+  var subgroups = [],
+      subgroup,
+      node;
+
+  selector = d3_selection_selectorAll(selector);
+
+  for (var j = -1, m = this.length; ++j < m;) {
+    for (var group = this[j], i = -1, n = group.length; ++i < n;) {
+      if (node = group[i]) {
+        subgroups.push(subgroup = d3_array(selector.call(node, node.__data__, i, j)));
+        subgroup.parentNode = node;
+      }
+    }
+  }
+
+  return d3_selection(subgroups);
+};
+
+function d3_selection_selectorAll(selector) {
+  return typeof selector === "function" ? selector : function() {
+    return d3_selectAll(selector, this);
+  };
+}

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

@@ -0,0 +1,81 @@
+import "../core/array";
+import "../core/document";
+import "../core/subclass";
+import "../core/vendor";
+
+function d3_selection(groups) {
+  d3_subclass(groups, d3_selectionPrototype);
+  return groups;
+}
+
+var d3_select = function(s, n) { return n.querySelector(s); },
+    d3_selectAll = function(s, n) { return n.querySelectorAll(s); },
+    d3_selectMatches = function(n, s) {
+      var d3_selectMatcher = n.matches || n[d3_vendorSymbol(n, "matchesSelector")];
+      d3_selectMatches = function(n, s) {
+        return d3_selectMatcher.call(n, s);
+      };
+      return d3_selectMatches(n, s);
+    };
+
+// Prefer Sizzle, if available.
+if (typeof Sizzle === "function") {
+  d3_select = function(s, n) { return Sizzle(s, n)[0] || null; };
+  d3_selectAll = Sizzle;
+  d3_selectMatches = Sizzle.matchesSelector;
+}
+
+d3.selection = function() {
+  return d3.select(d3_document.documentElement);
+};
+
+var d3_selectionPrototype = d3.selection.prototype = [];
+
+import "select";
+import "selectAll";
+import "attr";
+import "classed";
+import "style";
+import "property";
+import "text";
+import "html";
+import "append";
+import "insert";
+import "remove";
+import "data";
+import "datum";
+import "filter";
+import "order";
+import "sort";
+import "on";
+import "each";
+import "call";
+import "empty";
+import "node";
+import "size";
+import "enter";
+
+// TODO fast singleton implementation?
+d3.select = function(node) {
+  var group;
+  if (typeof node === "string") {
+    group = [d3_select(node, d3_document)];
+    group.parentNode = d3_document.documentElement;
+  } else {
+    group = [node];
+    group.parentNode = d3_documentElement(node);
+  }
+  return d3_selection([group]);
+};
+
+d3.selectAll = function(nodes) {
+  var group;
+  if (typeof nodes === "string") {
+    group = d3_array(d3_selectAll(nodes, d3_document));
+    group.parentNode = d3_document.documentElement;
+  } else {
+    group = d3_array(nodes);
+    group.parentNode = null;
+  }
+  return d3_selection([group]);
+};

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

@@ -0,0 +1,7 @@
+import "each";
+
+d3_selectionPrototype.size = function() {
+  var n = 0;
+  d3_selection_each(this, function() { ++n; });
+  return n;
+};

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

@@ -0,0 +1,15 @@
+import "../arrays/ascending";
+import "selection";
+
+d3_selectionPrototype.sort = function(comparator) {
+  comparator = d3_selection_sortComparator.apply(this, arguments);
+  for (var j = -1, m = this.length; ++j < m;) this[j].sort(comparator);
+  return this.order();
+};
+
+function d3_selection_sortComparator(comparator) {
+  if (!arguments.length) comparator = d3_ascending;
+  return function(a, b) {
+    return a && b ? comparator(a.__data__, b.__data__) : !a - !b;
+  };
+}

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

@@ -0,0 +1,59 @@
+import "../core/document";
+import "selection";
+
+d3_selectionPrototype.style = function(name, value, priority) {
+  var n = arguments.length;
+  if (n < 3) {
+
+    // For style(object) or style(object, string), the object specifies the
+    // names and values of the attributes to set or remove. The values may be
+    // functions that are evaluated for each element. The optional string
+    // specifies the priority.
+    if (typeof name !== "string") {
+      if (n < 2) value = "";
+      for (priority in name) this.each(d3_selection_style(priority, name[priority], value));
+      return this;
+    }
+
+    // For style(string), return the computed style value for the first node.
+    if (n < 2) {
+      var node = this.node();
+      return d3_window(node).getComputedStyle(node, null).getPropertyValue(name);
+    }
+
+    // For style(string, string) or style(string, function), use the default
+    // priority. The priority is ignored for style(string, null).
+    priority = "";
+  }
+
+  // Otherwise, a name, value and priority are specified, and handled as below.
+  return this.each(d3_selection_style(name, value, priority));
+};
+
+function d3_selection_style(name, value, priority) {
+
+  // For style(name, null) or style(name, null, priority), remove the style
+  // property with the specified name. The priority is ignored.
+  function styleNull() {
+    this.style.removeProperty(name);
+  }
+
+  // For style(name, string) or style(name, string, priority), set the style
+  // property with the specified name, using the specified priority.
+  function styleConstant() {
+    this.style.setProperty(name, value, priority);
+  }
+
+  // For style(name, function) or style(name, function, priority), evaluate the
+  // function for each element, and set or remove the style property as
+  // appropriate. When setting, use the specified priority.
+  function styleFunction() {
+    var x = value.apply(this, arguments);
+    if (x == null) this.style.removeProperty(name);
+    else this.style.setProperty(name, x, priority);
+  }
+
+  return value == null
+      ? styleNull : (typeof value === "function"
+      ? styleFunction : styleConstant);
+}