@zipify/wysiwyg 1.1.0 → 1.2.0

package/node_modules_lambda/jsdom/lib/jsdom/living/helpers/svg/basic-types.js

@@ -0,0 +1,41 @@
+"use strict";
+
+// https://svgwg.org/svg2-draft/types.html#TermDetach
+function detach(value) {
+  if (typeof value === "string") {
+    return;
+  }
+
+  throw new TypeError(`jsdom internal error: detaching object of wrong type ${value}`);
+}
+exports.detach = detach;
+
+// https://svgwg.org/svg2-draft/types.html#TermAttach
+// listObject corresponds to the parameter taken by the algorithm in the spec, but is currently unused because only
+// DOMString type is supported by jsdom (and this function) right now.
+// eslint-disable-next-line no-unused-vars
+function attach(value, listObject) {
+  if (typeof value === "string") {
+    return;
+  }
+
+  throw new TypeError(`jsdom internal error: attaching object of wrong type ${value}`);
+}
+exports.attach = attach;
+
+// https://svgwg.org/svg2-draft/types.html#TermReserialize for DOMString.
+function reserializeSpaceSeparatedTokens(elements) {
+  return elements.join(" ");
+}
+exports.reserializeSpaceSeparatedTokens = reserializeSpaceSeparatedTokens;
+
+// Used for systemLanguage attribute, whose value is a set of comma-separated tokens:
+// https://svgwg.org/svg2-draft/struct.html#SystemLanguageAttribute
+// SVG 2 spec (https://svgwg.org/svg2-draft/types.html#TermReserialize) says any SVGStringList should reserialize the
+// same way, as space-separated tokens, but doing so for systemLanguage is illogical and contradicts the Firefox
+// behavior.
+// I cannot find a description of reserialization of SVGStringList in the SVG 1.1 spec.
+function reserializeCommaSeparatedTokens(elements) {
+  return elements.join(", ");
+}
+exports.reserializeCommaSeparatedTokens = reserializeCommaSeparatedTokens;

package/node_modules_lambda/jsdom/lib/jsdom/living/helpers/svg/render.js

@@ -0,0 +1,46 @@
+"use strict";
+const { SVG_NS } = require("../namespaces");
+
+// https://svgwg.org/svg2-draft/render.html#TermNeverRenderedElement
+const neverRenderedElements = new Set([
+  "clipPath",
+  "defs",
+  "desc",
+  "linearGradient",
+  "marker",
+  "mask",
+  "metadata",
+  "pattern",
+  "radialGradient",
+  "script",
+  "style",
+  "title",
+  "symbol"
+]);
+
+// https://svgwg.org/svg2-draft/render.html#Rendered-vs-NonRendered
+exports.isRenderedElement = elImpl => {
+  if (neverRenderedElements.has(elImpl._localName)) {
+    return false;
+  }
+
+  // This does not check for elements excluded because of conditional processing attributes or ‘switch’ structures,
+  // because conditional processing is not implemented.
+  // https://svgwg.org/svg2-draft/struct.html#ConditionalProcessing
+
+  // This does not check for computed style of display being none, since that is not yet implemented for HTML
+  // focusability either (and there are no tests yet).
+
+  if (!elImpl.isConnected) {
+    return false;
+  }
+
+  // The spec is unclear about how to deal with non-SVG parents, so we only perform this check for SVG-namespace
+  // parents.
+  if (elImpl.parentElement && elImpl.parentElement._namespaceURI === SVG_NS &&
+                              !exports.isRenderedElement(elImpl.parentNode)) {
+    return false;
+  }
+
+  return true;
+};

package/node_modules_lambda/jsdom/lib/jsdom/living/helpers/text.js

