vasuzex 2.0.13 → 2.0.15

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

@@ -0,0 +1,22 @@
+"use strict";
+const cssstyle = require("cssstyle");
+
+class ElementCSSInlineStyle {
+  _initElementCSSInlineStyle() {
+    this._settingCssText = false;
+    this._style = new cssstyle.CSSStyleDeclaration(newCssText => {
+      if (!this._settingCssText) {
+        this._settingCssText = true;
+        this.setAttributeNS(null, "style", newCssText);
+        this._settingCssText = false;
+      }
+    });
+  }
+  get style() {
+    return this._style;
+  }
+}
+
+module.exports = {
+  implementation: ElementCSSInlineStyle
+};

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

@@ -0,0 +1,7 @@
+"use strict";
+
+class ElementContentEditableImpl { }
+
+module.exports = {
+  implementation: ElementContentEditableImpl
+};

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

@@ -0,0 +1,145 @@
+"use strict";
+
+const { appendHandler, createEventAccessor } = require("../helpers/create-event-accessor");
+
+// Must be kept in sync with GlobalEventHandlers.webidl.
+const events = new Set([
+  "abort",
+  "auxclick",
+  "beforeinput",
+  "beforematch",
+  "beforetoggle",
+  "blur",
+  "cancel",
+  "canplay",
+  "canplaythrough",
+  "change",
+  "click",
+  "close",
+  "contextlost",
+  "contextmenu",
+  "contextrestored",
+  "copy",
+  "cuechange",
+  "cut",
+  "dblclick",
+  "drag",
+  "dragend",
+  "dragenter",
+  "dragleave",
+  "dragover",
+  "dragstart",
+  "drop",
+  "durationchange",
+  "emptied",
+  "ended",
+  "error",
+  "focus",
+  "formdata",
+  "input",
+  "invalid",
+  "keydown",
+  "keypress",
+  "keyup",
+  "load",
+  "loadeddata",
+  "loadedmetadata",
+  "loadstart",
+  "mousedown",
+  "mouseenter",
+  "mouseleave",
+  "mousemove",
+  "mouseout",
+  "mouseover",
+  "mouseup",
+  "paste",
+  "pause",
+  "play",
+  "playing",
+  "progress",
+  "ratechange",
+  "reset",
+  "resize",
+  "scroll",
+  "scrollend",
+  "securitypolicyviolation",
+  "seeked",
+  "seeking",
+  "select",
+  "slotchange",
+  "stalled",
+  "submit",
+  "suspend",
+  "timeupdate",
+  "toggle",
+  "volumechange",
+  "waiting",
+  "webkitanimationend",
+  "webkitanimationiteration",
+  "webkitanimationstart",
+  "webkittransitionend",
+  "wheel",
+  "touchstart",
+  "touchend",
+  "touchmove",
+  "touchcancel"
+]);
+
+class GlobalEventHandlersImpl {
+  _initGlobalEvents() {
+    this._registeredHandlers = new Set();
+    this._eventHandlers = Object.create(null);
+  }
+
+  _getEventHandlerTarget() {
+    return this;
+  }
+
+  _getEventHandlerFor(event) {
+    const target = this._getEventHandlerTarget(event);
+    if (!target) {
+      return null;
+    }
+
+    return target._eventHandlers[event];
+  }
+
+  _setEventHandlerFor(event, handler) {
+    const target = this._getEventHandlerTarget(event);
+    if (!target) {
+      return;
+    }
+
+    if (!target._registeredHandlers.has(event) && handler !== null) {
+      target._registeredHandlers.add(event);
+      appendHandler(target, event);
+    }
+    target._eventHandlers[event] = handler;
+  }
+
+  _globalEventChanged(event) {
+    const propName = "on" + event;
+    if (!(propName in this)) {
+      return;
+    }
+
+    // Only translate attribute changes into properties when runScripts: "dangerously" is set.
+    // Documents without a browsing context (i.e. without a _defaultView) never run scripts.
+    const runScripts = "_runScripts" in this ? this._runScripts : (this._ownerDocument._defaultView || {})._runScripts;
+    if (runScripts !== "dangerously") {
+      return;
+    }
+
+    const val = this.getAttributeNS(null, propName);
+    const handler = val === null ? null : { body: val };
+    this._setEventHandlerFor(event, handler);
+  }
+}
+
+for (const event of events) {
+  createEventAccessor(GlobalEventHandlersImpl.prototype, event);
+}
+
+module.exports = {
+  implementation: GlobalEventHandlersImpl
+};

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

