powerpagestoolkit 1.3.101 → 1.3.103

package/dist/index.js

@@ -0,0 +1,1180 @@
+/******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 672:
+/***/ ((module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(354);
+/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(314);
+/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__);
+// Imports
+
+
+var ___CSS_LOADER_EXPORT___ = _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default()));
+// Module
+___CSS_LOADER_EXPORT___.push([module.id, `.info-icon {
+  position: relative;
+  display: inline-block;
+}
+
+.info-icon .fa-info-circle {
+  cursor: pointer; /* Ensures the icon is recognized as interactive */
+}
+
+.info-icon .flyout-content {
+  max-width: calc(100vw - 20px); /* 20px margin on both sides */
+  display: none; /* Initially hidden */
+  position: absolute;
+  left: 50%; /* Center horizontally */
+  transform: translateX(-50%); /* Adjust positioning */
+  background-color: #f9f9f9;
+  padding: 10px;
+  border: 1px solid #ddd;
+  z-index: 1;
+  min-width: 200px; /* Minimum width for better readability */
+  box-shadow: 0px 4px 8px rgba(0, 0, 0, 0.1);
+  border-radius: 4px; /* Rounded corners */
+}
+
+@media (max-width: 600px) {
+  .info-icon .flyout-content {
+    max-width: 95vw;
+    padding: 12px;
+    font-size: 0.9em;
+    display: block;
+    right: auto;
+  }
+}
+
+.required-field::after {
+  content: " *" !important;
+  color: #f00 !important;
+}
+`, "",{"version":3,"sources":["webpack://./src/CSS/style.css"],"names":[],"mappings":"AAAA;EACE,kBAAkB;EAClB,qBAAqB;AACvB;;AAEA;EACE,eAAe,EAAE,kDAAkD;AACrE;;AAEA;EACE,6BAA6B,EAAE,8BAA8B;EAC7D,aAAa,EAAE,qBAAqB;EACpC,kBAAkB;EAClB,SAAS,EAAE,wBAAwB;EACnC,2BAA2B,EAAE,uBAAuB;EACpD,yBAAyB;EACzB,aAAa;EACb,sBAAsB;EACtB,UAAU;EACV,gBAAgB,EAAE,yCAAyC;EAC3D,0CAA0C;EAC1C,kBAAkB,EAAE,oBAAoB;AAC1C;;AAEA;EACE;IACE,eAAe;IACf,aAAa;IACb,gBAAgB;IAChB,cAAc;IACd,WAAW;EACb;AACF;;AAEA;EACE,wBAAwB;EACxB,sBAAsB;AACxB","sourcesContent":[".info-icon {\r\n  position: relative;\r\n  display: inline-block;\r\n}\r\n\r\n.info-icon .fa-info-circle {\r\n  cursor: pointer; /* Ensures the icon is recognized as interactive */\r\n}\r\n\r\n.info-icon .flyout-content {\r\n  max-width: calc(100vw - 20px); /* 20px margin on both sides */\r\n  display: none; /* Initially hidden */\r\n  position: absolute;\r\n  left: 50%; /* Center horizontally */\r\n  transform: translateX(-50%); /* Adjust positioning */\r\n  background-color: #f9f9f9;\r\n  padding: 10px;\r\n  border: 1px solid #ddd;\r\n  z-index: 1;\r\n  min-width: 200px; /* Minimum width for better readability */\r\n  box-shadow: 0px 4px 8px rgba(0, 0, 0, 0.1);\r\n  border-radius: 4px; /* Rounded corners */\r\n}\r\n\r\n@media (max-width: 600px) {\r\n  .info-icon .flyout-content {\r\n    max-width: 95vw;\r\n    padding: 12px;\r\n    font-size: 0.9em;\r\n    display: block;\r\n    right: auto;\r\n  }\r\n}\r\n\r\n.required-field::after {\r\n  content: \" *\" !important;\r\n  color: #f00 !important;\r\n}\r\n"],"sourceRoot":""}]);
+// Exports
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___);
+
+
+/***/ }),
+
+/***/ 314:
+/***/ ((module) => {
+
+
+
+/*
+  MIT License http://www.opensource.org/licenses/mit-license.php
+  Author Tobias Koppers @sokra
+*/
+module.exports = function (cssWithMappingToString) {
+  var list = [];
+
+  // return the list of modules as css string
+  list.toString = function toString() {
+    return this.map(function (item) {
+      var content = "";
+      var needLayer = typeof item[5] !== "undefined";
+      if (item[4]) {
+        content += "@supports (".concat(item[4], ") {");
+      }
+      if (item[2]) {
+        content += "@media ".concat(item[2], " {");
+      }
+      if (needLayer) {
+        content += "@layer".concat(item[5].length > 0 ? " ".concat(item[5]) : "", " {");
+      }
+      content += cssWithMappingToString(item);
+      if (needLayer) {
+        content += "}";
+      }
+      if (item[2]) {
+        content += "}";
+      }
+      if (item[4]) {
+        content += "}";
+      }
+      return content;
+    }).join("");
+  };
+
+  // import a list of modules into the list
+  list.i = function i(modules, media, dedupe, supports, layer) {
+    if (typeof modules === "string") {
+      modules = [[null, modules, undefined]];
+    }
+    var alreadyImportedModules = {};
+    if (dedupe) {
+      for (var k = 0; k < this.length; k++) {
+        var id = this[k][0];
+        if (id != null) {
+          alreadyImportedModules[id] = true;
+        }
+      }
+    }
+    for (var _k = 0; _k < modules.length; _k++) {
+      var item = [].concat(modules[_k]);
+      if (dedupe && alreadyImportedModules[item[0]]) {
+        continue;
+      }
+      if (typeof layer !== "undefined") {
+        if (typeof item[5] === "undefined") {
+          item[5] = layer;
+        } else {
+          item[1] = "@layer".concat(item[5].length > 0 ? " ".concat(item[5]) : "", " {").concat(item[1], "}");
+          item[5] = layer;
+        }
+      }
+      if (media) {
+        if (!item[2]) {
+          item[2] = media;
+        } else {
+          item[1] = "@media ".concat(item[2], " {").concat(item[1], "}");
+          item[2] = media;
+        }
+      }
+      if (supports) {
+        if (!item[4]) {
+          item[4] = "".concat(supports);
+        } else {
+          item[1] = "@supports (".concat(item[4], ") {").concat(item[1], "}");
+          item[4] = supports;
+        }
+      }
+      list.push(item);
+    }
+  };
+  return list;
+};
+
+/***/ }),
+
+/***/ 354:
+/***/ ((module) => {
+
+
+
+module.exports = function (item) {
+  var content = item[1];
+  var cssMapping = item[3];
+  if (!cssMapping) {
+    return content;
+  }
+  if (typeof btoa === "function") {
+    var base64 = btoa(unescape(encodeURIComponent(JSON.stringify(cssMapping))));
+    var data = "sourceMappingURL=data:application/json;charset=utf-8;base64,".concat(base64);
+    var sourceMapping = "/*# ".concat(data, " */");
+    return [content].concat([sourceMapping]).join("\n");
+  }
+  return [content].join("\n");
+};
+
+/***/ }),
+
+/***/ 39:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(72);
+/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(825);
+/* harmony import */ var _node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(659);
+/* harmony import */ var _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(56);
+/* harmony import */ var _node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(540);
+/* harmony import */ var _node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__);
+/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(113);
+/* harmony import */ var _node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__);
+/* harmony import */ var _node_modules_css_loader_dist_cjs_js_style_css__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(672);
+
+      
+      
+      
+      
+      
+      
+      
+      
+      
+
+var options = {};
+
+options.styleTagTransform = (_node_modules_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default());
+options.setAttributes = (_node_modules_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default());
+options.insert = _node_modules_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default().bind(null, "head");
+options.domAPI = (_node_modules_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default());
+options.insertStyleElement = (_node_modules_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default());
+
+var update = _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default()(_node_modules_css_loader_dist_cjs_js_style_css__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A, options);
+
+
+
+
+       /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (_node_modules_css_loader_dist_cjs_js_style_css__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A && _node_modules_css_loader_dist_cjs_js_style_css__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.locals ? _node_modules_css_loader_dist_cjs_js_style_css__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.locals : undefined);
+
+
+/***/ }),
+
+/***/ 72:
+/***/ ((module) => {
+
+
+
+var stylesInDOM = [];
+function getIndexByIdentifier(identifier) {
+  var result = -1;
+  for (var i = 0; i < stylesInDOM.length; i++) {
+    if (stylesInDOM[i].identifier === identifier) {
+      result = i;
+      break;
+    }
+  }
+  return result;
+}
+function modulesToDom(list, options) {
+  var idCountMap = {};
+  var identifiers = [];
+  for (var i = 0; i < list.length; i++) {
+    var item = list[i];
+    var id = options.base ? item[0] + options.base : item[0];
+    var count = idCountMap[id] || 0;
+    var identifier = "".concat(id, " ").concat(count);
+    idCountMap[id] = count + 1;
+    var indexByIdentifier = getIndexByIdentifier(identifier);
+    var obj = {
+      css: item[1],
+      media: item[2],
+      sourceMap: item[3],
+      supports: item[4],
+      layer: item[5]
+    };
+    if (indexByIdentifier !== -1) {
+      stylesInDOM[indexByIdentifier].references++;
+      stylesInDOM[indexByIdentifier].updater(obj);
+    } else {
+      var updater = addElementStyle(obj, options);
+      options.byIndex = i;
+      stylesInDOM.splice(i, 0, {
+        identifier: identifier,
+        updater: updater,
+        references: 1
+      });
+    }
+    identifiers.push(identifier);
+  }
+  return identifiers;
+}
+function addElementStyle(obj, options) {
+  var api = options.domAPI(options);
+  api.update(obj);
+  var updater = function updater(newObj) {
+    if (newObj) {
+      if (newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap && newObj.supports === obj.supports && newObj.layer === obj.layer) {
+        return;
+      }
+      api.update(obj = newObj);
+    } else {
+      api.remove();
+    }
+  };
+  return updater;
+}
+module.exports = function (list, options) {
+  options = options || {};
+  list = list || [];
+  var lastIdentifiers = modulesToDom(list, options);
+  return function update(newList) {
+    newList = newList || [];
+    for (var i = 0; i < lastIdentifiers.length; i++) {
+      var identifier = lastIdentifiers[i];
+      var index = getIndexByIdentifier(identifier);
+      stylesInDOM[index].references--;
+    }
+    var newLastIdentifiers = modulesToDom(newList, options);
+    for (var _i = 0; _i < lastIdentifiers.length; _i++) {
+      var _identifier = lastIdentifiers[_i];
+      var _index = getIndexByIdentifier(_identifier);
+      if (stylesInDOM[_index].references === 0) {
+        stylesInDOM[_index].updater();
+        stylesInDOM.splice(_index, 1);
+      }
+    }
+    lastIdentifiers = newLastIdentifiers;
+  };
+};
+
+/***/ }),
+
+/***/ 659:
+/***/ ((module) => {
+
+
+
+var memo = {};
+
+/* istanbul ignore next  */
+function getTarget(target) {
+  if (typeof memo[target] === "undefined") {
+    var styleTarget = document.querySelector(target);
+
+    // Special case to return head of iframe instead of iframe itself
+    if (window.HTMLIFrameElement && styleTarget instanceof window.HTMLIFrameElement) {
+      try {
+        // This will throw an exception if access to iframe is blocked
+        // due to cross-origin restrictions
+        styleTarget = styleTarget.contentDocument.head;
+      } catch (e) {
+        // istanbul ignore next
+        styleTarget = null;
+      }
+    }
+    memo[target] = styleTarget;
+  }
+  return memo[target];
+}
+
+/* istanbul ignore next  */
+function insertBySelector(insert, style) {
+  var target = getTarget(insert);
+  if (!target) {
+    throw new Error("Couldn't find a style target. This probably means that the value for the 'insert' parameter is invalid.");
+  }
+  target.appendChild(style);
+}
+module.exports = insertBySelector;
+
+/***/ }),
+
+/***/ 540:
+/***/ ((module) => {
+
+
+
+/* istanbul ignore next  */
+function insertStyleElement(options) {
+  var element = document.createElement("style");
+  options.setAttributes(element, options.attributes);
+  options.insert(element, options.options);
+  return element;
+}
+module.exports = insertStyleElement;
+
+/***/ }),
+
+/***/ 56:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+
+
+/* istanbul ignore next  */
+function setAttributesWithoutAttributes(styleElement) {
+  var nonce =  true ? __webpack_require__.nc : 0;
+  if (nonce) {
+    styleElement.setAttribute("nonce", nonce);
+  }
+}
+module.exports = setAttributesWithoutAttributes;
+
+/***/ }),
+
+/***/ 825:
+/***/ ((module) => {
+
+
+
+/* istanbul ignore next  */
+function apply(styleElement, options, obj) {
+  var css = "";
+  if (obj.supports) {
+    css += "@supports (".concat(obj.supports, ") {");
+  }
+  if (obj.media) {
+    css += "@media ".concat(obj.media, " {");
+  }
+  var needLayer = typeof obj.layer !== "undefined";
+  if (needLayer) {
+    css += "@layer".concat(obj.layer.length > 0 ? " ".concat(obj.layer) : "", " {");
+  }
+  css += obj.css;
+  if (needLayer) {
+    css += "}";
+  }
+  if (obj.media) {
+    css += "}";
+  }
+  if (obj.supports) {
+    css += "}";
+  }
+  var sourceMap = obj.sourceMap;
+  if (sourceMap && typeof btoa !== "undefined") {
+    css += "\n/*# sourceMappingURL=data:application/json;base64,".concat(btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))), " */");
+  }
+
+  // For old IE
+  /* istanbul ignore if  */
+  options.styleTagTransform(css, styleElement, options.options);
+}
+function removeStyleElement(styleElement) {
+  // istanbul ignore if
+  if (styleElement.parentNode === null) {
+    return false;
+  }
+  styleElement.parentNode.removeChild(styleElement);
+}
+
+/* istanbul ignore next  */
+function domAPI(options) {
+  if (typeof document === "undefined") {
+    return {
+      update: function update() {},
+      remove: function remove() {}
+    };
+  }
+  var styleElement = options.insertStyleElement(options);
+  return {
+    update: function update(obj) {
+      apply(styleElement, options, obj);
+    },
+    remove: function remove() {
+      removeStyleElement(styleElement);
+    }
+  };
+}
+module.exports = domAPI;
+
+/***/ }),
+
+/***/ 113:
+/***/ ((module) => {
+
+
+
+/* istanbul ignore next  */
+function styleTagTransform(css, styleElement) {
+  if (styleElement.styleSheet) {
+    styleElement.styleSheet.cssText = css;
+  } else {
+    while (styleElement.firstChild) {
+      styleElement.removeChild(styleElement.firstChild);
+    }
+    styleElement.appendChild(document.createTextNode(css));
+  }
+}
+module.exports = styleTagTransform;
+
+/***/ }),
+
+/***/ 377:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+//@ts-nocheck
+const safeAjax_js_1 = __importDefault(__webpack_require__(626));
+const API = {
+    /**
+     *
+     * @param {Class} schema an instance of a schema class, containing the desired information for the POST request
+     * @returns a Promise resolving the successful results *[record id]* of the POST request, or rejecting the failed results *[error]* of the POST request.
+     */
+    createRecord(schema) {
+        return new Promise((resolve, reject) => {
+            (0, safeAjax_js_1.default)({
+                type: "POST",
+                url: `/_api/${schema.logicalName()}`,
+                data: schema.value(),
+                contentType: "application/json",
+                success: function (response, status, xhr) {
+                    resolve(xhr.getResponseHeader("entityid"));
+                },
+                error: (error) => {
+                    reject(error);
+                },
+            });
+        });
+    },
+    /**
+     *
+     * @param {string} tableSetName The DataVerse SET name of the table being queried
+     * @param {string} recordID the GUID of the records to be retrieved
+     * @param {string} selectColumns *OPTIONAL* if desired, enter your own custom OData query for advanced GET results. Format = select=column1,column2,column3...
+     * @returns a Promise resolving the successful results of the GET request, or rejecting the failed results of the GET request
+     */
+    getRecord(tableSetName, recordID, selectColumns) {
+        return new Promise((resolve, reject) => {
+            const url = `/_api/${tableSetName}(${recordID})${selectColumns ? `?$${selectColumns}` : ""}`;
+            (0, safeAjax_js_1.default)({
+                type: "GET",
+                url: url,
+                success: resolve,
+                error: reject,
+            });
+        });
+    },
+    /**
+     *
+     * @param {String} tableSetName The DataVerse SET name of the table being queried
+     * @param {String} queryParameters *OPTIONAL* the OData query parameters for refining search results: *format = $filter=filters&$select=columns*
+     * @returns a Promise resolving the successful results of the GET request, or rejecting the failed results of the GET request
+     */
+    getMultiple(tableSetName, queryParameters) {
+        return new Promise((resolve, reject) => {
+            // Construct the URL based on the presence of query parameters
+            const url = `/_api/${tableSetName}${queryParameters ? `?${queryParameters}` : ""}`;
+            (0, safeAjax_js_1.default)({
+                type: "GET",
+                url: url,
+                success: function (response) {
+                    resolve(response.value);
+                },
+                error: reject,
+            });
+        });
+    },
+};
+exports["default"] = API;
+
+
+/***/ }),
+
+/***/ 539:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.DOMNodeReference = void 0;
+exports.createDOMNodeReference = createDOMNodeReference;
+exports.createMultipleDOMNodeReferences = createMultipleDOMNodeReferences;
+const waitFor_js_1 = __importDefault(__webpack_require__(565));
+const createInfoElement_js_1 = __importDefault(__webpack_require__(465));
+const errors_js_1 = __webpack_require__(598);
+__webpack_require__(39);
+/**
+ * Class representing a reference to a DOM node.
+ */
+/******/ /******/ /******/ class DOMNodeReference {
+    /**
+     * Creates an instance of DOMNodeReference.
+     * @param {string} target - The CSS selector to find the desired DOM element.
+     */
+    /******/ /******/ constructor(target) {
+        this.target = target;
+        this.isLoaded = false;
+        this.defaultDisplay = "";
+        this.value = null;
+        // we defer the rest of initialization
+    }
+    _init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const element = yield (0, waitFor_js_1.default)(this.target);
+                this.element = element;
+                if (!this.element) {
+                    throw new errors_js_1.DOMNodeNotFoundError(this);
+                }
+                if (this.element.classList.contains("boolean-radio")) {
+                    yield this._attachRadioButtons();
+                }
+                this._initValueSync();
+                this._attachVisibilityController();
+                this.defaultDisplay = this.visibilityController.style.display;
+                this.isLoaded = true;
+            }
+            catch (e) {
+                throw new errors_js_1.DOMNodeInitializationError(this, e);
+            }
+        });
+    }
+    _initValueSync() {
+        // Function to update this.value based on element type
+        // Initial sync
+        this.updateValue();
+        // Event listeners for real-time changes based on element type
+        const elementType = this.element.type;
+        if (elementType === "checkbox" || elementType === "radio") {
+            this.element.addEventListener("click", this.updateValue.bind(this));
+        }
+        else if (elementType === "select-one" ||
+            elementType === "select-multiple") {
+            this.element.addEventListener("change", this.updateValue.bind(this));
+        }
+        else {
+            this.element.addEventListener("input", this.updateValue.bind(this));
+        }
+    }
+    updateValue() {
+        switch (this.element.type) {
+            case "checkbox":
+            case "radio":
+                this.value = this.element.checked;
+                this.checked = this.element.checked;
+                break;
+            case "select-multiple":
+                this.value = Array.from(this.element.selectedOptions).map((option) => option.value);
+                break;
+            case "number":
+                this.value =
+                    this.element.value !== ""
+                        ? Number(this.element.value)
+                        : null;
+                break;
+            default:
+                this.value = null;
+                break;
+        }
+        if (this.element.classList.contains("boolean-radio")) {
+            this.yesRadio.updateValue();
+            this.noRadio.updateValue();
+        }
+    }
+    _attachVisibilityController() {
+        // Set the default visibility controller to the element itself
+        this.visibilityController = this.element;
+        // If the element is a table, use its closest fieldset as the controller
+        if (this.element.tagName === "TABLE") {
+            const fieldset = this.element.closest("fieldset");
+            if (fieldset) {
+                this.visibilityController = fieldset;
+            }
+            return;
+        }
+        // For specific tag types, use the closest 'td' if available as the controller
+        const tagsRequiringTdParent = [
+            "SPAN",
+            "INPUT",
+            "TEXTAREA",
+            "SELECT",
+            "TABLE",
+        ];
+        if (tagsRequiringTdParent.includes(this.element.tagName)) {
+            const tdParent = this.element.closest("td");
+            if (tdParent) {
+                this.visibilityController = tdParent;
+            }
+        }
+    }
+    _attachRadioButtons() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.yesRadio = yield createDOMNodeReference(`#${this.element.id}_1`);
+            this.noRadio = yield createDOMNodeReference(`#${this.element.id}_0`);
+        });
+    }
+    on(eventType, eventHandler) {
+        this.element.addEventListener(eventType, eventHandler.bind(this));
+    }
+    hide() {
+        this.visibilityController.style.display = "none";
+    }
+    show() {
+        this.visibilityController.style.display = this.defaultDisplay;
+    }
+    toggleVisibility(shouldShow) {
+        if (shouldShow instanceof Function) {
+            shouldShow() ? this.show() : this.hide();
+        }
+        else {
+            shouldShow ? this.show() : this.hide();
+        }
+    }
+    setValue(value) {
+        if (this.element.classList.contains("boolean-radio")) {
+            this.yesRadio.element.checked = value;
+            this.noRadio.element.checked =
+                !value;
+        }
+        else {
+            this.element.value = value;
+        }
+    }
+    disable() {
+        try {
+            this.element.disabled = true;
+        }
+        catch (e) {
+            throw new Error(`There was an error trying to disable the target: ${this.target}`);
+        }
+    }
+    enable() {
+        try {
+            this.element.disabled = false;
+        }
+        catch (e) {
+            throw new Error(`There was an error trying to disable the target: ${this.target}`);
+        }
+    }
+    append(...elements) {
+        this.element.append(...elements);
+    }
+    before(...elements) {
+        this.element.before(...elements);
+    }
+    after(...elements) {
+        this.element.after(...elements);
+    }
+    getLabel() {
+        return document.querySelector(`#${this.element.id}_label`) || null;
+    }
+    appendToLabel(...elements) {
+        const label = this.getLabel();
+        if (label) {
+            label.append(" ", ...elements);
+        }
+    }
+    addLabelTooltip(text) {
+        this.appendToLabel((0, createInfoElement_js_1.default)(text));
+    }
+    addToolTip(text) {
+        this.append((0, createInfoElement_js_1.default)(text));
+    }
+    setTextContent(text) {
+        this.element.innerHTML = text;
+    }
+    uncheckRadios() {
+        if (this.yesRadio && this.noRadio) {
+            this.yesRadio.element.checked = false;
+            this.noRadio.element.checked = false;
+        }
+        else {
+            console.error("[SYNACT] Attempted to uncheck radios for an element that has no radios");
+        }
+    }
+    configureConditionalRendering(condition, triggerNodes) {
+        try {
+            this.toggleVisibility(condition());
+            if (triggerNodes) {
+                const nodes = Array.isArray(triggerNodes)
+                    ? triggerNodes
+                    : [triggerNodes];
+                nodes.forEach((node) => {
+                    node.on("change", () => this.toggleVisibility(condition()));
+                    const observer = new MutationObserver(() => {
+                        const display = window.getComputedStyle(node.visibilityController).display;
+                        this.toggleVisibility(display !== "none" && condition());
+                    });
+                    observer.observe(node.visibilityController, {
+                        attributes: true,
+                        attributeFilter: ["style"],
+                    });
+                });
+            }
+        }
+        catch (e) {
+            throw new errors_js_1.ConditionalRenderingError(this, e);
+        }
+    }
+    configureValidationAndRequirements(logic, fieldDisplayName, dependencies) {
+        if (typeof Page_Validators !== "undefined") {
+            const newValidator = document.createElement("span");
+            newValidator.style.display = "none";
+            newValidator.id = `${this.element.id}Validator`;
+            newValidator.controltovalidate = this.element.id;
+            newValidator.errormessage = `<a href='#${this.element.id}_label'>${fieldDisplayName} is a required field</a>`;
+            newValidator.evaluationfunction =
+                logic.validationLogic.bind(this);
+            //eslint-disable-next-line
+            Page_Validators.push(newValidator);
+        }
+        else {
+            throw new Error("Attempted to add to Validator where Page_Validators do not exist");
+        }
+        this.setRequiredLevel(logic.requirementLogic(this));
+        if (!dependencies)
+            return;
+        dependencies = Array.isArray(dependencies) ? dependencies : [dependencies];
+        dependencies.forEach((dep) => {
+            dep.element.addEventListener("change", () => this.setRequiredLevel(logic.requirementLogic(this)));
+        });
+    }
+    setRequiredLevel(isRequired) {
+        var _a, _b, _c, _d;
+        if (isRequired instanceof Function) {
+            isRequired()
+                ? (_a = this.getLabel()) === null || _a === void 0 ? void 0 : _a.classList.add("required-field")
+                : (_b = this.getLabel()) === null || _b === void 0 ? void 0 : _b.classList.remove("required-field");
+            return;
+        }
+        else {
+            isRequired
+                ? (_c = this.getLabel()) === null || _c === void 0 ? void 0 : _c.classList.add("required-field")
+                : (_d = this.getLabel()) === null || _d === void 0 ? void 0 : _d.classList.remove("required-field");
+        }
+    }
+    onceLoaded(callback) {
+        if (this.isLoaded) {
+            callback(this);
+            return;
+        }
+        if (this.target instanceof HTMLElement) {
+            callback(this);
+            return;
+        }
+        const observer = new MutationObserver(() => {
+            if (document.querySelector(this.target)) {
+                observer.disconnect(); // Stop observing once loaded
+                this.isLoaded = true;
+                callback(this); // Call the provided callback
+            }
+        });
+        observer.observe(document.body, {
+            subtree: true,
+            childList: true,
+        });
+    }
+}
+exports.DOMNodeReference = DOMNodeReference;
+/**
+ * Creates and initializes a DOMNodeReference instance.
+ * @async
+ * @function createDOMNodeReference
+ * @param {string | HTMLElement} target - The CSS selector for the desired DOM element.
+ * @returns {Promise<DOMNodeReference>} A promise that resolves to a Proxy of the initialized DOMNodeReference instance.
+ */
+function createDOMNodeReference(target) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const instance = new DOMNodeReference(target);
+            yield instance._init();
+            return new Proxy(instance, {
+                get: (target, prop) => {
+                    // do not proxy the initialization method
+                    // init() is only needed in this factory function
+                    if (prop.toString().startsWith("_"))
+                        return undefined;
+                    // proxy the class to wrap all methods in the 'onceLoaded' method, to make sure the
+                    // element is always available before executing method
+                    const value = target[prop];
+                    if (typeof value === "function" && prop !== "onceLoaded") {
+                        return (...args) => target.onceLoaded(() => value.apply(target, args));
+                    }
+                    return value;
+                },
+            });
+        }
+        catch (e) {
+            console.error(`There was an error creating a DOMNodeReference: ${e}`);
+            throw new Error(e);
+        }
+    });
+}
+/**
+ * Creates and initializes multiple DOMNodeReference instances.
+ * @async
+ * @function createMultipleDOMNodeReferences
+ * @param {string} querySelector - The CSS selector for the desired DOM elements.
+ * @returns {Promise<DOMNodeReference[]>} A promise that resolves to an array of Proxies of initialized DOMNodeReference instances.
+ */
+function createMultipleDOMNodeReferences(querySelector) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const elements = Array.from(document.querySelectorAll(querySelector));
+            const initializedElements = yield Promise.all(elements.map((element) => createDOMNodeReference(element)));
+            const domNodeArray = initializedElements;
+            domNodeArray.hideAll = () => domNodeArray.forEach((instance) => instance.hide());
+            domNodeArray.showAll = () => domNodeArray.forEach((instance) => instance.show());
+            return elements;
+        }
+        catch (e) {
+            console.error(`There was an error creating multiple DOMNodeReferences: ${e}`);
+            throw new Error(e);
+        }
+    });
+}
+
+
+/***/ }),
+
+/***/ 465:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports["default"] = CreateInfoEl;
+function CreateInfoEl(titleString) {
+    const span = document.createElement("span");
+    span.classList.add("info-icon");
+    const icon = document.createElement("i");
+    icon.classList.add("fa", "fa-solid", "fa-info-circle");
+    icon.setAttribute("aria-label", "Info");
+    icon.style.cursor = "pointer";
+    const flyoutContent = document.createElement("div");
+    flyoutContent.innerHTML = titleString;
+    flyoutContent.classList.add("flyout-content");
+    span.appendChild(icon);
+    span.appendChild(flyoutContent);
+    // Function to position flyout content
+    const positionFlyout = () => {
+        flyoutContent.style.display = "block"; // Show the flyout to calculate dimensions
+        const flyoutRect = flyoutContent.getBoundingClientRect();
+        const viewportWidth = window.innerWidth;
+        // Position the flyout
+        // Adjust if flyout is too far to the right
+        if (flyoutRect.right > viewportWidth) {
+            const overflowAmount = flyoutRect.right - viewportWidth;
+            flyoutContent.style.left = `calc(50% - ${overflowAmount}px)`; // Shift left
+        }
+        // Adjust if flyout is too far to the left
+        if (flyoutRect.left < 0) {
+            const overflowAmount = Math.abs(flyoutRect.left);
+            flyoutContent.style.left = `calc(50% + ${overflowAmount}px)`; // Shift right
+        }
+    };
+    icon.addEventListener("mouseenter", positionFlyout);
+    icon.addEventListener("mouseleave", () => {
+        flyoutContent.style.display = "none"; // Hide on mouse leave
+    });
+    icon.addEventListener("touchstart", (event) => {
+        event.preventDefault();
+        // Toggle flyout visibility on touch
+        flyoutContent.style.display =
+            flyoutContent.style.display === "block" ? "none" : "block";
+        if (flyoutContent.style.display === "block") {
+            positionFlyout(); // Position the flyout when displayed
+        }
+    });
+    document.body.addEventListener("click", (event) => {
+        if (!span.contains(event.target)) {
+            flyoutContent.style.display = "none"; // Hide on body click
+        }
+    });
+    return span;
+}
+
+
+/***/ }),
+
+/***/ 598:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.ConditionalRenderingError = exports.DOMNodeNotFoundError = exports.DOMNodeInitializationError = void 0;
+class DOMNodeInitializationError extends Error {
+    constructor(instance, error) {
+        super(`There was an error initializing a DOMNodeReference for target: ${instance.target}, :: ${error}`);
+        this.name = "DOMNodeInitializationError";
+    }
+}
+exports.DOMNodeInitializationError = DOMNodeInitializationError;
+class DOMNodeNotFoundError extends Error {
+    constructor(instance) {
+        super(`The targeted DOM element was not found: ${instance.target}`);
+    }
+}
+exports.DOMNodeNotFoundError = DOMNodeNotFoundError;
+class ConditionalRenderingError extends Error {
+    constructor(instance, error) {
+        super(`There was an error condiguring conditional rendering for target: ${instance.target} :: ${error}`);
+    }
+}
+exports.ConditionalRenderingError = ConditionalRenderingError;
+
+
+/***/ }),
+
+/***/ 626:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports["default"] = safeAjax;
+// @ts-nocheck
+function safeAjax(ajaxOptions) {
+    const deferredAjax = $.Deferred();
+    // shell is only available via runtime in a PowerPages portal
+    shell
+        .getTokenDeferred()
+        .done(function (token) {
+        // add headers for AJAX
+        if (!ajaxOptions.headers) {
+            $.extend(ajaxOptions, {
+                headers: {
+                    __RequestVerificationToken: token,
+                },
+            });
+        }
+        else {
+            ajaxOptions.headers["__RequestVerificationToken"] = token;
+        }
+        $.ajax(ajaxOptions)
+            .done(function (data, textStatus, jqXHR) {
+            //eslint-disable-next-line
+            validateLoginSession(data, textStatus, jqXHR, deferredAjax.resolve);
+        })
+            .fail(deferredAjax.reject); //AJAX
+    })
+        .fail(function () {
+        deferredAjax.rejectWith(this, arguments); // on token failure pass the token AJAX and args
+    });
+    return deferredAjax.promise();
+}
+
+
+/***/ }),
+
+/***/ 565:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports["default"] = waitFor;
+function waitFor(target) {
+    return new Promise((resolve, reject) => {
+        // Create observer to watch for target in DOM
+        const observer = new MutationObserver(() => {
+            const observedElement = (document.querySelector(target));
+            if (observedElement) {
+                clearTimeout(timeout);
+                observer.disconnect();
+                resolve(observedElement);
+            }
+        });
+        const timeout = setTimeout(() => {
+            observer.disconnect();
+            reject(new Error(`Element not found: ${target} within 5 seconds`));
+        }, 5000);
+        // Check if target is already in DOM
+        if (target instanceof HTMLElement) {
+            clearTimeout(timeout);
+            return resolve(target);
+        }
+        const element = document.querySelector(target);
+        if (element) {
+            clearTimeout(timeout);
+            return resolve(element);
+        }
+        observer.observe(document.body, {
+            subtree: true,
+            attributes: true,
+            childList: true, // Detects added/removed child elements
+        });
+    });
+}
+
+
+/***/ }),
+
+/***/ 229:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.createMultipleDOMNodeReferences = exports.createDOMNodeReference = exports.API = void 0;
+const API_js_1 = __importDefault(__webpack_require__(377));
+exports.API = API_js_1.default;
+const DOMNodeReferences_js_1 = __webpack_require__(539);
+Object.defineProperty(exports, "createDOMNodeReference", ({ enumerable: true, get: function () { return DOMNodeReferences_js_1.createDOMNodeReference; } }));
+Object.defineProperty(exports, "createMultipleDOMNodeReferences", ({ enumerable: true, get: function () { return DOMNodeReferences_js_1.createMultipleDOMNodeReferences; } }));
+
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			id: moduleId,
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/compat get default export */
+/******/ 	(() => {
+/******/ 		// getDefaultExport function for compatibility with non-harmony modules
+/******/ 		__webpack_require__.n = (module) => {
+/******/ 			var getter = module && module.__esModule ?
+/******/ 				() => (module['default']) :
+/******/ 				() => (module);
+/******/ 			__webpack_require__.d(getter, { a: getter });
+/******/ 			return getter;
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/nonce */
+/******/ 	(() => {
+/******/ 		__webpack_require__.nc = undefined;
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+/******/ 	
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	// This entry module is referenced by other modules so it can't be inlined
+/******/ 	var __webpack_exports__ = __webpack_require__(229);
+/******/ 	module.exports = __webpack_exports__;
+/******/ 	
+/******/ })()
+;
+//# sourceMappingURL=index.js.map