vasuzex 2.0.13 → 2.0.15

package/frontend/react-ui/node_modules/jsdom/lib/jsdom/living/events/KeyboardEvent-impl.js

@@ -0,0 +1,29 @@
+"use strict";
+
+const { mixin } = require("../../utils");
+const EventModifierMixinImpl = require("./EventModifierMixin-impl").implementation;
+const UIEventImpl = require("./UIEvent-impl").implementation;
+
+const KeyboardEventInit = require("../generated/KeyboardEventInit");
+
+class KeyboardEventImpl extends UIEventImpl {
+  initKeyboardEvent(type, bubbles, cancelable, view, key, location, ctrlKey, altKey, shiftKey, metaKey) {
+    if (this._dispatchFlag) {
+      return;
+    }
+
+    this.initUIEvent(type, bubbles, cancelable, view, 0);
+    this.key = key;
+    this.location = location;
+    this.ctrlKey = ctrlKey;
+    this.altKey = altKey;
+    this.shiftKey = shiftKey;
+    this.metaKey = metaKey;
+  }
+}
+mixin(KeyboardEventImpl.prototype, EventModifierMixinImpl.prototype);
+KeyboardEventImpl.defaultInit = KeyboardEventInit.convert(undefined, undefined);
+
+module.exports = {
+  implementation: KeyboardEventImpl
+};

package/frontend/react-ui/node_modules/jsdom/lib/jsdom/living/events/MessageEvent-impl.js

@@ -0,0 +1,25 @@
+"use strict";
+
+const EventImpl = require("./Event-impl").implementation;
+
+const MessageEventInit = require("../generated/MessageEventInit");
+
+class MessageEventImpl extends EventImpl {
+  initMessageEvent(type, bubbles, cancelable, data, origin, lastEventId, source, ports) {
+    if (this._dispatchFlag) {
+      return;
+    }
+
+    this.initEvent(type, bubbles, cancelable);
+    this.data = data;
+    this.origin = origin;
+    this.lastEventId = lastEventId;
+    this.source = source;
+    this.ports = ports;
+  }
+}
+MessageEventImpl.defaultInit = MessageEventInit.convert(undefined, undefined);
+
+module.exports = {
+  implementation: MessageEventImpl
+};

package/frontend/react-ui/node_modules/jsdom/lib/jsdom/living/events/MouseEvent-impl.js

@@ -0,0 +1,72 @@
+"use strict";
+
+const { mixin } = require("../../utils");
+const EventModifierMixinImpl = require("./EventModifierMixin-impl").implementation;
+const UIEventImpl = require("./UIEvent-impl").implementation;
+
+const MouseEventInit = require("../generated/MouseEventInit");
+
+class MouseEventImpl extends UIEventImpl {
+  get x() {
+    return this.clientX;
+  }
+  get y() {
+    return this.clientY;
+  }
+  get pageX() {
+    // TODO: consider dispatch flag and return page-relative event coordinate once layout is supported
+    return this.clientX; // TODO: add horizontal scroll offset once jsdom implements scrolling support
+  }
+  get pageY() {
+    // TODO: consider dispatch flag and return page-relative event coordinate once layout is supported
+    return this.clientY; // TODO: add vertical scroll offset once jsdom implements scrolling support
+  }
+  get offsetX() {
+    // TODO: consider dispatch flag and return target-relative event coordinate once layout is supported
+    return this.pageX;
+  }
+  get offsetY() {
+    // TODO: consider dispatch flag and return target-relative event coordinate once layout is supported
+    return this.pageY;
+  }
+
+  initMouseEvent(
+    type,
+    bubbles,
+    cancelable,
+    view,
+    detail,
+    screenX,
+    screenY,
+    clientX,
+    clientY,
+    ctrlKey,
+    altKey,
+    shiftKey,
+    metaKey,
+    button,
+    relatedTarget
+  ) {
+    if (this._dispatchFlag) {
+      return;
+    }
+
+    this.initUIEvent(type, bubbles, cancelable, view, detail);
+    this.screenX = screenX;
+    this.screenY = screenY;
+    this.clientX = clientX;
+    this.clientY = clientY;
+    this.ctrlKey = ctrlKey;
+    this.altKey = altKey;
+    this.shiftKey = shiftKey;
+    this.metaKey = metaKey;
+    this.button = button;
+    this.relatedTarget = relatedTarget;
+  }
+}
+mixin(MouseEventImpl.prototype, EventModifierMixinImpl.prototype);
+MouseEventImpl.defaultInit = MouseEventInit.convert(undefined, undefined);
+
+module.exports = {
+  implementation: MouseEventImpl
+};

