@zipify/wysiwyg 1.1.0 → 1.2.0

package/node_modules_lambda/jsdom/lib/jsdom/living/nodes/NodeList-impl.js

@@ -0,0 +1,43 @@
+"use strict";
+
+const idlUtils = require("../generated/utils.js");
+
+exports.implementation = class NodeListImpl {
+  constructor(globalObject, args, privateData) {
+    if (privateData.nodes) {
+      this._list = [...privateData.nodes];
+      this._isLive = false;
+    } else {
+      this._list = [];
+      this._isLive = true;
+      this._version = -1;
+      this._element = privateData.element;
+      this._query = privateData.query;
+      this._update();
+    }
+  }
+  get length() {
+    this._update();
+    return this._list.length;
+  }
+  item(index) {
+    this._update();
+    return this._list[index] || null;
+  }
+  _update() {
+    if (this._isLive) {
+      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();
+  }
+};

package/node_modules_lambda/jsdom/lib/jsdom/living/nodes/NonDocumentTypeChildNode-impl.js

@@ -0,0 +1,28 @@
+"use strict";
+
+const { domSymbolTree } = require("../helpers/internal-constants");
+const NODE_TYPE = require("../node-type");
+
+class NonDocumentTypeChildNodeImpl {
+  get nextElementSibling() {
+    for (const sibling of domSymbolTree.nextSiblingsIterator(this)) {
+      if (sibling.nodeType === NODE_TYPE.ELEMENT_NODE) {
+        return sibling;
+      }
+    }
+    return null;
+  }
+
+  get previousElementSibling() {
+    for (const sibling of domSymbolTree.previousSiblingsIterator(this)) {
+      if (sibling.nodeType === NODE_TYPE.ELEMENT_NODE) {
+        return sibling;
+      }
+    }
+    return null;
+  }
+}
+
+module.exports = {
+  implementation: NonDocumentTypeChildNodeImpl
+};

package/node_modules_lambda/jsdom/lib/jsdom/living/nodes/NonElementParentNode-impl.js

@@ -0,0 +1,11 @@
+"use strict";
+
+// https://dom.spec.whatwg.org/#interface-nonelementparentnode
+// getElementById is implemented separately inside Document and DocumentFragment.
+class NonElementParentNodeImpl {
+
+}
+
+module.exports = {
+  implementation: NonElementParentNodeImpl
+};

package/node_modules_lambda/jsdom/lib/jsdom/living/nodes/ParentNode-impl.js

@@ -0,0 +1,91 @@
+"use strict";
+
+const idlUtils = require("../generated/utils");
+const NodeList = require("../generated/NodeList");
+const HTMLCollection = require("../generated/HTMLCollection");
+const { addNwsapi } = require("../helpers/selectors");
+const { domSymbolTree } = require("../helpers/internal-constants");
+const NODE_TYPE = require("../node-type");
+const { convertNodesIntoNode } = require("../node");
+
+class ParentNodeImpl {
+  get children() {
+    if (!this._childrenList) {
+      this._childrenList = HTMLCollection.createImpl(this._globalObject, [], {
+        element: this,
+        query: () => domSymbolTree.childrenToArray(this, {
+          filter: node => node.nodeType === NODE_TYPE.ELEMENT_NODE
+        })
+      });
+    } else {
+      this._childrenList._update();
+    }
+    return this._childrenList;
+  }
+
+  get firstElementChild() {
+    for (const child of domSymbolTree.childrenIterator(this)) {
+      if (child.nodeType === NODE_TYPE.ELEMENT_NODE) {
+        return child;
+      }
+    }
+
+    return null;
+  }
+
+  get lastElementChild() {
+    for (const child of domSymbolTree.childrenIterator(this, { reverse: true })) {
+      if (child.nodeType === NODE_TYPE.ELEMENT_NODE) {
+        return child;
+      }
+    }
+
+    return null;
+  }
+
+  get childElementCount() {
+    return this.children.length;
+  }
+
+  prepend(...nodes) {
+    this._preInsert(convertNodesIntoNode(this._ownerDocument, nodes), this.firstChild);
+  }
+
+  append(...nodes) {
+    this._append(convertNodesIntoNode(this._ownerDocument, nodes));
+  }
+
+  replaceChildren(...nodes) {
+    const node = convertNodesIntoNode(this._ownerDocument, nodes);
+    this._preInsertValidity(node, null);
+    this._replaceAll(node);
+  }
+
+  querySelector(selectors) {
+    if (shouldAlwaysSelectNothing(this)) {
+      return null;
+    }
+    const matcher = addNwsapi(this);
+    return idlUtils.implForWrapper(matcher.first(selectors, idlUtils.wrapperForImpl(this)));
+  }
+
+  // Warning for internal users: this returns a NodeList containing IDL wrappers instead of impls
+  querySelectorAll(selectors) {
+    if (shouldAlwaysSelectNothing(this)) {
+      return NodeList.create(this._globalObject, [], { nodes: [] });
+    }
+    const matcher = addNwsapi(this);
+    const list = matcher.select(selectors, idlUtils.wrapperForImpl(this));
+
+    return NodeList.create(this._globalObject, [], { nodes: list.map(n => idlUtils.tryImplForWrapper(n)) });
+  }
+}
+
+function shouldAlwaysSelectNothing(elImpl) {
+  // This is true during initialization.
+  return elImpl === elImpl._ownerDocument && !elImpl.documentElement;
+}
+
+module.exports = {
+  implementation: ParentNodeImpl
+};

package/node_modules_lambda/jsdom/lib/jsdom/living/nodes/ProcessingInstruction-impl.js

@@ -0,0 +1,22 @@
+"use strict";
+
+const CharacterDataImpl = require("./CharacterData-impl").implementation;
+
+const NODE_TYPE = require("../node-type");
+
+class ProcessingInstructionImpl extends CharacterDataImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this.nodeType = NODE_TYPE.PROCESSING_INSTRUCTION_NODE;
+    this._target = privateData.target;
+  }
+
+  get target() {
+    return this._target;
+  }
+}
+
+module.exports = {
+  implementation: ProcessingInstructionImpl
+};