@@ -0,0 +1,19 @@
+"use strict";
+const { domSymbolTree } = require("./internal-constants");
+const { CDATA_SECTION_NODE, TEXT_NODE } = require("../node-type");
+
+//
+// https://dom.spec.whatwg.org/#concept-child-text-content
+//
+exports.childTextContent = node => {
+  let result = "";
+  const iterator = domSymbolTree.childrenIterator(node);
+  for (const child of iterator) {
+    if (child.nodeType === TEXT_NODE ||
+        // The CDataSection extends Text.
+        child.nodeType === CDATA_SECTION_NODE) {
+      result += child.data;
+    }
+  }
+  return result;
+};

package/node_modules_lambda/jsdom/lib/jsdom/living/helpers/traversal.js

@@ -0,0 +1,72 @@
+"use strict";
+const { domSymbolTree } = require("./internal-constants");
+const { HTML_NS } = require("./namespaces");
+
+// All these operate on and return impls, not wrappers!
+
+exports.closest = (e, localName, namespace = HTML_NS) => {
+  while (e) {
+    if (e.localName === localName && e.namespaceURI === namespace) {
+      return e;
+    }
+    e = domSymbolTree.parent(e);
+  }
+
+  return null;
+};
+
+exports.childrenByLocalName = (parent, localName, namespace = HTML_NS) => {
+  return domSymbolTree.childrenToArray(parent, { filter(node) {
+    return node._localName === localName && node._namespaceURI === namespace;
+  } });
+};
+
+exports.descendantsByLocalName = (parent, localName, namespace = HTML_NS) => {
+  return domSymbolTree.treeToArray(parent, { filter(node) {
+    return node._localName === localName && node._namespaceURI === namespace && node !== parent;
+  } });
+};
+
+exports.childrenByLocalNames = (parent, localNamesSet, namespace = HTML_NS) => {
+  return domSymbolTree.childrenToArray(parent, { filter(node) {
+    return localNamesSet.has(node._localName) && node._namespaceURI === namespace;
+  } });
+};
+
+exports.descendantsByLocalNames = (parent, localNamesSet, namespace = HTML_NS) => {
+  return domSymbolTree.treeToArray(parent, { filter(node) {
+    return localNamesSet.has(node._localName) &&
+           node._namespaceURI === namespace &&
+           node !== parent;
+  } });
+};
+
+exports.firstChildWithLocalName = (parent, localName, namespace = HTML_NS) => {
+  const iterator = domSymbolTree.childrenIterator(parent);
+  for (const child of iterator) {
+    if (child._localName === localName && child._namespaceURI === namespace) {
+      return child;
+    }
+  }
+  return null;
+};
+
+exports.firstChildWithLocalNames = (parent, localNamesSet, namespace = HTML_NS) => {
+  const iterator = domSymbolTree.childrenIterator(parent);
+  for (const child of iterator) {
+    if (localNamesSet.has(child._localName) && child._namespaceURI === namespace) {
+      return child;
+    }
+  }
+  return null;
+};
+
+exports.firstDescendantWithLocalName = (parent, localName, namespace = HTML_NS) => {
+  const iterator = domSymbolTree.treeIterator(parent);
+  for (const descendant of iterator) {
+    if (descendant._localName === localName && descendant._namespaceURI === namespace) {
+      return descendant;
+    }
+  }
+  return null;
+};

package/node_modules_lambda/jsdom/lib/jsdom/living/helpers/validate-names.js

