@zipify/wysiwyg 1.1.1 → 1.2.0

package/node_modules_lambda/jsdom/lib/jsdom/living/websockets/WebSocket-impl.js

@@ -0,0 +1,328 @@
+"use strict";
+
+const nodeURL = require("url");
+
+const DOMException = require("domexception/webidl2js-wrapper");
+const { parseURL, serializeURL, serializeURLOrigin } = require("whatwg-url");
+const WebSocket = require("ws");
+
+const { setupForSimpleEventAccessors } = require("../helpers/create-event-accessor");
+const { fireAnEvent } = require("../helpers/events");
+const { isArrayBuffer } = require("../generated/utils");
+const { copyToArrayBufferInNewRealm } = require("../helpers/binary-data");
+
+const EventTargetImpl = require("../events/EventTarget-impl").implementation;
+
+const idlUtils = require("../generated/utils");
+const Blob = require("../generated/Blob");
+const CloseEvent = require("../generated/CloseEvent");
+const MessageEvent = require("../generated/MessageEvent");
+
+const CONNECTING = 0;
+const OPEN = 1;
+const CLOSING = 2;
+const CLOSED = 3;
+
+const productions = {
+  // https://tools.ietf.org/html/rfc7230#section-3.2.6
+  token: /^[!#$%&'*+\-.^_`|~\dA-Za-z]+$/
+};
+
+const readyStateWSToDOM = [];
+readyStateWSToDOM[WebSocket.CONNECTING] = CONNECTING;
+readyStateWSToDOM[WebSocket.OPEN] = OPEN;
+readyStateWSToDOM[WebSocket.CLOSING] = CLOSING;
+readyStateWSToDOM[WebSocket.CLOSED] = CLOSED;
+
+// https://tools.ietf.org/html/rfc6455#section-4.3
+// See Sec-WebSocket-Protocol-Client, which is for the syntax of an entire header value. This function checks if a
+// single header conforms to the rules.
+function verifySecWebSocketProtocol(str) {
+  return productions.token.test(str);
+}
+
+class PromiseQueues extends WeakMap {
+  get(window) {
+    const cur = super.get(window);
+    return cur !== undefined ? cur : Promise.resolve();
+  }
+}
+
+const openSockets = new WeakMap();
+const openingQueues = new PromiseQueues();
+
+class WebSocketImpl extends EventTargetImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this._ownerDocument = idlUtils.implForWrapper(globalObject._document);
+
+    const url = args[0];
+    let protocols = args[1] !== undefined ? args[1] : [];
+
+    const urlRecord = parseURL(url);
+    if (urlRecord === null) {
+      throw DOMException.create(this._globalObject, [`The URL '${url}' is invalid.`, "SyntaxError"]);
+    }
+    if (urlRecord.scheme !== "ws" && urlRecord.scheme !== "wss") {
+      throw DOMException.create(this._globalObject, [
+        `The URL's scheme must be either 'ws' or 'wss'. '${urlRecord.scheme}' is not allowed.`,
+        "SyntaxError"
+      ]);
+    }
+    if (urlRecord.fragment !== null) {
+      throw DOMException.create(this._globalObject, [
+        `The URL contains a fragment identifier ('${urlRecord.fragment}'). Fragment identifiers ` +
+        "are not allowed in WebSocket URLs.",
+        "SyntaxError"
+      ]);
+    }
+
+    if (typeof protocols === "string") {
+      protocols = [protocols];
+    }
+    const protocolSet = new Set();
+    for (const protocol of protocols) {
+      if (!verifySecWebSocketProtocol(protocol)) {
+        throw DOMException.create(this._globalObject, [`The subprotocol '${protocol}' is invalid.`, "SyntaxError"]);
+      }
+      const lowered = protocol.toLowerCase();
+      if (protocolSet.has(lowered)) {
+        throw DOMException.create(this._globalObject, [
+          `The subprotocol '${protocol}' is duplicated.`,
+          "SyntaxError"
+        ]);
+      }
+      protocolSet.add(lowered);
+    }
+
+    this._urlRecord = urlRecord;
+    this.url = serializeURL(urlRecord);
+    const nodeParsedURL = nodeURL.parse(this.url);
+    this.extensions = "";
+
+    this.binaryType = "blob";
+
+    this._ws = null;
+    // Used when this._ws has not been initialized yet.
+    this._readyState = CONNECTING;
+    this._requiredToFail = false;
+    this.bufferedAmount = 0;
+    this._sendQueue = [];
+
+    let openSocketsForWindow = openSockets.get(globalObject._globalProxy);
+    if (openSocketsForWindow === undefined) {
+      openSocketsForWindow = new Set();
+      openSockets.set(globalObject._globalProxy, openSocketsForWindow);
+    }
+    openSocketsForWindow.add(this);
+
+    openingQueues.set(this._ownerDocument, openingQueues.get(this._ownerDocument).then(() => new Promise(resolve => {
+      // close() called before _ws has been initialized.
+      if (this._requiredToFail) {
+        resolve();
+        this._readyState = CLOSED;
+        this._onConnectionClosed(1006, "");
+        return;
+      }
+
+      this._ws = new WebSocket(this.url, protocols, {
+        headers: {
+          "user-agent": globalObject.navigator.userAgent,
+          "cookie": this._ownerDocument._cookieJar.getCookieStringSync(nodeParsedURL, { http: true }),
+          "origin": globalObject._origin
+        },
+        rejectUnauthorized: globalObject._resourceLoader._strictSSL
+      });
+      this._ws.once("open", () => {
+        resolve();
+        this._onConnectionEstablished();
+      });
+      this._ws.on("message", this._onMessageReceived.bind(this));
+      this._ws.once("close", (...closeArgs) => {
+        resolve();
+        this._onConnectionClosed(...closeArgs);
+      });
+      this._ws.once("upgrade", ({ headers }) => {
+        if (Array.isArray(headers["set-cookie"])) {
+          for (const cookie of headers["set-cookie"]) {
+            this._ownerDocument._cookieJar.setCookieSync(
+              cookie,
+              nodeParsedURL,
+              { http: true, ignoreError: true }
+            );
+          }
+        } else if (headers["set-cookie"] !== undefined) {
+          this._ownerDocument._cookieJar.setCookieSync(
+            headers["set-cookie"],
+            nodeParsedURL,
+            { http: true, ignoreError: true }
+          );
+        }
+      });
+      this._ws.once("error", () => {
+        // The exact error is passed into this callback, but it is ignored as we don't really care about it.
+        resolve();
+        this._requiredToFail = true;
+        // Do not emit an error here, as that will be handled in _onConnectionClosed. ws always emits a close event
+        // after errors.
+      });
+    })));
+  }
+
+  // https://html.spec.whatwg.org/multipage/web-sockets.html#make-disappear
+  _makeDisappear() {
+    this._eventListeners = Object.create(null);
+    this._close(1001);
+  }
+
+  static cleanUpWindow(window) {
+    const openSocketsForWindow = openSockets.get(window._globalProxy);
+    if (openSocketsForWindow !== undefined) {
+      for (const ws of openSocketsForWindow) {
+        ws._makeDisappear();
+      }
+    }
+  }
+
+  // https://html.spec.whatwg.org/multipage/web-sockets.html#feedback-from-the-protocol
+  _onConnectionEstablished() {
+    // readyState is a getter.
+    if (this._ws.extensions !== null) {
+      // Right now, ws only supports one extension, permessage-deflate, without any parameters. This algorithm may need
+      // to be more sophiscated as more extenions are supported.
+      this.extensions = Object.keys(this._ws.extensions).join(", ");
+    }
+    // protocol is a getter.
+    fireAnEvent("open", this);
+  }
+
+  _onMessageReceived(data, isBinary) {
+    if (this.readyState !== OPEN) {
+      return;
+    }
+    let dataForEvent;
+    if (!isBinary) {
+      dataForEvent = data.toString();
+    } else if (this.binaryType === "arraybuffer") {
+      if (isArrayBuffer(data)) {
+        dataForEvent = data;
+      } else if (Array.isArray(data)) {
+        dataForEvent = copyToArrayBufferInNewRealm(Buffer.concat(data), this._globalObject);
+      } else {
+        dataForEvent = copyToArrayBufferInNewRealm(data, this._globalObject);
+      }
+    } else { // this.binaryType === "blob"
+      if (!Array.isArray(data)) {
+        data = [data];
+      }
+      dataForEvent = Blob.create(this._globalObject, [data, { type: "" }]);
+    }
+    fireAnEvent("message", this, MessageEvent, {
+      data: dataForEvent,
+      origin: serializeURLOrigin(this._urlRecord)
+    });
+  }
+
+  _onConnectionClosed(code, reason) {
+    const openSocketsForWindow = openSockets.get(this._ownerDocument._defaultView);
+    openSocketsForWindow.delete(this);
+
+    const wasClean = !this._requiredToFail;
+    if (this._requiredToFail) {
+      fireAnEvent("error", this);
+    }
+    fireAnEvent("close", this, CloseEvent, {
+      wasClean,
+      code,
+      reason: reason.toString()
+    });
+  }
+
+  get readyState() {
+    if (this._ws !== null) {
+      return readyStateWSToDOM[this._ws.readyState];
+    }
+    return this._readyState;
+  }
+
+  get protocol() {
+    if (this._ws === null) {
+      return "";
+    }
+    return this._ws.protocol;
+  }
+
+  close(code = undefined, reason = undefined) {
+    if (code !== undefined && code !== 1000 && !(code >= 3000 && code <= 4999)) {
+      throw DOMException.create(this._globalObject, [
+        `The code must be either 1000, or between 3000 and 4999. ${code} is neither.`,
+        "InvalidAccessError"
+      ]);
+    }
+    if (reason !== undefined && Buffer.byteLength(reason, "utf8") > 123) {
+      throw DOMException.create(this._globalObject, [
+        "The message must not be greater than 123 bytes.",
+        "SyntaxError"
+      ]);
+    }
+    this._close(code, reason);
+  }
+
+  _close(code = undefined, reason = undefined) {
+    if (this.readyState === CONNECTING) {
+      this._requiredToFail = true;
+      if (this._ws !== null) {
+        this._ws.terminate();
+      } else {
+        this._readyState = CLOSING;
+      }
+    } else if (this.readyState === OPEN) {
+      this._ws.close(code, reason);
+    }
+  }
+
+  send(data) {
+    if (this.readyState === CONNECTING) {
+      throw DOMException.create(this._globalObject, ["Still in CONNECTING state.", "InvalidStateError"]);
+    }
+    if (this.readyState !== OPEN) {
+      return;
+    }
+    if (Blob.isImpl(data)) {
+      data = data._buffer;
+    }
+    let length;
+    if (typeof data === "string") {
+      length = Buffer.byteLength(data, "utf8");
+    } else {
+      length = data.byteLength;
+    }
+    this.bufferedAmount += length;
+    this._sendQueue.push([data, length]);
+    this._scheduleSend();
+  }
+
+  _actuallySend() {
+    for (const [data, length] of this._sendQueue.splice(0)) {
+      this._ws.send(data, { binary: typeof data !== "string" }, () => {
+        this.bufferedAmount -= length;
+      });
+    }
+  }
+
+  _scheduleSend() {
+    if (this._dequeueScheduled) {
+      return;
+    }
+    this._dequeueScheduled = true;
+    process.nextTick(() => {
+      this._dequeueScheduled = false;
+      this._actuallySend();
+    });
+  }
+}
+
+setupForSimpleEventAccessors(WebSocketImpl.prototype, ["open", "message", "error", "close"]);
+
+exports.implementation = WebSocketImpl;