package/node_modules_lambda/jsdom/lib/jsdom/living/nodes/SVGElement-impl.js

@@ -0,0 +1,64 @@
+"use strict";
+
+const { domSymbolTree } = require("../helpers/internal-constants");
+const { SVG_NS } = require("../helpers/namespaces");
+const { mixin } = require("../../utils");
+const SVGAnimatedString = require("../generated/SVGAnimatedString");
+const ElementImpl = require("./Element-impl").implementation;
+const ElementCSSInlineStyleImpl = require("./ElementCSSInlineStyle-impl").implementation;
+const GlobalEventHandlersImpl = require("./GlobalEventHandlers-impl").implementation;
+const HTMLOrSVGElementImpl = require("./HTMLOrSVGElement-impl").implementation;
+
+class SVGElementImpl extends ElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+    this._initHTMLOrSVGElement();
+    this._initElementCSSInlineStyle();
+    this._initGlobalEvents();
+  }
+
+  // Keep in sync with HTMLElement. https://github.com/jsdom/jsdom/issues/2599
+  _attrModified(name, value, oldValue) {
+    if (name === "style" && value !== oldValue && !this._settingCssText) {
+      this._settingCssText = true;
+      this._style.cssText = value;
+      this._settingCssText = false;
+    } else if (name.startsWith("on")) {
+      this._globalEventChanged(name.substring(2));
+    }
+
+    super._attrModified(name, value, oldValue);
+  }
+
+  get className() {
+    return SVGAnimatedString.createImpl(this._globalObject, [], {
+      element: this,
+      attribute: "class"
+    });
+  }
+
+  get ownerSVGElement() {
+    let e = domSymbolTree.parent(this);
+    while (e && e.namespaceURI === SVG_NS) {
+      if (e.localName === "svg") {
+        return e;
+      }
+      e = domSymbolTree.parent(e);
+    }
+
+    return null;
+  }
+
+  get viewportElement() {
+    // TODO: <symbol>/<use> may make this different from ownerSVGElement.
+    return this.ownerSVGElement;
+  }
+}
+
+SVGElementImpl.attributeRegistry = new Map();
+
+mixin(SVGElementImpl.prototype, ElementCSSInlineStyleImpl.prototype);
+mixin(SVGElementImpl.prototype, GlobalEventHandlersImpl.prototype);
+mixin(SVGElementImpl.prototype, HTMLOrSVGElementImpl.prototype);
+
+exports.implementation = SVGElementImpl;

package/node_modules_lambda/jsdom/lib/jsdom/living/nodes/SVGGraphicsElement-impl.js

