vasuzex 2.0.13 → 2.0.15

package/frontend/react-ui/node_modules/jsdom/lib/jsdom/living/node.js

@@ -0,0 +1,331 @@
+"use strict";
+const { appendAttribute } = require("./attributes");
+const NODE_TYPE = require("./node-type");
+
+const orderedSetParse = require("./helpers/ordered-set").parse;
+const { createElement } = require("./helpers/create-element");
+const { HTML_NS, XMLNS_NS } = require("./helpers/namespaces");
+const { cloningSteps, domSymbolTree } = require("./helpers/internal-constants");
+const { asciiCaseInsensitiveMatch, asciiLowercase } = require("./helpers/strings");
+
+const HTMLCollection = require("./generated/HTMLCollection");
+
+exports.clone = (node, document, cloneChildren) => {
+  if (document === undefined) {
+    document = node._ownerDocument;
+  }
+
+  let copy;
+  switch (node.nodeType) {
+    case NODE_TYPE.DOCUMENT_NODE:
+      // Can't use a simple `Document.createImpl` because of circular dependency issues :-/
+      copy = node._cloneDocument();
+      break;
+
+    case NODE_TYPE.DOCUMENT_TYPE_NODE:
+      copy = document.implementation.createDocumentType(node.name, node.publicId, node.systemId);
+      break;
+
+    case NODE_TYPE.ELEMENT_NODE:
+      copy = createElement(
+        document,
+        node._localName,
+        node._namespaceURI,
+        node._prefix,
+        node._isValue,
+        false
+      );
+
+      for (const attribute of node._attributeList) {
+        appendAttribute(copy, exports.clone(attribute, document));
+      }
+      break;
+
+    case NODE_TYPE.ATTRIBUTE_NODE:
+      copy = document._createAttribute({
+        namespace: node._namespace,
+        namespacePrefix: node._namespacePrefix,
+        localName: node._localName,
+        value: node._value
+      });
+      break;
+
+    case NODE_TYPE.TEXT_NODE:
+      copy = document.createTextNode(node._data);
+      break;
+
+    case NODE_TYPE.CDATA_SECTION_NODE:
+      copy = document.createCDATASection(node._data);
+      break;
+
+    case NODE_TYPE.COMMENT_NODE:
+      copy = document.createComment(node._data);
+      break;
+
+    case NODE_TYPE.PROCESSING_INSTRUCTION_NODE:
+      copy = document.createProcessingInstruction(node.target, node._data);
+      break;
+
+    case NODE_TYPE.DOCUMENT_FRAGMENT_NODE:
+      copy = document.createDocumentFragment();
+      break;
+  }
+
+  if (node[cloningSteps]) {
+    node[cloningSteps](copy, node, document, cloneChildren);
+  }
+
+  if (cloneChildren) {
+    for (const child of domSymbolTree.childrenIterator(node)) {
+      const childCopy = exports.clone(child, document, true);
+      copy._append(childCopy);
+    }
+  }
+
+  return copy;
+};
+
+// For the following, memoization is not applied here since the memoized results are stored on `this`.
+
+exports.listOfElementsWithClassNames = (classNames, root) => {
+  // https://dom.spec.whatwg.org/#concept-getElementsByClassName
+
+  const classes = orderedSetParse(classNames);
+
+  if (classes.size === 0) {
+    return HTMLCollection.createImpl(root._globalObject, [], { element: root, query: () => [] });
+  }
+
+  return HTMLCollection.createImpl(root._globalObject, [], {
+    element: root,
+    query: () => {
+      const isQuirksMode = root._ownerDocument.compatMode === "BackCompat";
+
+      return domSymbolTree.treeToArray(root, { filter(node) {
+        if (node.nodeType !== NODE_TYPE.ELEMENT_NODE || node === root) {
+          return false;
+        }
+
+        const { classList } = node;
+        if (isQuirksMode) {
+          for (const className of classes) {
+            if (!classList.tokenSet.some(cur => asciiCaseInsensitiveMatch(cur, className))) {
+              return false;
+            }
+          }
+        } else {
+          for (const className of classes) {
+            if (!classList.tokenSet.contains(className)) {
+              return false;
+            }
+          }
+        }
+
+        return true;
+      } });
+    }
+  });
+};
+
+exports.listOfElementsWithQualifiedName = (qualifiedName, root) => {
+  // https://dom.spec.whatwg.org/#concept-getelementsbytagname
+
+  if (qualifiedName === "*") {
+    return HTMLCollection.createImpl(root._globalObject, [], {
+      element: root,
+      query: () => domSymbolTree.treeToArray(root, {
+        filter: node => node.nodeType === NODE_TYPE.ELEMENT_NODE && node !== root
+      })
+    });
+  }
+
+  if (root._ownerDocument._parsingMode === "html") {
+    const lowerQualifiedName = asciiLowercase(qualifiedName);
+
+    return HTMLCollection.createImpl(root._globalObject, [], {
+      element: root,
+      query: () => domSymbolTree.treeToArray(root, {
+        filter(node) {
+          if (node.nodeType !== NODE_TYPE.ELEMENT_NODE || node === root) {
+            return false;
+          }
+
+          if (node._namespaceURI === HTML_NS) {
+            return node._qualifiedName === lowerQualifiedName;
+          }
+
+          return node._qualifiedName === qualifiedName;
+        }
+      })
+    });
+  }
+
+  return HTMLCollection.createImpl(root._globalObject, [], {
+    element: root,
+    query: () => domSymbolTree.treeToArray(root, {
+      filter(node) {
+        if (node.nodeType !== NODE_TYPE.ELEMENT_NODE || node === root) {
+          return false;
+        }
+
+        return node._qualifiedName === qualifiedName;
+      }
+    })
+  });
+};
+
+exports.listOfElementsWithNamespaceAndLocalName = (namespace, localName, root) => {
+  // https://dom.spec.whatwg.org/#concept-getelementsbytagnamens
+
+  if (namespace === "") {
+    namespace = null;
+  }
+
+  if (namespace === "*" && localName === "*") {
+    return HTMLCollection.createImpl(root._globalObject, [], {
+      element: root,
+      query: () => domSymbolTree.treeToArray(root, {
+        filter: node => node.nodeType === NODE_TYPE.ELEMENT_NODE && node !== root
+      })
+    });
+  }
+
+  if (namespace === "*") {
+    return HTMLCollection.createImpl(root._globalObject, [], {
+      element: root,
+      query: () => domSymbolTree.treeToArray(root, {
+        filter(node) {
+          if (node.nodeType !== NODE_TYPE.ELEMENT_NODE || node === root) {
+            return false;
+          }
+
+          return node._localName === localName;
+        }
+      })
+    });
+  }
+
+  if (localName === "*") {
+    return HTMLCollection.createImpl(root._globalObject, [], {
+      element: root,
+      query: () => domSymbolTree.treeToArray(root, {
+        filter(node) {
+          if (node.nodeType !== NODE_TYPE.ELEMENT_NODE || node === root) {
+            return false;
+          }
+
+          return node._namespaceURI === namespace;
+        }
+      })
+    });
+  }
+
+  return HTMLCollection.createImpl(root._globalObject, [], {
+    element: root,
+    query: () => domSymbolTree.treeToArray(root, {
+      filter(node) {
+        if (node.nodeType !== NODE_TYPE.ELEMENT_NODE || node === root) {
+          return false;
+        }
+
+        return node._localName === localName && node._namespaceURI === namespace;
+      }
+    })
+  });
+};
+
+// https://dom.spec.whatwg.org/#converting-nodes-into-a-node
+// create a fragment (or just return a node for one item)
+exports.convertNodesIntoNode = (document, nodes) => {
+  if (nodes.length === 1) { // note: I'd prefer to check instanceof Node rather than string
+    return typeof nodes[0] === "string" ? document.createTextNode(nodes[0]) : nodes[0];
+  }
+  const fragment = document.createDocumentFragment();
+  for (let i = 0; i < nodes.length; i++) {
+    fragment._append(typeof nodes[i] === "string" ? document.createTextNode(nodes[i]) : nodes[i]);
+  }
+  return fragment;
+};
+
+// https://dom.spec.whatwg.org/#locate-a-namespace-prefix
+exports.locateNamespacePrefix = (element, namespace) => {
+  if (element._namespaceURI === namespace && element._prefix !== null) {
+    return element._prefix;
+  }
+
+  for (const attribute of element._attributeList) {
+    if (attribute._namespacePrefix === "xmlns" && attribute._value === namespace) {
+      return attribute._localName;
+    }
+  }
+
+  if (element.parentElement !== null) {
+    return exports.locateNamespacePrefix(element.parentElement, namespace);
+  }
+
+  return null;
+};
+
+// https://dom.spec.whatwg.org/#locate-a-namespace
+exports.locateNamespace = (node, prefix) => {
+  switch (node.nodeType) {
+    case NODE_TYPE.ELEMENT_NODE: {
+      if (node._namespaceURI !== null && node._prefix === prefix) {
+        return node._namespaceURI;
+      }
+
+      if (prefix === null) {
+        for (const attribute of node._attributeList) {
+          if (attribute._namespace === XMLNS_NS &&
+              attribute._namespacePrefix === null &&
+              attribute._localName === "xmlns") {
+            return attribute._value !== "" ? attribute._value : null;
+          }
+        }
+      } else {
+        for (const attribute of node._attributeList) {
+          if (attribute._namespace === XMLNS_NS &&
+              attribute._namespacePrefix === "xmlns" &&
+              attribute._localName === prefix) {
+            return attribute._value !== "" ? attribute._value : null;
+          }
+        }
+      }
+
+      if (node.parentElement === null) {
+        return null;
+      }
+
+      return exports.locateNamespace(node.parentElement, prefix);
+    }
+
+    case NODE_TYPE.DOCUMENT_NODE: {
+      if (node.documentElement === null) {
+        return null;
+      }
+
+      return exports.locateNamespace(node.documentElement, prefix);
+    }
+
+    case NODE_TYPE.DOCUMENT_TYPE_NODE:
+    case NODE_TYPE.DOCUMENT_FRAGMENT_NODE: {
+      return null;
+    }
+
+    case NODE_TYPE.ATTRIBUTE_NODE: {
+      if (node._element === null) {
+        return null;
+      }
+
+      return exports.locateNamespace(node._element, prefix);
+    }
+
+    default: {
+      if (node.parentElement === null) {
+        return null;
+      }
+
+      return exports.locateNamespace(node.parentElement, prefix);
+    }
+  }
+};

