domino 2.0.3 → 2.1.0

package/CHANGELOG.md

@@ -1,10 +1,56 @@
+# domino 2.1.0 (13 Aug 2018)
+* Fix `ContainerNode#removeChildren()` when there is more than one child (#129)
+* Implement `Document#scrollingElement` (#107)
+* Implement setter for `Element#outerHTML` (#102)
+* Handle null/undefined in setter for `Node#textContent`
+* Handle null/undefined/negative values in `CharacterData` interface methods
+* Spec-correctness fixes for `DOMTokenList`, including handling of duplicate
+  keys.
+* Fix `[src=...]` selectors in `Document#querySelector()` and similar
+* Spec-correctness fixes for `Document#createElement()` and
+  `Document#createElementNS()`, including proper exception type and type
+  coercion.
+* Implement `Attr#cloneNode()`, `Element#getAttributeNode()`,
+  `Element#getAttributeNodeNS()`, `Element#setAttributeNode()`,
+  `Element#setAttributeNodeNS()`, and `Element#removeAttributeNode()`
+  (DOM3 compatibility)
+* Implement `Document#createAttribute()` and `Document#createAttributeNS()`
+* Implement `Element#hasAttributes()`, `Element#toggleAttribute()`, and
+  `Element#getAttributeNames()`
+* Implement `Text#wholeText`
+* Implement `Document#cloneNode()` and `DocumentType#cloneNode()`
+* Spec-correctness fixes for `Node#lookupPrefix()`,
+  `Node#lookupNamespaceURI()`, and `Node#isDefaultNamespace`, including
+  proper type coercion and reconciling DOM 3 and DOM 4 specifications.
+* Ensure `Document#title` continues to use correct whitespace stripping
+  for node > 4, and properly set `<title>` when `undefined` is passed to
+  `DOMImplementation#createHTMLDocument()`
+* Ensure `Element#attributes` implements `NamedNodeMap` and that indexed
+  properties of `Element#attributes` work (previously you needed to use
+  the `item()` accessor method)
+* Improve stubs for `HTMLElement#style`, `Document#documentURI`, and
+  `Document#contentType`
+* Implement proper accessors for `HTMLSelectElement#autocomplete`,
+  `HTMLTextAreaElement#type/value/defaultValue/textLength`, and
+  `HTMLInputElement#width/height/minLength`
+* Implement `Element#insertAdjacentElement()`, `Element#insertAdjacentText()`,
+  and `Element#insertAdjacentHTML()` (#102)
+* Spec-correctness fixes for `TreeWalker` and `NodeIterator`: read-only
+  properties, proper exception types, type coercion of `NodeFilter` results.
+* Implement `NodeIterator` pre-removal steps.  Note that in the absence
+  of weak references, be cautious about the number of `NodeIterator`s you
+  create on any single document, since domino does not artificially limit
+  these.
+  See https://github.com/tc39/proposal-weakrefs/issues/17 for details.
+* Preserve prefix of SVG elements during parsing. (#102)
+
 # domino 2.0.3 (12 Jul 2018)
 * Define `blur()`, `focus()` and `forceSpellCheck()` on `HTMLElement` (#125)
 * Stringify argument tokens for DOMTokenList methods (#126)
 * Fix `HTMLAnchorElement#hash` when `href` attribute contains bare
   fragment (#127)
 * Implement case-insensitive CSS attribute matching (#128)
-* Implement DOMTokenList#replace()`, `DOMTokenList#toggle(token, force)`,
+* Implement `DOMTokenList#replace()`, `DOMTokenList#toggle(token, force)`,
   and `DOMTokenList#value`. Fix handling of non-space whitespace. (#111)
 
 # domino 2.0.2 (28 Mar 2018)

package/README.md

@@ -6,21 +6,24 @@ As the name might suggest, domino's goal is to provide a <b>DOM in No</b>de.
 
 In contrast to the original [dom.js](https://github.com/andreasgal/dom.js) project, domino was not designed to run untrusted code. Hence it doesn't have to hide its internals behind a proxy facade which makes the code not only simpler, but also [more performant](https://github.com/fgnass/dombench).
 
-Domino currently doesn't use any harmony features like proxies or WeakMaps and therefore also runs in older Node versions.
+Domino currently doesn't use any harmony/ES6 features like proxies or WeakMaps and therefore also runs in older Node versions.
 
 ## Speed over Compliance
 
 Domino is intended for _building_ pages rather than scraping them. Hence Domino doesn't execute scripts nor does it download external resources.
 
-Also Domino doesn't implement any properties which have been deprecated in HTML5.
+Also Domino doesn't generally implement properties which have been deprecated in HTML5.
 
-Domino sticks to the [DOM level 4](http://dvcs.w3.org/hg/domcore/raw-file/tip/Overview.html#interface-attr) working draft, which means that Attributes do not inherit the Node interface. Also [Element.attributes](http://dvcs.w3.org/hg/domcore/raw-file/tip/Overview.html#dom-element-attributes) returns a read-only array instead of a NamedNodeMap.
+Domino sticks to [DOM level 4](http://dvcs.w3.org/hg/domcore/raw-file/tip/Overview.html#interface-attr), which means that Attributes do not inherit the Node interface.
 
 <b>Note that</b> because domino does not use proxies,
 `Element.attributes` is not a true JavaScript array; it is an object
 with a `length` property and an `item(n)` accessor method.  See
 [github issue #27](https://github.com/fgnass/domino/issues/27) for
-further discussion.
+further discussion.  It does however implement direct indexed accessors
+(`element.attributes[i]`) and is live.
+
+
 
 ## CSS Selector Support
 

package/lib/CharacterData.js

@@ -1,3 +1,4 @@
+/* jshint bitwise: false */
 "use strict";
 module.exports = CharacterData;
 
@@ -28,8 +29,13 @@ CharacterData.prototype = Object.create(Leaf.prototype, {
   //     units from the offsetth UTF-16 code unit to the
   //     offset+countth UTF-16 code unit in data.
   substringData: { value: function substringData(offset, count) {
-    if (offset > this.data.length || offset < 0 || count < 0) 
+    if (arguments.length < 2) { throw new TypeError("Not enough arguments"); }
+    // Convert arguments to WebIDL "unsigned long"
+    offset = offset >>> 0;
+    count = count >>> 0;
+    if (offset > this.data.length || offset < 0 || count < 0) {
       utils.IndexSizeError();
+    }
     return this.data.substring(offset, offset+count);
   }},
 
@@ -37,7 +43,8 @@ CharacterData.prototype = Object.create(Leaf.prototype, {
   // The appendData(data) method must append data to the context
   // object's data.
   appendData: { value: function appendData(data) {
-    this.data = this.data + data;
+    if (arguments.length < 1) { throw new TypeError("Not enough arguments"); }
+    this.data += String(data);
   }},
 
   // void insertData(unsigned long offset, DOMString data);
@@ -51,11 +58,7 @@ CharacterData.prototype = Object.create(Leaf.prototype, {
   //     offset UTF-16 code units.
   //
   insertData: { value: function insertData(offset, data) {
-    var curtext = this.data;
-    if (offset > curtext.length || offset < 0) utils.IndexSizeError();
-    var prefix = curtext.substring(0, offset),
-    suffix = curtext.substring(offset);
-    this.data = prefix + data + suffix;
+    return this.replaceData(offset, 0, data);
   }},
 
 
@@ -72,17 +75,7 @@ CharacterData.prototype = Object.create(Leaf.prototype, {
   //     Starting from offset UTF-16 code units remove count
   //     UTF-16 code units from the context object's data.
   deleteData: { value: function deleteData(offset, count) {
-    var curtext = this.data, len = curtext.length;
-
-    if (offset > len || offset < 0) utils.IndexSizeError();
-
-    if (offset+count > len)
-      count = len - offset;
-
-    var prefix = curtext.substring(0, offset),
-    suffix = curtext.substring(offset+count);
-
-    this.data = prefix + suffix;
+    return this.replaceData(offset, count, '');
   }},
 
 
@@ -96,6 +89,10 @@ CharacterData.prototype = Object.create(Leaf.prototype, {
   // exceptions these methods might have thrown.
   replaceData: { value: function replaceData(offset, count, data) {
     var curtext = this.data, len = curtext.length;
+    // Convert arguments to correct WebIDL type
+    offset = offset >>> 0;
+    count = count >>> 0;
+    data = String(data);
 
     if (offset > len || offset < 0) utils.IndexSizeError();
 

package/lib/ChildNode.js

@@ -62,7 +62,12 @@ var ChildNode = {
     if (this.parentNode === null) return;
 
     // Send mutation events if necessary
-    if (this.rooted && this.doc) this.doc.mutateRemove(this);
+    if (this.doc) {
+      this.doc._preremoveNodeIterators(this);
+      if (this.rooted) {
+        this.doc.mutateRemove(this);
+      }
+    }
 
     // Remove this node from its parents array of children
     // and update the structure id for all ancestors

package/lib/Comment.js

@@ -14,6 +14,7 @@ function Comment(doc, data) {
 var nodeValue = {
   get: function() { return this._data; },
   set: function(v) {
+    if (v === null || v === undefined) { v = ''; } else { v = String(v); }
     this._data = v;
     if (this.rooted)
       this.ownerDocument.mutateValue(this);
@@ -24,7 +25,12 @@ Comment.prototype = Object.create(CharacterData.prototype, {
   nodeName: { value: '#comment' },
   nodeValue: nodeValue,
   textContent: nodeValue,
-  data: nodeValue,
+  data: {
+    get: nodeValue.get,
+    set: function(v) {
+      nodeValue.set.call(this, v===null ? '' : String(v));
+    },
+  },
 
   // Utility methods
   clone: { value: function clone() {

package/lib/ContainerNode.js

@@ -59,8 +59,13 @@ ContainerNode.prototype = Object.create(Node.prototype, {
   // Remove all of this node's children.  This is a minor
   // optimization that only calls modify() once.
   removeChildren: { value: function removeChildren() {
-    var root = this.rooted ? this.ownerDocument : null;
-    for (var kid = this.firstChild; kid !== null; kid = kid.nextSibling) {
+    var root = this.rooted ? this.ownerDocument : null,
+        next = this.firstChild,
+        kid;
+    while (next !== null) {
+      kid = next;
+      next = kid.nextSibling;
+
       if (root) root.mutateRemove(kid);
       kid.parentNode = null;
     }

package/lib/DOMException.js

@@ -35,7 +35,7 @@ var names = [
   'NO_MODIFICATION_ALLOWED_ERR',
   'NOT_FOUND_ERR',
   'NOT_SUPPORTED_ERR',
-  null, // historical
+  'INUSE_ATTRIBUTE_ERR', // historical
   'INVALID_STATE_ERR',
   'SYNTAX_ERR',
   'INVALID_MODIFICATION_ERR',
@@ -70,7 +70,7 @@ var messages = [
   'NO_MODIFICATION_ALLOWED_ERR (7): the object can not be modified',
   'NOT_FOUND_ERR (8): the object can not be found here',
   'NOT_SUPPORTED_ERR (9): this operation is not supported',
-  null,
+  'INUSE_ATTRIBUTE_ERR (10): setAttributeNode called on owned Attribute',
   'INVALID_STATE_ERR (11): the object is in an invalid state',
   'SYNTAX_ERR (12): the string did not match the expected pattern',
   'INVALID_MODIFICATION_ERR (13): the object can not be modified in this way',

package/lib/DOMImplementation.js

@@ -8,8 +8,9 @@ var utils = require('./utils');
 var xml = require('./xmlnames');
 
 // Each document must have its own instance of the domimplementation object
-// Even though these objects have no state
-function DOMImplementation() {}
+function DOMImplementation(contextObject) {
+  this.contextObject = contextObject;
+}
 
 
 // Feature/version pairs that DOMImplementation.hasFeature() returns
@@ -28,10 +29,9 @@ DOMImplementation.prototype = {
   },
 
   createDocumentType: function createDocumentType(qualifiedName, publicId, systemId) {
-    if (!xml.isValidName(qualifiedName)) utils.InvalidCharacterError();
-    if (!xml.isValidQName(qualifiedName)) utils.NamespaceError();
+    if (!xml.isValidQName(qualifiedName)) utils.InvalidCharacterError();
 
-    return new DocumentType(qualifiedName, publicId, systemId);
+    return new DocumentType(this.contextObject, qualifiedName, publicId, systemId);
   },
 
   createDocument: function createDocument(namespace, qualifiedName, doctype) {
@@ -50,25 +50,33 @@ DOMImplementation.prototype = {
       e = null;
 
     if (doctype) {
-      if (doctype.ownerDocument) utils.WrongDocumentError();
       d.appendChild(doctype);
     }
 
     if (e) d.appendChild(e);
+    if (namespace === utils.NAMESPACE.HTML) {
+      d._contentType = 'application/xhtml+xml';
+    } else if (namespace === utils.NAMESPACE.SVG) {
+      d._contentType = 'image/svg+xml';
+    } else {
+      d._contentType = 'application/xml';
+    }
 
     return d;
   },
 
   createHTMLDocument: function createHTMLDocument(titleText) {
     var d = new Document(true, null);
-    d.appendChild(new DocumentType('html'));
+    d.appendChild(new DocumentType(d, 'html'));
     var html = d.createElement('html');
     d.appendChild(html);
     var head = d.createElement('head');
     html.appendChild(head);
-    var title = d.createElement('title');
-    head.appendChild(title);
-    title.appendChild(d.createTextNode(titleText));
+    if (titleText !== undefined) {
+      var title = d.createElement('title');
+      head.appendChild(title);
+      title.appendChild(d.createTextNode(titleText));
+    }
     html.appendChild(d.createElement('body'));
     d.modclock = 1; // Start tracking modifications
     return d;

package/lib/DOMTokenList.js

@@ -1,5 +1,6 @@
 "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;
@@ -7,15 +8,18 @@ module.exports = DOMTokenList;
 function DOMTokenList(getter, setter) {
   this._getString = getter;
   this._setString = setter;
-  fixIndex(this, getList(this));
+  this._length = 0;
+  this._update();
 }
 
 Object.defineProperties(DOMTokenList.prototype, {
+  length: { get: function() { return this._length; } },
   item: { value: function(index) {
-    if (index >= this.length) {
+    var list = getList(this);
+    if (index < 0 || index >= list.length) {
       return null;
     }
-    return getList(this)[index];
+    return list[index];
   }},
 
   contains: { value: function(token) {
@@ -25,29 +29,34 @@ Object.defineProperties(DOMTokenList.prototype, {
   }},
 
   add: { value: function() {
+    var list = getList(this);
     for (var i = 0, len = arguments.length; i < len; i++) {
       var token = handleErrors(arguments[i]);
-      var list = getList(this);
-      if (list.indexOf(token) > -1) {
-        return;
+      if (list.indexOf(token) < 0) {
+        list.push(token);
       }
-      list.push(token);
-      this._setString(list.join(" ").trim());
-      fixIndex(this, list);
     }
+    // Note: as per spec, if handleErrors() throws any errors, we never
+    // make it here and none of the changes take effect.
+    // Also per spec: we run the "update steps" even if no change was
+    // made (ie, if the token already existed)
+    this._update(list);
   }},
 
   remove: { value: function() {
+    var list = getList(this);
     for (var i = 0, len = arguments.length; i < len; i++) {
       var token = handleErrors(arguments[i]);
-      var list = getList(this);
       var index = list.indexOf(token);
       if (index > -1) {
         list.splice(index, 1);
-        this._setString(list.join(" ").trim());
       }
-      fixIndex(this, list);
     }
+    // Note: as per spec, if handleErrors() throws any errors, we never
+    // make it here and none of the changes take effect.
+    // Also per spec: we run the "update steps" even if no change was
+    // made (ie, if the token wasn't previously present)
+    this._update(list);
   }},
 
   toggle: { value: function toggle(token, force) {
@@ -68,16 +77,33 @@ Object.defineProperties(DOMTokenList.prototype, {
   }},
 
   replace: { value: function replace(token, newToken) {
+    // weird corner case of spec: if `token` contains whitespace, but
+    // `newToken` is the empty string, we must throw SyntaxError not
+    // InvalidCharacterError (sigh)
+    if (String(newToken)==='') { utils.SyntaxError(); }
     token = handleErrors(token);
     newToken = handleErrors(newToken);
     var list = getList(this);
     var idx = list.indexOf(token);
     if (idx < 0) {
+      // Note that, per spec, we do not run the update steps on this path.
       return false;
     }
-    list[idx] = newToken;
-    this._setString(list.join(" ").trim());
-    fixIndex(this, list);
+    var idx2 = list.indexOf(newToken);
+    if (idx2 < 0) {
+      list[idx] = newToken;
+    } else {
+      // "replace the first instance of either `token` or `newToken` with
+      // `newToken` and remove all other instances"
+      if (idx < idx2) {
+        list[idx] = newToken;
+        list.splice(idx2, 1);
+      } else {
+        // idx2 is already `newToken`
+        list.splice(idx, 1);
+      }
+    }
+    this._update(list);
     return true;
   }},
 
@@ -91,16 +117,32 @@ Object.defineProperties(DOMTokenList.prototype, {
     },
     set: function(v) {
       this._setString(v);
-      fixIndex(this, getList(this));
+      this._update();
     }
   },
+
+  // Called when the setter is called from outside this interface.
+  _update: { value: function(list) {
+    if (list) {
+      fixIndex(this, list);
+      this._setString(list.join(" ").trim());
+    } else {
+      fixIndex(this, getList(this));
+    }
+  } },
 });
 
 function fixIndex(clist, list) {
-  clist.length = list.length;
-  for (var i = 0; i < list.length; i++) {
+  var oldLength = clist._length;
+  var i;
+  clist._length = list.length;
+  for (i = 0; i < list.length; i++) {
     clist[i] = list[i];
   }
+  // Clear/free old entries.
+  for (; i < oldLength; i++) {
+    clist[i] = undefined;
+  }
 }
 
 function handleErrors(token) {
@@ -119,6 +161,12 @@ function getList(clist) {
   if (str === "") {
     return [];
   } else {
-    return str.split(/[ \t\r\n\f]+/g);
+    var seen = Object.create(null);
+    return str.split(/[ \t\r\n\f]+/g).filter(function(n) {
+      var key = '$' + n;
+      if (seen[key]) { return false; }
+      seen[key] = true;
+      return true;
+    });
   }
 }