@@ -0,0 +1,50 @@
+"use strict";
+const { mixin } = require("../../utils");
+const DOMTokenList = require("../generated/DOMTokenList");
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const HTMLHyperlinkElementUtilsImpl = require("./HTMLHyperlinkElementUtils-impl").implementation;
+
+class HTMLAnchorElementImpl extends HTMLElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this._htmlHyperlinkElementUtilsSetup();
+
+    this._hasActivationBehavior = true;
+  }
+
+  _activationBehavior() {
+    this._followAHyperlink();
+  }
+
+  get relList() {
+    if (this._relList === undefined) {
+      this._relList = DOMTokenList.createImpl(this._globalObject, [], {
+        element: this,
+        attributeLocalName: "rel"
+      });
+    }
+    return this._relList;
+  }
+
+  get text() {
+    return this.textContent;
+  }
+  set text(v) {
+    this.textContent = v;
+  }
+
+  _attrModified(name, value, oldValue) {
+    super._attrModified(name, value, oldValue);
+
+    if (name === "rel" && this._relList !== undefined) {
+      this._relList.attrModified();
+    }
+  }
+}
+
+mixin(HTMLAnchorElementImpl.prototype, HTMLHyperlinkElementUtilsImpl.prototype);
+
+module.exports = {
+  implementation: HTMLAnchorElementImpl
+};

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

@@ -0,0 +1,43 @@
+"use strict";
+const { mixin } = require("../../utils");
+const DOMTokenList = require("../generated/DOMTokenList");
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const HTMLHyperlinkElementUtilsImpl = require("./HTMLHyperlinkElementUtils-impl").implementation;
+
+class HTMLAreaElementImpl extends HTMLElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this._htmlHyperlinkElementUtilsSetup();
+
+    this._hasActivationBehavior = true;
+  }
+
+  _activationBehavior() {
+    this._followAHyperlink();
+  }
+
+  get relList() {
+    if (this._relList === undefined) {
+      this._relList = DOMTokenList.createImpl(this._globalObject, [], {
+        element: this,
+        attributeLocalName: "rel"
+      });
+    }
+    return this._relList;
+  }
+
+  _attrModified(name, value, oldValue) {
+    super._attrModified(name, value, oldValue);
+
+    if (name === "rel" && this._relList !== undefined) {
+      this._relList.attrModified();
+    }
+  }
+}
+
+mixin(HTMLAreaElementImpl.prototype, HTMLHyperlinkElementUtilsImpl.prototype);
+
+module.exports = {
+  implementation: HTMLAreaElementImpl
+};

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

@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLMediaElementImpl = require("./HTMLMediaElement-impl").implementation;
+
+class HTMLAudioElementImpl extends HTMLMediaElementImpl { }
+
+module.exports = {
+  implementation: HTMLAudioElementImpl
+};

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

@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLBRElementImpl extends HTMLElementImpl { }
+
+module.exports = {
+  implementation: HTMLBRElementImpl
+};

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

@@ -0,0 +1,27 @@
+"use strict";
+const whatwgURL = require("whatwg-url");
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const { fallbackBaseURL } = require("../helpers/document-base-url");
+
+class HTMLBaseElementImpl extends HTMLElementImpl {
+  get href() {
+    const document = this._ownerDocument;
+
+    const url = this.hasAttributeNS(null, "href") ? this.getAttributeNS(null, "href") : "";
+    const parsed = whatwgURL.parseURL(url, { baseURL: fallbackBaseURL(document) });
+
+    if (parsed === null) {
+      return url;
+    }
+
+    return whatwgURL.serializeURL(parsed);
+  }
+
+  set href(value) {
+    this.setAttributeNS(null, "href", value);
+  }
+}
+
+module.exports = {
+  implementation: HTMLBaseElementImpl
+};

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

@@ -0,0 +1,17 @@
+"use strict";
+const { mixin } = require("../../utils");
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const WindowEventHandlersImpl = require("./WindowEventHandlers-impl").implementation;
+
+class HTMLBodyElementImpl extends HTMLElementImpl {
+  constructor(...args) {
+    super(...args);
+    this._proxyWindowEventsToWindow();
+  }
+}
+
+mixin(HTMLBodyElementImpl.prototype, WindowEventHandlersImpl.prototype);
+
+module.exports = {
+  implementation: HTMLBodyElementImpl
+};

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