@@ -0,0 +1,16 @@
+"use strict";
+
+const { mixin } = require("../../utils");
+const SVGElementImpl = require("./SVGElement-impl").implementation;
+const SVGTestsImpl = require("./SVGTests-impl").implementation;
+
+class SVGGraphicsElementImpl extends SVGElementImpl {}
+
+SVGGraphicsElementImpl.attributeRegistry = new Map([
+  ...SVGElementImpl.attributeRegistry,
+  ...SVGTestsImpl.attributeRegistry
+]);
+
+mixin(SVGGraphicsElementImpl.prototype, SVGTestsImpl.prototype);
+
+exports.implementation = SVGGraphicsElementImpl;

package/node_modules_lambda/jsdom/lib/jsdom/living/nodes/SVGSVGElement-impl.js

@@ -0,0 +1,42 @@
+"use strict";
+
+const { mixin } = require("../../utils");
+const SVGNumber = require("../generated/SVGNumber");
+const SVGGraphicsElementImpl = require("./SVGGraphicsElement-impl").implementation;
+const WindowEventHandlersImpl = require("./WindowEventHandlers-impl").implementation;
+const { domSymbolTree } = require("../helpers/internal-constants");
+const { ELEMENT_NODE } = require("../node-type");
+
+class SVGSVGElementImpl extends SVGGraphicsElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+    this._proxyWindowEventsToWindow();
+  }
+
+  createSVGNumber() {
+    return SVGNumber.createImpl(this._globalObject, [], {});
+  }
+
+  getElementById(elementId) {
+    // TODO: optimize with _ids caching trick; see Document class.
+    for (const node of domSymbolTree.treeIterator(this)) {
+      if (node.nodeType === ELEMENT_NODE && node.getAttributeNS(null, "id") === elementId) {
+        return node;
+      }
+    }
+    return null;
+  }
+
+  suspendRedraw() {
+    return 1;
+  }
+  unsuspendRedraw() {}
+  unsuspendRedrawAll() {}
+  forceRedraw() {}
+}
+
+mixin(SVGSVGElementImpl.prototype, WindowEventHandlersImpl.prototype);
+
+module.exports = {
+  implementation: SVGSVGElementImpl
+};

package/node_modules_lambda/jsdom/lib/jsdom/living/nodes/SVGTests-impl.js

@@ -0,0 +1,42 @@
+"use strict";
+
+const { splitOnASCIIWhitespace, splitOnCommas } = require("../helpers/strings");
+const { reserializeCommaSeparatedTokens, reserializeSpaceSeparatedTokens } = require("../helpers/svg/basic-types");
+const SVGStringList = require("../generated/SVGStringList");
+
+class SVGTestsImpl {
+  get requiredExtensions() {
+    return SVGStringList.createImpl(this._globalObject, [], {
+      element: this,
+      attribute: "requiredExtensions"
+    });
+  }
+
+  get systemLanguage() {
+    return SVGStringList.createImpl(this._globalObject, [], {
+      element: this,
+      attribute: "systemLanguage"
+    });
+  }
+}
+
+SVGTestsImpl.attributeRegistry = new Map([
+  // https://svgwg.org/svg2-draft/struct.html#RequiredExtensionsAttribute
+  [
+    "requiredExtensions", {
+      getValue: splitOnASCIIWhitespace,
+      serialize: reserializeSpaceSeparatedTokens,
+      initialValue: undefined
+    }
+  ],
+  // https://svgwg.org/svg2-draft/struct.html#SystemLanguageAttribute
+  [
+    "systemLanguage", {
+      getValue: splitOnCommas,
+      serialize: reserializeCommaSeparatedTokens,
+      initialValue: undefined
+    }
+  ]
+]);
+
+exports.implementation = SVGTestsImpl;

package/node_modules_lambda/jsdom/lib/jsdom/living/nodes/SVGTitleElement-impl.js

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

package/node_modules_lambda/jsdom/lib/jsdom/living/nodes/ShadowRoot-impl.js

