pi-lean-dimension 0.1.0

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

@@ -0,0 +1,24 @@
+"use strict";
+var NodeFilter = {
+  // Constants for acceptNode()
+  FILTER_ACCEPT: 1,
+  FILTER_REJECT: 2,
+  FILTER_SKIP: 3,
+
+  // Constants for whatToShow
+  SHOW_ALL: 0xFFFFFFFF,
+  SHOW_ELEMENT: 0x1,
+  SHOW_ATTRIBUTE: 0x2, // historical
+  SHOW_TEXT: 0x4,
+  SHOW_CDATA_SECTION: 0x8, // historical
+  SHOW_ENTITY_REFERENCE: 0x10, // historical
+  SHOW_ENTITY: 0x20, // historical
+  SHOW_PROCESSING_INSTRUCTION: 0x40,
+  SHOW_COMMENT: 0x80,
+  SHOW_DOCUMENT: 0x100,
+  SHOW_DOCUMENT_TYPE: 0x200,
+  SHOW_DOCUMENT_FRAGMENT: 0x400,
+  SHOW_NOTATION: 0x800 // historical
+};
+
+module.exports = (NodeFilter.constructor = NodeFilter.prototype = NodeFilter);

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

@@ -0,0 +1,217 @@
+"use strict";
+module.exports = NodeIterator;
+
+var NodeFilter = require('./NodeFilter');
+var NodeTraversal = require('./NodeTraversal');
+var utils = require('./utils');
+
+/* Private methods and helpers */
+
+/**
+ * @based on WebKit's NodeIterator::moveToNext and NodeIterator::moveToPrevious
+ * https://trac.webkit.org/browser/trunk/Source/WebCore/dom/NodeIterator.cpp?rev=186279#L51
+ */
+function move(node, stayWithin, directionIsNext) {
+  if (directionIsNext) {
+    return NodeTraversal.next(node, stayWithin);
+  } else {
+    if (node === stayWithin) {
+      return null;
+    }
+    return NodeTraversal.previous(node, null);
+  }
+}
+
+function isInclusiveAncestor(node, possibleChild) {
+  for ( ; possibleChild; possibleChild = possibleChild.parentNode) {
+    if (node === possibleChild) { return true; }
+  }
+  return false;
+}
+
+/**
+ * @spec http://www.w3.org/TR/dom/#concept-nodeiterator-traverse
+ * @method
+ * @access private
+ * @param {NodeIterator} ni
+ * @param {string} direction One of 'next' or 'previous'.
+ * @return {Node|null}
+ */
+function traverse(ni, directionIsNext) {
+  var node, beforeNode;
+  node = ni._referenceNode;
+  beforeNode = ni._pointerBeforeReferenceNode;
+  while (true) {
+    if (beforeNode === directionIsNext) {
+      beforeNode = !beforeNode;
+    } else {
+      node = move(node, ni._root, directionIsNext);
+      if (node === null) {
+        return null;
+      }
+    }
+    var result = ni._internalFilter(node);
+    if (result === NodeFilter.FILTER_ACCEPT) {
+      break;
+    }
+  }
+  ni._referenceNode = node;
+  ni._pointerBeforeReferenceNode = beforeNode;
+  return node;
+}
+
+/* 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) {
+  if (!root || !root.nodeType) {
+    utils.NotSupportedError();
+  }
+
+  // Read-only properties
+  this._root = root;
+  this._referenceNode = root;
+  this._pointerBeforeReferenceNode = true;
+  this._whatToShow = Number(whatToShow) || 0;
+  this._filter = filter || null;
+  this._active = false;
+  // Record active node iterators in the document, in order to perform
+  // "node iterator pre-removal steps".
+  root.doc._attachNodeIterator(this);
+}
+
+Object.defineProperties(NodeIterator.prototype, {
+  root: { get: function root() {
+    return this._root;
+  } },
+  referenceNode: { get: function referenceNode() {
+    return this._referenceNode;
+  } },
+  pointerBeforeReferenceNode: { get: function pointerBeforeReferenceNode() {
+    return this._pointerBeforeReferenceNode;
+  } },
+  whatToShow: { get: function whatToShow() {
+    return this._whatToShow;
+  } },
+  filter: { get: function filter() {
+    return this._filter;
+  } },
+
+  /**
+   * @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/#nodeiterator-pre-removing-steps
+   * @method
+   * @return void
+   */
+  _preremove: { value: function _preremove(toBeRemovedNode) {
+    if (isInclusiveAncestor(toBeRemovedNode, this._root)) { return; }
+    if (!isInclusiveAncestor(toBeRemovedNode, this._referenceNode)) { return; }
+    if (this._pointerBeforeReferenceNode) {
+      var next = toBeRemovedNode;
+      while (next.lastChild) {
+        next = next.lastChild;
+      }
+      next = NodeTraversal.next(next, this.root);
+      if (next) {
+        this._referenceNode = next;
+        return;
+      }
+      this._pointerBeforeReferenceNode = false;
+      // fall through
+    }
+    if (toBeRemovedNode.previousSibling === null) {
+      this._referenceNode = toBeRemovedNode.parentNode;
+    } else {
+      this._referenceNode = toBeRemovedNode.previousSibling;
+      var lastChild;
+      for (lastChild = this._referenceNode.lastChild;
+           lastChild;
+           lastChild = this._referenceNode.lastChild) {
+        this._referenceNode = lastChild;
+      }
+    }
+  } },
+
+  /**
+   * @spec http://www.w3.org/TR/dom/#dom-nodeiterator-nextnode
+   * @method
+   * @return {Node|null}
+   */
+  nextNode: { value: function nextNode() {
+    return traverse(this, true);
+  } },
+
+  /**
+   * @spec http://www.w3.org/TR/dom/#dom-nodeiterator-previousnode
+   * @method
+   * @return {Node|null}
+   */
+  previousNode: { value: function previousNode() {
+    return traverse(this, false);
+  } },
+
+  /**
+   * @spec http://www.w3.org/TR/dom/#dom-nodeiterator-detach
+   * @method
+   * @return void
+   */
+  detach: { value: function detach() {
+    /* "The detach() method must do nothing.
+     * Its functionality (disabling a NodeIterator object) was removed,
+     * but the method itself is preserved for compatibility.
+     */
+  } },
+
+  /** For compatibility with web-platform-tests. */
+  toString: { value: function toString() {
+    return "[object NodeIterator]";
+  } },
+});