package/frontend/react-ui/node_modules/jsdom/lib/jsdom/living/events/PageTransitionEvent-impl.js

@@ -0,0 +1,20 @@
+"use strict";
+
+const EventImpl = require("./Event-impl").implementation;
+
+const PageTransitionEventInit = require("../generated/PageTransitionEventInit");
+
+// https://html.spec.whatwg.org/multipage/browsing-the-web.html#pagetransitionevent
+class PageTransitionEventImpl extends EventImpl {
+  initPageTransitionEvent(type, bubbles, cancelable, persisted) {
+    if (this._dispatchFlag) {
+      return;
+    }
+
+    this.initEvent(type, bubbles, cancelable);
+    this.persisted = persisted;
+  }
+}
+PageTransitionEventImpl.defaultInit = PageTransitionEventInit.convert(undefined, undefined);
+
+exports.implementation = PageTransitionEventImpl;

package/frontend/react-ui/node_modules/jsdom/lib/jsdom/living/events/PopStateEvent-impl.js

@@ -0,0 +1,9 @@
+"use strict";
+const EventImpl = require("./Event-impl.js").implementation;
+
+const PopStateEventInit = require("../generated/PopStateEventInit");
+
+class PopStateEventImpl extends EventImpl {}
+PopStateEventImpl.defaultInit = PopStateEventInit.convert(undefined, undefined);
+
+exports.implementation = PopStateEventImpl;

package/frontend/react-ui/node_modules/jsdom/lib/jsdom/living/events/ProgressEvent-impl.js

@@ -0,0 +1,14 @@
+"use strict";
+
+const EventImpl = require("./Event-impl").implementation;
+
+const ProgressEventInit = require("../generated/ProgressEventInit");
+
+class ProgressEventImpl extends EventImpl {
+
+}
+ProgressEventImpl.defaultInit = ProgressEventInit.convert(undefined, undefined);
+
+module.exports = {
+  implementation: ProgressEventImpl
+};

package/frontend/react-ui/node_modules/jsdom/lib/jsdom/living/events/StorageEvent-impl.js

@@ -0,0 +1,26 @@
+"use strict";
+
+const EventImpl = require("./Event-impl").implementation;
+
+const StorageEventInit = require("../generated/StorageEventInit");
+
+// https://html.spec.whatwg.org/multipage/webstorage.html#the-storageevent-interface
+class StorageEventImpl extends EventImpl {
+  initStorageEvent(type, bubbles, cancelable, key, oldValue, newValue, url, storageArea) {
+    if (this._dispatchFlag) {
+      return;
+    }
+
+    this.initEvent(type, bubbles, cancelable);
+    this.key = key;
+    this.oldValue = oldValue;
+    this.newValue = newValue;
+    this.url = url;
+    this.storageArea = storageArea;
+  }
+}
+StorageEventImpl.defaultInit = StorageEventInit.convert(undefined, undefined);
+
+module.exports = {
+  implementation: StorageEventImpl
+};

package/frontend/react-ui/node_modules/jsdom/lib/jsdom/living/events/SubmitEvent-impl.js

@@ -0,0 +1,13 @@
+"use strict";
+
+const EventImpl = require("./Event-impl").implementation;
+
+const SubmitEventInit = require("../generated/SubmitEventInit");
+
+// https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#the-submitevent-interface
+class SubmitEventImpl extends EventImpl {}
+SubmitEventImpl.defaultInit = SubmitEventInit.convert(undefined, undefined);
+
+module.exports = {
+  implementation: SubmitEventImpl
+};

package/frontend/react-ui/node_modules/jsdom/lib/jsdom/living/events/TouchEvent-impl.js