@@ -0,0 +1,65 @@
+"use strict";
+const xnv = require("xml-name-validator");
+const DOMException = require("domexception/webidl2js-wrapper");
+const { XML_NS, XMLNS_NS } = require("../helpers/namespaces");
+
+// https://dom.spec.whatwg.org/#validate
+
+exports.name = (globalObject, name) => {
+  if (!xnv.name(name)) {
+    throw DOMException.create(globalObject, [`"${name}" did not match the Name production`, "InvalidCharacterError"]);
+  }
+};
+
+exports.qname = (globalObject, qname) => {
+  if (!xnv.qname(qname)) {
+    throw DOMException.create(globalObject, [`"${qname}" did not match the QName production`, "InvalidCharacterError"]);
+  }
+};
+
+exports.validateAndExtract = (globalObject, namespace, qualifiedName) => {
+  if (namespace === "") {
+    namespace = null;
+  }
+
+  exports.qname(globalObject, qualifiedName);
+
+  let prefix = null;
+  let localName = qualifiedName;
+
+  const colonIndex = qualifiedName.indexOf(":");
+  if (colonIndex !== -1) {
+    prefix = qualifiedName.substring(0, colonIndex);
+    localName = qualifiedName.substring(colonIndex + 1);
+  }
+
+  if (prefix !== null && namespace === null) {
+    throw DOMException.create(globalObject, [
+      "A namespace was given but a prefix was also extracted from the qualifiedName",
+      "NamespaceError"
+    ]);
+  }
+
+  if (prefix === "xml" && namespace !== XML_NS) {
+    throw DOMException.create(globalObject, [
+      "A prefix of \"xml\" was given but the namespace was not the XML namespace",
+      "NamespaceError"
+    ]);
+  }
+
+  if ((qualifiedName === "xmlns" || prefix === "xmlns") && namespace !== XMLNS_NS) {
+    throw DOMException.create(globalObject, [
+      "A prefix or qualifiedName of \"xmlns\" was given but the namespace was not the XMLNS namespace",
+      "NamespaceError"
+    ]);
+  }
+
+  if (namespace === XMLNS_NS && qualifiedName !== "xmlns" && prefix !== "xmlns") {
+    throw DOMException.create(globalObject, [
+      "The XMLNS namespace was given but neither the prefix nor qualifiedName was \"xmlns\"",
+      "NamespaceError"
+    ]);
+  }
+
+  return { namespace, prefix, localName };
+};

package/node_modules_lambda/jsdom/lib/jsdom/living/hr-time/Performance-impl.js

@@ -0,0 +1,25 @@
+"use strict";
+
+const EventTargetImpl = require("../events/EventTarget-impl").implementation;
+
+class PerformanceImpl extends EventTargetImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this._rawPerformance = privateData.rawPerformance;
+  }
+
+  now() {
+    return this._rawPerformance.now();
+  }
+
+  get timeOrigin() {
+    return this._rawPerformance.timeOrigin;
+  }
+
+  toJSON() {
+    return this._rawPerformance.toJSON();
+  }
+}
+
+exports.implementation = PerformanceImpl;

package/node_modules_lambda/jsdom/lib/jsdom/living/interfaces.js