package/node_modules/@mixmark-io/domino/lib/NodeList.es5.js

@@ -0,0 +1,15 @@
+"use strict";
+
+// No support for subclassing array, return an actual Array object.
+function item(i) {
+    /* jshint validthis: true */
+    return this[i] || null;
+}
+
+function NodeList(a) {
+    if (!a) a = [];
+    a.item = item;
+    return a;
+}
+
+module.exports = NodeList;

package/node_modules/@mixmark-io/domino/lib/NodeList.es6.js

@@ -0,0 +1,12 @@
+/* jshint esversion: 6 */
+"use strict";
+
+module.exports = 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; }
+};

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

@@ -0,0 +1,13 @@
+"use strict";
+
+var NodeList;
+
+try {
+    // Attempt to use ES6-style Array subclass if possible.
+    NodeList = require('./NodeList.es6.js');
+} catch (e) {
+    // No support for subclassing array, return an actual Array object.
+    NodeList = require('./NodeList.es5.js');
+}
+
+module.exports = NodeList;

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

@@ -0,0 +1,87 @@
+"use strict";
+/* exported NodeTraversal */
+var NodeTraversal = module.exports = {
+  nextSkippingChildren: nextSkippingChildren,
+  nextAncestorSibling: nextAncestorSibling,
+  next: next,
+  previous: previous,
+  deepLastChild: deepLastChild
+};
+
+/**
+ * @based on WebKit's NodeTraversal::nextSkippingChildren
+ * https://trac.webkit.org/browser/trunk/Source/WebCore/dom/NodeTraversal.h?rev=179143#L109
+ */
+function nextSkippingChildren(node, stayWithin) {
+  if (node === stayWithin) {
+    return null;
+  }
+  if (node.nextSibling !== null) {
+    return node.nextSibling;
+  }
+  return nextAncestorSibling(node, stayWithin);
+}
+
+/**
+ * @based on WebKit's NodeTraversal::nextAncestorSibling
+ * https://trac.webkit.org/browser/trunk/Source/WebCore/dom/NodeTraversal.cpp?rev=179143#L93
+ */
+function nextAncestorSibling(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;
+}
+
+/**
+ * @based on WebKit's NodeTraversal::next
+ * https://trac.webkit.org/browser/trunk/Source/WebCore/dom/NodeTraversal.h?rev=179143#L99
+ */
+function next(node, stayWithin) {
+  var n;
+  n = node.firstChild;
+  if (n !== null) {
+    return n;
+  }
+  if (node === stayWithin) {
+    return null;
+  }
+  n = node.nextSibling;
+  if (n !== null) {
+    return n;
+  }
+  return nextAncestorSibling(node, stayWithin);
+}
+
+/**
+ * @based on WebKit's NodeTraversal::deepLastChild
+ * https://trac.webkit.org/browser/trunk/Source/WebCore/dom/NodeTraversal.cpp?rev=179143#L116
+ */
+function deepLastChild(node) {
+  while (node.lastChild) {
+    node = node.lastChild;
+  }
+  return node;
+}
+
+/**
+ * @based on WebKit's NodeTraversal::previous
+ * https://trac.webkit.org/browser/trunk/Source/WebCore/dom/NodeTraversal.h?rev=179143#L121
+ */
+function previous(node, stayWithin) {
+  var p;
+  p = node.previousSibling;
+  if (p !== null) {
+    return deepLastChild(p);
+  }
+  p = node.parentNode;
+  if (p === stayWithin) {
+    return null;
+  }
+  return p;
+}

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