@@ -0,0 +1,14 @@
+"use strict";
+
+const UIEventImpl = require("./UIEvent-impl").implementation;
+
+const TouchEventInit = require("../generated/TouchEventInit");
+
+class TouchEventImpl extends UIEventImpl {
+
+}
+TouchEventImpl.defaultInit = TouchEventInit.convert(undefined, undefined);
+
+module.exports = {
+  implementation: TouchEventImpl
+};

package/frontend/react-ui/node_modules/jsdom/lib/jsdom/living/events/UIEvent-impl.js

@@ -0,0 +1,59 @@
+"use strict";
+
+const idlUtils = require("../generated/utils");
+const UIEventInit = require("../generated/UIEventInit");
+const EventImpl = require("./Event-impl").implementation;
+
+// Until webidl2js gains support for checking for Window, this would have to do.
+function isWindow(val) {
+  if (typeof val !== "object") {
+    return false;
+  }
+  const wrapper = idlUtils.wrapperForImpl(val);
+  if (typeof wrapper === "object") {
+    return wrapper === wrapper._globalProxy;
+  }
+
+  // `val` may be either impl or wrapper currently, because webidl2js currently unwraps Window objects (and their global
+  // proxies) to their underlying EventTargetImpl during conversion, which is not what we want. But at the same time,
+  // some internal usage call this constructor with the actual global proxy.
+  return isWindow(idlUtils.implForWrapper(val));
+}
+
+class UIEventImpl extends EventImpl {
+  constructor(globalObject, args, privateData) {
+    const eventInitDict = args[1];
+
+    // undefined check included so that we can omit the property in internal usage.
+    if (eventInitDict && eventInitDict.view !== null && eventInitDict.view !== undefined) {
+      if (!isWindow(eventInitDict.view)) {
+        throw new TypeError(`Failed to construct '${new.target.name.replace(/Impl$/, "")}': member view is not of ` +
+                            "type Window.");
+      }
+    }
+
+    super(globalObject, args, privateData);
+  }
+
+  initUIEvent(type, bubbles, cancelable, view, detail) {
+    if (view !== null) {
+      if (!isWindow(view)) {
+        throw new TypeError(`Failed to execute 'initUIEvent' on '${this.constructor.name.replace(/Impl$/, "")}': ` +
+                            "parameter 4 is not of type 'Window'.");
+      }
+    }
+
+    if (this._dispatchFlag) {
+      return;
+    }
+
+    this.initEvent(type, bubbles, cancelable);
+    this.view = view;
+    this.detail = detail;
+  }
+}
+UIEventImpl.defaultInit = UIEventInit.convert(undefined, undefined);
+
+module.exports = {
+  implementation: UIEventImpl
+};

package/frontend/react-ui/node_modules/jsdom/lib/jsdom/living/events/WheelEvent-impl.js

@@ -0,0 +1,12 @@
+"use strict";
+
+const MouseEventImpl = require("./MouseEvent-impl").implementation;
+
+const WheelEventInit = require("../generated/WheelEventInit");
+
+class WheelEventImpl extends MouseEventImpl {}
+WheelEventImpl.defaultInit = WheelEventInit.convert(undefined, undefined);
+
+module.exports = {
+  implementation: WheelEventImpl
+};

package/frontend/react-ui/node_modules/jsdom/lib/jsdom/living/fetch/Headers-impl.js