@@ -0,0 +1,217 @@
+/* eslint-disable global-require */
+"use strict";
+
+const style = require("../level2/style");
+const xpath = require("../level3/xpath");
+
+// This object defines the mapping between the interface name and the generated interface wrapper code.
+// Note: The mapping needs to stay as-is in order due to interface evaluation.
+// We cannot "refactor" this to something less duplicative because that would break bundlers which depend on static
+// analysis of require()s.
+const generatedInterfaces = {
+  DOMException: require("domexception/webidl2js-wrapper"),
+
+  URL: require("whatwg-url/webidl2js-wrapper").URL,
+  URLSearchParams: require("whatwg-url/webidl2js-wrapper").URLSearchParams,
+
+  EventTarget: require("./generated/EventTarget"),
+
+  NamedNodeMap: require("./generated/NamedNodeMap"),
+  Node: require("./generated/Node"),
+  Attr: require("./generated/Attr"),
+  Element: require("./generated/Element"),
+  DocumentFragment: require("./generated/DocumentFragment"),
+  DOMImplementation: require("./generated/DOMImplementation"),
+  Document: require("./generated/Document"),
+  XMLDocument: require("./generated/XMLDocument"),
+  CharacterData: require("./generated/CharacterData"),
+  Text: require("./generated/Text"),
+  CDATASection: require("./generated/CDATASection"),
+  ProcessingInstruction: require("./generated/ProcessingInstruction"),
+  Comment: require("./generated/Comment"),
+  DocumentType: require("./generated/DocumentType"),
+  NodeList: require("./generated/NodeList"),
+  HTMLCollection: require("./generated/HTMLCollection"),
+  HTMLOptionsCollection: require("./generated/HTMLOptionsCollection"),
+  DOMStringMap: require("./generated/DOMStringMap"),
+  DOMTokenList: require("./generated/DOMTokenList"),
+
+  StyleSheetList: require("./generated/StyleSheetList.js"),
+
+  HTMLElement: require("./generated/HTMLElement.js"),
+  HTMLHeadElement: require("./generated/HTMLHeadElement.js"),
+  HTMLTitleElement: require("./generated/HTMLTitleElement.js"),
+  HTMLBaseElement: require("./generated/HTMLBaseElement.js"),
+  HTMLLinkElement: require("./generated/HTMLLinkElement.js"),
+  HTMLMetaElement: require("./generated/HTMLMetaElement.js"),
+  HTMLStyleElement: require("./generated/HTMLStyleElement.js"),
+  HTMLBodyElement: require("./generated/HTMLBodyElement.js"),
+  HTMLHeadingElement: require("./generated/HTMLHeadingElement.js"),
+  HTMLParagraphElement: require("./generated/HTMLParagraphElement.js"),
+  HTMLHRElement: require("./generated/HTMLHRElement.js"),
+  HTMLPreElement: require("./generated/HTMLPreElement.js"),
+  HTMLUListElement: require("./generated/HTMLUListElement.js"),
+  HTMLOListElement: require("./generated/HTMLOListElement.js"),
+  HTMLLIElement: require("./generated/HTMLLIElement.js"),
+  HTMLMenuElement: require("./generated/HTMLMenuElement.js"),
+  HTMLDListElement: require("./generated/HTMLDListElement.js"),
+  HTMLDivElement: require("./generated/HTMLDivElement.js"),
+  HTMLAnchorElement: require("./generated/HTMLAnchorElement.js"),
+  HTMLAreaElement: require("./generated/HTMLAreaElement.js"),
+  HTMLBRElement: require("./generated/HTMLBRElement.js"),
+  HTMLButtonElement: require("./generated/HTMLButtonElement.js"),
+  HTMLCanvasElement: require("./generated/HTMLCanvasElement.js"),
+  HTMLDataElement: require("./generated/HTMLDataElement.js"),
+  HTMLDataListElement: require("./generated/HTMLDataListElement.js"),
+  HTMLDetailsElement: require("./generated/HTMLDetailsElement.js"),
+  HTMLDialogElement: require("./generated/HTMLDialogElement.js"),
+  HTMLDirectoryElement: require("./generated/HTMLDirectoryElement.js"),
+  HTMLFieldSetElement: require("./generated/HTMLFieldSetElement.js"),
+  HTMLFontElement: require("./generated/HTMLFontElement.js"),
+  HTMLFormElement: require("./generated/HTMLFormElement.js"),
+  HTMLHtmlElement: require("./generated/HTMLHtmlElement.js"),
+  HTMLImageElement: require("./generated/HTMLImageElement.js"),
+  HTMLInputElement: require("./generated/HTMLInputElement.js"),
+  HTMLLabelElement: require("./generated/HTMLLabelElement.js"),
+  HTMLLegendElement: require("./generated/HTMLLegendElement.js"),
+  HTMLMapElement: require("./generated/HTMLMapElement.js"),
+  HTMLMarqueeElement: require("./generated/HTMLMarqueeElement.js"),
+  HTMLMediaElement: require("./generated/HTMLMediaElement.js"),
+  HTMLMeterElement: require("./generated/HTMLMeterElement.js"),
+  HTMLModElement: require("./generated/HTMLModElement.js"),
+  HTMLOptGroupElement: require("./generated/HTMLOptGroupElement.js"),
+  HTMLOptionElement: require("./generated/HTMLOptionElement.js"),
+  HTMLOutputElement: require("./generated/HTMLOutputElement.js"),
+  HTMLPictureElement: require("./generated/HTMLPictureElement.js"),
+  HTMLProgressElement: require("./generated/HTMLProgressElement.js"),
+  HTMLQuoteElement: require("./generated/HTMLQuoteElement.js"),
+  HTMLScriptElement: require("./generated/HTMLScriptElement.js"),
+  HTMLSelectElement: require("./generated/HTMLSelectElement.js"),
+  HTMLSlotElement: require("./generated/HTMLSlotElement.js"),
+  HTMLSourceElement: require("./generated/HTMLSourceElement.js"),
+  HTMLSpanElement: require("./generated/HTMLSpanElement.js"),
+  HTMLTableCaptionElement: require("./generated/HTMLTableCaptionElement.js"),
+  HTMLTableCellElement: require("./generated/HTMLTableCellElement.js"),
+  HTMLTableColElement: require("./generated/HTMLTableColElement.js"),
+  HTMLTableElement: require("./generated/HTMLTableElement.js"),
+  HTMLTimeElement: require("./generated/HTMLTimeElement.js"),
+  HTMLTableRowElement: require("./generated/HTMLTableRowElement.js"),
+  HTMLTableSectionElement: require("./generated/HTMLTableSectionElement.js"),
+  HTMLTemplateElement: require("./generated/HTMLTemplateElement.js"),
+  HTMLTextAreaElement: require("./generated/HTMLTextAreaElement.js"),
+  HTMLUnknownElement: require("./generated/HTMLUnknownElement.js"),
+  HTMLFrameElement: require("./generated/HTMLFrameElement.js"),
+  HTMLFrameSetElement: require("./generated/HTMLFrameSetElement.js"),
+  HTMLIFrameElement: require("./generated/HTMLIFrameElement.js"),
+  HTMLEmbedElement: require("./generated/HTMLEmbedElement.js"),
+  HTMLObjectElement: require("./generated/HTMLObjectElement.js"),
+  HTMLParamElement: require("./generated/HTMLParamElement.js"),
+  HTMLVideoElement: require("./generated/HTMLVideoElement.js"),
+  HTMLAudioElement: require("./generated/HTMLAudioElement.js"),
+  HTMLTrackElement: require("./generated/HTMLTrackElement.js"),
+
+  SVGElement: require("./generated/SVGElement.js"),
+  SVGGraphicsElement: require("./generated/SVGGraphicsElement.js"),
+  SVGSVGElement: require("./generated/SVGSVGElement.js"),
+  SVGTitleElement: require("./generated/SVGTitleElement.js"),
+  SVGAnimatedString: require("./generated/SVGAnimatedString"),
+  SVGNumber: require("./generated/SVGNumber"),
+  SVGStringList: require("./generated/SVGStringList"),
+
+  Event: require("./generated/Event"),
+  CloseEvent: require("./generated/CloseEvent"),
+  CustomEvent: require("./generated/CustomEvent"),
+  MessageEvent: require("./generated/MessageEvent"),
+  ErrorEvent: require("./generated/ErrorEvent"),
+  HashChangeEvent: require("./generated/HashChangeEvent"),
+  PopStateEvent: require("./generated/PopStateEvent"),
+  StorageEvent: require("./generated/StorageEvent"),
+  ProgressEvent: require("./generated/ProgressEvent"),
+  PageTransitionEvent: require("./generated/PageTransitionEvent"),
+
+  UIEvent: require("./generated/UIEvent"),
+  FocusEvent: require("./generated/FocusEvent"),
+  InputEvent: require("./generated/InputEvent"),
+  MouseEvent: require("./generated/MouseEvent"),
+  KeyboardEvent: require("./generated/KeyboardEvent"),
+  TouchEvent: require("./generated/TouchEvent"),
+  CompositionEvent: require("./generated/CompositionEvent"),
+  WheelEvent: require("./generated/WheelEvent"),
+
+  BarProp: require("./generated/BarProp"),
+  External: require("./generated/External"),
+  Location: require("./generated/Location"),
+  History: require("./generated/History"),
+  Screen: require("./generated/Screen"),
+  Performance: require("./generated/Performance"),
+  Navigator: require("./generated/Navigator"),
+
+  PluginArray: require("./generated/PluginArray"),
+  MimeTypeArray: require("./generated/MimeTypeArray"),
+  Plugin: require("./generated/Plugin"),
+  MimeType: require("./generated/MimeType"),
+
+  FileReader: require("./generated/FileReader"),
+  Blob: require("./generated/Blob"),
+  File: require("./generated/File"),
+  FileList: require("./generated/FileList"),
+  ValidityState: require("./generated/ValidityState"),
+
+  DOMParser: require("./generated/DOMParser"),
+  XMLSerializer: require("./generated/XMLSerializer"),
+
+  FormData: require("./generated/FormData"),
+  XMLHttpRequestEventTarget: require("./generated/XMLHttpRequestEventTarget"),
+  XMLHttpRequestUpload: require("./generated/XMLHttpRequestUpload"),
+  XMLHttpRequest: require("./generated/XMLHttpRequest"),
+  WebSocket: require("./generated/WebSocket"),
+
+  NodeFilter: require("./generated/NodeFilter"),
+  NodeIterator: require("./generated/NodeIterator"),
+  TreeWalker: require("./generated/TreeWalker"),
+
+  AbstractRange: require("./generated/AbstractRange"),
+  Range: require("./generated/Range"),
+  StaticRange: require("./generated/StaticRange"),
+  Selection: require("./generated/Selection"),
+
+  Storage: require("./generated/Storage"),
+
+  CustomElementRegistry: require("./generated/CustomElementRegistry"),
+  ShadowRoot: require("./generated/ShadowRoot"),
+
+  MutationObserver: require("./generated/MutationObserver"),
+  MutationRecord: require("./generated/MutationRecord"),
+
+  Headers: require("./generated/Headers"),
+  AbortController: require("./generated/AbortController"),
+  AbortSignal: require("./generated/AbortSignal")
+};
+
+function install(window, name, interfaceConstructor) {
+  Object.defineProperty(window, name, {
+    configurable: true,
+    writable: true,
+    value: interfaceConstructor
+  });
+}
+
+exports.installInterfaces = (window, globalNames) => {
+  // Install generated interface.
+  for (const generatedInterface of Object.values(generatedInterfaces)) {
+    generatedInterface.install(window, globalNames);
+  }
+
+  // Install legacy HTMLDocument interface
+  // https://html.spec.whatwg.org/#htmldocument
+  install(window, "HTMLDocument", window.Document);
+
+  // These need to be cleaned up...
+  style.addToCore(window);
+  xpath(window);
+};
+
+// Returns an interface webidl2js wrapper given its an interface name.
+exports.getInterfaceWrapper = name => {
+  return generatedInterfaces[name];
+};