package/frontend/react-ui/node_modules/jsdom/lib/jsdom/living/nodes/CDATASection-impl.js

@@ -0,0 +1,16 @@
+"use strict";
+
+const TextImpl = require("./Text-impl").implementation;
+const NODE_TYPE = require("../node-type");
+
+class CDATASectionImpl extends TextImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this.nodeType = NODE_TYPE.CDATA_SECTION_NODE;
+  }
+}
+
+module.exports = {
+  implementation: CDATASectionImpl
+};

package/frontend/react-ui/node_modules/jsdom/lib/jsdom/living/nodes/CharacterData-impl.js

@@ -0,0 +1,118 @@
+"use strict";
+
+const DOMException = require("../generated/DOMException");
+
+const { mixin } = require("../../utils");
+const NodeImpl = require("./Node-impl").implementation;
+const ChildNodeImpl = require("./ChildNode-impl").implementation;
+const NonDocumentTypeChildNodeImpl = require("./NonDocumentTypeChildNode-impl").implementation;
+
+const { TEXT_NODE } = require("../node-type");
+const { MUTATION_TYPE, queueMutationRecord } = require("../helpers/mutation-observers");
+
+// https://dom.spec.whatwg.org/#characterdata
+class CharacterDataImpl extends NodeImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this._data = privateData.data;
+  }
+
+  // https://dom.spec.whatwg.org/#dom-characterdata-data
+  get data() {
+    return this._data;
+  }
+  set data(data) {
+    this.replaceData(0, this.length, data);
+  }
+
+  // https://dom.spec.whatwg.org/#dom-characterdata-length
+  get length() {
+    return this._data.length;
+  }
+
+  // https://dom.spec.whatwg.org/#dom-characterdata-substringdata
+  // https://dom.spec.whatwg.org/#concept-cd-substring
+  substringData(offset, count) {
+    const { length } = this;
+
+    if (offset > length) {
+      throw DOMException.create(this._globalObject, ["The index is not in the allowed range.", "IndexSizeError"]);
+    }
+
+    if (offset + count > length) {
+      return this._data.slice(offset);
+    }
+
+    return this._data.slice(offset, offset + count);
+  }
+
+  // https://dom.spec.whatwg.org/#dom-characterdata-appenddata
+  appendData(data) {
+    this.replaceData(this.length, 0, data);
+  }
+
+  // https://dom.spec.whatwg.org/#dom-characterdata-insertdata
+  insertData(offset, data) {
+    this.replaceData(offset, 0, data);
+  }
+
+  // https://dom.spec.whatwg.org/#dom-characterdata-deletedata
+  deleteData(offset, count) {
+    this.replaceData(offset, count, "");
+  }
+
+  // https://dom.spec.whatwg.org/#dom-characterdata-replacedata
+  // https://dom.spec.whatwg.org/#concept-cd-replace
+  replaceData(offset, count, data) {
+    const { length } = this;
+
+    if (offset > length) {
+      throw DOMException.create(this._globalObject, [
+        "The index is not in the allowed range.",
+        "IndexSizeError"
+      ]);
+    }
+
+    if (offset + count > length) {
+      count = length - offset;
+    }
+
+    queueMutationRecord(MUTATION_TYPE.CHARACTER_DATA, this, null, null, this._data, [], [], null, null);
+
+    const start = this._data.slice(0, offset);
+    const end = this._data.slice(offset + count);
+    this._data = start + data + end;
+
+    for (const range of this._referencedRanges) {
+      const { _start, _end } = range;
+
+      if (_start.node === this && _start.offset > offset && _start.offset <= offset + count) {
+        range._setLiveRangeStart(this, offset);
+      }
+
+      if (_end.node === this && _end.offset > offset && _end.offset <= offset + count) {
+        range._setLiveRangeEnd(this, offset);
+      }
+
+      if (_start.node === this && _start.offset > offset + count) {
+        range._setLiveRangeStart(this, _start.offset + data.length - count);
+      }
+
+      if (_end.node === this && _end.offset > offset + count) {
+        range._setLiveRangeEnd(this, _end.offset + data.length - count);
+      }
+    }
+
+    if (this.nodeType === TEXT_NODE && this.parentNode) {
+      this.parentNode._childTextContentChangeSteps();
+    }
+  }
+}
+
+mixin(CharacterDataImpl.prototype, NonDocumentTypeChildNodeImpl.prototype);
+mixin(CharacterDataImpl.prototype, ChildNodeImpl.prototype);
+
+module.exports = {
+  implementation: CharacterDataImpl
+};