@@ -0,0 +1,172 @@
+"use strict";
+
+const {
+  isForbidden,
+  isForbiddenResponse,
+  isPrivilegedNoCORSRequest,
+  isNoCORSSafelistedRequest,
+  isCORSWhitelisted
+} = require("./header-types");
+const HeaderList = require("./header-list");
+
+function assertName(name) {
+  if (!name.match(/^[!#$%&'*+\-.^`|~\w]+$/)) {
+    throw new TypeError("name is invalid");
+  }
+}
+
+function assertValue(value) {
+  if (value.match(/[\0\r\n]/)) {
+    throw new TypeError("value is invalid");
+  }
+}
+
+// https://fetch.spec.whatwg.org/#concept-header-value-normalize
+function normalizeValue(potentialValue) {
+  return potentialValue.replace(/^[\n\r\t ]+|[\n\r\t ]+$/g, "");
+}
+
+class HeadersImpl {
+  constructor(globalObject, args) {
+    this.guard = "none";
+    this.headersList = new HeaderList();
+
+    if (args[0]) {
+      this._fill(args[0]);
+    }
+  }
+
+  _fill(init) {
+    if (Array.isArray(init)) {
+      for (const header of init) {
+        if (header.length !== 2) {
+          throw new TypeError("init is invalid");
+        }
+        this.append(header[0], header[1]);
+      }
+    } else {
+      for (const key of Object.keys(init)) {
+        this.append(key, init[key]);
+      }
+    }
+  }
+
+  has(name) {
+    assertName(name);
+    return this.headersList.contains(name);
+  }
+
+  getSetCookie() {
+    return this.headersList.get("Set-Cookie") || [];
+  }
+
+  get(name) {
+    assertName(name);
+    const r = this.headersList.get(name);
+    if (!r) {
+      return null;
+    }
+    return r.join(", ");
+  }
+
+  _removePrivilegedNoCORSHeaders() {
+    this.headersList.delete("range");
+  }
+
+  append(name, value) {
+    value = normalizeValue(value);
+    assertName(name);
+    assertValue(value);
+
+    switch (this.guard) {
+      case "immutable":
+        throw new TypeError("Headers is immutable");
+      case "request":
+        if (isForbidden(name)) {
+          return;
+        }
+        break;
+      case "request-no-cors": {
+        if (!isCORSWhitelisted(name, value)) {
+          return;
+        }
+        break;
+      }
+      case "response":
+        if (isForbiddenResponse(name)) {
+          return;
+        }
+        break;
+    }
+
+    this.headersList.append(name, value);
+    this._removePrivilegedNoCORSHeaders();
+  }
+
+  set(name, value) {
+    value = normalizeValue(value);
+    assertName(name);
+    assertValue(value);
+
+    switch (this.guard) {
+      case "immutable":
+        throw new TypeError("Headers is immutable");
+      case "request":
+        if (isForbidden(name)) {
+          return;
+        }
+        break;
+      case "request-no-cors": {
+        if (!isCORSWhitelisted(name, value)) {
+          return;
+        }
+        break;
+      }
+      case "response":
+        if (isForbiddenResponse(name)) {
+          return;
+        }
+        break;
+    }
+    this.headersList.set(name, value);
+    this._removePrivilegedNoCORSHeaders();
+  }
+
+  delete(name) {
+    assertName(name);
+
+    switch (this.guard) {
+      case "immutable":
+        throw new TypeError("Headers is immutable");
+      case "request":
+        if (isForbidden(name)) {
+          return;
+        }
+        break;
+      case "request-no-cors": {
+        if (
+          !isNoCORSSafelistedRequest(name) &&
+          !isPrivilegedNoCORSRequest(name)
+        ) {
+          return;
+        }
+        break;
+      }
+      case "response":
+        if (isForbiddenResponse(name)) {
+          return;
+        }
+        break;
+    }
+    this.headersList.delete(name);
+    this._removePrivilegedNoCORSHeaders();
+  }
+
+  * [Symbol.iterator]() {
+    for (const header of this.headersList.sortAndCombine()) {
+      yield header;
+    }
+  }
+}
+
+exports.implementation = HeadersImpl;

package/frontend/react-ui/node_modules/jsdom/lib/jsdom/living/fetch/header-list.js

@@ -0,0 +1,65 @@
+"use strict";
+
+/**
+ * Provides some utility functions for somewhat efficiently modifying a
+ * collection of headers.
+ *
+ * Note that this class only operates on ByteStrings (which is also why we use
+ * toLowerCase internally).
+ */
+class HeaderList {
+  constructor() {
+    this.headers = new Map();
+  }
+
+  append(name, value) {
+    const existing = this.headers.get(name.toLowerCase());
+    if (existing) {
+      existing.push(value);
+    } else {
+      this.headers.set(name.toLowerCase(), [value]);
+    }
+  }
+
+  contains(name) {
+    return this.headers.has(name.toLowerCase());
+  }
+
+  get(name) {
+    name = name.toLowerCase();
+    const values = this.headers.get(name);
+    if (!values) {
+      return null;
+    }
+    return values;
+  }
+
+  delete(name) {
+    this.headers.delete(name.toLowerCase());
+  }
+
+  set(name, value) {
+    const lowerName = name.toLowerCase();
+    this.headers.delete(lowerName);
+    this.headers.set(lowerName, [value]);
+  }
+
+  sortAndCombine() {
+    const names = [...this.headers.keys()].sort();
+
+    const headers = [];
+    for (const name of names) {
+      if (name === "set-cookie") {
+        for (const value of this.get(name)) {
+          headers.push([name, value]);
+        }
+      } else {
+        headers.push([name, this.get(name).join(", ")]);
+      }
+    }
+
+    return headers;
+  }
+}
+
+module.exports = HeaderList;

package/frontend/react-ui/node_modules/jsdom/lib/jsdom/living/fetch/header-types.js

@@ -0,0 +1,103 @@
+"use strict";
+
+const MIMEType = require("whatwg-mimetype");
+
+const PRIVILEGED_NO_CORS_REQUEST = new Set(["range"]);
+function isPrivilegedNoCORSRequest(name) {
+  return PRIVILEGED_NO_CORS_REQUEST.has(name.toLowerCase());
+}
+
+const NO_CORS_SAFELISTED_REQUEST = new Set([
+  `accept`,
+  `accept-language`,
+  `content-language`,
+  `content-type`
+]);
+function isNoCORSSafelistedRequest(name) {
+  return NO_CORS_SAFELISTED_REQUEST.has(name.toLowerCase());
+}
+
+const FORBIDDEN = new Set([
+  `accept-charset`,
+  `accept-encoding`,
+  `access-control-request-headers`,
+  `access-control-request-method`,
+  `connection`,
+  `content-length`,
+  `cookie`,
+  `cookie2`,
+  `date`,
+  `dnt`,
+  `expect`,
+  `host`,
+  `keep-alive`,
+  `origin`,
+  `referer`,
+  `te`,
+  `trailer`,
+  `transfer-encoding`,
+  `upgrade`,
+  `via`
+]);
+function isForbidden(name) {
+  name = name.toLowerCase();
+  return (
+    FORBIDDEN.has(name) || name.startsWith("proxy-") || name.startsWith("sec-")
+  );
+}
+
+const FORBIDDEN_RESPONSE = new Set(["set-cookie", "set-cookie2"]);
+function isForbiddenResponse(name) {
+  return FORBIDDEN_RESPONSE.has(name.toLowerCase());
+}
+
+const CORS_UNSAFE_BYTE = /[\x00-\x08\x0A-\x1F"():<>?@[\\\]{}\x7F]/;
+function isCORSWhitelisted(name, value) {
+  name = name.toLowerCase();
+  switch (name) {
+    case "accept":
+      if (value.match(CORS_UNSAFE_BYTE)) {
+        return false;
+      }
+      break;
+    case "accept-language":
+    case "content-language":
+      if (value.match(/[^\x30-\x39\x41-\x5A\x61-\x7A *,\-.;=]/)) {
+        return false;
+      }
+      break;
+    case "content-type": {
+      if (value.match(CORS_UNSAFE_BYTE)) {
+        return false;
+      }
+      const mimeType = MIMEType.parse(value);
+      if (mimeType === null) {
+        return false;
+      }
+      if (
+        ![
+          "application/x-www-form-urlencoded",
+          "multipart/form-data",
+          "text/plain"
+        ].includes(mimeType.essence)
+      ) {
+        return false;
+      }
+      break;
+    }
+    default:
+      return false;
+  }
+  if (Buffer.from(value).length > 128) {
+    return false;
+  }
+  return true;
+}
+
+module.exports = {
+  isPrivilegedNoCORSRequest,
+  isNoCORSSafelistedRequest,
+  isForbidden,
+  isForbiddenResponse,
+  isCORSWhitelisted
+};