@@ -0,0 +1,40 @@
+"use strict";
+
+const { nodeRoot } = require("../helpers/node");
+const { mixin } = require("../../utils");
+
+const DocumentFragment = require("./DocumentFragment-impl").implementation;
+const DocumentOrShadowRootImpl = require("./DocumentOrShadowRoot-impl").implementation;
+const InnerHTMLImpl = require("../domparsing/InnerHTML-impl").implementation;
+
+class ShadowRootImpl extends DocumentFragment {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    const { mode } = privateData;
+    this._mode = mode;
+  }
+
+  _getTheParent(event) {
+    if (!event.composed && this === nodeRoot(event._path[0].item)) {
+      return null;
+    }
+
+    return this._host;
+  }
+
+  get mode() {
+    return this._mode;
+  }
+
+  get host() {
+    return this._host;
+  }
+}
+
+mixin(ShadowRootImpl.prototype, DocumentOrShadowRootImpl.prototype);
+mixin(ShadowRootImpl.prototype, InnerHTMLImpl.prototype);
+
+module.exports = {
+  implementation: ShadowRootImpl
+};

package/node_modules_lambda/jsdom/lib/jsdom/living/nodes/Slotable-impl.js

@@ -0,0 +1,48 @@
+"use strict";
+
+const { findSlot, assignSlot, assignSlotable } = require("../helpers/shadow-dom");
+
+// https://dom.spec.whatwg.org/#mixin-slotable
+// https://dom.spec.whatwg.org/#light-tree-slotables
+class SlotableMixinImpl {
+  _initSlotableMixin() {
+    this._slotableName = "";
+  }
+
+  _attrModifiedSlotableMixin(name, value, oldValue) {
+    if (name === "slot") {
+      if (value === oldValue) {
+        return;
+      }
+
+      if (value === null && oldValue === "") {
+        return;
+      }
+
+      if (value === "" && oldValue === null) {
+        return;
+      }
+
+      if (value === null || value === "") {
+        this._slotableName = "";
+      } else {
+        this._slotableName = value;
+      }
+
+
+      if (this._assignedSlot) {
+        assignSlotable(this._assignedSlot);
+      }
+
+      assignSlot(this);
+    }
+  }
+
+  get assignedSlot() {
+    return findSlot(this, "open");
+  }
+}
+
+module.exports = {
+  implementation: SlotableMixinImpl
+};

package/node_modules_lambda/jsdom/lib/jsdom/living/nodes/Text-impl.js

@@ -0,0 +1,96 @@
+"use strict";
+const SlotableMixinImpl = require("./Slotable-impl").implementation;
+const CharacterDataImpl = require("./CharacterData-impl").implementation;
+const idlUtils = require("../generated/utils");
+const { domSymbolTree } = require("../helpers/internal-constants");
+const DOMException = require("domexception/webidl2js-wrapper");
+const NODE_TYPE = require("../node-type");
+const { mixin } = require("../../utils");
+
+// https://dom.spec.whatwg.org/#text
+class TextImpl extends CharacterDataImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, {
+      data: args[0],
+      ownerDocument: idlUtils.implForWrapper(globalObject._document),
+      ...privateData
+    });
+
+    this._initSlotableMixin();
+
+    this.nodeType = NODE_TYPE.TEXT_NODE;
+  }
+
+  // https://dom.spec.whatwg.org/#dom-text-splittext
+  // https://dom.spec.whatwg.org/#concept-text-split
+  splitText(offset) {
+    const { length } = this;
+
+    if (offset > length) {
+      throw DOMException.create(this._globalObject, ["The index is not in the allowed range.", "IndexSizeError"]);
+    }
+
+    const count = length - offset;
+    const newData = this.substringData(offset, count);
+
+    const newNode = this._ownerDocument.createTextNode(newData);
+
+    const parent = domSymbolTree.parent(this);
+
+    if (parent !== null) {
+      parent._insert(newNode, this.nextSibling);
+
+      for (const range of this._referencedRanges) {
+        const { _start, _end } = range;
+
+        if (_start.node === this && _start.offset > offset) {
+          range._setLiveRangeStart(newNode, _start.offset - offset);
+        }
+
+        if (_end.node === this && _end.offset > offset) {
+          range._setLiveRangeEnd(newNode, _end.offset - offset);
+        }
+      }
+
+      const nodeIndex = domSymbolTree.index(this);
+      for (const range of parent._referencedRanges) {
+        const { _start, _end } = range;
+
+        if (_start.node === parent && _start.offset === nodeIndex + 1) {
+          range._setLiveRangeStart(parent, _start.offset + 1);
+        }
+
+        if (_end.node === parent && _end.offset === nodeIndex + 1) {
+          range._setLiveRangeEnd(parent, _end.offset + 1);
+        }
+      }
+    }
+
+    this.replaceData(offset, count, "");
+
+    return newNode;
+  }
+
+  // https://dom.spec.whatwg.org/#dom-text-wholetext
+  get wholeText() {
+    let wholeText = this.textContent;
+    let next;
+    let current = this;
+    while ((next = domSymbolTree.previousSibling(current)) && next.nodeType === NODE_TYPE.TEXT_NODE) {
+      wholeText = next.textContent + wholeText;
+      current = next;
+    }
+    current = this;
+    while ((next = domSymbolTree.nextSibling(current)) && next.nodeType === NODE_TYPE.TEXT_NODE) {
+      wholeText += next.textContent;
+      current = next;
+    }
+    return wholeText;
+  }
+}
+
+mixin(TextImpl.prototype, SlotableMixinImpl.prototype);
+
+module.exports = {
+  implementation: TextImpl
+};

