[html5lib] implement querySelector/querySelectorAll

pkg/third_party/html5lib/lib/dom.dart

 /// A simple tree API that results from parsing html. Intended to be compatible
-/// with dart:html, but right now it resembles the classic JS DOM.
+/// with dart:html, but it is missing many types and APIs.
 library dom;
 
+// TODO(jmesserly): lots to do here. Originally I wanted to generate this using
+// our Blink IDL generator, but another idea is to directly use the excellent
+// http://dom.spec.whatwg.org/ and http://html.spec.whatwg.org/ and just
+// implement that.
+
 import 'dart:collection';
 import 'package:source_maps/span.dart' show FileSpan;
 
 import 'src/constants.dart';
+import 'src/css_class_set.dart';
 import 'src/list_proxy.dart';
+import 'src/query_selector.dart' as query;
 import 'src/token.dart';
 import 'src/tokenizer.dart';
-import 'src/utils.dart';
 import 'dom_parsing.dart';
 import 'parser.dart';
 
+export 'src/css_class_set.dart' show CssClassSet;
+
 // TODO(jmesserly): this needs to be replaced by an AttributeMap for attributes
 // that exposes namespace info.
 class AttributeName implements Comparable {
   /// The namespace prefix, e.g. `xlink`.
   final String prefix;
 
   /// The attribute name, e.g. `title`.
   final String name;
 
   /// The namespace url, e.g. `http://www.w3.org/1999/xlink`
@@ skipping 27 matching lines @@
     if (cmp != 0) return cmp;
     return namespace.compareTo(other.namespace);
   }
 
   bool operator ==(x) {
     if (x is! AttributeName) return false;
     return prefix == x.prefix && name == x.name && namespace == x.namespace;
   }
 }
 
