domino 2.1.5 → 2.1.7

package/CHANGELOG.md

@@ -1,3 +1,14 @@
+# domino 2.1.7 (26 Mar 2026)
+* Updated CSS parser to latest upstream from
+  https://github.com/CSSLint/parser-lib including basic support for
+  CSS custom properties.
+
+# domino 2.1.6 (16 Jul 2020)
+* Bumped version of lodash (#169)
+* Performance improvement to DOMTokenList (#166)
+* `mocha` dependency has been updated to 6.x.  As a result, we are
+  no longer testing on node 4.
+
 # domino 2.1.5 (30 Apr 2020)
 * Bumped version of jquery dev dependency (#163)
 * Omit tests/ directory from NPM package (#161)

package/lib/ChildNode.js~

@@ -0,0 +1,27 @@
+"use strict";
+
+// The ChildNode interface contains methods that are particular to `Node`
+// objects that can have a parent.  It is implemented by `Element`,
+// `DocumentType`, and `CharacterData` objects.
+var ChildNode = {
+
+  // Remove this node from its parent
+  remove: { value: function remove() {
+    if (this.parentNode === null) return;
+
+    // Send mutation events if necessary
+    if (this.rooted && this.doc) this.doc.mutateRemove(this);
+
+    // Remove this node from its parents array of children
+    this.parentNode.childNodes.splice(this.index, 1);
+
+    // Update the structure id for all ancestors
+    this.parentNode.modify();
+
+    // Forget this node's parent
+    this.parentNode = null;
+  }},
+
+};
+
+module.exports = ChildNode;

package/lib/ContainerNode.js~

@@ -0,0 +1,52 @@
+"use strict";
+module.exports = ContainerNode;
+
+var Node = require('./Node');
+var utils = require('./utils');
+
+// This class defines common functionality for node subtypes that
+// can have children
+
+function ContainerNode() {
+    this._firstChild = this._childNodes = null;
+}
+
+// Primary representation is a circular linked list of siblings
+ContainerNode.prototype = Object.create(Node.prototype, {
+    hasChildNodes: { value: function() {
+        if (this._childNodes) {
+            return this._childNodes.length > 0;
+        }
+        return this._firstChild !== null;
+    }},
+    childNodes: { get: function() {
+        this._ensureChildNodes();
+        return this._childNodes;
+    }},
+    firstChild: { value: function() {
+        if (this._childNodes) {
+            return this._childNodes.length === 0 ? null : this._childNodes[0];
+        }
+        return this._firstChild;
+    }},
+    lastChild: { value: function() {
+        var kids = this._childNodes, first;
+        if (kids) {
+            return kids.length === 0 ? null: kids[kids.length-1];
+        }
+        first = this._firstChild;
+        if (first === null) { return null; }
+        return first._previousChild; // circular linked list
+    }},
+    _ensureChildNodes: { value: function() {
+        if (this._childNodes) { return; }
+        var first = this._firstChild,
+            kid = first,
+            childNodes = this._childNodes = [];
+        if (first) do {
+            childNodes.push(kid);
+            kid = kid._nextSibling;
+        } while (kid !== first); // circular linked list
+        this._firstChild = null; // free memory
+    }}
+});

package/lib/DOMTokenList.js

@@ -1,6 +1,5 @@
 "use strict";
 // DOMTokenList implementation based on https://github.com/Raynos/DOM-shim
-// XXX: should cache the getList(this) value more aggressively!
 var utils = require('./utils');
 
 module.exports = DOMTokenList;
@@ -9,6 +8,7 @@ function DOMTokenList(getter, setter) {
   this._getString = getter;
   this._setString = setter;
   this._length = 0;
+  this._lastStringValue = '';
   this._update();
 }
 
@@ -129,6 +129,7 @@ Object.defineProperties(DOMTokenList.prototype, {
     } else {
       fixIndex(this, getList(this));
     }
+    this._lastStringValue = this._getString();
   } },
 });
 
@@ -156,8 +157,21 @@ function handleErrors(token) {
   return token;
 }
 
+function toArray(clist) {
+  var length = clist._length;
+  var arr = Array(length);
+  for (var i = 0; i < length; i++) {
+    arr[i] = clist[i];
+  }
+  return arr;
+}
+
 function getList(clist) {
-  var str = clist._getString().replace(/(^[ \t\r\n\f]+)|([ \t\r\n\f]+$)/g, '');
+  var strProp = clist._getString();
+  if (strProp === clist._lastStringValue) {
+    return toArray(clist);
+  }
+  var str = strProp.replace(/(^[ \t\r\n\f]+)|([ \t\r\n\f]+$)/g, '');
   if (str === "") {
     return [];
   } else {

package/lib/LinkedList.js~

@@ -0,0 +1,21 @@
+"use strict";
+
+var LinkedList = module.exports.LinkedList = {
+    // insert a before b
+    insertBefore: function(a, b) {
+        var a_first = a, a_last = a._previousSibling;
+        var b_first = b, b_last = b._previousSibling;
+        a_first._previousSibling = b_last;
+        a_last._nextSibling = b_first;
+        b_last._nextSibling = a_first;
+        b_first._previousSibling = a_last;
+    },
+    // remove single node a from a list
+    remove: function(a, b) {
+        var prev = a._previousSibling;
+        var next = a._nextSibling;
+        prev._nextSibling = next;
+        next._previousSibling = prev;
+        a._previousSibling = a._nextSibling = a;
+    }
+};

package/lib/NamedNodeMap.js~

@@ -0,0 +1,23 @@
+"use strict";
+module.exports = NamedNodeMap;
+
+var utils = require('./utils');
+
+/* This is a hacky implementation of NamedNodeMap, intended primarily to
+ * satisfy clients (like dompurify and the web-platform-tests) which check
+ * to ensure that Node#attributes instanceof NamedNodeMap. */
+
+function NamedNodeMap(element) {
+  this.element = element;
+}
+Object.defineProperties(NamedNodeMap.prototype, {
+  length: { get: function length() { utils.shouldOverride(); } },
+  item: { value: function item(index) { utils.shouldOverride(); } },
+  getNamedItem: { value: function getNamedItem(qualifiedName) {
+    return this.element.getAttributeNode(qualifiedName);
+  } },
+  getNamedItemNS: { value: function getNamedItemNS(namespace, localName) {
+    return this.element.getAttributeNodeNS(namespace, localName);
+  } },
+
+});

package/lib/NavigatorID.js~

@@ -0,0 +1,17 @@
+"use strict";
+
+// https://html.spec.whatwg.org/multipage/webappapis.html#navigatorid
+var NavigatorID = {
+  appCodeName: "Mozilla",
+  appName: "Netscape",
+  appVersion: "4.0",
+  platform: "",
+  product: "Gecko",
+  productSub: "20100101",
+  userAgent: "",
+  vendor: "",
+  vendorSub: "",
+  taintEnabled: function() { return false; }
+};
+
+module.exports = NavigatorID;

package/lib/NodeIterator.js~

@@ -0,0 +1,71 @@
+module.exports = NodeIterator;
+
+var NodeFilter = require('./NodeFilter');
+
+/* Public API */
+
+/**
+ * Implemented version: http://www.w3.org/TR/2015/WD-dom-20150618/#nodeiterator
+ * Latest version: http://www.w3.org/TR/dom/#nodeiterator
+ *
+ * @constructor
+ * @param {Node} root
+ * @param {number} whatToShow [optional]
+ * @param {Function|NodeFilter} filter [optional]
+ * @throws Error
+ */
+function NodeIterator(root, whatToShow, filter) {
+  var ni = this, active = false;
+
+  if (!root || !root.nodeType) {
+    throw new Error('DOMException: NOT_SUPPORTED_ERR');
+  }
+
+  ni.root = ni.referenceNode = root;
+  ni.pointerBeforeReferenceNode = true;
+  ni.whatToShow = Number(whatToShow) || 0;
+
+  if (typeof filter !== 'function') {
+    // Allow filter to implement NodeFilter
+    if (filter && typeof filter === 'object' &&
+        typeof filter.acceptNode === 'function') {
+      filter = filter.acceptNode.bind(filter);
+    } else {
+      filter = null;
+    }
+  }
+
+  ni.filter = Object.create(NodeFilter.prototype);
+
+  /**
+   * @method
+   * @param {Node} node
+   * @return {Number} Constant NodeFilter.FILTER_ACCEPT,
+   *  NodeFilter.FILTER_REJECT or NodeFilter.FILTER_SKIP.
+   */
+  ni.filter.acceptNode = function (node) {
+    var result;
+    if (active) {
+      throw new Error('DOMException: INVALID_STATE_ERR');
+    }
+
+    // Maps nodeType to whatToShow
+    if (!(((1 << (node.nodeType - 1)) & tw.whatToShow))) {
+      return NodeFilter.FILTER_SKIP;
+    }
+
+    if (filter === null) {
+      return NodeFilter.FILTER_ACCEPT;
+    }
+
+    active = true;
+    result = filter(node);
+    active = false;
+
+    return result;
+  };
+};
+
+NodeIterator.prototype = {
+  constructor: NodeIterator,
+};

package/lib/NodeList.es5.js~

@@ -0,0 +1,33 @@
+/* jshint esversion: 6 */
+"use strict";
+
+var NodeList;
+
+// Attempt to use ES6-style Array subclass if possible.
+try {
+    NodeList = class NodeList extends Array {
+        constructor(a) {
+            super((a && a.length) || 0);
+            if (a) {
+                for (var idx in a) { this[idx] = a[idx]; }
+            }
+        }
+        item(i) { return this[i] || null; }
+    };
+} catch (e) {
+    console.log("using fallback");
+
+    // No support for subclassing array, return an actual Array object.
+    var item = function item(i) {
+        /* jshint validthis: true */
+        return this[i] || null;
+    };
+
+    NodeList = function NodeList(a) {
+        if (!a) a = [];
+        a.item = item;
+        return a;
+    };
+}
+
+module.exports = NodeList;

package/lib/NodeList.es6.js~

@@ -0,0 +1,33 @@
+/* jshint esversion: 6 */
+"use strict";
+
+var NodeList;
+
+// Attempt to use ES6-style Array subclass if possible.
+try {
+    NodeList = class NodeList extends Array {
+        constructor(a) {
+            super((a && a.length) || 0);
+            if (a) {
+                for (var idx in a) { this[idx] = a[idx]; }
+            }
+        }
+        item(i) { return this[i] || null; }
+    };
+} catch (e) {
+    console.log("using fallback");
+
+    // No support for subclassing array, return an actual Array object.
+    var item = function item(i) {
+        /* jshint validthis: true */
+        return this[i] || null;
+    };
+
+    NodeList = function NodeList(a) {
+        if (!a) a = [];
+        a.item = item;
+        return a;
+    };
+}
+
+module.exports = NodeList;

package/lib/NodeList2.js.bak

@@ -0,0 +1,21 @@
+"use strict";
+
+class NodeList2 extends Array {
+    constructor() { super(); }
+    item(i) { return this[i]; }
+}
+
+/*
+var handler = {
+    get: function(target, name) {
+        if (name === 'item') return function(i) { return this.backing[i]; };
+        return target.backing[name];
+    }
+};
+
+class NodeList2 extends Proxy {
+    constructor() { super({backing:[]}, handler); }
+}
+*/
+
+module.exports = NodeList2;

package/lib/NodeList2.js~

@@ -0,0 +1,7 @@
+"use strict";
+module.exports = NodeList2;
+
+class NodeList2 extends Array {
+    constructor() { super(); }
+    item(i) { return this[i]; }
+}

package/lib/NodeTraversal.js~

@@ -0,0 +1,31 @@
+var NodeTraversal = module.exports = {};
+
+/**
+ * @based on WebKit's NodeTraversal::nextSkippingChildren
+ * https://trac.webkit.org/browser/trunk/Source/WebCore/dom/NodeTraversal.h?rev=179143#L109
+ */
+NodeTraversal.nextSkippingChildren = function(node, stayWithin) {
+  if (node === stayWithin) {
+    return null;
+  }
+  if (node.nextSibling !== null) {
+    return node.nextSibling;
+  }
+  return NodeTraversal.nextAncestorSibling(node, stayWithin);
+};
+
+/**
+ * @based on WebKit's NodeTraversal::nextAncestorSibling
+ * https://trac.webkit.org/browser/trunk/Source/WebCore/dom/NodeTraversal.cpp?rev=179143#L93
+ */
+NodeTraversal.nextAncestorSibling = function(node, stayWithin) {
+  for (node = node.parentNode; node !== null; node = node.parentNode) {
+    if (node === stayWithin) {
+      return null;
+    }
+    if (node.nextSibling !== null) {
+      return node.nextSibling;
+    }
+  }
+  return null;
+};

package/lib/WindowTimers.js~

@@ -0,0 +1,11 @@
+"use strict";
+
+// https://html.spec.whatwg.org/multipage/webappapis.html#windowtimers
+var WindowTimers = {
+	setTimeout: setTimeout,
+	clearTimeout: clearTimeout,
+	setInterval: setInterval,
+	clearInterval: clearInterval
+};
+
+module.exports = WindowTimers;