playbook_ui 13.32.0.pre.alpha.PLAY14143251 → 13.32.0.pre.alpha.PLAY14143255

data/dist/chunks/lazysizes.js

@@ -0,0 +1,611 @@
+var lazysizes = { exports: {} };
+var hasRequiredLazysizes;
+function requireLazysizes() {
+  if (hasRequiredLazysizes) return lazysizes.exports;
+  hasRequiredLazysizes = 1;
+  (function(module) {
+    (function(window2, factory) {
+      var lazySizes = factory(window2, window2.document, Date);
+      window2.lazySizes = lazySizes;
+      if (module.exports) {
+        module.exports = lazySizes;
+      }
+    })(
+      typeof window != "undefined" ? window : {},
+      /**
+       * import("./types/global")
+       * @typedef { import("./types/lazysizes-config").LazySizesConfigPartial } LazySizesConfigPartial
+       */
+      function l(window2, document, Date2) {
+        var lazysizes2, lazySizesCfg;
+        (function() {
+          var prop;
+          var lazySizesDefaults = {
+            lazyClass: "lazyload",
+            loadedClass: "lazyloaded",
+            loadingClass: "lazyloading",
+            preloadClass: "lazypreload",
+            errorClass: "lazyerror",
+            //strictClass: 'lazystrict',
+            autosizesClass: "lazyautosizes",
+            fastLoadedClass: "ls-is-cached",
+            iframeLoadMode: 0,
+            srcAttr: "data-src",
+            srcsetAttr: "data-srcset",
+            sizesAttr: "data-sizes",
+            //preloadAfterLoad: false,
+            minSize: 40,
+            customMedia: {},
+            init: true,
+            expFactor: 1.5,
+            hFac: 0.8,
+            loadMode: 2,
+            loadHidden: true,
+            ricTimeout: 0,
+            throttleDelay: 125
+          };
+          lazySizesCfg = window2.lazySizesConfig || window2.lazysizesConfig || {};
+          for (prop in lazySizesDefaults) {
+            if (!(prop in lazySizesCfg)) {
+              lazySizesCfg[prop] = lazySizesDefaults[prop];
+            }
+          }
+        })();
+        if (!document || !document.getElementsByClassName) {
+          return {
+            init: function() {
+            },
+            /**
+             * @type { LazySizesConfigPartial }
+             */
+            cfg: lazySizesCfg,
+            /**
+             * @type { true }
+             */
+            noSupport: true
+          };
+        }
+        var docElem = document.documentElement;
+        var supportPicture = window2.HTMLPictureElement;
+        var _addEventListener = "addEventListener";
+        var _getAttribute = "getAttribute";
+        var addEventListener = window2[_addEventListener].bind(window2);
+        var setTimeout = window2.setTimeout;
+        var requestAnimationFrame = window2.requestAnimationFrame || setTimeout;
+        var requestIdleCallback = window2.requestIdleCallback;
+        var regPicture = /^picture$/i;
+        var loadEvents = ["load", "error", "lazyincluded", "_lazyloaded"];
+        var regClassCache = {};
+        var forEach = Array.prototype.forEach;
+        var hasClass = function(ele, cls) {
+          if (!regClassCache[cls]) {
+            regClassCache[cls] = new RegExp("(\\s|^)" + cls + "(\\s|$)");
+          }
+          return regClassCache[cls].test(ele[_getAttribute]("class") || "") && regClassCache[cls];
+        };
+        var addClass = function(ele, cls) {
+          if (!hasClass(ele, cls)) {
+            ele.setAttribute("class", (ele[_getAttribute]("class") || "").trim() + " " + cls);
+          }
+        };
+        var removeClass = function(ele, cls) {
+          var reg;
+          if (reg = hasClass(ele, cls)) {
+            ele.setAttribute("class", (ele[_getAttribute]("class") || "").replace(reg, " "));
+          }
+        };
+        var addRemoveLoadEvents = function(dom, fn, add) {
+          var action = add ? _addEventListener : "removeEventListener";
+          if (add) {
+            addRemoveLoadEvents(dom, fn);
+          }
+          loadEvents.forEach(function(evt) {
+            dom[action](evt, fn);
+          });
+        };
+        var triggerEvent = function(elem, name, detail, noBubbles, noCancelable) {
+          var event = document.createEvent("Event");
+          if (!detail) {
+            detail = {};
+          }
+          detail.instance = lazysizes2;
+          event.initEvent(name, !noBubbles, !noCancelable);
+          event.detail = detail;
+          elem.dispatchEvent(event);
+          return event;
+        };
+        var updatePolyfill = function(el, full) {
+          var polyfill;
+          if (!supportPicture && (polyfill = window2.picturefill || lazySizesCfg.pf)) {
+            if (full && full.src && !el[_getAttribute]("srcset")) {
+              el.setAttribute("srcset", full.src);
+            }
+            polyfill({ reevaluate: true, elements: [el] });
+          } else if (full && full.src) {
+            el.src = full.src;
+          }
+        };
+        var getCSS = function(elem, style) {
+          return (getComputedStyle(elem, null) || {})[style];
+        };
+        var getWidth = function(elem, parent, width) {
+          width = width || elem.offsetWidth;
+          while (width < lazySizesCfg.minSize && parent && !elem._lazysizesWidth) {
+            width = parent.offsetWidth;
+            parent = parent.parentNode;
+          }
+          return width;
+        };
+        var rAF = function() {
+          var running, waiting;
+          var firstFns = [];
+          var secondFns = [];
+          var fns = firstFns;
+          var run = function() {
+            var runFns = fns;
+            fns = firstFns.length ? secondFns : firstFns;
+            running = true;
+            waiting = false;
+            while (runFns.length) {
+              runFns.shift()();
+            }
+            running = false;
+          };
+          var rafBatch = function(fn, queue) {
+            if (running && !queue) {
+              fn.apply(this, arguments);
+            } else {
+              fns.push(fn);
+              if (!waiting) {
+                waiting = true;
+                (document.hidden ? setTimeout : requestAnimationFrame)(run);
+              }
+            }
+          };
+          rafBatch._lsFlush = run;
+          return rafBatch;
+        }();
+        var rAFIt = function(fn, simple) {
+          return simple ? function() {
+            rAF(fn);
+          } : function() {
+            var that = this;
+            var args = arguments;
+            rAF(function() {
+              fn.apply(that, args);
+            });
+          };
+        };
+        var throttle = function(fn) {
+          var running;
+          var lastTime = 0;
+          var gDelay = lazySizesCfg.throttleDelay;
+          var rICTimeout = lazySizesCfg.ricTimeout;
+          var run = function() {
+            running = false;
+            lastTime = Date2.now();
+            fn();
+          };
+          var idleCallback = requestIdleCallback && rICTimeout > 49 ? function() {
+            requestIdleCallback(run, { timeout: rICTimeout });
+            if (rICTimeout !== lazySizesCfg.ricTimeout) {
+              rICTimeout = lazySizesCfg.ricTimeout;
+            }
+          } : rAFIt(function() {
+            setTimeout(run);
+          }, true);
+          return function(isPriority) {
+            var delay;
+            if (isPriority = isPriority === true) {
+              rICTimeout = 33;
+            }
+            if (running) {
+              return;
+            }
+            running = true;
+            delay = gDelay - (Date2.now() - lastTime);
+            if (delay < 0) {
+              delay = 0;
+            }
+            if (isPriority || delay < 9) {
+              idleCallback();
+            } else {
+              setTimeout(idleCallback, delay);
+            }
+          };
+        };
+        var debounce = function(func) {
+          var timeout, timestamp;
+          var wait = 99;
+          var run = function() {
+            timeout = null;
+            func();
+          };
+          var later = function() {
+            var last = Date2.now() - timestamp;
+            if (last < wait) {
+              setTimeout(later, wait - last);
+            } else {
+              (requestIdleCallback || run)(run);
+            }
+          };
+          return function() {
+            timestamp = Date2.now();
+            if (!timeout) {
+              timeout = setTimeout(later, wait);
+            }
+          };
+        };
+        var loader = function() {
+          var preloadElems, isCompleted, resetPreloadingTimer, loadMode, started;
+          var eLvW, elvH, eLtop, eLleft, eLright, eLbottom, isBodyHidden;
+          var regImg = /^img$/i;
+          var regIframe = /^iframe$/i;
+          var supportScroll = "onscroll" in window2 && !/(gle|ing)bot/.test(navigator.userAgent);
+          var shrinkExpand = 0;
+          var currentExpand = 0;
+          var isLoading = 0;
+          var lowRuns = -1;
+          var resetPreloading = function(e) {
+            isLoading--;
+            if (!e || isLoading < 0 || !e.target) {
+              isLoading = 0;
+            }
+          };
+          var isVisible = function(elem) {
+            if (isBodyHidden == null) {
+              isBodyHidden = getCSS(document.body, "visibility") == "hidden";
+            }
+            return isBodyHidden || !(getCSS(elem.parentNode, "visibility") == "hidden" && getCSS(elem, "visibility") == "hidden");
+          };
+          var isNestedVisible = function(elem, elemExpand) {
+            var outerRect;
+            var parent = elem;
+            var visible = isVisible(elem);
+            eLtop -= elemExpand;
+            eLbottom += elemExpand;
+            eLleft -= elemExpand;
+            eLright += elemExpand;
+            while (visible && (parent = parent.offsetParent) && parent != document.body && parent != docElem) {
+              visible = (getCSS(parent, "opacity") || 1) > 0;
+              if (visible && getCSS(parent, "overflow") != "visible") {
+                outerRect = parent.getBoundingClientRect();
+                visible = eLright > outerRect.left && eLleft < outerRect.right && eLbottom > outerRect.top - 1 && eLtop < outerRect.bottom + 1;
+              }
+            }
+            return visible;
+          };
+          var checkElements = function() {
+            var eLlen, i, rect, autoLoadElem, loadedSomething, elemExpand, elemNegativeExpand, elemExpandVal, beforeExpandVal, defaultExpand, preloadExpand, hFac;
+            var lazyloadElems = lazysizes2.elements;
+            if ((loadMode = lazySizesCfg.loadMode) && isLoading < 8 && (eLlen = lazyloadElems.length)) {
+              i = 0;
+              lowRuns++;
+              for (; i < eLlen; i++) {
+                if (!lazyloadElems[i] || lazyloadElems[i]._lazyRace) {
+                  continue;
+                }
+                if (!supportScroll || lazysizes2.prematureUnveil && lazysizes2.prematureUnveil(lazyloadElems[i])) {
+                  unveilElement(lazyloadElems[i]);
+                  continue;
+                }
+                if (!(elemExpandVal = lazyloadElems[i][_getAttribute]("data-expand")) || !(elemExpand = elemExpandVal * 1)) {
+                  elemExpand = currentExpand;
+                }
+                if (!defaultExpand) {
+                  defaultExpand = !lazySizesCfg.expand || lazySizesCfg.expand < 1 ? docElem.clientHeight > 500 && docElem.clientWidth > 500 ? 500 : 370 : lazySizesCfg.expand;
+                  lazysizes2._defEx = defaultExpand;
+                  preloadExpand = defaultExpand * lazySizesCfg.expFactor;
+                  hFac = lazySizesCfg.hFac;
+                  isBodyHidden = null;
+                  if (currentExpand < preloadExpand && isLoading < 1 && lowRuns > 2 && loadMode > 2 && !document.hidden) {
+                    currentExpand = preloadExpand;
+                    lowRuns = 0;
+                  } else if (loadMode > 1 && lowRuns > 1 && isLoading < 6) {
+                    currentExpand = defaultExpand;
+                  } else {
+                    currentExpand = shrinkExpand;
+                  }
+                }
+                if (beforeExpandVal !== elemExpand) {
+                  eLvW = innerWidth + elemExpand * hFac;
+                  elvH = innerHeight + elemExpand;
+                  elemNegativeExpand = elemExpand * -1;
+                  beforeExpandVal = elemExpand;
+                }
+                rect = lazyloadElems[i].getBoundingClientRect();
+                if ((eLbottom = rect.bottom) >= elemNegativeExpand && (eLtop = rect.top) <= elvH && (eLright = rect.right) >= elemNegativeExpand * hFac && (eLleft = rect.left) <= eLvW && (eLbottom || eLright || eLleft || eLtop) && (lazySizesCfg.loadHidden || isVisible(lazyloadElems[i])) && (isCompleted && isLoading < 3 && !elemExpandVal && (loadMode < 3 || lowRuns < 4) || isNestedVisible(lazyloadElems[i], elemExpand))) {
+                  unveilElement(lazyloadElems[i]);
+                  loadedSomething = true;
+                  if (isLoading > 9) {
+                    break;
+                  }
+                } else if (!loadedSomething && isCompleted && !autoLoadElem && isLoading < 4 && lowRuns < 4 && loadMode > 2 && (preloadElems[0] || lazySizesCfg.preloadAfterLoad) && (preloadElems[0] || !elemExpandVal && (eLbottom || eLright || eLleft || eLtop || lazyloadElems[i][_getAttribute](lazySizesCfg.sizesAttr) != "auto"))) {
+                  autoLoadElem = preloadElems[0] || lazyloadElems[i];
+                }
+              }
+              if (autoLoadElem && !loadedSomething) {
+                unveilElement(autoLoadElem);
+              }
+            }
+          };
+          var throttledCheckElements = throttle(checkElements);
+          var switchLoadingClass = function(e) {
+            var elem = e.target;
+            if (elem._lazyCache) {
+              delete elem._lazyCache;
+              return;
+            }
+            resetPreloading(e);
+            addClass(elem, lazySizesCfg.loadedClass);
+            removeClass(elem, lazySizesCfg.loadingClass);
+            addRemoveLoadEvents(elem, rafSwitchLoadingClass);
+            triggerEvent(elem, "lazyloaded");
+          };
+          var rafedSwitchLoadingClass = rAFIt(switchLoadingClass);
+          var rafSwitchLoadingClass = function(e) {
+            rafedSwitchLoadingClass({ target: e.target });
+          };
+          var changeIframeSrc = function(elem, src) {
+            var loadMode2 = elem.getAttribute("data-load-mode") || lazySizesCfg.iframeLoadMode;
+            if (loadMode2 == 0) {
+              elem.contentWindow.location.replace(src);
+            } else if (loadMode2 == 1) {
+              elem.src = src;
+            }
+          };
+          var handleSources = function(source) {
+            var customMedia;
+            var sourceSrcset = source[_getAttribute](lazySizesCfg.srcsetAttr);
+            if (customMedia = lazySizesCfg.customMedia[source[_getAttribute]("data-media") || source[_getAttribute]("media")]) {
+              source.setAttribute("media", customMedia);
+            }
+            if (sourceSrcset) {
+              source.setAttribute("srcset", sourceSrcset);
+            }
+          };
+          var lazyUnveil = rAFIt(function(elem, detail, isAuto, sizes, isImg) {
+            var src, srcset, parent, isPicture, event, firesLoad;
+            if (!(event = triggerEvent(elem, "lazybeforeunveil", detail)).defaultPrevented) {
+              if (sizes) {
+                if (isAuto) {
+                  addClass(elem, lazySizesCfg.autosizesClass);
+                } else {
+                  elem.setAttribute("sizes", sizes);
+                }
+              }
+              srcset = elem[_getAttribute](lazySizesCfg.srcsetAttr);
+              src = elem[_getAttribute](lazySizesCfg.srcAttr);
+              if (isImg) {
+                parent = elem.parentNode;
+                isPicture = parent && regPicture.test(parent.nodeName || "");
+              }
+              firesLoad = detail.firesLoad || "src" in elem && (srcset || src || isPicture);
+              event = { target: elem };
+              addClass(elem, lazySizesCfg.loadingClass);
+              if (firesLoad) {
+                clearTimeout(resetPreloadingTimer);
+                resetPreloadingTimer = setTimeout(resetPreloading, 2500);
+                addRemoveLoadEvents(elem, rafSwitchLoadingClass, true);
+              }
+              if (isPicture) {
+                forEach.call(parent.getElementsByTagName("source"), handleSources);
+              }
+              if (srcset) {
+                elem.setAttribute("srcset", srcset);
+              } else if (src && !isPicture) {
+                if (regIframe.test(elem.nodeName)) {
+                  changeIframeSrc(elem, src);
+                } else {
+                  elem.src = src;
+                }
+              }
+              if (isImg && (srcset || isPicture)) {
+                updatePolyfill(elem, { src });
+              }
+            }
+            if (elem._lazyRace) {
+              delete elem._lazyRace;
+            }
+            removeClass(elem, lazySizesCfg.lazyClass);
+            rAF(function() {
+              var isLoaded = elem.complete && elem.naturalWidth > 1;
+              if (!firesLoad || isLoaded) {
+                if (isLoaded) {
+                  addClass(elem, lazySizesCfg.fastLoadedClass);
+                }
+                switchLoadingClass(event);
+                elem._lazyCache = true;
+                setTimeout(function() {
+                  if ("_lazyCache" in elem) {
+                    delete elem._lazyCache;
+                  }
+                }, 9);
+              }
+              if (elem.loading == "lazy") {
+                isLoading--;
+              }
+            }, true);
+          });
+          var unveilElement = function(elem) {
+            if (elem._lazyRace) {
+              return;
+            }
+            var detail;
+            var isImg = regImg.test(elem.nodeName);
+            var sizes = isImg && (elem[_getAttribute](lazySizesCfg.sizesAttr) || elem[_getAttribute]("sizes"));
+            var isAuto = sizes == "auto";
+            if ((isAuto || !isCompleted) && isImg && (elem[_getAttribute]("src") || elem.srcset) && !elem.complete && !hasClass(elem, lazySizesCfg.errorClass) && hasClass(elem, lazySizesCfg.lazyClass)) {
+              return;
+            }
+            detail = triggerEvent(elem, "lazyunveilread").detail;
+            if (isAuto) {
+              autoSizer.updateElem(elem, true, elem.offsetWidth);
+            }
+            elem._lazyRace = true;
+            isLoading++;
+            lazyUnveil(elem, detail, isAuto, sizes, isImg);
+          };
+          var afterScroll = debounce(function() {
+            lazySizesCfg.loadMode = 3;
+            throttledCheckElements();
+          });
+          var altLoadmodeScrollListner = function() {
+            if (lazySizesCfg.loadMode == 3) {
+              lazySizesCfg.loadMode = 2;
+            }
+            afterScroll();
+          };
+          var onload = function() {
+            if (isCompleted) {
+              return;
+            }
+            if (Date2.now() - started < 999) {
+              setTimeout(onload, 999);
+              return;
+            }
+            isCompleted = true;
+            lazySizesCfg.loadMode = 3;
+            throttledCheckElements();
+            addEventListener("scroll", altLoadmodeScrollListner, true);
+          };
+          return {
+            _: function() {
+              started = Date2.now();
+              lazysizes2.elements = document.getElementsByClassName(lazySizesCfg.lazyClass);
+              preloadElems = document.getElementsByClassName(lazySizesCfg.lazyClass + " " + lazySizesCfg.preloadClass);
+              addEventListener("scroll", throttledCheckElements, true);
+              addEventListener("resize", throttledCheckElements, true);
+              addEventListener("pageshow", function(e) {
+                if (e.persisted) {
+                  var loadingElements = document.querySelectorAll("." + lazySizesCfg.loadingClass);
+                  if (loadingElements.length && loadingElements.forEach) {
+                    requestAnimationFrame(function() {
+                      loadingElements.forEach(function(img) {
+                        if (img.complete) {
+                          unveilElement(img);
+                        }
+                      });
+                    });
+                  }
+                }
+              });
+              if (window2.MutationObserver) {
+                new MutationObserver(throttledCheckElements).observe(docElem, { childList: true, subtree: true, attributes: true });
+              } else {
+                docElem[_addEventListener]("DOMNodeInserted", throttledCheckElements, true);
+                docElem[_addEventListener]("DOMAttrModified", throttledCheckElements, true);
+                setInterval(throttledCheckElements, 999);
+              }
+              addEventListener("hashchange", throttledCheckElements, true);
+              ["focus", "mouseover", "click", "load", "transitionend", "animationend"].forEach(function(name) {
+                document[_addEventListener](name, throttledCheckElements, true);
+              });
+              if (/d$|^c/.test(document.readyState)) {
+                onload();
+              } else {
+                addEventListener("load", onload);
+                document[_addEventListener]("DOMContentLoaded", throttledCheckElements);
+                setTimeout(onload, 2e4);
+              }
+              if (lazysizes2.elements.length) {
+                checkElements();
+                rAF._lsFlush();
+              } else {
+                throttledCheckElements();
+              }
+            },
+            checkElems: throttledCheckElements,
+            unveil: unveilElement,
+            _aLSL: altLoadmodeScrollListner
+          };
+        }();
+        var autoSizer = function() {
+          var autosizesElems;
+          var sizeElement = rAFIt(function(elem, parent, event, width) {
+            var sources, i, len;
+            elem._lazysizesWidth = width;
+            width += "px";
+            elem.setAttribute("sizes", width);
+            if (regPicture.test(parent.nodeName || "")) {
+              sources = parent.getElementsByTagName("source");
+              for (i = 0, len = sources.length; i < len; i++) {
+                sources[i].setAttribute("sizes", width);
+              }
+            }
+            if (!event.detail.dataAttr) {
+              updatePolyfill(elem, event.detail);
+            }
+          });
+          var getSizeElement = function(elem, dataAttr, width) {
+            var event;
+            var parent = elem.parentNode;
+            if (parent) {
+              width = getWidth(elem, parent, width);
+              event = triggerEvent(elem, "lazybeforesizes", { width, dataAttr: !!dataAttr });
+              if (!event.defaultPrevented) {
+                width = event.detail.width;
+                if (width && width !== elem._lazysizesWidth) {
+                  sizeElement(elem, parent, event, width);
+                }
+              }
+            }
+          };
+          var updateElementsSizes = function() {
+            var i;
+            var len = autosizesElems.length;
+            if (len) {
+              i = 0;
+              for (; i < len; i++) {
+                getSizeElement(autosizesElems[i]);
+              }
+            }
+          };
+          var debouncedUpdateElementsSizes = debounce(updateElementsSizes);
+          return {
+            _: function() {
+              autosizesElems = document.getElementsByClassName(lazySizesCfg.autosizesClass);
+              addEventListener("resize", debouncedUpdateElementsSizes);
+            },
+            checkElems: debouncedUpdateElementsSizes,
+            updateElem: getSizeElement
+          };
+        }();
+        var init = function() {
+          if (!init.i && document.getElementsByClassName) {
+            init.i = true;
+            autoSizer._();
+            loader._();
+          }
+        };
+        setTimeout(function() {
+          if (lazySizesCfg.init) {
+            init();
+          }
+        });
+        lazysizes2 = {
+          /**
+           * @type { LazySizesConfigPartial }
+           */
+          cfg: lazySizesCfg,
+          autoSizer,
+          loader,
+          init,
+          uP: updatePolyfill,
+          aC: addClass,
+          rC: removeClass,
+          hC: hasClass,
+          fire: triggerEvent,
+          gW: getWidth,
+          rAF
+        };
+        return lazysizes2;
+      }
+    );
+  })(lazysizes);
+  return lazysizes.exports;
+}
+requireLazysizes();
+export {
+  requireLazysizes as r
+};