@@ -0,0 +1,79 @@
+"use strict";
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const DefaultConstraintValidationImpl =
+  require("../constraint-validation/DefaultConstraintValidation-impl").implementation;
+const { mixin } = require("../../utils");
+const { isDisabled, formOwner, getLabelsForLabelable } = require("../helpers/form-controls");
+const { asciiLowercase } = require("../helpers/strings");
+
+class HTMLButtonElementImpl extends HTMLElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this._customValidityErrorMessage = "";
+    this._labels = null;
+
+    this._hasActivationBehavior = true;
+  }
+
+  _activationBehavior() {
+    const { form } = this;
+    if (form && !isDisabled(this)) {
+      if (this.type === "submit") {
+        form._doRequestSubmit(this);
+      }
+      if (this.type === "reset") {
+        form._doReset();
+      }
+    }
+  }
+
+  _getValue() {
+    const valueAttr = this.getAttributeNS(null, "value");
+    return valueAttr === null ? "" : valueAttr;
+  }
+
+  get labels() {
+    return getLabelsForLabelable(this);
+  }
+
+  get form() {
+    return formOwner(this);
+  }
+
+  get type() {
+    const typeAttr = asciiLowercase(this.getAttributeNS(null, "type") || "");
+    switch (typeAttr) {
+      case "submit":
+      case "reset":
+      case "button":
+        return typeAttr;
+      default:
+        return "submit";
+    }
+  }
+
+  set type(v) {
+    v = asciiLowercase(String(v));
+    switch (v) {
+      case "submit":
+      case "reset":
+      case "button":
+        this.setAttributeNS(null, "type", v);
+        break;
+      default:
+        this.setAttributeNS(null, "type", "submit");
+        break;
+    }
+  }
+
+  _barredFromConstraintValidationSpecialization() {
+    return this.type === "reset" || this.type === "button";
+  }
+}
+
+mixin(HTMLButtonElementImpl.prototype, DefaultConstraintValidationImpl.prototype);
+
+module.exports = {
+  implementation: HTMLButtonElementImpl
+};

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

@@ -0,0 +1,130 @@
+"use strict";
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const notImplemented = require("../../browser/not-implemented");
+const idlUtils = require("../generated/utils");
+const { Canvas } = require("../../utils");
+
+class HTMLCanvasElementImpl extends HTMLElementImpl {
+  _attrModified(name, value, oldValue) {
+    if (this._canvas && (name === "width" || name === "height")) {
+      this._canvas[name] = parseInt(value);
+    }
+
+    super._attrModified(name, value, oldValue);
+  }
+
+  _getCanvas() {
+    if (Canvas && !this._canvas) {
+      this._canvas = Canvas.createCanvas(this.width, this.height);
+    }
+    return this._canvas;
+  }
+
+  getContext(contextId) {
+    const canvas = this._getCanvas();
+    if (canvas) {
+      if (!this._context) {
+        this._context = canvas.getContext(contextId) || null;
+        if (this._context) {
+          // Override the native canvas reference with our wrapper. This is the
+          // reason why we need to locally cache _context, since each call to
+          // canvas.getContext(contextId) would replace this reference again.
+          // Perhaps in the longer term, a better solution would be to create a
+          // full wrapper for the Context object as well.
+          this._context.canvas = idlUtils.wrapperForImpl(this);
+          wrapNodeCanvasMethod(this._context, "createPattern");
+          wrapNodeCanvasMethod(this._context, "drawImage");
+        }
+      }
+      return this._context;
+    }
+
+    notImplemented(
+      "HTMLCanvasElement.prototype.getContext (without installing the canvas npm package)",
+      this._ownerDocument._defaultView
+    );
+    return null;
+  }
+
+  toDataURL(...args) {
+    const canvas = this._getCanvas();
+    if (canvas) {
+      return canvas.toDataURL(...args);
+    }
+
+    notImplemented(
+      "HTMLCanvasElement.prototype.toDataURL (without installing the canvas npm package)",
+      this._ownerDocument._defaultView
+    );
+    return null;
+  }
+
+  toBlob(callback, type, qualityArgument) {
+    const window = this._ownerDocument._defaultView;
+    const canvas = this._getCanvas();
+    if (canvas) {
+      const options = {};
+      switch (type) {
+        case "image/jpg":
+        case "image/jpeg":
+          type = "image/jpeg";
+          options.quality = qualityArgument;
+          break;
+        default:
+          type = "image/png";
+      }
+      canvas.toBuffer((err, buff) => {
+        if (err) {
+          throw err;
+        }
+        callback(new window.Blob([buff], { type }));
+      }, type, options);
+    } else {
+      notImplemented(
+        "HTMLCanvasElement.prototype.toBlob (without installing the canvas npm package)",
+        window
+      );
+    }
+  }
+
+  get width() {
+    const parsed = parseInt(this.getAttributeNS(null, "width"));
+    return isNaN(parsed) || parsed < 0 || parsed > 2147483647 ? 300 : parsed;
+  }
+
+  set width(v) {
+    v = v > 2147483647 ? 300 : v;
+    this.setAttributeNS(null, "width", String(v));
+  }
+
+  get height() {
+    const parsed = parseInt(this.getAttributeNS(null, "height"));
+    return isNaN(parsed) || parsed < 0 || parsed > 2147483647 ? 150 : parsed;
+  }
+
+  set height(v) {
+    v = v > 2147483647 ? 150 : v;
+    this.setAttributeNS(null, "height", String(v));
+  }
+}
+
+// We need to wrap the methods that receive an image or canvas object
+// (luckily, always as the first argument), so that these objects can be
+// unwrapped an the expected types passed.
+function wrapNodeCanvasMethod(ctx, name) {
+  const prev = ctx[name];
+  ctx[name] = function (image, ...rest) {
+    const impl = idlUtils.implForWrapper(image);
+    if (impl) {
+      if (impl instanceof HTMLCanvasElementImpl && !impl._canvas) {
+        impl._getCanvas();
+      }
+      image = impl._image || impl._canvas;
+    }
+    return prev.call(ctx, image, ...rest);
+  };
+}
+
+module.exports = {
+  implementation: HTMLCanvasElementImpl
+};

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