+// http://dom.spec.whatwg.org/#parentnode
+abstract class _ParentNode implements Node {
+  // TODO(jmesserly): this is only a partial implementation
+
+  /// Seaches for the first descendant node matching the given selectors, using
+  /// a preorder traversal.
+  ///
+  /// NOTE: Not all selectors from
+  /// [selectors level 4](http://dev.w3.org/csswg/selectors-4/)
+  /// are implemented. For example, nth-child does not implement An+B syntax
+  /// and *-of-type is not implemented. If a selector is not implemented this
+  /// method will throw [UniplmentedError].
+  Element querySelector(String selector) =>
+      query.querySelector(this, selector);
+
+  /// Returns all descendant nodes matching the given selectors, using a
+  /// preorder traversal.
+  ///
+  /// NOTE: Not all selectors from
+  /// [selectors level 4](http://dev.w3.org/csswg/selectors-4/)
+  /// are implemented. For example, nth-child does not implement An+B syntax
+  /// and *-of-type is not implemented. If a selector is not implemented this
+  /// method will throw [UniplmentedError].
+  List<Element> querySelectorAll(String selector) =>
+      query.querySelectorAll(this, selector);
+}
+
+// http://dom.spec.whatwg.org/#interface-nonelementparentnode
+abstract class _NonElementParentNode implements _ParentNode {
+  // TODO(jmesserly): could be faster, should throw on invalid id.
+  Element getElementById(String id) => querySelector('#$id');
+}
+
+// This doesn't exist as an interface in the spec, but it's useful to merge
+// common methods from these:
+// http://dom.spec.whatwg.org/#interface-document
+// http://dom.spec.whatwg.org/#element
+abstract class _ElementAndDocument implements _ParentNode {
+  // TODO(jmesserly): could be faster, should throw on invalid tag/class names.
+
+  List<Element> getElementsByTagName(String localName) =>
+      querySelectorAll(localName);
+
+  List<Element> getElementsByClassName(String classNames) =>
+      querySelectorAll(classNames.splitMapJoin(' ',
+          onNonMatch: (m) => m.isNotEmpty ? '.$m' : m,
+          onMatch: (m) => ''));
+}
+
 /// Really basic implementation of a DOM-core like Node.
 abstract class Node {
   static const int ATTRIBUTE_NODE = 2;
   static const int CDATA_SECTION_NODE = 4;
   static const int COMMENT_NODE = 8;
   static const int DOCUMENT_FRAGMENT_NODE = 11;
   static const int DOCUMENT_NODE = 9;
   static const int DOCUMENT_TYPE_NODE = 10;
   static const int ELEMENT_NODE = 1;
   static const int ENTITY_NODE = 6;
   static const int ENTITY_REFERENCE_NODE = 5;
   static const int NOTATION_NODE = 12;
   static const int PROCESSING_INSTRUCTION_NODE = 7;
   static const int TEXT_NODE = 3;
 
-  /// Note: For now we use it to implement the deprecated tagName property.
-  final String _tagName;
+  /// The parent of the current node (or null for the document node).
+  Node parentNode;
 
-  /// *Deprecated* use [Element.localName] instead.
-  /// Note: after removal, this will be replaced by a correct version that
-  /// returns uppercase [as specified](http://dom.spec.whatwg.org/#dom-element-tagname).
-  @deprecated String get tagName => _tagName;
-
-  /// The parent of the current node (or null for the document node).
-  Node parent;
+  /// The parent element of this node.
+  ///
+  /// Returns null if this node either does not have a parent or its parent is
+  /// not an element.
+  Element get parent => parentNode is Element ? parentNode : null;
 
   // TODO(jmesserly): should move to Element.
   /// A map holding name, value pairs for attributes of the node.
   ///
   /// Note that attribute order needs to be stable for serialization, so we use
   /// a LinkedHashMap. Each key is a [String] or [AttributeName].
   LinkedHashMap<dynamic, String> attributes = new LinkedHashMap();
 
   /// A list of child nodes of the current node. This must
   /// include all elements but not necessarily other node types.
   final NodeList nodes = new NodeList._();
 
   List<Element> _elements;
 
   // TODO(jmesserly): consider using an Expando for this, and put it in
   // dom_parsing. Need to check the performance affect.
   /// The source span of this node, if it was created by the [HtmlParser].
   FileSpan sourceSpan;
 
   /// The attribute spans if requested. Otherwise null.
   LinkedHashMap<dynamic, FileSpan> _attributeSpans;
   LinkedHashMap<dynamic, FileSpan> _attributeValueSpans;
 
-  /// *Deprecated* use [new Element.tag] instead.
-  @deprecated Node(String tagName) : this._(tagName);
-
-  Node._([this._tagName]) {
+  Node._() {
     nodes._parent = this;
   }
 
   /// If [sourceSpan] is available, this contains the spans of each attribute.
   /// The span of an attribute is the entire attribute, including the name and
   /// quotes (if any). For example, the span of "attr" in `<a attr="value">`
   /// would be the text `attr="value"`.
   LinkedHashMap<dynamic, FileSpan> get attributeSpans {
     _ensureAttributeSpans();
     return _attributeSpans;
   }
 
   /// If [sourceSpan] is available, this contains the spans of each attribute's
   /// value. Unlike [attributeSpans], this span will inlcude only the value.
   /// For example, the value span of "attr" in `<a attr="value">` would be the
   /// text `value`.
   LinkedHashMap<dynamic, FileSpan> get attributeValueSpans {
     _ensureAttributeSpans();
     return _attributeValueSpans;
   }
 
   List<Element> get children {
     if (_elements == null) {
       _elements = new FilteredElementList(this);
     }
     return _elements;
   }
 
-  // TODO(jmesserly): needs to support deep clone.
-  /// Return a shallow copy of the current node i.e. a node with the same
-  /// name and attributes but with no parent or child nodes.
-  Node clone();
-
-  /// *Deprecated* use [Element.namespaceUri] instead.
-  @deprecated String get namespace => null;
+  /// Returns a copy of this node.
+  ///
+  /// If [deep] is `true`, then all of this node's children and decendents are
+  /// copied as well. If [deep] is `false`, then only this node is copied.
+  Node clone(bool deep);
 
   int get nodeType;
 
-  /// *Deprecated* use [text], [Text.data] or [Comment.data].
-  @deprecated String get value => null;
-
-  /// *Deprecated* use [nodeType].
-  @deprecated int get $dom_nodeType => nodeType;
-
-  /// *Deprecated* use [Element.outerHtml]
-  @deprecated String get outerHtml => _outerHtml;
-
-  /// *Deprecated* use [Element.innerHtml]
-  @deprecated String get innerHtml => _innerHtml;
-  @deprecated set innerHtml(String value) { _innerHtml = value; }
-
   // http://domparsing.spec.whatwg.org/#extensions-to-the-element-interface
   String get _outerHtml {
     var str = new StringBuffer();
     _addOuterHtml(str);
     return str.toString();
   }
 
   String get _innerHtml {
     var str = new StringBuffer();
     _addInnerHtml(str);
     return str.toString();
   }
 
-  set _innerHtml(String value) {
-    nodes.clear();
-    // TODO(jmesserly): should be able to get the same effect by adding the
-    // fragment directly.
-    nodes.addAll(parseFragment(value, container: _tagName).nodes);
-  }
-
   // Implemented per: http://dom.spec.whatwg.org/#dom-node-textcontent
   String get text => null;
   set text(String value) {}
 
   void append(Node node) => nodes.add(node);
 
   Node get firstChild => nodes.isNotEmpty ? nodes[0] : null;
 
   void _addOuterHtml(StringBuffer str);
 
   void _addInnerHtml(StringBuffer str) {
     for (Node child in nodes) child._addOuterHtml(str);
   }
 
   Node remove() {
     // TODO(jmesserly): is parent == null an error?
-    if (parent != null) {
-      parent.nodes.remove(this);
+    if (parentNode != null) {
+      parentNode.nodes.remove(this);
     }
     return this;
   }
 
   /// Insert [node] as a child of the current node, before [refNode] in the
   /// list of child nodes. Raises [UnsupportedOperationException] if [refNode]
   /// is not a child of the current node. If refNode is null, this adds to the
   /// end of the list.
   void insertBefore(Node node, Node refNode) {
     if (refNode == null) {
       nodes.add(node);
     } else {
       nodes.insert(nodes.indexOf(refNode), node);
     }
   }
 
   /// Replaces this node with another node.
   Node replaceWith(Node otherNode) {
-    if (parent == null) {
+    if (parentNode == null) {
       throw new UnsupportedError('Node must have a parent to replace it.');
     }
-    parent.nodes[parent.nodes.indexOf(this)] = otherNode;
+    parentNode.nodes[parentNode.nodes.indexOf(this)] = otherNode;
     return this;
   }
 
   // TODO(jmesserly): should this be a property or remove?
   /// Return true if the node has children or text.
   bool hasContent() => nodes.length > 0;
 
-  /// *Deprecated* construct a pair using the namespaceUri and the name.
-  @deprecated Pair<String, String> get nameTuple =>
-      this is Element ? getElementNameTuple(this) : null;
-
   /// Move all the children of the current node to [newParent].
   /// This is needed so that trees that don't store text as nodes move the
   /// text in the correct way.
   void reparentChildren(Node newParent) {
     newParent.nodes.addAll(nodes);
     nodes.clear();
   }
 
-  /// *Deprecated* use [querySelector] instead.
-  @deprecated
-  Element query(String selectors) => querySelector(selectors);
-
-  /// *Deprecated* use [querySelectorAll] instead.
-  @deprecated
-  List<Element> queryAll(String selectors) => querySelectorAll(selectors);
-
-  /// Seaches for the first descendant node matching the given selectors, using a
-  /// preorder traversal. NOTE: right now, this supports only a single type
-  /// selectors, e.g. `node.query('div')`.
-
-  Element querySelector(String selectors) =>
-      _queryType(_typeSelector(selectors));
-
-  /// Returns all descendant nodes matching the given selectors, using a
-  /// preorder traversal. NOTE: right now, this supports only a single type
-  /// selectors, e.g. `node.queryAll('div')`.
-  List<Element> querySelectorAll(String selectors) {
-    var results = new List<Element>();
-    _queryAllType(_typeSelector(selectors), results);
-    return results;
-  }
-
   bool hasChildNodes() => !nodes.isEmpty;
 
   bool contains(Node node) => nodes.contains(node);
 
-  String _typeSelector(String selectors) {
-    selectors = selectors.trim();
-    if (!_isTypeSelector(selectors)) {
-      throw new UnimplementedError('only type selectors are implemented');
-    }
-    return selectors;
-  }
-
   /// Checks if this is a type selector.
   /// See <http://www.w3.org/TR/CSS2/grammar.html>.
   /// Note: this doesn't support '*', the universal selector, non-ascii chars or
   /// escape chars.
   bool _isTypeSelector(String selector) {
     // Parser:
 
     // element_name
     //   : IDENT | '*'
     //   ;
@@ skipping 20 matching lines @@
 
     for (; i < len; i++) {
       if (!isLetterOrDigit(selector[i]) && selector.codeUnitAt(i) != DASH) {
         return false;
       }
     }
 
     return true;
   }
 
-  Element _queryType(String tag) {
-    for (var node in nodes) {
-      if (node is! Element) continue;
-      if (node.localName == tag) return node;
-      var result = node._queryType(tag);
-      if (result != null) return result;
-    }
-    return null;
-  }
-
-  void _queryAllType(String tag, List<Element> results) {
-    for (var node in nodes) {
-      if (node is! Element) continue;
-      if (node.localName == tag) results.add(node);
-      node._queryAllType(tag, results);
-    }
-  }
-
   /// Initialize [attributeSpans] using [sourceSpan].
   void _ensureAttributeSpans() {
     if (_attributeSpans != null) return;
 
     _attributeSpans = new LinkedHashMap<dynamic, FileSpan>();
     _attributeValueSpans = new LinkedHashMap<dynamic, FileSpan>();
 
     if (sourceSpan == null) return;
 
     var tokenizer = new HtmlTokenizer(sourceSpan.text, generateSpans: true,
         attributeSpans: true);
 
     tokenizer.moveNext();
     var token = tokenizer.current as StartTagToken;
 
     if (token.attributeSpans == null) return; // no attributes
 
     for (var attr in token.attributeSpans) {
       var offset = sourceSpan.start.offset;
       _attributeSpans[attr.name] = sourceSpan.file.span(
           offset + attr.start, offset + attr.end);
       if (attr.startValue != null) {
         _attributeValueSpans[attr.name] = sourceSpan.file.span(
             offset + attr.startValue, offset + attr.endValue);
       }
     }
   }
+
+  _clone(Node shallowClone, bool deep) {
+    if (deep) {
+      for (var child in nodes) {
+        shallowClone.append(child.clone(true));
+      }
+    }
+    return shallowClone;
+  }
 }
 
-class Document extends Node {
+class Document extends Node
+    with _ParentNode, _NonElementParentNode, _ElementAndDocument {
+
   Document() : super._();
   factory Document.html(String html) => parse(html);
 
   int get nodeType => Node.DOCUMENT_NODE;
 
   // TODO(jmesserly): optmize this if needed
   Element get documentElement => querySelector('html');
   Element get head => documentElement.querySelector('head');
   Element get body => documentElement.querySelector('body');
 
   /// Returns a fragment of HTML or XML that represents the element and its
   /// contents.
   // TODO(jmesserly): this API is not specified in:
   // <http://domparsing.spec.whatwg.org/> nor is it in dart:html, instead
   // only Element has outerHtml. However it is quite useful. Should we move it
   // to dom_parsing, where we keep other custom APIs?
   String get outerHtml => _outerHtml;
 
   String toString() => "#document";
 
   void _addOuterHtml(StringBuffer str) => _addInnerHtml(str);
 
-  Document clone() => new Document();
+  Document clone(bool deep) => _clone(new Document(), deep);
+
+  Element createElement(String tag) => new Element.tag(tag);
+
+  // TODO(jmesserly): this is only a partial implementation of:
+  // http://dom.spec.whatwg.org/#dom-document-createelementns
+  Element createElementNS(String namespaceUri, String tag) {
+    if (namespaceUri == '') namespaceUri = null;
+    return new Element._(tag, namespaceUri);
+  }
+
+  DocumentFragment createDocumentFragment() => new DocumentFragment();
 }
 
-class DocumentFragment extends Document {
-  DocumentFragment();
+class DocumentFragment extends Node
+    with _ParentNode, _NonElementParentNode {
+
+  DocumentFragment() : super._();
   factory DocumentFragment.html(String html) => parseFragment(html);
 
   int get nodeType => Node.DOCUMENT_FRAGMENT_NODE;
 
+  /// Returns a fragment of HTML or XML that represents the element and its
+  /// contents.
+  // TODO(jmesserly): this API is not specified in:
+  // <http://domparsing.spec.whatwg.org/> nor is it in dart:html, instead
+  // only Element has outerHtml. However it is quite useful. Should we move it
+  // to dom_parsing, where we keep other custom APIs?
+  String get outerHtml => _outerHtml;
+
   String toString() => "#document-fragment";
 
-  DocumentFragment clone() => new DocumentFragment();
+  DocumentFragment clone(bool deep) => _clone(new DocumentFragment(), deep);
+
+  void _addOuterHtml(StringBuffer str) => _addInnerHtml(str);
 
   String get text => _getText(this);
   set text(String value) => _setText(this, value);
 }
 
 class DocumentType extends Node {
   final String name;
   final String publicId;
   final String systemId;
 
   DocumentType(String name, this.publicId, this.systemId)
       // Note: once Node.tagName is removed, don't pass "name" to super
-      : name = name, super._(name);
+      : name = name, super._();
 
   int get nodeType => Node.DOCUMENT_TYPE_NODE;
 
   String toString() {
     if (publicId != null || systemId != null) {
       // TODO(jmesserly): the html5 serialization spec does not add these. But
       // it seems useful, and the parser can handle it, so for now keeping it.
       var pid = publicId != null ? publicId : '';
       var sid = systemId != null ? systemId : '';
       return '<!DOCTYPE $name "$pid" "$sid">';
     } else {
       return '<!DOCTYPE $name>';
     }
   }
 
 
   void _addOuterHtml(StringBuffer str) {
     str.write(toString());
   }
 
-  DocumentType clone() => new DocumentType(name, publicId, systemId);
+  DocumentType clone(bool deep) => new DocumentType(name, publicId, systemId);
 }
 
 class Text extends Node {
   String data;
 
   Text(this.data) : super._();
 
-  /// *Deprecated* use [data].
-  @deprecated String get value => data;
-  @deprecated set value(String x) { data = x; }
-
   int get nodeType => Node.TEXT_NODE;
 
   String toString() => '"$data"';
 
   void _addOuterHtml(StringBuffer str) => writeTextNodeAsHtml(str, this);
 
-  Text clone() => new Text(data);
+  Text clone(bool deep) => new Text(data);
 
   String get text => data;
   set text(String value) { data = value; }
 }
 
-class Element extends Node {
+// TODO(jmesserly): Elements should have a pointer back to their document
+class Element extends Node with _ParentNode, _ElementAndDocument {
   final String namespaceUri;
 
-  @deprecated String get namespace => namespaceUri;
-
   /// The [local name](http://dom.spec.whatwg.org/#concept-element-local-name)
   /// of this element.
-  String get localName => _tagName;
+  final String localName;
 
-  // TODO(jmesserly): deprecate in favor of [Document.createElementNS].
-  // However we need every element to have a Document before this can work.
-  Element(String name, [this.namespaceUri]) : super._(name);
+  Element._(this.localName, [this.namespaceUri]) : super._();
 
-  Element.tag(String name) : namespaceUri = null, super._(name);
+  Element.tag(this.localName) : namespaceUri = Namespaces.html, super._();
 
   static final _START_TAG_REGEXP = new RegExp('<(\\w+)');
 
   static final _CUSTOM_PARENT_TAG_MAP = const {
     'body': 'html',
     'head': 'html',
     'caption': 'table',
     'td': 'tr',
     'colgroup': 'table',
     'col': 'colgroup',
@@ skipping 37 matching lines @@
     } else {
       throw new ArgumentError('HTML had ${fragment.children.length} '
           'top level elements but 1 expected');
     }
     element.remove();
     return element;
   }
 
   int get nodeType => Node.ELEMENT_NODE;
 
+  // TODO(jmesserly): we can make this faster
+  Element get previousElementSibling {
+    if (parentNode == null) return null;
+    var siblings = parentNode.nodes;
+    for (int i = siblings.indexOf(this) - 1; i >= 0; i--) {
+      var s = siblings[i];
+      if (s is Element) return s;
+    }
+    return null;
+  }
+
+  Element get nextElementSibling {
+    if (parentNode == null) return null;
+    var siblings = parentNode.nodes;
+    for (int i = siblings.indexOf(this) + 1; i < siblings.length; i++) {
+      var s = siblings[i];
+      if (s is Element) return s;
+    }
+    return null;
+  }
+
   String toString() {
-    if (namespaceUri == null) return "<$localName>";
-    return "<${Namespaces.getPrefix(namespaceUri)} $localName>";
+    var prefix = Namespaces.getPrefix(namespaceUri);
+    return "<${prefix == null ? '' : '$prefix '}$localName>";
   }
 
   String get text => _getText(this);
   set text(String value) => _setText(this, value);
 
   /// Returns a fragment of HTML or XML that represents the element and its
   /// contents.
   String get outerHtml => _outerHtml;
 
   /// Returns a fragment of HTML or XML that represents the element's contents.
   /// Can be set, to replace the contents of the element with nodes parsed from
   /// the given string.
   String get innerHtml => _innerHtml;
   // TODO(jmesserly): deprecate in favor of:
   // <https://api.dartlang.org/apidocs/channels/stable/#dart-dom-html.Element@id_setInnerHtml>
-  set innerHtml(String value) { _innerHtml = value; }
+  set innerHtml(String value) {
+    nodes.clear();
+    // TODO(jmesserly): should be able to get the same effect by adding the
+    // fragment directly.
+    nodes.addAll(parseFragment(value, container: localName).nodes);
+  }
 
   void _addOuterHtml(StringBuffer str) {
     // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-end.html#serializing-html-fragments
     // Element is the most complicated one.
-    if (namespaceUri == null ||
-        namespaceUri == Namespaces.html ||
-        namespaceUri == Namespaces.mathml ||
-        namespaceUri == Namespaces.svg) {
-      str.write('<$localName');
-    } else {
-      // TODO(jmesserly): the spec doesn't define "qualified name".
-      // I'm not sure if this is correct, but it should parse reasonably.
-      str.write('<${Namespaces.getPrefix(namespaceUri)}:$localName');
-    }
+    str.write('<${_getSerializationPrefix(namespaceUri)}$localName');
 
     if (attributes.length > 0) {
       attributes.forEach((key, v) {
         // Note: AttributeName.toString handles serialization of attribute
         // namespace, if needed.
         str.write(' $key="${htmlSerializeEscape(v, attributeMode: true)}"');
       });
     }
 
     str.write('>');
@@ skipping 10 matching lines @@
       }
 
       _addInnerHtml(str);
     }
 
     // void elements must not have an end tag
     // http://dev.w3.org/html5/markup/syntax.html#void-elements
     if (!isVoidElement(localName)) str.write('</$localName>');
   }
 
-  Element clone() => new Element(localName, namespaceUri)
-      ..attributes = new LinkedHashMap.from(attributes);
+  static String _getSerializationPrefix(String uri) {
+    if (uri == null ||
+        uri == Namespaces.html ||
+        uri == Namespaces.mathml ||
+        uri == Namespaces.svg) {
+      return '';
+    }
+    var prefix = Namespaces.getPrefix(uri);
+    // TODO(jmesserly): the spec doesn't define "qualified name".
+    // I'm not sure if this is correct, but it should parse reasonably.
+    return prefix == null ? '' : '$prefix:';
+  }
 
+  Element clone(bool deep) {
+    var result = new Element._(localName, namespaceUri)
+        ..attributes = new LinkedHashMap.from(attributes);
+    return _clone(result, deep);
+  }
+
+  // http://dom.spec.whatwg.org/#dom-element-id
   String get id {
     var result = attributes['id'];
     return result != null ? result : '';
   }
 
   set id(String value) {
-    if (value == null) {
-      attributes.remove('id');
-    } else {
-      attributes['id'] = value;
-    }
+    attributes['id'] = '$value';
   }
+
+  // http://dom.spec.whatwg.org/#dom-element-classname
+  String get className {
+    var result = attributes['class'];
+    return result != null ? result : '';
+  }
+
+  set className(String value) {
+    attributes['class'] = '$value';
+  }
+
+  /**
+   * The set of CSS classes applied to this element.
+   *
+   * This set makes it easy to add, remove or toggle the classes applied to
+   * this element.
+   *
+   *     element.classes.add('selected');
+   *     element.classes.toggle('isOnline');
+   *     element.classes.remove('selected');
+   */
+  CssClassSet get classes => new ElementCssClassSet(this);
 }
 
 class Comment extends Node {
   String data;
 
   Comment(this.data) : super._();
 
   int get nodeType => Node.COMMENT_NODE;
 
   String toString() => "<!-- $data -->";
 
   void _addOuterHtml(StringBuffer str) {
     str.write("<!--$data-->");
   }
 
-  Comment clone() => new Comment(data);
+  Comment clone(bool deep) => new Comment(data);
 
   String get text => data;
   set text(String value) {
     this.data = value;
   }
 }
 
 
 // TODO(jmesserly): fix this to extend one of the corelib classes if possible.
 // (The requirement to remove the node from the old node list makes it tricky.)
 // TODO(jmesserly): is there any way to share code with the _NodeListImpl?
 class NodeList extends ListProxy<Node> {
   // Note: this is conceptually final, but because of circular reference
   // between Node and NodeList we initialize it after construction.
   Node _parent;
 
   NodeList._();
 
   Node get first => this[0];
 
   Node _setParent(Node node) {
     // Note: we need to remove the node from its previous parent node, if any,
     // before updating its parent pointer to point at our parent.
     node.remove();
-    node.parent = _parent;
+    node.parentNode = _parent;
     return node;
   }
 
   void add(Node value) {
     if (value is DocumentFragment) {
       addAll(value.nodes);
     } else {
       super.add(_setParent(value));
     }
   }
@@ skipping 14 matching lines @@
   }
 
   void insert(int index, Node value) {
     if (value is DocumentFragment) {
       insertAll(index, value.nodes);
     } else {
       super.insert(index, _setParent(value));
     }
   }
 
-  Node removeLast() => super.removeLast()..parent = null;
+  Node removeLast() => super.removeLast()..parentNode = null;
 
-  Node removeAt(int i) => super.removeAt(i)..parent = null;
+  Node removeAt(int i) => super.removeAt(i)..parentNode = null;
 
   void clear() {
-    for (var node in this) node.parent = null;
+    for (var node in this) node.parentNode = null;
     super.clear();
   }
 
   void operator []=(int index, Node value) {
     if (value is DocumentFragment) {
       removeAt(index);
       insertAll(index, value.nodes);
     } else {
-      this[index].parent = null;
+      this[index].parentNode = null;
       super[index] = _setParent(value);
     }
   }
 
   // TODO(jmesserly): These aren't implemented in DOM _NodeListImpl, see
   // http://code.google.com/p/dart/issues/detail?id=5371
   void setRange(int start, int rangeLength, List<Node> from,
                 [int startFrom = 0]) {
     if (from is NodeList) {
       // Note: this is presumed to make a copy
       from = from.sublist(startFrom, startFrom + rangeLength);
     }
     // Note: see comment in [addAll]. We need to be careful about the order of
     // operations if [from] is also a NodeList.
     for (int i = rangeLength - 1; i >= 0; i--) {
       this[start + i] = from[startFrom + i];
     }
   }
 
   void replaceRange(int start, int end, Iterable<Node> newContents) {
     removeRange(start, end);
     insertAll(start, newContents);
   }
 
   void removeRange(int start, int rangeLength) {
-    for (int i = start; i < rangeLength; i++) this[i].parent = null;
+    for (int i = start; i < rangeLength; i++) this[i].parentNode = null;
     super.removeRange(start, rangeLength);
   }
 
   void removeWhere(bool test(Element e)) {
     for (var node in where(test)) {
-      node.parent = null;
+      node.parentNode = null;
     }
     super.removeWhere(test);
   }
 
   void retainWhere(bool test(Element e)) {
     for (var node in where((n) => !test(n))) {
-      node.parent = null;
+      node.parentNode = null;
     }
     super.retainWhere(test);
   }
 
   void insertAll(int index, Iterable<Node> collection) {
     // Note: we need to be careful how we copy nodes. See note in addAll.
     var list = _flattenDocFragments(collection);
     for (var node in list.reversed) _setParent(node);
     super.insertAll(index, list);
   }
@@ skipping 208 matching lines @@
 
 class _ConcatTextVisitor extends TreeVisitor {
   final _str = new StringBuffer();
 
   String toString() => _str.toString();
 
   visitText(Text node) {
     _str.write(node.data);
   }
 }