@jacfrost/autopm 0.0.1

package/node_modules/@mixmark-io/domino/lib/Text.js

@@ -0,0 +1,75 @@
+"use strict";
+module.exports = Text;
+
+var utils = require('./utils');
+var Node = require('./Node');
+var CharacterData = require('./CharacterData');
+
+function Text(doc, data) {
+  CharacterData.call(this);
+  this.nodeType = Node.TEXT_NODE;
+  this.ownerDocument = doc;
+  this._data = data;
+  this._index = undefined;
+}
+
+var nodeValue = {
+  get: function() { return this._data; },
+  set: function(v) {
+    if (v === null || v === undefined) { v = ''; } else { v = String(v); }
+    if (v === this._data) return;
+    this._data = v;
+    if (this.rooted)
+      this.ownerDocument.mutateValue(this);
+    if (this.parentNode &&
+      this.parentNode._textchangehook)
+      this.parentNode._textchangehook(this);
+  }
+};
+
+Text.prototype = Object.create(CharacterData.prototype, {
+  nodeName: { value: "#text" },
+  // These three attributes are all the same.
+  // The data attribute has a [TreatNullAs=EmptyString] but we'll
+  // implement that at the interface level
+  nodeValue: nodeValue,
+  textContent: nodeValue,
+  innerText: nodeValue,
+  data: {
+    get: nodeValue.get,
+    set: function(v) {
+      nodeValue.set.call(this, v===null ? '' : String(v));
+    },
+  },
+
+  splitText: { value: function splitText(offset) {
+    if (offset > this._data.length || offset < 0) utils.IndexSizeError();
+
+    var newdata = this._data.substring(offset),
+      newnode = this.ownerDocument.createTextNode(newdata);
+    this.data = this.data.substring(0, offset);
+
+    var parent = this.parentNode;
+    if (parent !== null)
+      parent.insertBefore(newnode, this.nextSibling);
+
+    return newnode;
+  }},
+
+  wholeText: { get: function wholeText() {
+    var result = this.textContent;
+    for (var next = this.nextSibling; next; next = next.nextSibling) {
+      if (next.nodeType !== Node.TEXT_NODE) { break; }
+      result += next.textContent;
+    }
+    return result;
+  }},
+  // Obsolete, removed from spec.
+  replaceWholeText: { value: utils.nyi },
+
+  // Utility methods
+  clone: { value: function clone() {
+    return new Text(this.ownerDocument, this._data);
+  }},
+
+});

package/node_modules/@mixmark-io/domino/lib/TreeWalker.js