@@ -0,0 +1,246 @@
+"use strict";
+module.exports = {
+  // NOTE: The `serializeOne()` function used to live on the `Node.prototype`
+  // as a private method `Node#_serializeOne(child)`, however that requires
+  // a megamorphic property access `this._serializeOne` just to get to the
+  // method, and this is being done on lots of different `Node` subclasses,
+  // which puts a lot of pressure on V8's megamorphic stub cache. So by
+  // moving the helper off of the `Node.prototype` and into a separate
+  // function in this helper module, we get a monomorphic property access
+  // `NodeUtils.serializeOne` to get to the function and reduce pressure
+  // on the megamorphic stub cache.
+  // See https://github.com/fgnass/domino/pull/142 for more information.
+  serializeOne: serializeOne,
+
+  // Export util functions so that we can run extra test for them.
+  // Note: we prefix function names with `ɵ`, similar to what we do
+  // with internal functions in Angular packages.
+  ɵescapeMatchingClosingTag: escapeMatchingClosingTag,
+  ɵescapeClosingCommentTag: escapeClosingCommentTag,
+  ɵescapeProcessingInstructionContent: escapeProcessingInstructionContent
+};
+
+var utils = require('./utils');
+var NAMESPACE = utils.NAMESPACE;
+
+var hasRawContent = {
+  STYLE: true,
+  SCRIPT: true,
+  XMP: true,
+  IFRAME: true,
+  NOEMBED: true,
+  NOFRAMES: true,
+  PLAINTEXT: true
+};
+
+var emptyElements = {
+  area: true,
+  base: true,
+  basefont: true,
+  bgsound: true,
+  br: true,
+  col: true,
+  embed: true,
+  frame: true,
+  hr: true,
+  img: true,
+  input: true,
+  keygen: true,
+  link: true,
+  meta: true,
+  param: true,
+  source: true,
+  track: true,
+  wbr: true
+};
+
+var extraNewLine = {
+  /* Removed in https://github.com/whatwg/html/issues/944
+  pre: true,
+  textarea: true,
+  listing: true
+  */
+};
+
+const ESCAPE_REGEXP = /[&<>\u00A0]/g;
+const ESCAPE_ATTR_REGEXP = /[&"<>\u00A0]/g;
+
+function escape(s) {
+  if (!ESCAPE_REGEXP.test(s)) {
+    // nothing to do, fast path
+    return s;
+  }
+
+  return s.replace(ESCAPE_REGEXP, (c) => {
+    switch (c) {
+      case "&":
+        return "&amp;";
+      case "<":
+        return "&lt;";
+      case ">":
+        return "&gt;";
+      case "\u00A0":
+        return "&nbsp;";
+    }
+  });
+}
+
+function escapeAttr(s) {
+  if (!ESCAPE_ATTR_REGEXP.test(s)) {
+    // nothing to do, fast path
+    return s;
+  }
+
+  return s.replace(ESCAPE_ATTR_REGEXP, (c) => {
+    switch (c) {
+      case "<":
+        return "&lt;";
+      case ">":
+        return "&gt;";
+      case "&":
+        return "&amp;";
+      case '"':
+        return "&quot;";
+      case "\u00A0":
+        return "&nbsp;";
+    }
+  });
+}
+
+function attrname(a) {
+  var ns = a.namespaceURI;
+  if (!ns)
+    return a.localName;
+  if (ns === NAMESPACE.XML)
+    return 'xml:' + a.localName;
+  if (ns === NAMESPACE.XLINK)
+    return 'xlink:' + a.localName;
+
+  if (ns === NAMESPACE.XMLNS) {
+    if (a.localName === 'xmlns') return 'xmlns';
+    else return 'xmlns:' + a.localName;
+  }
+  return a.name;
+}
+
+/**
+ * Escapes matching closing tag in a raw text.
+ *
+ * For example, given `<style>#text(</style><script></script>)</style>`,
+ * the parent tag would by "style" and the raw text is
+ * "</style><script></script>". If we come across a matching closing tag
+ * (in out case `</style>`) - replace `<` with `&lt;` to avoid unexpected
+ * and unsafe behavior after de-serialization.
+ */
+function escapeMatchingClosingTag(rawText, parentTag) {
+  const parentClosingTag = '</' + parentTag;
+  if (!rawText.toLowerCase().includes(parentClosingTag)) {
+    return rawText; // fast path
+  }
+  const result = [...rawText];
+  const matches = rawText.matchAll(new RegExp(parentClosingTag, 'ig'));
+  for (const match of matches) {
+    result[match.index] = '&lt;';
+  }
+  return result.join('');
+}
+
+const CLOSING_COMMENT_REGEXP = /--!?>/;
+
+/**
+ * Escapes closing comment tag in a comment content.
+ *
+ * For example, given `#comment('-->')`, the content of a comment would be
+ * updated to `--&gt;` to avoid unexpected and unsafe behavior after
+ * de-serialization.
+ */
+function escapeClosingCommentTag(rawContent) {
+  if (!CLOSING_COMMENT_REGEXP.test(rawContent)) {
+    return rawContent; // fast path
+  }
+  return rawContent.replace(/(--\!?)>/g, '$1&gt;');
+}
+
+/**
+ * Escapes processing instruction content by replacing `>` with `&gt`.
+ */
+function escapeProcessingInstructionContent(rawContent) {
+  return rawContent.includes('>')
+    ? rawContent.replaceAll('>', '&gt;')
+    : rawContent;
+}
+
+function serializeOne(kid, parent) {
+  var s = '';
+  switch(kid.nodeType) {
+    case 1: //ELEMENT_NODE
+      var ns = kid.namespaceURI;
+      var html = ns === NAMESPACE.HTML;
+      var tagname = (html || ns === NAMESPACE.SVG || ns === NAMESPACE.MATHML) ? kid.localName : kid.tagName;
+
+      s += '<' + tagname;
+
+      for(var j = 0, k = kid._numattrs; j < k; j++) {
+        var a = kid._attr(j);
+        s += ' ' + attrname(a);
+        if (a.value !== undefined) s += '="' + escapeAttr(a.value) + '"';
+      }
+      s += '>';
+
+      if (!(html && emptyElements[tagname])) {
+        var ss = kid.serialize();
+        // If an element can have raw content, this content may
+        // potentially require escaping to avoid XSS.
+        if (hasRawContent[tagname.toUpperCase()]) {
+          ss = escapeMatchingClosingTag(ss, tagname);
+        }
+        if (html && extraNewLine[tagname] && ss.charAt(0)==='\n') s += '\n';
+        // Serialize children and add end tag for all others
+        s += ss;
+        s += '</' + tagname + '>';
+      }
+      break;
+    case 3: //TEXT_NODE
+    case 4: //CDATA_SECTION_NODE
+      var parenttag;
+      if (parent.nodeType === 1 /*ELEMENT_NODE*/ &&
+        parent.namespaceURI === NAMESPACE.HTML)
+        parenttag = parent.tagName;
+      else
+        parenttag = '';
+
+      if (hasRawContent[parenttag] ||
+          (parenttag==='NOSCRIPT' && parent.ownerDocument._scripting_enabled)) {
+        s += kid.data;
+      } else {
+        s += escape(kid.data);
+      }
+      break;
+    case 8: //COMMENT_NODE
+      s += '<!--' + escapeClosingCommentTag(kid.data) + '-->';
+      break;
+    case 7: //PROCESSING_INSTRUCTION_NODE
+      const content = escapeProcessingInstructionContent(kid.data);
+      s += '<?' + kid.target + ' ' + content + '?>';
+      break;
+    case 10: //DOCUMENT_TYPE_NODE
+      s += '<!DOCTYPE ' + kid.name;
+
+      if (false) {
+        // Latest HTML serialization spec omits the public/system ID
+        if (kid.publicID) {
+          s += ' PUBLIC "' + kid.publicId + '"';
+        }
+
+        if (kid.systemId) {
+          s += ' "' + kid.systemId + '"';
+        }
+      }
+
+      s += '>';
+      break;
+    default:
+      utils.InvalidStateError();
+  }
+  return s;
+}

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

@@ -0,0 +1,26 @@
+"use strict";
+var Node = require('./Node');
+
+var NonDocumentTypeChildNode = {
+
+  nextElementSibling: { get: function() {
+    if (this.parentNode) {
+      for (var kid = this.nextSibling; kid !== null; kid = kid.nextSibling) {
+        if (kid.nodeType === Node.ELEMENT_NODE) return kid;
+      }
+    }
+    return null;
+  }},
+
+  previousElementSibling: { get: function() {
+    if (this.parentNode) {
+      for (var kid = this.previousSibling; kid !== null; kid = kid.previousSibling) {
+        if (kid.nodeType === Node.ELEMENT_NODE) return kid;
+      }
+    }
+    return null;
+  }}
+
+};
+
+module.exports = NonDocumentTypeChildNode;

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

@@ -0,0 +1,44 @@
+"use strict";
+module.exports = ProcessingInstruction;
+
+var Node = require('./Node');
+var CharacterData = require('./CharacterData');
+
+function ProcessingInstruction(doc, target, data) {
+  CharacterData.call(this);
+  this.nodeType = Node.PROCESSING_INSTRUCTION_NODE;
+  this.ownerDocument = doc;
+  this.target = target;
+  this._data = 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);
+  }
+};
+
+ProcessingInstruction.prototype = Object.create(CharacterData.prototype, {
+  nodeName: { get: function() { return this.target; }},
+  nodeValue: nodeValue,
+  textContent: nodeValue,
+  innerText: nodeValue,
+  data: {
+    get: nodeValue.get,
+    set: function(v) {
+      nodeValue.set.call(this, v===null ? '' : String(v));
+    },
+  },
+
+  // Utility methods
+  clone: { value: function clone() {
+      return new ProcessingInstruction(this.ownerDocument, this.target, this._data);
+  }},
+  isEqual: { value: function isEqual(n) {
+      return this.target === n.target && this._data === n._data;
+  }}
+
+});