stripmem 0.0.1

data/lib/stripmem/public/components/d3/src/compat/date.js

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

data/lib/stripmem/public/components/d3/src/compat/index.js

@@ -0,0 +1,2 @@
+import "date";
+import "style";

data/lib/stripmem/public/components/d3/src/compat/style.js

@@ -0,0 +1,20 @@
+import "../core/document";
+
+try {
+  d3_document.createElement("div").style.setProperty("opacity", 0, "");
+} catch (error) {
+  var d3_element_prototype = d3_window.Element.prototype,
+      d3_element_setAttribute = d3_element_prototype.setAttribute,
+      d3_element_setAttributeNS = d3_element_prototype.setAttributeNS,
+      d3_style_prototype = d3_window.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/lib/stripmem/public/components/d3/src/core/array.js

@@ -0,0 +1,19 @@
+import "document";
+
+var d3_array = d3_arraySlice; // conversion for NodeLists
+
+function d3_arrayCopy(pseudoarray) {
+  var i = -1, n = pseudoarray.length, array = [];
+  while (++i < n) array.push(pseudoarray[i]);
+  return array;
+}
+
+function d3_arraySlice(pseudoarray) {
+  return Array.prototype.slice.call(pseudoarray);
+}
+
+try {
+  d3_array(d3_documentElement.childNodes)[0].nodeType;
+} catch(e) {
+  d3_array = d3_arrayCopy;
+}

data/lib/stripmem/public/components/d3/src/core/class.js

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

data/lib/stripmem/public/components/d3/src/core/document.js

@@ -0,0 +1,3 @@
+var d3_document = document,
+    d3_documentElement = d3_document.documentElement,
+    d3_window = window;

data/lib/stripmem/public/components/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/lib/stripmem/public/components/d3/src/core/identity.js

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

data/lib/stripmem/public/components/d3/src/core/index.js

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

data/lib/stripmem/public/components/d3/src/core/noop.js

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

data/lib/stripmem/public/components/d3/src/core/ns.js

@@ -0,0 +1,22 @@
+var d3_nsPrefix = {
+  svg: "http://www.w3.org/2000/svg",
+  xhtml: "http://www.w3.org/1999/xhtml",
+  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.substring(0, i);
+      name = name.substring(i + 1);
+    }
+    return d3_nsPrefix.hasOwnProperty(prefix)
+        ? {space: d3_nsPrefix[prefix], local: name}
+        : name;
+  }
+};

data/lib/stripmem/public/components/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/lib/stripmem/public/components/d3/src/core/source.js

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

data/lib/stripmem/public/components/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/lib/stripmem/public/components/d3/src/core/target.js

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

data/lib/stripmem/public/components/d3/src/core/true.js

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

data/lib/stripmem/public/components/d3/src/core/vendor.js

@@ -0,0 +1,12 @@
+import "document";
+
+function d3_vendorSymbol(object, name) {
+  if (name in object) return name;
+  name = name.charAt(0).toUpperCase() + name.substring(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/lib/stripmem/public/components/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/lib/stripmem/public/components/d3/src/dsv/csv.js

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

data/lib/stripmem/public/components/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, callback);
+
+    xhr.row = function(_) {
+      return arguments.length
+          ? xhr.response((row = _) == null ? response : typedResponse(_))
+          : row;
+    };
+
+    return xhr.row(row);
+  }
+
+  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.substring(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.substring(j, I - k);
+      }
+
+      // special case: last token before EOF
+      return text.substring(j);
+    }
+
+    while ((t = token()) !== EOF) {
+      var a = [];
+      while (t !== EOL && t !== EOF) {
+        a.push(t);
+        t = token();
+      }
+      if (f && !(a = f(a, n++))) 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/lib/stripmem/public/components/d3/src/dsv/index.js

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

data/lib/stripmem/public/components/d3/src/dsv/tsv.js

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

data/lib/stripmem/public/components/d3/src/end.js

@@ -0,0 +1,2 @@
+  return d3;
+})();