package/frontend/react-ui/node_modules/jsdom/lib/jsdom/living/nodes/ChildNode-impl.js

@@ -0,0 +1,80 @@
+"use strict";
+
+const { convertNodesIntoNode } = require("../node");
+
+class ChildNodeImpl {
+  remove() {
+    if (!this.parentNode) {
+      return;
+    }
+
+    this.parentNode._remove(this);
+  }
+
+  after(...nodes) {
+    const parent = this.parentNode;
+    if (parent) {
+      let viableNextSibling = this.nextSibling;
+      let idx = viableNextSibling ? nodes.indexOf(viableNextSibling) : -1;
+
+      while (idx !== -1) {
+        viableNextSibling = viableNextSibling.nextSibling;
+        if (!viableNextSibling) {
+          break;
+        }
+        idx = nodes.indexOf(viableNextSibling);
+      }
+
+      parent._preInsert(convertNodesIntoNode(this._ownerDocument, nodes), viableNextSibling);
+    }
+  }
+
+  before(...nodes) {
+    const parent = this.parentNode;
+    if (parent) {
+      let viablePreviousSibling = this.previousSibling;
+      let idx = viablePreviousSibling ? nodes.indexOf(viablePreviousSibling) : -1;
+
+      while (idx !== -1) {
+        viablePreviousSibling = viablePreviousSibling.previousSibling;
+        if (!viablePreviousSibling) {
+          break;
+        }
+        idx = nodes.indexOf(viablePreviousSibling);
+      }
+
+      parent._preInsert(
+        convertNodesIntoNode(this._ownerDocument, nodes),
+        viablePreviousSibling ? viablePreviousSibling.nextSibling : parent.firstChild
+      );
+    }
+  }
+
+  replaceWith(...nodes) {
+    const parent = this.parentNode;
+    if (parent) {
+      let viableNextSibling = this.nextSibling;
+      let idx = viableNextSibling ? nodes.indexOf(viableNextSibling) : -1;
+
+      while (idx !== -1) {
+        viableNextSibling = viableNextSibling.nextSibling;
+        if (!viableNextSibling) {
+          break;
+        }
+        idx = nodes.indexOf(viableNextSibling);
+      }
+
+      const node = convertNodesIntoNode(this._ownerDocument, nodes);
+
+      if (this.parentNode === parent) {
+        parent._replace(node, this);
+      } else {
+        parent._preInsert(node, viableNextSibling);
+      }
+    }
+  }
+}
+
+module.exports = {
+  implementation: ChildNodeImpl
+};