package/node_modules_lambda/jsdom/lib/jsdom/living/webstorage/Storage-impl.js

@@ -0,0 +1,102 @@
+"use strict";
+
+const DOMException = require("domexception/webidl2js-wrapper");
+const StorageEvent = require("../generated/StorageEvent");
+const idlUtils = require("../generated/utils");
+const { fireAnEvent } = require("../helpers/events");
+
+// https://html.spec.whatwg.org/multipage/webstorage.html#the-storage-interface
+class StorageImpl {
+  constructor(globalObject, args, privateData) {
+    const { associatedWindow, storageArea, url, type, storageQuota } = privateData;
+
+    this._associatedWindow = associatedWindow;
+    this._items = storageArea;
+    this._url = url;
+    this._type = type;
+    this._quota = storageQuota;
+
+    this._globalObject = globalObject;
+  }
+
+  _dispatchStorageEvent(key, oldValue, newValue) {
+    return this._associatedWindow._currentOriginData.windowsInSameOrigin
+      .filter(target => target !== this._associatedWindow)
+      .forEach(target => fireAnEvent("storage", target, StorageEvent, {
+        key,
+        oldValue,
+        newValue,
+        url: this._url,
+        storageArea: target["_" + this._type]
+      }));
+  }
+
+  get length() {
+    return this._items.size;
+  }
+
+  key(n) {
+    if (n >= this._items.size) {
+      return null;
+    }
+    return [...this._items.keys()][n];
+  }
+
+  getItem(key) {
+    if (this._items.has(key)) {
+      return this._items.get(key);
+    }
+    return null;
+  }
+
+  setItem(key, value) {
+    const oldValue = this._items.get(key) || null;
+
+    if (oldValue === value) {
+      return;
+    }
+
+    // Concatenate all keys and values to measure their length against the quota
+    let itemsTotalLength = key.length + value.length;
+    for (const [curKey, curValue] of this._items) {
+      // If the key already exists, skip it as it will be set to the new value instead
+      if (key !== curKey) {
+        itemsTotalLength += curKey.length + curValue.length;
+      }
+    }
+    if (itemsTotalLength > this._quota) {
+      throw DOMException.create(this._globalObject, [
+        `The ${this._quota}-code unit storage quota has been exceeded.`,
+        "QuotaExceededError"
+      ]);
+    }
+
+    setTimeout(this._dispatchStorageEvent.bind(this), 0, key, oldValue, value);
+
+    this._items.set(key, value);
+  }
+
+  removeItem(key) {
+    if (this._items.has(key)) {
+      setTimeout(this._dispatchStorageEvent.bind(this), 0, key, this._items.get(key), null);
+
+      this._items.delete(key);
+    }
+  }
+
+  clear() {
+    if (this._items.size > 0) {
+      setTimeout(this._dispatchStorageEvent.bind(this), 0, null, null, null);
+
+      this._items.clear();
+    }
+  }
+
+  get [idlUtils.supportedPropertyNames]() {
+    return this._items.keys();
+  }
+}
+
+module.exports = {
+  implementation: StorageImpl
+};