@@ -0,0 +1,96 @@
+"use strict";
+
+const idlUtils = require("../generated/utils.js");
+const { HTML_NS } = require("../helpers/namespaces");
+
+exports.implementation = class HTMLCollectionImpl {
+  constructor(globalObject, args, privateData) {
+    this._list = [];
+    this._version = -1;
+    this._element = privateData.element;
+    this._query = privateData.query;
+
+    this._globalObject = globalObject;
+
+    this._update();
+  }
+  get length() {
+    this._update();
+    return this._list.length;
+  }
+  item(index) {
+    this._update();
+    return this._list[index] || null;
+  }
+  namedItem(key) {
+    if (key === "") {
+      return null;
+    }
+    this._update();
+    for (const element of this._list) {
+      if (element.getAttributeNS(null, "id") === key) {
+        return element;
+      }
+      if (element._namespaceURI === HTML_NS) {
+        const name = element.getAttributeNS(null, "name");
+        if (name === key) {
+          return element;
+        }
+      }
+    }
+    return null;
+  }
+  _update() {
+    if (this._version < this._element._version) {
+      const snapshot = this._query();
+      for (let i = 0; i < snapshot.length; i++) {
+        this._list[i] = snapshot[i];
+      }
+      this._list.length = snapshot.length;
+      this._version = this._element._version;
+    }
+  }
+  get [idlUtils.supportedPropertyIndices]() {
+    this._update();
+    return this._list.keys();
+  }
+  get [idlUtils.supportedPropertyNames]() {
+    this._update();
+    const result = new Set();
+    for (const element of this._list) {
+      const id = element.getAttributeNS(null, "id");
+      if (id) {
+        result.add(id);
+      }
+      if (element._namespaceURI === HTML_NS) {
+        const name = element.getAttributeNS(null, "name");
+        if (name) {
+          result.add(name);
+        }
+      }
+    }
+    return result;
+  }
+
+  // Inherit some useful functions from Array.
+  [Symbol.iterator]() {
+    this._update();
+    return this._list[Symbol.iterator]();
+  }
+  entries() {
+    this._update();
+    return this._list.entries();
+  }
+  filter(...args) {
+    this._update();
+    return this._list.filter(...args);
+  }
+  map(...args) {
+    this._update();
+    return this._list.map(...args);
+  }
+  indexOf(...args) {
+    this._update();
+    return this._list.indexOf(...args);
+  }
+};

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

@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLDListElementImpl extends HTMLElementImpl { }
+
+module.exports = {
+  implementation: HTMLDListElementImpl
+};

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

@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLDataElementImpl extends HTMLElementImpl { }
+
+module.exports = {
+  implementation: HTMLDataElementImpl
+};

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

@@ -0,0 +1,20 @@
+"use strict";
+
+const HTMLCollection = require("../generated/HTMLCollection");
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+const { descendantsByLocalName } = require("../helpers/traversal");
+
+class HTMLDataListElementImpl extends HTMLElementImpl {
+  // https://html.spec.whatwg.org/multipage/form-elements.html#dom-datalist-options
+  get options() {
+    return HTMLCollection.createImpl(this._globalObject, [], {
+      element: this,
+      query: () => descendantsByLocalName(this, "option")
+    });
+  }
+}
+
+module.exports = {
+  implementation: HTMLDataListElementImpl
+};