data/lib/stripmem/public/components/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.substring(i + 1);
+    type = type.substring(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/lib/stripmem/public/components/d3/src/event/drag.js

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

data/lib/stripmem/public/components/d3/src/event/event.js

@@ -0,0 +1,50 @@
+import "dispatch";
+
+d3.event = null;
+
+function d3_eventPreventDefault() {
+  d3.event.preventDefault();
+}
+
+function d3_eventSource() {
+  var e = d3.event, s;
+  while (s = e.sourceEvent) e = s;
+  return e;
+}
+
+// Like d3.dispatch, but for custom events abstracting native UI events. These
+// events have a target component (such as a brush), a target element (such as
+// the svg:g element containing the brush) and the standard arguments `d` (the
+// target element's data) and `i` (the selection index of the target element).
+function d3_eventDispatch(target) {
+  var dispatch = new d3_dispatch,
+      i = 0,
+      n = arguments.length;
+
+  while (++i < n) dispatch[arguments[i]] = d3_dispatch_event(dispatch);
+
+  // Creates a dispatch context for the specified `thiz` (typically, the target
+  // DOM element that received the source event) and `argumentz` (typically, the
+  // data `d` and index `i` of the target element). The returned function can be
+  // used to dispatch an event to any registered listeners; the function takes a
+  // single argument as input, being the event to dispatch. The event must have
+  // a "type" attribute which corresponds to a type registered in the
+  // constructor. This context will automatically populate the "sourceEvent" and
+  // "target" attributes of the event, as well as setting the `d3.event` global
+  // for the duration of the notification.
+  dispatch.of = function(thiz, argumentz) {
+    return function(e1) {
+      try {
+        var e0 =
+        e1.sourceEvent = d3.event;
+        e1.target = target;
+        d3.event = e1;
+        dispatch[e1.type].apply(thiz, argumentz);
+      } finally {
+        d3.event = e0;
+      }
+    };
+  };
+
+  return dispatch;
+}

data/lib/stripmem/public/components/d3/src/event/index.js

@@ -0,0 +1,5 @@
+import "dispatch";
+import "event";
+import "mouse";
+import "touches";
+import "timer";

data/lib/stripmem/public/components/d3/src/event/mouse.js

@@ -0,0 +1,39 @@
+import "../core/document";
+
+d3.mouse = function(container) {
+  return d3_mousePoint(container, d3_eventSource());
+};
+
+// https://bugs.webkit.org/show_bug.cgi?id=44083
+var d3_mouse_bug44083 = /WebKit/.test(d3_window.navigator.userAgent) ? -1 : 0;
+
+function d3_mousePoint(container, e) {
+  var svg = container.ownerSVGElement || container;
+  if (svg.createSVGPoint) {
+    var point = svg.createSVGPoint();
+    if (d3_mouse_bug44083 < 0 && (d3_window.scrollX || d3_window.scrollY)) {
+      svg = d3.select("body").append("svg").style({
+        position: "absolute",
+        top: 0,
+        left: 0,
+        margin: 0,
+        padding: 0,
+        border: "none"
+      }, "important");
+      var ctm = svg[0][0].getScreenCTM();
+      d3_mouse_bug44083 = !(ctm.f || ctm.e);
+      svg.remove();
+    }
+    if (d3_mouse_bug44083) {
+      point.x = e.pageX;
+      point.y = e.pageY;
+    } else {
+      point.x = e.clientX;
+      point.y = e.clientY;
+    }
+    point = point.matrixTransform(container.getScreenCTM().inverse());
+    return [point.x, point.y];
+  }
+  var rect = container.getBoundingClientRect();
+  return [e.clientX - rect.left - container.clientLeft, e.clientY - rect.top - container.clientTop];
+};

data/lib/stripmem/public/components/d3/src/event/timer.js

@@ -0,0 +1,82 @@
+import "../core/document";
+import "../core/vendor";
+
+var d3_timer_queueHead,
+    d3_timer_queueTail,
+    d3_timer_interval, // is an interval (or frame) active?
+    d3_timer_timeout; // is a timeout active?
+
+// The timer will continue to fire until callback returns true.
+d3.timer = function(callback, delay, then) {
+  if (arguments.length < 3) {
+    if (arguments.length < 2) delay = 0;
+    else if (!isFinite(delay)) return;
+    then = Date.now();
+  }
+
+  var time = then + delay;
+
+  // Add the callback to the tail of the queue.
+  var timer = {callback: callback, time: time, next: null};
+  if (d3_timer_queueTail) d3_timer_queueTail.next = timer;
+  else d3_timer_queueHead = timer;
+  d3_timer_queueTail = timer;
+
+  // Start animatin'!
+  if (!d3_timer_interval) {
+    d3_timer_timeout = clearTimeout(d3_timer_timeout);
+    d3_timer_interval = 1;
+    d3_timer_frame(d3_timer_step);
+  }
+};
+
+function d3_timer_step() {
+  var now = d3_timer_mark(),
+      delay = d3_timer_sweep() - now;
+  if (delay > 24) {
+    if (isFinite(delay)) {
+      clearTimeout(d3_timer_timeout);
+      d3_timer_timeout = setTimeout(d3_timer_step, delay);
+    }
+    d3_timer_interval = 0;
+  } else {
+    d3_timer_interval = 1;
+    d3_timer_frame(d3_timer_step);
+  }
+}
+
+d3.timer.flush = function() {
+  d3_timer_mark();
+  d3_timer_sweep();
+};
+
+function d3_timer_mark() {
+  var now = Date.now(),
+      timer = d3_timer_queueHead;
+  while (timer) {
+    if (now >= timer.time) timer.flush = timer.callback(now - timer.time);
+    timer = timer.next;
+  }
+  return now;
+}
+
+// Flush after callbacks to avoid concurrent queue modification.
+// Returns the time of the earliest active timer, post-sweep.
+function d3_timer_sweep() {
+  var t0,
+      t1 = d3_timer_queueHead,
+      time = Infinity;
+  while (t1) {
+    if (t1.flush) {
+      t1 = t0 ? t0.next = t1.next : d3_timer_queueHead = t1.next;
+    } else {
+      if (t1.time < time) time = t1.time;
+      t1 = (t0 = t1).next;
+    }
+  }
+  d3_timer_queueTail = t0;
+  return time;
+}
+
+var d3_timer_frame = d3_window[d3_vendorSymbol(d3_window, "requestAnimationFrame")]
+    || function(callback) { setTimeout(callback, 17); };

data/lib/stripmem/public/components/d3/src/event/touches.js

@@ -0,0 +1,12 @@
+import "../core/array";
+import "event";
+import "mouse";
+
+d3.touches = function(container, touches) {
+  if (arguments.length < 2) touches = d3_eventSource().touches;
+  return touches ? d3_array(touches).map(function(touch) {
+    var point = d3_mousePoint(container, touch);
+    point.identifier = touch.identifier;
+    return point;
+  }) : [];
+};

data/lib/stripmem/public/components/d3/src/format/collapse.js

@@ -0,0 +1,3 @@
+function d3_collapse(s) {
+  return s.trim().replace(/\s+/g, " ");
+}

data/lib/stripmem/public/components/d3/src/format/format-locale.js

@@ -0,0 +1,4 @@
+var d3_format_decimalPoint = {decimal_point},
+    d3_format_thousandsSeparator = {thousands_sep},
+    d3_format_grouping = {grouping},
+    d3_format_currencySymbol = {currency_symbol};

data/lib/stripmem/public/components/d3/src/format/format-localized.js

@@ -0,0 +1,5 @@
+var d3_format_decimalPoint = ".",
+    d3_format_thousandsSeparator = ",",
+    d3_format_grouping = [3, 3],
+    d3_format_currencySymbol = "$";
+