data/dist/chunks/pb_form_validation.js

@@ -0,0 +1,60 @@
+import { P as PbEnhancedElement, l as lodashExports } from "./lib.js";
+const KIT_SELECTOR = '[class^="pb_"][class*="_kit"]';
+const ERROR_MESSAGE_SELECTOR = ".pb_body_kit_negative";
+const FORM_SELECTOR = 'form[data-pb-form-validation="true"]';
+const REQUIRED_FIELDS_SELECTOR = "input[required],textarea[required],select[required]";
+const FIELD_EVENTS = [
+  "change",
+  "valid",
+  "invalid"
+];
+class PbFormValidation extends PbEnhancedElement {
+  static get selector() {
+    return FORM_SELECTOR;
+  }
+  connect() {
+    this.formValidationFields.forEach((field) => {
+      FIELD_EVENTS.forEach((e) => {
+        field.addEventListener(e, lodashExports.debounce((event) => {
+          this.validateFormField(event);
+        }, 250), false);
+      });
+    });
+  }
+  validateFormField(event) {
+    event.preventDefault();
+    const { target } = event;
+    target.setCustomValidity("");
+    const isValid = event.target.validity.valid;
+    if (isValid) {
+      this.clearError(target);
+    } else {
+      this.showValidationMessage(target);
+    }
+  }
+  showValidationMessage(target) {
+    const { parentElement } = target;
+    this.clearError(target);
+    parentElement.closest(KIT_SELECTOR).classList.add("error");
+    const errorMessageContainer = this.errorMessageContainer;
+    if (target.dataset.message) target.setCustomValidity(target.dataset.message);
+    errorMessageContainer.innerHTML = target.validationMessage;
+    parentElement.appendChild(errorMessageContainer);
+  }
+  clearError(target) {
+    const { parentElement } = target;
+    parentElement.closest(KIT_SELECTOR).classList.remove("error");
+    const errorMessageContainer = parentElement.querySelector(ERROR_MESSAGE_SELECTOR);
+    if (errorMessageContainer) errorMessageContainer.remove();
+  }
+  get errorMessageContainer() {
+    const errorContainer = document.createElement("div");
+    const kitClassName = ERROR_MESSAGE_SELECTOR.replace(/\./, "");
+    errorContainer.classList.add(kitClassName);
+    return errorContainer;
+  }
+  get formValidationFields() {
+    return this._formValidationFields = this._formValidationFields || this.element.querySelectorAll(REQUIRED_FIELDS_SELECTOR);
+  }
+}
+window.PbFormValidation = PbFormValidation;

data/dist/chunks/vendor.js

@@ -0,0 +1,6 @@
+import "./_weekday_stacked.js";
+import "./lazysizes.js";
+import "./_typeahead.js";
+import "./lib.js";
+import "react";
+import "react-dom";