package/node_modules_lambda/jsdom/lib/jsdom/living/nodes/WindowEventHandlers-impl.js

@@ -0,0 +1,52 @@
+"use strict";
+
+const { createEventAccessor } = require("../helpers/create-event-accessor");
+
+const events = new Set([
+  // WindowEventHandlers
+  "afterprint",
+  "beforeprint",
+  "beforeunload",
+  "hashchange",
+  "languagechange",
+  "message",
+  "messageerror",
+  "offline",
+  "online",
+  "pagehide",
+  "pageshow",
+  "popstate",
+  "rejectionhandled",
+  "storage",
+  "unhandledrejection",
+  "unload",
+
+  // inherited and overridden
+  "blur",
+  "error",
+  "focus",
+  "load",
+  "resize",
+  "scroll"
+]);
+
+// This class builds on GlobalEventHandlers, which must be mixed in first.
+class WindowEventHandlersImpl {
+  _proxyWindowEventsToWindow() {
+    // We're a <body> or <frameset>, so we need to proxy these specific events to the Window (if it exists)
+    this._getEventHandlerTarget = event => {
+      if (events.has(event)) {
+        return this.ownerDocument.defaultView || null;
+      }
+      return this;
+    };
+  }
+}
+
+for (const event of events) {
+  createEventAccessor(WindowEventHandlersImpl.prototype, event);
+}
+
+module.exports = {
+  implementation: WindowEventHandlersImpl
+};

package/node_modules_lambda/jsdom/lib/jsdom/living/nodes/XMLDocument-impl.js

@@ -0,0 +1,4 @@
+"use strict";
+const DocumentImpl = require("./Document-impl").implementation;
+
+exports.implementation = class XMLDocumentImpl extends DocumentImpl {};

package/node_modules_lambda/jsdom/lib/jsdom/living/post-message.js

@@ -0,0 +1,39 @@
+"use strict";
+const DOMException = require("domexception/webidl2js-wrapper");
+const MessageEvent = require("./generated/MessageEvent");
+const idlUtils = require("./generated/utils");
+const { isValidTargetOrigin } = require("../utils");
+const { fireAnEvent } = require("./helpers/events");
+
+module.exports = function (globalObject) {
+  return function (message, targetOrigin) {
+    if (arguments.length < 2) {
+      throw new TypeError("'postMessage' requires 2 arguments: 'message' and 'targetOrigin'");
+    }
+
+    targetOrigin = String(targetOrigin);
+
+    if (!isValidTargetOrigin(targetOrigin)) {
+      // TODO: Fix me
+      throw DOMException.create(globalObject, [
+        "Failed to execute 'postMessage' on 'Window': " +
+        "Invalid target origin '" + targetOrigin + "' in a call to 'postMessage'.",
+        "SyntaxError"
+      ]);
+    }
+
+    // TODO: targetOrigin === '/' - requires reference to source window
+    // See https://github.com/jsdom/jsdom/pull/1140#issuecomment-111587499
+    if (targetOrigin !== "*" && targetOrigin !== idlUtils.implForWrapper(globalObject._document)._origin) {
+      return;
+    }
+
+    // TODO: event.source - requires reference to source window
+    // TODO: event.origin - requires reference to source window
+    // TODO: event.ports
+    // TODO: event.data - structured clone message - requires cloning DOM nodes
+    setTimeout(() => {
+      fireAnEvent("message", this, MessageEvent, { data: message });
+    }, 0);
+  };
+};