@startinblox/core 0.17.31 → 0.18.0-beta.1

package/dist/_snowpack/pkg/dialog-polyfill.js

@@ -33,19 +33,10 @@ function safeDispatchEvent(target, event) {
 function createsStackingContext(el) {
   while (el && el !== document.body) {
     var s = window.getComputedStyle(el);
-    var invalid = function(k, ok) {
+    var invalid = function (k, ok) {
       return !(s[k] === undefined || s[k] === ok);
     };
-
-    if (s.opacity < 1 ||
-        invalid('zIndex', 'auto') ||
-        invalid('transform', 'none') ||
-        invalid('mixBlendMode', 'normal') ||
-        invalid('filter', 'none') ||
-        invalid('perspective', 'none') ||
-        s['isolation'] === 'isolate' ||
-        s.position === 'fixed' ||
-        s.webkitOverflowScrolling === 'touch') {
+    if (s.opacity < 1 || invalid('zIndex', 'auto') || invalid('transform', 'none') || invalid('mixBlendMode', 'normal') || invalid('filter', 'none') || invalid('perspective', 'none') || s['isolation'] === 'isolate' || s.position === 'fixed' || s.webkitOverflowScrolling === 'touch') {
       return true;
     }
     el = el.parentElement;
@@ -62,7 +53,8 @@ function createsStackingContext(el) {
 function findNearestDialog(el) {
   while (el) {
     if (el.localName === 'dialog') {
-      return /** @type {HTMLDialogElement} */ (el);
+      return (/** @type {HTMLDialogElement} */el
+      );
     }
     if (el.parentElement) {
       el = el.parentElement;
@@ -87,7 +79,6 @@ function safeBlur(el) {
   while (el && el.shadowRoot && el.shadowRoot.activeElement) {
     el = el.shadowRoot.activeElement;
   }
-
   if (el && el.blur && el !== document.body) {
     el.blur();
   }
@@ -126,13 +117,12 @@ function findFocusableElementWithin(hostElement) {
   // Note that this is 'any focusable area'. This list is probably not exhaustive, but the
   // alternative involves stepping through and trying to focus everything.
   var opts = ['button', 'input', 'keygen', 'select', 'textarea'];
-  var query = opts.map(function(el) {
+  var query = opts.map(function (el) {
     return el + ':not([disabled])';
   });
   // TODO(samthor): tabindex values that are not numeric are not focusable.
-  query.push('[tabindex]:not([disabled]):not([tabindex=""])');  // tabindex != "", not disabled
+  query.push('[tabindex]:not([disabled]):not([tabindex=""])'); // tabindex != "", not disabled
   var target = hostElement.querySelector(query.join(', '));
-
   if (!target && 'attachShadow' in Element.prototype) {
     // If we haven't found a focusable target, see if the host element contains an element
     // which has a shadowRoot.
@@ -167,19 +157,16 @@ function findFormSubmitter(event) {
   if (event.submitter) {
     return event.submitter;
   }
-
   var form = event.target;
   if (!(form instanceof HTMLFormElement)) {
     return null;
   }
-
   var submitter = dialogPolyfill.formSubmitter;
   if (!submitter) {
     var target = event.target;
-    var root = ('getRootNode' in target && target.getRootNode() || document);
+    var root = 'getRootNode' in target && target.getRootNode() || document;
     submitter = root.activeElement;
   }
-
   if (!submitter || submitter.form !== form) {
     return null;
   }
@@ -193,7 +180,7 @@ function maybeHandleSubmit(event) {
   if (event.defaultPrevented) {
     return;
   }
-  var form = /** @type {!HTMLFormElement} */ (event.target);
+  var form = /** @type {!HTMLFormElement} */event.target;
 
   // We'd have a value if we clicked on an imagemap.
   var value = dialogPolyfill.imagemapUseValue;
@@ -215,7 +202,6 @@ function maybeHandleSubmit(event) {
     return;
   }
   event.preventDefault();
-
   if (value != null) {
     // nb. we explicitly check against null/undefined
     dialog.close(value);
@@ -237,38 +223,39 @@ function dialogPolyfillInfo(dialog) {
   if (!dialog.hasAttribute('role')) {
     dialog.setAttribute('role', 'dialog');
   }
-
   dialog.show = this.show.bind(this);
   dialog.showModal = this.showModal.bind(this);
   dialog.close = this.close.bind(this);
-
   dialog.addEventListener('submit', maybeHandleSubmit, false);
-
   if (!('returnValue' in dialog)) {
     dialog.returnValue = '';
   }
-
   if ('MutationObserver' in window) {
     var mo = new MutationObserver(this.maybeHideModal.bind(this));
-    mo.observe(dialog, {attributes: true, attributeFilter: ['open']});
+    mo.observe(dialog, {
+      attributes: true,
+      attributeFilter: ['open']
+    });
   } else {
     // IE10 and below support. Note that DOMNodeRemoved etc fire _before_ removal. They also
     // seem to fire even if the element was removed as part of a parent removal. Use the removed
     // events to force downgrade (useful if removed/immediately added).
     var removed = false;
-    var cb = function() {
+    var cb = function () {
       removed ? this.downgradeModal() : this.maybeHideModal();
       removed = false;
     }.bind(this);
     var timeout;
-    var delayModel = function(ev) {
-      if (ev.target !== dialog) { return; }  // not for a child element
+    var delayModel = function (ev) {
+      if (ev.target !== dialog) {
+        return;
+      } // not for a child element
       var cand = 'DOMNodeRemoved';
-      removed |= (ev.type.substr(0, cand.length) === cand);
+      removed |= ev.type.substr(0, cand.length) === cand;
       window.clearTimeout(timeout);
       timeout = window.setTimeout(cb, 0);
     };
-    ['DOMAttrModified', 'DOMNodeRemoved', 'DOMNodeRemovedFromDocument'].forEach(function(name) {
+    ['DOMAttrModified', 'DOMNodeRemoved', 'DOMNodeRemovedFromDocument'].forEach(function (name) {
       dialog.addEventListener(name, delayModel);
     });
   }
@@ -279,35 +266,34 @@ function dialogPolyfillInfo(dialog) {
     set: this.setOpen.bind(this),
     get: dialog.hasAttribute.bind(dialog, 'open')
   });
-
   this.backdrop_ = document.createElement('div');
   this.backdrop_.className = 'backdrop';
-  this.backdrop_.addEventListener('mouseup'  , this.backdropMouseEvent_.bind(this));
+  this.backdrop_.addEventListener('mouseup', this.backdropMouseEvent_.bind(this));
   this.backdrop_.addEventListener('mousedown', this.backdropMouseEvent_.bind(this));
-  this.backdrop_.addEventListener('click'    , this.backdropMouseEvent_.bind(this));
+  this.backdrop_.addEventListener('click', this.backdropMouseEvent_.bind(this));
 }
-
-dialogPolyfillInfo.prototype = /** @type {HTMLDialogElement.prototype} */ ({
-
+dialogPolyfillInfo.prototype = /** @type {HTMLDialogElement.prototype} */{
   get dialog() {
     return this.dialog_;
   },
-
   /**
    * Maybe remove this dialog from the modal top layer. This is called when
    * a modal dialog may no longer be tenable, e.g., when the dialog is no
    * longer open or is no longer part of the DOM.
    */
-  maybeHideModal: function() {
-    if (this.dialog_.hasAttribute('open') && isConnected(this.dialog_)) { return; }
+  maybeHideModal: function () {
+    if (this.dialog_.hasAttribute('open') && isConnected(this.dialog_)) {
+      return;
+    }
     this.downgradeModal();
   },
-
   /**
    * Remove this dialog from the modal top layer, leaving it as a non-modal.
    */
-  downgradeModal: function() {
-    if (!this.openAsModal_) { return; }
+  downgradeModal: function () {
+    if (!this.openAsModal_) {
+      return;
+    }
     this.openAsModal_ = false;
     this.dialog_.style.zIndex = '';
 
@@ -323,16 +309,15 @@ dialogPolyfillInfo.prototype = /** @type {HTMLDialogElement.prototype} */ ({
     this.backdrop_.parentNode && this.backdrop_.parentNode.removeChild(this.backdrop_);
     dialogPolyfill.dm.removeDialog(this);
   },
-
   /**
    * @param {boolean} value whether to open or close this dialog
    */
-  setOpen: function(value) {
+  setOpen: function (value) {
     if (value) {
       this.dialog_.hasAttribute('open') || this.dialog_.setAttribute('open', '');
     } else {
       this.dialog_.removeAttribute('open');
-      this.maybeHideModal();  // nb. redundant with MutationObserver
+      this.maybeHideModal(); // nb. redundant with MutationObserver
     }
   },
 
@@ -342,7 +327,7 @@ dialogPolyfillInfo.prototype = /** @type {HTMLDialogElement.prototype} */ ({
    *
    * @param {!Event} e to redirect
    */
-  backdropMouseEvent_: function(e) {
+  backdropMouseEvent_: function (e) {
     if (!this.dialog_.hasAttribute('tabindex')) {
       // Clicking on the backdrop should move the implicit cursor, even if dialog cannot be
       // focused. Create a fake thing to focus on. If the backdrop was _before_ the dialog, this
@@ -355,20 +340,16 @@ dialogPolyfillInfo.prototype = /** @type {HTMLDialogElement.prototype} */ ({
     } else {
       this.dialog_.focus();
     }
-
     var redirectedEvent = document.createEvent('MouseEvents');
-    redirectedEvent.initMouseEvent(e.type, e.bubbles, e.cancelable, window,
-        e.detail, e.screenX, e.screenY, e.clientX, e.clientY, e.ctrlKey,
-        e.altKey, e.shiftKey, e.metaKey, e.button, e.relatedTarget);
+    redirectedEvent.initMouseEvent(e.type, e.bubbles, e.cancelable, window, e.detail, e.screenX, e.screenY, e.clientX, e.clientY, e.ctrlKey, e.altKey, e.shiftKey, e.metaKey, e.button, e.relatedTarget);
     this.dialog_.dispatchEvent(redirectedEvent);
     e.stopPropagation();
   },
-
   /**
    * Focuses on the first focusable element within the dialog. This will always blur the current
    * focus, even if nothing within the dialog is found.
    */
-  focus_: function() {
+  focus_: function () {
     // Find element with `autofocus` attribute, or fall back to the first form/tabindex control.
     var target = this.dialog_.querySelector('[autofocus]:not([disabled])');
     if (!target && this.dialog_.tabIndex >= 0) {
@@ -380,35 +361,32 @@ dialogPolyfillInfo.prototype = /** @type {HTMLDialogElement.prototype} */ ({
     safeBlur(document.activeElement);
     target && target.focus();
   },
-
   /**
    * Sets the zIndex for the backdrop and dialog.
    *
    * @param {number} dialogZ
    * @param {number} backdropZ
    */
-  updateZIndex: function(dialogZ, backdropZ) {
+  updateZIndex: function (dialogZ, backdropZ) {
     if (dialogZ < backdropZ) {
       throw new Error('dialogZ should never be < backdropZ');
     }
     this.dialog_.style.zIndex = dialogZ;
     this.backdrop_.style.zIndex = backdropZ;
   },
-
   /**
    * Shows the dialog. If the dialog is already open, this does nothing.
    */
-  show: function() {
+  show: function () {
     if (!this.dialog_.open) {
       this.setOpen(true);
       this.focus_();
     }
   },
-
   /**
    * Show this dialog modally.
    */
-  showModal: function() {
+  showModal: function () {
     if (this.dialog_.hasAttribute('open')) {
       throw new Error('Failed to execute \'showModal\' on dialog: The element is already open, and therefore cannot be opened modally.');
     }
@@ -418,13 +396,9 @@ dialogPolyfillInfo.prototype = /** @type {HTMLDialogElement.prototype} */ ({
     if (!dialogPolyfill.dm.pushDialog(this)) {
       throw new Error('Failed to execute \'showModal\' on dialog: There are too many open modal dialogs.');
     }
-
     if (createsStackingContext(this.dialog_.parentElement)) {
-      console.warn('A dialog is being shown inside a stacking context. ' +
-          'This may cause it to be unusable. For more information, see this link: ' +
-          'https://github.com/GoogleChrome/dialog-polyfill/#stacking-context');
+      console.warn('A dialog is being shown inside a stacking context. ' + 'This may cause it to be unusable. For more information, see this link: ' + 'https://github.com/GoogleChrome/dialog-polyfill/#stacking-context');
     }
-
     this.setOpen(true);
     this.openAsModal_ = true;
 
@@ -442,14 +416,13 @@ dialogPolyfillInfo.prototype = /** @type {HTMLDialogElement.prototype} */ ({
     // Focus on whatever inside the dialog.
     this.focus_();
   },
-
   /**
    * Closes this HTMLDialogElement. This is optional vs clearing the open
    * attribute, however this fires a 'close' event.
    *
    * @param {string=} opt_returnValue to use as the returnValue
    */
-  close: function(opt_returnValue) {
+  close: function (opt_returnValue) {
     if (!this.dialog_.hasAttribute('open')) {
       throw new Error('Failed to execute \'close\' on dialog: The element does not have an \'open\' attribute, and therefore cannot be closed.');
     }
@@ -467,18 +440,14 @@ dialogPolyfillInfo.prototype = /** @type {HTMLDialogElement.prototype} */ ({
     });
     safeDispatchEvent(this.dialog_, closeEvent);
   }
-
-});
-
+};
 var dialogPolyfill = {};
-
-dialogPolyfill.reposition = function(element) {
+dialogPolyfill.reposition = function (element) {
   var scrollTop = document.body.scrollTop || document.documentElement.scrollTop;
   var topValue = scrollTop + (window.innerHeight - element.offsetHeight) / 2;
   element.style.top = Math.max(scrollTop, topValue) + 'px';
 };
-
-dialogPolyfill.isInlinePositionSetByStylesheet = function(element) {
+dialogPolyfill.isInlinePositionSetByStylesheet = function (element) {
   for (var i = 0; i < document.styleSheets.length; ++i) {
     var styleSheet = document.styleSheets[i];
     var cssRules = null;
@@ -486,28 +455,29 @@ dialogPolyfill.isInlinePositionSetByStylesheet = function(element) {
     try {
       cssRules = styleSheet.cssRules;
     } catch (e) {}
-    if (!cssRules) { continue; }
+    if (!cssRules) {
+      continue;
+    }
     for (var j = 0; j < cssRules.length; ++j) {
       var rule = cssRules[j];
       var selectedNodes = null;
       // Ignore errors on invalid selector texts.
       try {
         selectedNodes = document.querySelectorAll(rule.selectorText);
-      } catch(e) {}
+      } catch (e) {}
       if (!selectedNodes || !inNodeList(selectedNodes, element)) {
         continue;
       }
       var cssTop = rule.style.getPropertyValue('top');
       var cssBottom = rule.style.getPropertyValue('bottom');
-      if ((cssTop && cssTop !== 'auto') || (cssBottom && cssBottom !== 'auto')) {
+      if (cssTop && cssTop !== 'auto' || cssBottom && cssBottom !== 'auto') {
         return true;
       }
     }
   }
   return false;
 };
-
-dialogPolyfill.needsCentering = function(dialog) {
+dialogPolyfill.needsCentering = function (dialog) {
   var computedStyle = window.getComputedStyle(dialog);
   if (computedStyle.position !== 'absolute') {
     return false;
@@ -517,8 +487,7 @@ dialogPolyfill.needsCentering = function(dialog) {
   // WebKit/Blink, checking computedStyle.top == 'auto' is sufficient, but
   // Firefox returns the used value. So we do this crazy thing instead: check
   // the inline style and then go through CSS rules.
-  if ((dialog.style.top !== 'auto' && dialog.style.top !== '') ||
-      (dialog.style.bottom !== 'auto' && dialog.style.bottom !== '')) {
+  if (dialog.style.top !== 'auto' && dialog.style.top !== '' || dialog.style.bottom !== 'auto' && dialog.style.bottom !== '') {
     return false;
   }
   return !dialogPolyfill.isInlinePositionSetByStylesheet(dialog);
@@ -527,21 +496,20 @@ dialogPolyfill.needsCentering = function(dialog) {
 /**
  * @param {!Element} element to force upgrade
  */
-dialogPolyfill.forceRegisterDialog = function(element) {
+dialogPolyfill.forceRegisterDialog = function (element) {
   if (window.HTMLDialogElement || element.showModal) {
-    console.warn('This browser already supports <dialog>, the polyfill ' +
-        'may not work correctly', element);
+    console.warn('This browser already supports <dialog>, the polyfill ' + 'may not work correctly', element);
   }
   if (element.localName !== 'dialog') {
     throw new Error('Failed to register dialog: The element is not a dialog.');
   }
-  new dialogPolyfillInfo(/** @type {!HTMLDialogElement} */ (element));
+  new dialogPolyfillInfo( /** @type {!HTMLDialogElement} */element);
 };
 
 /**
  * @param {!Element} element to upgrade, if necessary
  */
-dialogPolyfill.registerDialog = function(element) {
+dialogPolyfill.registerDialog = function (element) {
   if (!element.showModal) {
     dialogPolyfill.forceRegisterDialog(element);
   }
@@ -550,10 +518,9 @@ dialogPolyfill.registerDialog = function(element) {
 /**
  * @constructor
  */
-dialogPolyfill.DialogManager = function() {
+dialogPolyfill.DialogManager = function () {
   /** @type {!Array<!dialogPolyfillInfo>} */
   this.pendingDialogStack = [];
-
   var checkDOM = this.checkDOM_.bind(this);
 
   // The overlay is used to simulate how a modal dialog blocks the document.
@@ -563,24 +530,20 @@ dialogPolyfill.DialogManager = function() {
   // top layer, where z-index has no effect.
   this.overlay = document.createElement('div');
   this.overlay.className = '_dialog_overlay';
-  this.overlay.addEventListener('click', function(e) {
+  this.overlay.addEventListener('click', function (e) {
     this.forwardTab_ = undefined;
     e.stopPropagation();
-    checkDOM([]);  // sanity-check DOM
+    checkDOM([]); // sanity-check DOM
   }.bind(this));
-
   this.handleKey_ = this.handleKey_.bind(this);
   this.handleFocus_ = this.handleFocus_.bind(this);
-
   this.zIndexLow_ = 100000;
   this.zIndexHigh_ = 100000 + 150;
-
   this.forwardTab_ = undefined;
-
   if ('MutationObserver' in window) {
-    this.mo_ = new MutationObserver(function(records) {
+    this.mo_ = new MutationObserver(function (records) {
       var removed = [];
-      records.forEach(function(rec) {
+      records.forEach(function (rec) {
         for (var i = 0, c; c = rec.removedNodes[i]; ++i) {
           if (!(c instanceof Element)) {
             continue;
@@ -599,17 +562,20 @@ dialogPolyfill.DialogManager = function() {
  * Called on the first modal dialog being shown. Adds the overlay and related
  * handlers.
  */
-dialogPolyfill.DialogManager.prototype.blockDocument = function() {
+dialogPolyfill.DialogManager.prototype.blockDocument = function () {
   document.documentElement.addEventListener('focus', this.handleFocus_, true);
   document.addEventListener('keydown', this.handleKey_);
-  this.mo_ && this.mo_.observe(document, {childList: true, subtree: true});
+  this.mo_ && this.mo_.observe(document, {
+    childList: true,
+    subtree: true
+  });
 };
 
 /**
  * Called on the first modal dialog being removed, i.e., when no more modal
  * dialogs are visible.
  */
-dialogPolyfill.DialogManager.prototype.unblockDocument = function() {
+dialogPolyfill.DialogManager.prototype.unblockDocument = function () {
   document.documentElement.removeEventListener('focus', this.handleFocus_, true);
   document.removeEventListener('keydown', this.handleKey_);
   this.mo_ && this.mo_.disconnect();
@@ -618,9 +584,8 @@ dialogPolyfill.DialogManager.prototype.unblockDocument = function() {
 /**
  * Updates the stacking of all known dialogs.
  */
-dialogPolyfill.DialogManager.prototype.updateStacking = function() {
+dialogPolyfill.DialogManager.prototype.updateStacking = function () {
   var zIndex = this.zIndexHigh_;
-
   for (var i = 0, dpi; dpi = this.pendingDialogStack[i]; ++i) {
     dpi.updateZIndex(--zIndex, --zIndex);
     if (i === 0) {
@@ -642,30 +607,32 @@ dialogPolyfill.DialogManager.prototype.updateStacking = function() {
  * @param {Element} candidate to check if contained or is the top-most modal dialog
  * @return {boolean} whether candidate is contained in top dialog
  */
-dialogPolyfill.DialogManager.prototype.containedByTopDialog_ = function(candidate) {
+dialogPolyfill.DialogManager.prototype.containedByTopDialog_ = function (candidate) {
   while (candidate = findNearestDialog(candidate)) {
     for (var i = 0, dpi; dpi = this.pendingDialogStack[i]; ++i) {
       if (dpi.dialog === candidate) {
-        return i === 0;  // only valid if top-most
+        return i === 0; // only valid if top-most
       }
     }
+
     candidate = candidate.parentElement;
   }
   return false;
 };
-
-dialogPolyfill.DialogManager.prototype.handleFocus_ = function(event) {
+dialogPolyfill.DialogManager.prototype.handleFocus_ = function (event) {
   var target = event.composedPath ? event.composedPath()[0] : event.target;
-
-  if (this.containedByTopDialog_(target)) { return; }
-
-  if (document.activeElement === document.documentElement) { return; }
-
+  if (this.containedByTopDialog_(target)) {
+    return;
+  }
+  if (document.activeElement === document.documentElement) {
+    return;
+  }
   event.preventDefault();
   event.stopPropagation();
-  safeBlur(/** @type {Element} */ (target));
-
-  if (this.forwardTab_ === undefined) { return; }  // move focus only from a tab key
+  safeBlur( /** @type {Element} */target);
+  if (this.forwardTab_ === undefined) {
+    return;
+  } // move focus only from a tab key
 
   var dpi = this.pendingDialogStack[0];
   var dialog = dpi.dialog;
@@ -679,11 +646,9 @@ dialogPolyfill.DialogManager.prototype.handleFocus_ = function(event) {
       document.documentElement.focus();
     }
   }
-
   return false;
 };
-
-dialogPolyfill.DialogManager.prototype.handleKey_ = function(event) {
+dialogPolyfill.DialogManager.prototype.handleKey_ = function (event) {
   this.forwardTab_ = undefined;
   if (event.keyCode === 27) {
     event.preventDefault();
@@ -707,12 +672,12 @@ dialogPolyfill.DialogManager.prototype.handleKey_ = function(event) {
  *
  * @param {!Array<!HTMLDialogElement>} removed that have definitely been removed
  */
-dialogPolyfill.DialogManager.prototype.checkDOM_ = function(removed) {
+dialogPolyfill.DialogManager.prototype.checkDOM_ = function (removed) {
   // This operates on a clone because it may cause it to change. Each change also calls
   // updateStacking, which only actually needs to happen once. But who removes many modal dialogs
   // at a time?!
   var clone = this.pendingDialogStack.slice();
-  clone.forEach(function(dpi) {
+  clone.forEach(function (dpi) {
     if (removed.indexOf(dpi.dialog) !== -1) {
       dpi.downgradeModal();
     } else {
@@ -725,7 +690,7 @@ dialogPolyfill.DialogManager.prototype.checkDOM_ = function(removed) {
  * @param {!dialogPolyfillInfo} dpi
  * @return {boolean} whether the dialog was allowed
  */
-dialogPolyfill.DialogManager.prototype.pushDialog = function(dpi) {
+dialogPolyfill.DialogManager.prototype.pushDialog = function (dpi) {
   var allowed = (this.zIndexHigh_ - this.zIndexLow_) / 2 - 1;
   if (this.pendingDialogStack.length >= allowed) {
     return false;
@@ -740,17 +705,17 @@ dialogPolyfill.DialogManager.prototype.pushDialog = function(dpi) {
 /**
  * @param {!dialogPolyfillInfo} dpi
  */
-dialogPolyfill.DialogManager.prototype.removeDialog = function(dpi) {
+dialogPolyfill.DialogManager.prototype.removeDialog = function (dpi) {
   var index = this.pendingDialogStack.indexOf(dpi);
-  if (index === -1) { return; }
-
+  if (index === -1) {
+    return;
+  }
   this.pendingDialogStack.splice(index, 1);
   if (this.pendingDialogStack.length === 0) {
     this.unblockDocument();
   }
   this.updateStacking();
 };
-
 dialogPolyfill.dm = new dialogPolyfill.DialogManager();
 dialogPolyfill.formSubmitter = null;
 dialogPolyfill.imagemapUseValue = null;
@@ -760,7 +725,6 @@ dialogPolyfill.imagemapUseValue = null;
  * even if a no dialog is registered, as they deal with <form method="dialog">.
  */
 if (window.HTMLDialogElement === undefined) {
-
   /**
    * If HTMLFormElement translates method="DIALOG" into 'get', then replace the descriptor with
    * one that returns the correct value.
@@ -773,7 +737,7 @@ if (window.HTMLDialogElement === undefined) {
       // nb. Some older iOS and older PhantomJS fail to return the descriptor. Don't do anything
       // and don't bother to update the element.
       var realGet = methodDescriptor.get;
-      methodDescriptor.get = function() {
+      methodDescriptor.get = function () {
         if (isFormMethodDialog(this)) {
           return 'dialog';
         }
@@ -781,7 +745,7 @@ if (window.HTMLDialogElement === undefined) {
       };
       var realSet = methodDescriptor.set;
       /** @this {HTMLElement} */
-      methodDescriptor.set = function(v) {
+      methodDescriptor.set = function (v) {
         if (typeof v === 'string' && v.toLowerCase() === 'dialog') {
           return this.setAttribute('method', v);
         }
@@ -796,41 +760,45 @@ if (window.HTMLDialogElement === undefined) {
    * submitted a <form method="dialog">. Needed as Safari and others don't report this inside
    * document.activeElement.
    */
-  document.addEventListener('click', function(ev) {
+  document.addEventListener('click', function (ev) {
     dialogPolyfill.formSubmitter = null;
     dialogPolyfill.imagemapUseValue = null;
-    if (ev.defaultPrevented) { return; }  // e.g. a submit which prevents default submission
+    if (ev.defaultPrevented) {
+      return;
+    } // e.g. a submit which prevents default submission
 
-    var target = /** @type {Element} */ (ev.target);
+    var target = /** @type {Element} */ev.target;
     if ('composedPath' in ev) {
       var path = ev.composedPath();
       target = path.shift() || target;
     }
-    if (!target || !isFormMethodDialog(target.form)) { return; }
-
-    var valid = (target.type === 'submit' && ['button', 'input'].indexOf(target.localName) > -1);
+    if (!target || !isFormMethodDialog(target.form)) {
+      return;
+    }
+    var valid = target.type === 'submit' && ['button', 'input'].indexOf(target.localName) > -1;
     if (!valid) {
-      if (!(target.localName === 'input' && target.type === 'image')) { return; }
+      if (!(target.localName === 'input' && target.type === 'image')) {
+        return;
+      }
       // this is a <input type="image">, which can submit forms
       dialogPolyfill.imagemapUseValue = ev.offsetX + ',' + ev.offsetY;
     }
-
     var dialog = findNearestDialog(target);
-    if (!dialog) { return; }
-
+    if (!dialog) {
+      return;
+    }
     dialogPolyfill.formSubmitter = target;
-
   }, false);
 
   /**
    * Global 'submit' handler. This handles submits of `method="dialog"` which are invalid, i.e.,
    * outside a dialog. They get prevented.
    */
-  document.addEventListener('submit', function(ev) {
+  document.addEventListener('submit', function (ev) {
     var form = ev.target;
     var dialog = findNearestDialog(form);
     if (dialog) {
-      return;  // ignore, handle there
+      return; // ignore, handle there
     }
 
     var submitter = findFormSubmitter(ev);