@@ -0,0 +1,336 @@
+"use strict";
+module.exports = TreeWalker;
+
+var Node = require('./Node');
+var NodeFilter = require('./NodeFilter');
+var NodeTraversal = require('./NodeTraversal');
+var utils = require('./utils');
+
+var mapChild = {
+  first: 'firstChild',
+  last: 'lastChild',
+  next: 'firstChild',
+  previous: 'lastChild'
+};
+
+var mapSibling = {
+  first: 'nextSibling',
+  last: 'previousSibling',
+  next: 'nextSibling',
+  previous: 'previousSibling'
+};
+
+/* Private methods and helpers */
+
+/**
+ * @spec https://dom.spec.whatwg.org/#concept-traverse-children
+ * @method
+ * @access private
+ * @param {TreeWalker} tw
+ * @param {string} type One of 'first' or 'last'.
+ * @return {Node|null}
+ */
+function traverseChildren(tw, type) {
+  var child, node, parent, result, sibling;
+  node = tw._currentNode[mapChild[type]];
+  while (node !== null) {
+    result = tw._internalFilter(node);
+    if (result === NodeFilter.FILTER_ACCEPT) {
+      tw._currentNode = node;
+      return node;
+    }
+    if (result === NodeFilter.FILTER_SKIP) {
+      child = node[mapChild[type]];
+      if (child !== null) {
+        node = child;
+        continue;
+      }
+    }
+    while (node !== null) {
+      sibling = node[mapSibling[type]];
+      if (sibling !== null) {
+        node = sibling;
+        break;
+      }
+      parent = node.parentNode;
+      if (parent === null || parent === tw.root || parent === tw._currentNode) {
+        return null;
+      } else {
+        node = parent;
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * @spec https://dom.spec.whatwg.org/#concept-traverse-siblings
+ * @method
+ * @access private
+ * @param {TreeWalker} tw
+ * @param {TreeWalker} type One of 'next' or 'previous'.
+ * @return {Node|nul}
+ */
+function traverseSiblings(tw, type) {
+  var node, result, sibling;
+  node = tw._currentNode;
+  if (node === tw.root) {
+    return null;
+  }
+  while (true) {
+    sibling = node[mapSibling[type]];
+    while (sibling !== null) {
+      node = sibling;
+      result = tw._internalFilter(node);
+      if (result === NodeFilter.FILTER_ACCEPT) {
+        tw._currentNode = node;
+        return node;
+      }
+      sibling = node[mapChild[type]];
+      if (result === NodeFilter.FILTER_REJECT || sibling === null) {
+        sibling = node[mapSibling[type]];
+      }
+    }
+    node = node.parentNode;
+    if (node === null || node === tw.root) {
+      return null;
+    }
+    if (tw._internalFilter(node) === NodeFilter.FILTER_ACCEPT) {
+      return null;
+    }
+  }
+}
+
+
+/* Public API */
+
+/**
+ * Latest version: https://dom.spec.whatwg.org/#treewalker
+ *
+ * @constructor
+ * @param {Node} root
+ * @param {number} whatToShow [optional]
+ * @param {Function|NodeFilter} filter [optional]
+ * @throws Error
+ */
+function TreeWalker(root, whatToShow, filter) {
+  if (!root || !root.nodeType) {
+    utils.NotSupportedError();
+  }
+
+  // Read-only properties
+  this._root = root;
+  this._whatToShow = Number(whatToShow) || 0;
+  this._filter = filter || null;
+  this._active = false;
+  // Read-write property
+  this._currentNode = root;
+}
+
+Object.defineProperties(TreeWalker.prototype, {
+  root: { get: function() { return this._root; } },
+  whatToShow: { get: function() { return this._whatToShow; } },
+  filter: { get: function() { return this._filter; } },
+
+  currentNode: {
+    get: function currentNode() {
+      return this._currentNode;
+    },
+    set: function setCurrentNode(v) {
+      if (!(v instanceof Node)) {
+        throw new TypeError("Not a Node"); // `null` is also not a node
+      }
+      this._currentNode = v;
+    },
+  },
+
+  /**
+   * @method
+   * @param {Node} node
+   * @return {Number} Constant NodeFilter.FILTER_ACCEPT,
+   *  NodeFilter.FILTER_REJECT or NodeFilter.FILTER_SKIP.
+   */
+  _internalFilter: { value: function _internalFilter(node) {
+    /* jshint bitwise: false */
+    var result, filter;
+    if (this._active) {
+      utils.InvalidStateError();
+    }
+
+    // Maps nodeType to whatToShow
+    if (!(((1 << (node.nodeType - 1)) & this._whatToShow))) {
+      return NodeFilter.FILTER_SKIP;
+    }
+
+    filter = this._filter;
+    if (filter === null) {
+      result = NodeFilter.FILTER_ACCEPT;
+    } else {
+      this._active = true;
+      try {
+        if (typeof filter === 'function') {
+          result = filter(node);
+        } else {
+          result = filter.acceptNode(node);
+        }
+      } finally {
+        this._active = false;
+      }
+    }
+
+    // Note that coercing to a number means that
+    //  `true` becomes `1` (which is NodeFilter.FILTER_ACCEPT)
+    //  `false` becomes `0` (neither accept, reject, or skip)
+    return (+result);
+  }},
+
+  /**
+   * @spec https://dom.spec.whatwg.org/#dom-treewalker-parentnode
+   * @based on WebKit's TreeWalker::parentNode
+   * https://trac.webkit.org/browser/webkit/trunk/Source/WebCore/dom/TreeWalker.cpp?rev=220453#L50
+   * @method
+   * @return {Node|null}
+   */
+  parentNode: { value: function parentNode() {
+    var node = this._currentNode;
+    while (node !== this.root) {
+      node = node.parentNode;
+      if (node === null) {
+        return null;
+      }
+      if (this._internalFilter(node) === NodeFilter.FILTER_ACCEPT) {
+        this._currentNode = node;
+        return node;
+      }
+    }
+    return null;
+  }},
+
+  /**
+   * @spec https://dom.spec.whatwg.org/#dom-treewalker-firstchild
+   * @method
+   * @return {Node|null}
+   */
+  firstChild: { value: function firstChild() {
+    return traverseChildren(this, 'first');
+  }},
+
+  /**
+   * @spec https://dom.spec.whatwg.org/#dom-treewalker-lastchild
+   * @method
+   * @return {Node|null}
+   */
+  lastChild: { value: function lastChild() {
+    return traverseChildren(this, 'last');
+  }},
+
+  /**
+   * @spec http://www.w3.org/TR/dom/#dom-treewalker-previoussibling
+   * @method
+   * @return {Node|null}
+   */
+  previousSibling: { value: function previousSibling() {
+    return traverseSiblings(this, 'previous');
+  }},
+
+  /**
+   * @spec http://www.w3.org/TR/dom/#dom-treewalker-nextsibling
+   * @method
+   * @return {Node|null}
+   */
+  nextSibling: { value: function nextSibling() {
+    return traverseSiblings(this, 'next');
+  }},
+
+  /**
+   * @spec https://dom.spec.whatwg.org/#dom-treewalker-previousnode
+   * @based on WebKit's TreeWalker::previousNode
+   * https://trac.webkit.org/browser/webkit/trunk/Source/WebCore/dom/TreeWalker.cpp?rev=220453#L181
+   * @method
+   * @return {Node|null}
+   */
+  previousNode: { value: function previousNode() {
+    var node, result, previousSibling, lastChild;
+    node = this._currentNode;
+    while (node !== this._root) {
+      for (previousSibling = node.previousSibling;
+           previousSibling;
+           previousSibling = node.previousSibling) {
+        node = previousSibling;
+        result = this._internalFilter(node);
+        if (result === NodeFilter.FILTER_REJECT) {
+          continue;
+        }
+        for (lastChild = node.lastChild;
+             lastChild;
+             lastChild = node.lastChild) {
+          node = lastChild;
+          result = this._internalFilter(node);
+          if (result === NodeFilter.FILTER_REJECT) {
+            break;
+          }
+        }
+        if (result === NodeFilter.FILTER_ACCEPT) {
+          this._currentNode = node;
+          return node;
+        }
+      }
+      if (node === this.root || node.parentNode === null) {
+        return null;
+      }
+      node = node.parentNode;
+      if (this._internalFilter(node) === NodeFilter.FILTER_ACCEPT) {
+        this._currentNode = node;
+        return node;
+      }
+    }
+    return null;
+  }},
+
+  /**
+   * @spec https://dom.spec.whatwg.org/#dom-treewalker-nextnode
+   * @based on WebKit's TreeWalker::nextNode
+   * https://trac.webkit.org/browser/webkit/trunk/Source/WebCore/dom/TreeWalker.cpp?rev=220453#L228
+   * @method
+   * @return {Node|null}
+   */
+  nextNode: { value: function nextNode() {
+    var node, result, firstChild, nextSibling;
+    node = this._currentNode;
+    result = NodeFilter.FILTER_ACCEPT;
+
+    CHILDREN:
+    while (true) {
+      for (firstChild = node.firstChild;
+           firstChild;
+           firstChild = node.firstChild) {
+        node = firstChild;
+        result = this._internalFilter(node);
+        if (result === NodeFilter.FILTER_ACCEPT) {
+          this._currentNode = node;
+          return node;
+        } else if (result === NodeFilter.FILTER_REJECT) {
+          break;
+        }
+      }
+      for (nextSibling = NodeTraversal.nextSkippingChildren(node, this.root);
+           nextSibling;
+           nextSibling = NodeTraversal.nextSkippingChildren(node, this.root)) {
+        node = nextSibling;
+        result = this._internalFilter(node);
+        if (result === NodeFilter.FILTER_ACCEPT) {
+          this._currentNode = node;
+          return node;
+        } else if (result === NodeFilter.FILTER_SKIP) {
+          continue CHILDREN;
+        }
+      }
+      return null;
+    }
+  }},
+
+  /** For compatibility with web-platform-tests. */
+  toString: { value: function toString() {
+    return "[object TreeWalker]";
+  }},
+});

package/node_modules/@mixmark-io/domino/lib/UIEvent.js

@@ -0,0 +1,19 @@
+"use strict";
+var Event = require('./Event');
+
+module.exports = UIEvent;
+
+function UIEvent() {
+  // Just use the superclass constructor to initialize
+  Event.call(this);
+  this.view = null; // FF uses the current window
+  this.detail = 0;
+}
+UIEvent.prototype = Object.create(Event.prototype, {
+  constructor: { value: UIEvent },
+  initUIEvent: { value: function(type, bubbles, cancelable, view, detail) {
+    this.initEvent(type, bubbles, cancelable);
+    this.view = view;
+    this.detail = detail;
+  }}
+});

package/node_modules/@mixmark-io/domino/lib/URL.js

@@ -0,0 +1,194 @@
+"use strict";
+module.exports = URL;
+
+function URL(url) {
+  if (!url) return Object.create(URL.prototype);
+  // Can't use String.trim() since it defines whitespace differently than HTML
+  this.url = url.replace(/^[ \t\n\r\f]+|[ \t\n\r\f]+$/g, "");
+
+  // See http://tools.ietf.org/html/rfc3986#appendix-B
+  // and https://url.spec.whatwg.org/#parsing
+  var match = URL.pattern.exec(this.url);
+  if (match) {
+    if (match[2]) this.scheme = match[2];
+    if (match[4]) {
+      // parse username/password
+      var userinfo = match[4].match(URL.userinfoPattern);
+      if (userinfo) {
+        this.username = userinfo[1];
+        this.password = userinfo[3];
+        match[4] = match[4].substring(userinfo[0].length);
+      }
+      if (match[4].match(URL.portPattern)) {
+        var pos = match[4].lastIndexOf(':');
+        this.host = match[4].substring(0, pos);
+        this.port = match[4].substring(pos+1);
+      }
+      else {
+        this.host = match[4];
+      }
+    }
+    if (match[5]) this.path = match[5];
+    if (match[6]) this.query = match[7];
+    if (match[8]) this.fragment = match[9];
+  }
+}
+
+URL.pattern = /^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?$/;
+URL.userinfoPattern = /^([^@:]*)(:([^@]*))?@/;
+URL.portPattern = /:\d+$/;
+URL.authorityPattern = /^[^:\/?#]+:\/\//;
+URL.hierarchyPattern = /^[^:\/?#]+:\//;
+
+// Return a percentEncoded version of s.
+// S should be a single-character string
+// XXX: needs to do utf-8 encoding?
+URL.percentEncode = function percentEncode(s) {
+  var c = s.charCodeAt(0);
+  if (c < 256) return "%" + c.toString(16);
+  else throw Error("can't percent-encode codepoints > 255 yet");
+};
+
+URL.prototype = {
+  constructor: URL,
+
+  // XXX: not sure if this is the precise definition of absolute
+  isAbsolute: function() { return !!this.scheme; },
+  isAuthorityBased: function() {
+    return URL.authorityPattern.test(this.url);
+  },
+  isHierarchical: function() {
+    return URL.hierarchyPattern.test(this.url);
+  },
+
+  toString: function() {
+    var s = "";
+    if (this.scheme !== undefined) s += this.scheme + ":";
+    if (this.isAbsolute()) {
+      s += '//';
+      if (this.username || this.password) {
+        s += this.username || '';
+        if (this.password) {
+          s += ':' + this.password;
+        }
+        s += '@';
+      }
+      if (this.host) {
+        s += this.host;
+      }
+    }
+    if (this.port !== undefined) s += ":" + this.port;
+    if (this.path !== undefined) s += this.path;
+    if (this.query !== undefined) s += "?" + this.query;
+    if (this.fragment !== undefined) s += "#" + this.fragment;
+    return s;
+  },
+
+  // See: http://tools.ietf.org/html/rfc3986#section-5.2
+  // and https://url.spec.whatwg.org/#constructors
+  resolve: function(relative) {
+    var base = this;           // The base url we're resolving against
+    var r = new URL(relative); // The relative reference url to resolve
+    var t = new URL();         // The absolute target url we will return
+
+    if (r.scheme !== undefined) {
+      t.scheme = r.scheme;
+      t.username = r.username;
+      t.password = r.password;
+      t.host = r.host;
+      t.port = r.port;
+      t.path = remove_dot_segments(r.path);
+      t.query = r.query;
+    }
+    else {
+      t.scheme = base.scheme;
+      if (r.host !== undefined) {
+        t.username = r.username;
+        t.password = r.password;
+        t.host = r.host;
+        t.port = r.port;
+        t.path = remove_dot_segments(r.path);
+        t.query = r.query;
+      }
+      else {
+        t.username = base.username;
+        t.password = base.password;
+        t.host = base.host;
+        t.port = base.port;
+        if (!r.path) { // undefined or empty
+          t.path = base.path;
+          if (r.query !== undefined)
+            t.query = r.query;
+          else
+            t.query = base.query;
+        }
+        else {
+          if (r.path.charAt(0) === "/") {
+            t.path = remove_dot_segments(r.path);
+          }
+          else {
+            t.path = merge(base.path, r.path);
+            t.path = remove_dot_segments(t.path);
+          }
+          t.query = r.query;
+        }
+      }
+    }
+    t.fragment = r.fragment;
+
+    return t.toString();
+
+
+    function merge(basepath, refpath) {
+      if (base.host !== undefined && !base.path)
+        return "/" + refpath;
+
+      var lastslash = basepath.lastIndexOf("/");
+      if (lastslash === -1)
+        return refpath;
+      else
+        return basepath.substring(0, lastslash+1) + refpath;
+    }
+
+    function remove_dot_segments(path) {
+      if (!path) return path; // For "" or undefined
+
+      var output = "";
+      while(path.length > 0) {
+        if (path === "." || path === "..") {
+          path = "";
+          break;
+        }
+
+        var twochars = path.substring(0,2);
+        var threechars = path.substring(0,3);
+        var fourchars = path.substring(0,4);
+        if (threechars === "../") {
+          path = path.substring(3);
+        }
+        else if (twochars === "./") {
+          path = path.substring(2);
+        }
+        else if (threechars === "/./") {
+          path = "/" + path.substring(3);
+        }
+        else if (twochars === "/." && path.length === 2) {
+          path = "/";
+        }
+        else if (fourchars === "/../" ||
+             (threechars === "/.." && path.length === 3)) {
+          path = "/" + path.substring(4);
+
+          output = output.replace(/\/?[^\/]*$/, "");
+        }
+        else {
+          var segment = path.match(/(\/?([^\/]*))/)[0];
+          output += segment;
+          path = path.substring(segment.length);
+        }
+      }
+
+      return output;
+    }
+  },
+};