package/node_modules_lambda/jsdom/lib/jsdom/living/mutation-observer/MutationObserver-impl.js

@@ -0,0 +1,95 @@
+"use strict";
+
+const { wrapperForImpl } = require("../generated/utils");
+
+// If we were to implement the MutationObserver by spec, the MutationObservers will not be collected by the GC because
+// all the MO are kept in a mutation observer list (https://github.com/jsdom/jsdom/pull/2398/files#r238123889). The
+// mutation observer list is primarily used to invoke the mutation observer callback in the same order than the
+// mutation observer creation.
+// In order to get around this issue, we will assign an increasing id for each mutation observer, this way we would be
+// able to invoke the callback in the creation order without having to keep a list of all the mutation observers.
+let mutationObserverId = 0;
+
+// https://dom.spec.whatwg.org/#mutationobserver
+class MutationObserverImpl {
+  // https://dom.spec.whatwg.org/#dom-mutationobserver-mutationobserver
+  constructor(globalObject, args) {
+    const [callback] = args;
+
+    this._callback = callback;
+    this._nodeList = [];
+    this._recordQueue = [];
+
+    this._id = ++mutationObserverId;
+  }
+
+  // https://dom.spec.whatwg.org/#dom-mutationobserver-observe
+  observe(target, options) {
+    if (("attributeOldValue" in options || "attributeFilter" in options) && !("attributes" in options)) {
+      options.attributes = true;
+    }
+
+    if ("characterDataOldValue" in options & !("characterData" in options)) {
+      options.characterData = true;
+    }
+
+    if (!options.childList && !options.attributes && !options.characterData) {
+      throw new TypeError("The options object must set at least one of 'attributes', 'characterData', or 'childList' " +
+        "to true.");
+    } else if (options.attributeOldValue && !options.attributes) {
+      throw new TypeError("The options object may only set 'attributeOldValue' to true when 'attributes' is true or " +
+        "not present.");
+    } else if (("attributeFilter" in options) && !options.attributes) {
+      throw new TypeError("The options object may only set 'attributeFilter' when 'attributes' is true or not " +
+        "present.");
+    } else if (options.characterDataOldValue && !options.characterData) {
+      throw new TypeError("The options object may only set 'characterDataOldValue' to true when 'characterData' is " +
+        "true or not present.");
+    }
+
+    const existingRegisteredObserver = target._registeredObserverList.find(registeredObserver => {
+      return registeredObserver.observer === this;
+    });
+
+    if (existingRegisteredObserver) {
+      for (const node of this._nodeList) {
+        node._registeredObserverList = node._registeredObserverList.filter(registeredObserver => {
+          return registeredObserver.source !== existingRegisteredObserver;
+        });
+      }
+
+      existingRegisteredObserver.options = options;
+    } else {
+      target._registeredObserverList.push({
+        observer: this,
+        options
+      });
+
+      this._nodeList.push(target);
+    }
+  }
+
+  // https://dom.spec.whatwg.org/#dom-mutationobserver-disconnect
+  disconnect() {
+    for (const node of this._nodeList) {
+      node._registeredObserverList = node._registeredObserverList.filter(registeredObserver => {
+        return registeredObserver.observer !== this;
+      });
+    }
+
+    this._recordQueue = [];
+  }
+
+  // https://dom.spec.whatwg.org/#dom-mutationobserver-takerecords
+  takeRecords() {
+    // TODO: revisit if https://github.com/jsdom/webidl2js/pull/108 gets fixed.
+    const records = this._recordQueue.map(wrapperForImpl);
+    this._recordQueue = [];
+
+    return records;
+  }
+}
+
+module.exports = {
+  implementation: MutationObserverImpl
+};

package/node_modules_lambda/jsdom/lib/jsdom/living/mutation-observer/MutationRecord-impl.js

@@ -0,0 +1,37 @@
+"use strict";
+
+const NodeList = require("../generated/NodeList");
+
+// https://dom.spec.whatwg.org/#mutationrecord
+class MutationRecordImpl {
+  constructor(globalObject, args, privateData) {
+    this._globalObject = globalObject;
+
+    this.type = privateData.type;
+    this.target = privateData.target;
+    this.previousSibling = privateData.previousSibling;
+    this.nextSibling = privateData.nextSibling;
+    this.attributeName = privateData.attributeName;
+    this.attributeNamespace = privateData.attributeNamespace;
+    this.oldValue = privateData.oldValue;
+
+    this._addedNodes = privateData.addedNodes;
+    this._removedNodes = privateData.removedNodes;
+  }
+
+  get addedNodes() {
+    return NodeList.createImpl(this._globalObject, [], {
+      nodes: this._addedNodes
+    });
+  }
+
+  get removedNodes() {
+    return NodeList.createImpl(this._globalObject, [], {
+      nodes: this._removedNodes
+    });
+  }
+}
+
+module.exports = {
+  implementation: MutationRecordImpl
+};