package/frontend/react-ui/node_modules/jsdom/lib/jsdom/living/nodes/Comment-impl.js

@@ -0,0 +1,20 @@
+"use strict";
+const CharacterDataImpl = require("./CharacterData-impl").implementation;
+const idlUtils = require("../generated/utils");
+const NODE_TYPE = require("../node-type");
+
+class CommentImpl extends CharacterDataImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, {
+      data: args[0],
+      ownerDocument: idlUtils.implForWrapper(globalObject._document),
+      ...privateData
+    });
+
+    this.nodeType = NODE_TYPE.COMMENT_NODE;
+  }
+}
+
+module.exports = {
+  implementation: CommentImpl
+};

package/frontend/react-ui/node_modules/jsdom/lib/jsdom/living/nodes/DOMImplementation-impl.js

@@ -0,0 +1,120 @@
+"use strict";
+
+const validateNames = require("../helpers/validate-names");
+const { HTML_NS, SVG_NS } = require("../helpers/namespaces");
+const { createElement, internalCreateElementNSSteps } = require("../helpers/create-element");
+const DocumentType = require("../generated/DocumentType");
+const documents = require("../documents.js");
+
+class DOMImplementationImpl {
+  constructor(globalObject, args, privateData) {
+    this._globalObject = globalObject;
+    this._ownerDocument = privateData.ownerDocument;
+  }
+
+  hasFeature() {
+    return true;
+  }
+
+  createDocumentType(qualifiedName, publicId, systemId) {
+    validateNames.qname(this._globalObject, qualifiedName);
+
+    return DocumentType.createImpl(this._globalObject, [], {
+      ownerDocument: this._ownerDocument,
+      name: qualifiedName,
+      publicId,
+      systemId
+    });
+  }
+
+  // https://dom.spec.whatwg.org/#dom-domimplementation-createdocument
+  createDocument(namespace, qualifiedName, doctype) {
+    let contentType = "application/xml";
+
+    if (namespace === HTML_NS) {
+      contentType = "application/xhtml+xml";
+    } else if (namespace === SVG_NS) {
+      contentType = "image/svg+xml";
+    }
+
+    const document = documents.createImpl(this._globalObject, {
+      contentType,
+      parsingMode: "xml",
+      encoding: "UTF-8"
+    });
+
+    let element = null;
+    if (qualifiedName !== "") {
+      element = internalCreateElementNSSteps(document, namespace, qualifiedName, {});
+    }
+
+    if (doctype !== null) {
+      document.appendChild(doctype);
+    }
+
+    if (element !== null) {
+      document.appendChild(element);
+    }
+
+    document._origin = this._ownerDocument._origin;
+
+    return document;
+  }
+
+  // https://dom.spec.whatwg.org/#dom-domimplementation-createhtmldocument
+  createHTMLDocument(title) {
+    // Let doc be a new document that is an HTML document.
+    // Set doc's content type to "text/html".
+    const document = documents.createImpl(this._globalObject, {
+      parsingMode: "html",
+      encoding: "UTF-8"
+    });
+
+    // Create a doctype, with "html" as its name and with its node document set
+    // to doc. Append the newly created node to doc.
+    const doctype = DocumentType.createImpl(this._globalObject, [], {
+      ownerDocument: document,
+      name: "html",
+      publicId: "",
+      systemId: ""
+    });
+
+    document.appendChild(doctype);
+
+    // Create an html element in the HTML namespace, and append it to doc.
+    const htmlElement = createElement(document, "html", HTML_NS);
+    document.appendChild(htmlElement);
+
+    // Create a head element in the HTML namespace, and append it to the html
+    // element created in the previous step.
+    const headElement = createElement(document, "head", HTML_NS);
+    htmlElement.appendChild(headElement);
+
+    // If the title argument is not omitted:
+    if (title !== undefined) {
+      // Create a title element in the HTML namespace, and append it to the head
+      // element created in the previous step.
+      const titleElement = createElement(document, "title", HTML_NS);
+      headElement.appendChild(titleElement);
+
+      // Create a Text node, set its data to title (which could be the empty
+      // string), and append it to the title element created in the previous step.
+      titleElement.appendChild(document.createTextNode(title));
+    }
+
+    // Create a body element in the HTML namespace, and append it to the html
+    // element created in the earlier step.
+    const bodyElement = createElement(document, "body", HTML_NS);
+    htmlElement.appendChild(bodyElement);
+
+    // doc's origin is an alias to the origin of the context object's associated
+    // document, and doc's effective script origin is an alias to the effective
+    // script origin of the context object's associated document.
+
+    return document;
+  }
+}
+
+module.exports = {
+  implementation: DOMImplementationImpl
+};