package/node_modules_lambda/jsdom/lib/jsdom/living/window/BarProp-impl.js

@@ -0,0 +1,10 @@
+"use strict";
+
+// https://html.spec.whatwg.org/multipage/window-object.html#browser-interface-elements
+class BarPropImpl {}
+
+// Since many BarProps do not apply to modern browsers,
+// returning true in all cases seems to be common practice.
+BarPropImpl.prototype.visible = true;
+
+exports.implementation = BarPropImpl;

package/node_modules_lambda/jsdom/lib/jsdom/living/window/External-impl.js

@@ -0,0 +1,9 @@
+"use strict";
+
+// https://html.spec.whatwg.org/multipage/obsolete.html#dom-external
+exports.implementation = class ExternalImpl {
+  // The AddSearchProvider() and IsSearchProviderInstalled() methods must do nothing
+  AddSearchProvider() {}
+
+  IsSearchProviderInstalled() {}
+};

package/node_modules_lambda/jsdom/lib/jsdom/living/window/History-impl.js

@@ -0,0 +1,134 @@
+"use strict";
+const DOMException = require("domexception/webidl2js-wrapper");
+const { documentBaseURLSerialized, parseURLToResultingURLRecord } = require("../helpers/document-base-url.js");
+
+// https://html.spec.whatwg.org/#history-3
+exports.implementation = class HistoryImpl {
+  constructor(globalObject, args, privateData) {
+    this._window = privateData.window;
+    this._document = privateData.document;
+    this._actAsIfLocationReloadCalled = privateData.actAsIfLocationReloadCalled;
+    this._state = null;
+
+    this._globalObject = globalObject;
+  }
+
+  _guardAgainstInactiveDocuments() {
+    if (!this._window) {
+      throw DOMException.create(this._globalObject, [
+        "History object is associated with a document that is not fully active.",
+        "SecurityError"
+      ]);
+    }
+  }
+
+  get length() {
+    this._guardAgainstInactiveDocuments();
+
+    return this._window._sessionHistory.length;
+  }
+
+  get state() {
+    this._guardAgainstInactiveDocuments();
+
+    return this._state;
+  }
+
+  go(delta) {
+    this._guardAgainstInactiveDocuments();
+
+    if (delta === 0) {
+      // When the go(delta) method is invoked, if delta is zero, the user agent must act as
+      // if the location.reload() method was called instead.
+      this._actAsIfLocationReloadCalled();
+    } else {
+      // Otherwise, the user agent must traverse the history by a delta whose value is delta
+      this._window._sessionHistory.traverseByDelta(delta);
+    }
+  }
+
+  back() {
+    this.go(-1);
+  }
+
+  forward() {
+    this.go(+1);
+  }
+
+  pushState(data, title, url) {
+    this._sharedPushAndReplaceState(data, title, url, "pushState");
+  }
+  replaceState(data, title, url) {
+    this._sharedPushAndReplaceState(data, title, url, "replaceState");
+  }
+
+  // https://html.spec.whatwg.org/#dom-history-pushstate
+  _sharedPushAndReplaceState(data, title, url, methodName) {
+    this._guardAgainstInactiveDocuments();
+
+    // TODO structured clone data
+
+    let newURL;
+    if (url !== null) {
+      // Not implemented: use of entry settings object's API base URL. Instead we just use the document base URL. The
+      // difference matters in the case of cross-frame calls.
+      newURL = parseURLToResultingURLRecord(url, this._document);
+
+      if (newURL === null) {
+        throw DOMException.create(this._globalObject, [
+          `Could not parse url argument "${url}" to ${methodName} against base URL ` +
+          `"${documentBaseURLSerialized(this._document)}".`,
+          "SecurityError"
+        ]);
+      }
+
+      if (newURL.scheme !== this._document._URL.scheme ||
+          newURL.username !== this._document._URL.username ||
+          newURL.password !== this._document._URL.password ||
+          newURL.host !== this._document._URL.host ||
+          newURL.port !== this._document._URL.port ||
+          newURL.cannotBeABaseURL !== this._document._URL.cannotBeABaseURL) {
+        throw DOMException.create(this._globalObject, [
+          `${methodName} cannot update history to a URL which differs in components other than in ` +
+          `path, query, or fragment.`,
+          "SecurityError"
+        ]);
+      }
+
+      // Not implemented: origin check (seems to only apply to documents with weird origins, e.g. sandboxed ones)
+    } else {
+      newURL = this._window._sessionHistory.currentEntry.url;
+    }
+
+    if (methodName === "pushState") {
+      this._window._sessionHistory.removeAllEntriesAfterCurrentEntry();
+
+      this._window._sessionHistory.clearHistoryTraversalTasks();
+
+      const newEntry = {
+        document: this._document,
+        stateObject: data,
+        title,
+        url: newURL
+      };
+      this._window._sessionHistory.addEntryAfterCurrentEntry(newEntry);
+      this._window._sessionHistory.updateCurrentEntry(newEntry);
+    } else {
+      const { currentEntry } = this._window._sessionHistory;
+      currentEntry.stateObject = data;
+      currentEntry.title = title;
+      currentEntry.url = newURL;
+    }
+
+    // TODO: If the current entry in the session history represents a non-GET request
+    // (e.g. it was the result of a POST submission) then update it to instead represent
+    // a GET request.
+
+    this._document._URL = newURL;
+
+    // arguably it's a bit odd that the state and latestEntry do not belong to the SessionHistory
+    // but the spec gives them to "History" and "Document" respecively.
+    this._state = data; // TODO clone again!! O_o
+    this._document._latestEntry = this._window._sessionHistory.currentEntry;
+  }
+};