@adobe/alloy 2.27.0 → 2.28.0-beta.1

package/dist/utils.cjs

@@ -0,0 +1,3258 @@
+'use strict';
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/**
+ * Returns true when the value is null.
+ * @param {*} value
+ * @returns {boolean}
+ */
+var isNil = (value) => value == null;
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+/**
+ * Returns whether the value is an object.
+ * @param {*} value
+ * @returns {boolean}
+ */
+var isObject = (value) =>
+  !isNil(value) && !Array.isArray(value) && typeof value === "object";
+
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+var assignConcatArrayValues = (...values) => {
+  if (values.length < 2) {
+    // if the number of args is 0 or 1, just use the default behavior from Object.assign
+    return Object.assign(...values);
+  }
+  return values.reduce((accumulator, currentValue) => {
+    if (isObject(currentValue)) {
+      Object.keys(currentValue).forEach((key) => {
+        if (Array.isArray(currentValue[key])) {
+          if (Array.isArray(accumulator[key])) {
+            accumulator[key].push(...currentValue[key]);
+          } else {
+            // clone the array so the original isn't modified.
+            accumulator[key] = [...currentValue[key]];
+          }
+        } else {
+          accumulator[key] = currentValue[key];
+        }
+      });
+    }
+    return accumulator;
+  }); // no default value to pass into reduce because we want to skip the first value
+};
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/**
+ * Clones a value by serializing then deserializing the value.
+ * @param {*} value
+ * @returns {any}
+ */
+var clone = (value) => JSON.parse(JSON.stringify(value));
+
+/*! js-cookie v3.0.5 | MIT */
+/* eslint-disable no-var */
+function assign (target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i];
+    for (var key in source) {
+      target[key] = source[key];
+    }
+  }
+  return target
+}
+/* eslint-enable no-var */
+
+/* eslint-disable no-var */
+var defaultConverter = {
+  read: function (value) {
+    if (value[0] === '"') {
+      value = value.slice(1, -1);
+    }
+    return value.replace(/(%[\dA-F]{2})+/gi, decodeURIComponent)
+  },
+  write: function (value) {
+    return encodeURIComponent(value).replace(
+      /%(2[346BF]|3[AC-F]|40|5[BDE]|60|7[BCD])/g,
+      decodeURIComponent
+    )
+  }
+};
+/* eslint-enable no-var */
+
+/* eslint-disable no-var */
+
+function init (converter, defaultAttributes) {
+  function set (name, value, attributes) {
+    if (typeof document === 'undefined') {
+      return
+    }
+
+    attributes = assign({}, defaultAttributes, attributes);
+
+    if (typeof attributes.expires === 'number') {
+      attributes.expires = new Date(Date.now() + attributes.expires * 864e5);
+    }
+    if (attributes.expires) {
+      attributes.expires = attributes.expires.toUTCString();
+    }
+
+    name = encodeURIComponent(name)
+      .replace(/%(2[346B]|5E|60|7C)/g, decodeURIComponent)
+      .replace(/[()]/g, escape);
+
+    var stringifiedAttributes = '';
+    for (var attributeName in attributes) {
+      if (!attributes[attributeName]) {
+        continue
+      }
+
+      stringifiedAttributes += '; ' + attributeName;
+
+      if (attributes[attributeName] === true) {
+        continue
+      }
+
+      // Considers RFC 6265 section 5.2:
+      // ...
+      // 3.  If the remaining unparsed-attributes contains a %x3B (";")
+      //     character:
+      // Consume the characters of the unparsed-attributes up to,
+      // not including, the first %x3B (";") character.
+      // ...
+      stringifiedAttributes += '=' + attributes[attributeName].split(';')[0];
+    }
+
+    return (document.cookie =
+      name + '=' + converter.write(value, name) + stringifiedAttributes)
+  }
+
+  function get (name) {
+    if (typeof document === 'undefined' || (arguments.length && !name)) {
+      return
+    }
+
+    // To prevent the for loop in the first place assign an empty array
+    // in case there are no cookies at all.
+    var cookies = document.cookie ? document.cookie.split('; ') : [];
+    var jar = {};
+    for (var i = 0; i < cookies.length; i++) {
+      var parts = cookies[i].split('=');
+      var value = parts.slice(1).join('=');
+
+      try {
+        var found = decodeURIComponent(parts[0]);
+        jar[found] = converter.read(value, found);
+
+        if (name === found) {
+          break
+        }
+      } catch (e) {}
+    }
+
+    return name ? jar[name] : jar
+  }
+
+  return Object.create(
+    {
+      set,
+      get,
+      remove: function (name, attributes) {
+        set(
+          name,
+          '',
+          assign({}, attributes, {
+            expires: -1
+          })
+        );
+      },
+      withAttributes: function (attributes) {
+        return init(this.converter, assign({}, this.attributes, attributes))
+      },
+      withConverter: function (converter) {
+        return init(assign({}, this.converter, converter), this.attributes)
+      }
+    },
+    {
+      attributes: { value: Object.freeze(defaultAttributes) },
+      converter: { value: Object.freeze(converter) }
+    }
+  )
+}
+
+var api = init(defaultConverter, { path: '/' });
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+
+var cookieJar = {
+  get: api.get.bind(api),
+  set: api.set.bind(api),
+  remove: api.remove.bind(api),
+  withConverter: api.withConverter.bind(api)
+};
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+const deepAssignObject = (target, source) => {
+  Object.keys(source).forEach((key) => {
+    if (isObject(target[key]) && isObject(source[key])) {
+      deepAssignObject(target[key], source[key]);
+      return;
+    }
+
+    target[key] = source[key];
+  });
+};
+
+/**
+ * Recursively copy the values of all enumerable own properties from a source item to a target item if the both items are objects
+ * @param {Object} target - a target object
+ * @param {...Object} source - an array of source objects
+ * @example
+ * deepAssign({ a: 'a', b: 'b' }, { b: 'B', c: 'c' });
+ * // { a: 'a', b: 'B', c: 'c' }
+ */
+var deepAssign = (target, ...sources) => {
+  if (isNil(target)) {
+    throw new TypeError('deepAssign "target" cannot be null or undefined');
+  }
+
+  const result = Object(target);
+
+  sources.forEach((source) => deepAssignObject(result, Object(source)));
+
+  return result;
+};
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+/**
+ * Creates a function that, when passed an object of updates, will merge
+ * the updates onto the current value of a payload property.
+ * @param {Object} content The base object to modify
+ * @param {String } key The property to merge updates into. This
+ * can be a dot-notation property path.
+ * @returns {Function}
+ */
+var createMerger = (content, key) => (updates) => {
+  const propertyPath = key.split(".");
+  const hostObjectForUpdates = propertyPath.reduce((obj, propertyName) => {
+    obj[propertyName] = obj[propertyName] || {};
+    return obj[propertyName];
+  }, content);
+  deepAssign(hostObjectForUpdates, updates);
+};
+
+/*
+Copyright 2020 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/**
+ * Allows callbacks to be registered and then later called. When the
+ * callbacks are called, their responses are combined into a single promise.
+ */
+var createCallbackAggregator = () => {
+  const callbacks = [];
+  return {
+    add(callback) {
+      callbacks.push(callback);
+    },
+    call(...args) {
+      // While this utility doesn't necessarily need to be doing the
+      // Promise.all, it's currently useful everywhere this is used and
+      // reduces repetitive code. We can factor it out later if we want
+      // to make this utility more "pure".
+      return Promise.all(callbacks.map((callback) => callback(...args)));
+    },
+  };
+};
+
+const byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+    byteToHex.push((i + 0x100).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+    return (byteToHex[arr[offset + 0]] +
+        byteToHex[arr[offset + 1]] +
+        byteToHex[arr[offset + 2]] +
+        byteToHex[arr[offset + 3]] +
+        '-' +
+        byteToHex[arr[offset + 4]] +
+        byteToHex[arr[offset + 5]] +
+        '-' +
+        byteToHex[arr[offset + 6]] +
+        byteToHex[arr[offset + 7]] +
+        '-' +
+        byteToHex[arr[offset + 8]] +
+        byteToHex[arr[offset + 9]] +
+        '-' +
+        byteToHex[arr[offset + 10]] +
+        byteToHex[arr[offset + 11]] +
+        byteToHex[arr[offset + 12]] +
+        byteToHex[arr[offset + 13]] +
+        byteToHex[arr[offset + 14]] +
+        byteToHex[arr[offset + 15]]).toLowerCase();
+}
+
+let getRandomValues;
+const rnds8 = new Uint8Array(16);
+function rng() {
+    if (!getRandomValues) {
+        if (typeof crypto === 'undefined' || !crypto.getRandomValues) {
+            throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
+        }
+        getRandomValues = crypto.getRandomValues.bind(crypto);
+    }
+    return getRandomValues(rnds8);
+}
+
+const randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+var native = { randomUUID };
+
+function v4(options, buf, offset) {
+    if (native.randomUUID && !buf && !options) {
+        return native.randomUUID();
+    }
+    options = options || {};
+    const rnds = options.random ?? options.rng?.() ?? rng();
+    if (rnds.length < 16) {
+        throw new Error('Random bytes length must be >= 16');
+    }
+    rnds[6] = (rnds[6] & 0x0f) | 0x40;
+    rnds[8] = (rnds[8] & 0x3f) | 0x80;
+    if (buf) {
+        offset = offset || 0;
+        if (offset < 0 || offset + 16 > buf.length) {
+            throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+        }
+        for (let i = 0; i < 16; ++i) {
+            buf[offset + i] = rnds[i];
+        }
+        return buf;
+    }
+    return unsafeStringify(rnds);
+}
+
+/*
+Copyright 20219 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+var createEventMergeId = () => {
+  return {
+    eventMergeId: v4(),
+  };
+};
+
+/*
+Copyright 2022 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+var createLoggingCookieJar = ({ logger, cookieJar }) => {
+  return {
+    ...cookieJar,
+    set(key, value, options) {
+      logger.info("Setting cookie", { name: key, value, ...options });
+      cookieJar.set(key, value, options);
+    },
+  };
+};
+
+/*
+Copyright 2020 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/**
+ * Sequences tasks.
+ */
+var createTaskQueue = () => {
+  let queueLength = 0;
+  let lastPromiseInQueue = Promise.resolve();
+  return {
+    /**
+     * Add a task to the queue. If no task is currenty running,
+     * the task will begin immediately.
+     * @param {Function} task A function that will be called when
+     * the task should be run. If the task it asynchronous, it should
+     * return a promise.
+     * @returns {Promise} A promise that will be resolved or rejected
+     * with whatever value the task resolved or rejects its promise.
+     */
+    addTask(task) {
+      queueLength += 1;
+
+      const lastPromiseFulfilledHandler = () => {
+        return task().finally(() => {
+          queueLength -= 1;
+        });
+      };
+
+      lastPromiseInQueue = lastPromiseInQueue.then(
+        lastPromiseFulfilledHandler,
+        lastPromiseFulfilledHandler,
+      );
+      return lastPromiseInQueue;
+    },
+    /**
+     * How many tasks are in the queue. This includes the task
+     * that's currently running.
+     * @returns {number}
+     */
+    get length() {
+      return queueLength;
+    },
+  };
+};
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/**
+ * A simple utility for managing a promise's state outside of
+ * the promise's "executor" (the function passed into the constructor).
+ */
+var defer = () => {
+  const deferred = {};
+
+  deferred.promise = new Promise((resolve, reject) => {
+    deferred.resolve = resolve;
+    deferred.reject = reject;
+  });
+
+  return deferred;
+};
+
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+const REFERENCE_EQUALITY = (a, b) => a === b;
+
+const findIndex = (array, item, isEqual) => {
+  for (let i = 0; i < array.length; i += 1) {
+    if (isEqual(array[i], item)) {
+      return i;
+    }
+  }
+  return -1;
+};
+
+var deduplicateArray = (array, isEqual = REFERENCE_EQUALITY) => {
+  return array.filter(
+    (item, index) => findIndex(array, item, isEqual) === index,
+  );
+};
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+var appendNodeToDocument = (parent, node) => {
+  return parent.appendChild(node);
+};
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+const populateElementProperties = (element, props) => {
+  Object.keys(props).forEach((key) => {
+    // The following is to support setting style properties to avoid CSP errors.
+    if (key === "style" && isObject(props[key])) {
+      const styleProps = props[key];
+      Object.keys(styleProps).forEach((styleKey) => {
+        element.style[styleKey] = styleProps[styleKey];
+      });
+    } else {
+      element[key] = props[key];
+    }
+  });
+};
+
+var createNodeInDocument = (tag, attrs = {}, props = {}, children = [], doc = document) => {
+  const result = doc.createElement(tag);
+  Object.keys(attrs).forEach((key) => {
+    // TODO: To highlight CSP problems consider throwing a descriptive error
+    //       if nonce is available and key is style.
+    result.setAttribute(key, attrs[key]);
+  });
+  populateElementProperties(result, props);
+  children.forEach((child) => appendNodeToDocument(result, child));
+  return result;
+};
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+const BODY = "BODY";
+const IFRAME = "IFRAME";
+const IMG = "IMG";
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+/**
+ * Fires an image pixel from the current document's window.
+ * @param {object} currentDocument
+ * @param {string} src
+ * @returns {Promise}
+ */
+var fireImageInDocument = ({ src, currentDocument = document }) => {
+  return new Promise((resolve, reject) => {
+    const attrs = { src };
+    const props = {
+      onload: resolve,
+      onerror: reject,
+      onabort: reject,
+    };
+
+    createNodeInDocument(IMG, attrs, props, [], currentDocument);
+  });
+};
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/**
+ * Returns whether the value is a function.
+ * @param {*} value
+ * @returns {boolean}
+ */
+var isFunction = (value) => typeof value === "function";
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/**
+ * Returns whether the value is a non-empty array.
+ * @param {*} value
+ * @returns {boolean}
+ */
+var isNonEmptyArray = (value) => Array.isArray(value) && value.length > 0;
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+var toArray = (value) => {
+  if (Array.isArray(value)) {
+    return value;
+  }
+
+  if (value == null) {
+    return [];
+  }
+
+  return [].slice.call(value);
+};
+
+/*
+Copyright 2021 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+const SIBLING_PATTERN = /^\s*>/;
+
+var querySelectorAll = (context, selector) => {
+  if (!SIBLING_PATTERN.test(selector)) {
+    return toArray(context.querySelectorAll(selector));
+  }
+  return toArray(context.querySelectorAll(`:scope ${selector}`));
+};
+
+/*
+Copyright 2022 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+var SHADOW_SEPARATOR = ":shadow";
+
+/*
+Copyright 2021 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+const splitWithShadow = (selector) => {
+  return selector.split(SHADOW_SEPARATOR);
+};
+
+const transformPrefix = (parent, selector) => {
+  const result = selector;
+  const hasChildCombinatorPrefix = result.startsWith(">");
+  if (!hasChildCombinatorPrefix) {
+    return result;
+  }
+
+  const prefix =
+    parent instanceof Element || parent instanceof Document
+      ? ":scope"
+      : ":host"; // see https://bugs.webkit.org/show_bug.cgi?id=233380
+
+  return `${prefix} ${result}`;
+};
+
+var selectNodesWithShadow = (context, selector) => {
+  const parts = splitWithShadow(selector);
+
+  if (parts.length < 2) {
+    return querySelectorAll(context, selector);
+  }
+
+  // split the selector into parts separated by :shadow pseudo-selectors
+  // find each subselector element based on the previously selected node's shadowRoot
+  let parent = context;
+  for (let i = 0; i < parts.length; i += 1) {
+    const part = parts[i].trim();
+    // if part is empty, it means there's a chained :eq:shadow selector
+    if (part === "" && parent.shadowRoot) {
+      parent = parent.shadowRoot;
+
+      continue;
+    }
+    const prefixed = transformPrefix(parent, part);
+    const partNode = querySelectorAll(parent, prefixed);
+
+    if (partNode.length === 0 || !partNode[0] || !partNode[0].shadowRoot) {
+      return partNode;
+    }
+
+    parent = partNode[0].shadowRoot;
+  }
+  return undefined;
+};
+
+/*
+Copyright 2022 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+var isShadowSelector = (str) => str.indexOf(SHADOW_SEPARATOR) !== -1;
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+/**
+ * Returns an array of matched DOM nodes.
+ * @param {String} selector
+ * @param {Node} [context=document] defaults to document
+ * @returns {Array} an array of DOM nodes
+ */
+var selectNodes = (selector, context = document) => {
+  if (!isShadowSelector(selector)) {
+    return querySelectorAll(context, selector);
+  }
+
+  return selectNodesWithShadow(context, selector);
+};
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+const MUTATION_OBSERVER = "MutationObserver";
+const RAF = "requestAnimationFrame";
+const MUTATION_OBSERVER_CONFIG = { childList: true, subtree: true };
+const VISIBILITY_STATE = "visibilityState";
+const VISIBLE = "visible";
+const DELAY = 100;
+const MAX_POLLING_TIMEOUT = 5000;
+
+const createError = (selector) => {
+  return new Error(`Could not find: ${selector}`);
+};
+
+const createPromise = (executor) => {
+  return new Promise(executor);
+};
+
+const canUseMutationObserver = (win) => {
+  return isFunction(win[MUTATION_OBSERVER]);
+};
+
+const awaitUsingMutationObserver = (
+  win,
+  doc,
+  selector,
+  timeout,
+  selectFunc,
+) => {
+  return createPromise((resolve, reject) => {
+    let timer;
+
+    const mutationObserver = new win[MUTATION_OBSERVER](() => {
+      const nodes = selectFunc(selector);
+
+      if (isNonEmptyArray(nodes)) {
+        mutationObserver.disconnect();
+        if (timer) {
+          clearTimeout(timer);
+        }
+        resolve(nodes);
+      }
+    });
+
+    timer = setTimeout(() => {
+      mutationObserver.disconnect();
+      reject(createError(selector));
+    }, timeout);
+
+    mutationObserver.observe(doc, MUTATION_OBSERVER_CONFIG);
+  });
+};
+
+const canUseRequestAnimationFrame = (doc) => {
+  return doc[VISIBILITY_STATE] === VISIBLE;
+};
+
+const awaitUsingRequestAnimation = (
+  win,
+  selector,
+  timeout,
+  selectFunc,
+) => {
+  return createPromise((resolve, reject) => {
+    const execute = () => {
+      const nodes = selectFunc(selector);
+
+      if (isNonEmptyArray(nodes)) {
+        resolve(nodes);
+        return;
+      }
+
+      win[RAF](execute);
+    };
+
+    execute();
+
+    setTimeout(() => {
+      reject(createError(selector));
+    }, timeout);
+  });
+};
+
+const awaitUsingTimer = (selector, timeout, selectFunc) => {
+  return createPromise((resolve, reject) => {
+    const execute = () => {
+      const nodes = selectFunc(selector);
+
+      if (isNonEmptyArray(nodes)) {
+        resolve(nodes);
+        return;
+      }
+
+      setTimeout(execute, DELAY);
+    };
+
+    execute();
+
+    setTimeout(() => {
+      reject(createError(selector));
+    }, timeout);
+  });
+};
+
+var awaitSelectorInDocument = (
+  selector,
+  selectFunc = selectNodes,
+  timeout = MAX_POLLING_TIMEOUT,
+  win = window,
+  doc = document,
+) => {
+  const nodes = selectFunc(selector);
+
+  if (isNonEmptyArray(nodes)) {
+    return Promise.resolve(nodes);
+  }
+
+  if (canUseMutationObserver(win)) {
+    return awaitUsingMutationObserver(win, doc, selector, timeout, selectFunc);
+  }
+
+  if (canUseRequestAnimationFrame(doc)) {
+    return awaitUsingRequestAnimation(win, selector, timeout, selectFunc);
+  }
+
+  return awaitUsingTimer(selector, timeout, selectFunc);
+};
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+const IFRAME_ATTRS = {
+  name: "Adobe Alloy",
+};
+
+const IFRAME_PROPS = {
+  style: {
+    display: "none",
+    width: 0,
+    height: 0,
+  },
+};
+
+var injectFireReferrerHideableImage = ({
+  appendNode = appendNodeToDocument,
+  awaitSelector = awaitSelectorInDocument,
+  createNode = createNodeInDocument,
+  fireImage = fireImageInDocument,
+} = {}) => {
+  const fireOnPage = fireImage;
+
+  let hiddenIframe;
+
+  const createIframe = () => {
+    return awaitSelector(BODY).then(([body]) => {
+      if (hiddenIframe) {
+        return hiddenIframe;
+      }
+      hiddenIframe = createNode(IFRAME, IFRAME_ATTRS, IFRAME_PROPS);
+      return appendNode(body, hiddenIframe);
+    });
+  };
+
+  const fireInIframe = ({ src }) => {
+    return createIframe().then((iframe) => {
+      const currentDocument = iframe.contentWindow.document;
+      return fireImage({ src, currentDocument });
+    });
+  };
+
+  return (request) => {
+    const { hideReferrer, url } = request;
+    return hideReferrer ? fireInIframe({ src: url }) : fireOnPage({ src: url });
+  };
+};
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+/**
+ * Returns whether the value is an empty object.
+ * @param {*} value
+ * @returns {boolean}
+ */
+var isEmptyObject = (value) => isObject(value) && Object.keys(value).length === 0;
+
+/*
+Copyright 2022 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+/**
+ * Given an object and a function that takes a value and returns a predicate, filter out
+ * all non-object deeply nested values that do not pass the predicate.
+ *
+ * Example: filterObject({ a: 2, b: { c: 6 } }, (val) => val > 5) returns { b { c: 6 } }
+ *
+ * @param {*} obj
+ * @param {* => boolean} predicate a function that takes a value and return a boolean,
+ * representing if it should be included in the result object or not.
+ * @returns A copy of the original object with the values that fail the predicate, filtered out.
+ */
+const filterObject = (obj, predicate) => {
+  if (isNil(obj) || !isObject(obj)) {
+    return obj;
+  }
+  return Object.keys(obj).reduce((result, key) => {
+    const value = obj[key];
+    if (isObject(value)) {
+      // value is object, go deeper
+      const filteredValue = filterObject(value, predicate);
+      if (isEmptyObject(filteredValue)) {
+        return result;
+      }
+      return { ...result, [key]: filteredValue };
+    }
+    // value is not an object, test predicate
+    if (predicate(value)) {
+      return { ...result, [key]: value };
+    }
+    return result;
+  }, {});
+};
+
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/* eslint-disable no-bitwise */
+
+/**
+ * Generates an FNV1A32 hash for the given input string.
+ * @param {string} str - The string to hash
+ * @returns {number} - The 32-bit FNV1A hash as a number
+ */
+const fnv1a32 = (str) => {
+  // FNV_offset_basis for 32-bit hash
+  let hash = 0x811c9dc5;
+
+  // FNV_prime for 32-bit hash
+  const prime = 0x01000193;
+
+  // Convert the string to a properly encoded UTF-8 byte array
+  const utf8Encoder = new TextEncoder();
+  const bytes = utf8Encoder.encode(str);
+
+  // Process each byte in the UTF-8 encoded array
+  for (let i = 0; i < bytes.length; i += 1) {
+    // XOR the hash with the byte value, then multiply by prime
+    hash ^= bytes[i];
+    hash = Math.imul(hash, prime);
+  }
+
+  // Return the final hash value (unsigned 32-bit integer)
+  return hash >>> 0;
+};
+
+/**
+ * Generates an FNV1A32 hash and returns it as a hexadecimal string.
+ * @param {string} str - The string to hash
+ * @returns {string} - The 32-bit FNV1A hash as a hexadecimal string
+ */
+const fnv1a32Hex = (str) => fnv1a32(str).toString(16).padStart(8, "0");
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+var baseNamespace = "com.adobe.alloy.";
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/**
+ * Returns the last N number of items from an array.
+ * @param {Array} arr
+ * @param {number} itemCount
+ * @returns {Array}
+ */
+var getLastArrayItems = (arr, itemCount) => arr.slice(-itemCount);
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+const cookieName = `${baseNamespace}getTld`;
+
+/**
+ * Of the current web page's hostname, this is the top-most domain that is
+ * not a "public suffix" as outlined in https://publicsuffix.org/. In other
+ * words, this is top-most domain that is able to accept cookies.
+ * @param {Object} window
+ * @param {Object} cookieJar
+ * @returns {string}
+ */
+var getApexDomain = (window, cookieJar) => {
+  let topLevelCookieDomain = "";
+
+  // If hostParts.length === 1, we may be on localhost.
+  const hostParts = window.location.hostname.toLowerCase().split(".");
+  let i = 1;
+
+  while (i < hostParts.length && !cookieJar.get(cookieName)) {
+    i += 1;
+    topLevelCookieDomain = getLastArrayItems(hostParts, i).join(".");
+    cookieJar.set(cookieName, cookieName, { domain: topLevelCookieDomain });
+  }
+
+  cookieJar.remove(cookieName, { domain: topLevelCookieDomain });
+
+  return topLevelCookieDomain;
+};
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+// Remember to also incorporate the org ID wherever cookies are read or written.
+var COOKIE_NAME_PREFIX = "kndctr";
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+var sanitizeOrgIdForCookieName = (orgId) => orgId.replace("@", "_");
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+var getNamespacedCookieName = (orgId, key) =>
+  `${COOKIE_NAME_PREFIX}_${sanitizeOrgIdForCookieName(orgId)}_${key}`;
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/**
+ * Group an array by a key getter provided
+ * @param {Array} arr Array to iterate over.
+ * @param {Function} keyGetter The key getter by which to group.
+ * @returns {Object}
+ */
+var groupBy = (arr, keyGetter) => {
+  const result = {};
+
+  arr.forEach((item) => {
+    const key = keyGetter(item);
+
+    if (!result[key]) {
+      result[key] = [];
+    }
+
+    result[key].push(item);
+  });
+
+  return result;
+};
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+const CHROME = "Chrome";
+const EDGE = "Edge";
+const EDGE_CHROMIUM = "EdgeChromium";
+const FIREFOX = "Firefox";
+const IE = "IE";
+const SAFARI = "Safari";
+const UNKNOWN = "Unknown";
+
+/*
+Copyright 2024 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+var lazy = (fn) => {
+  let called = false;
+  let result;
+  return () => {
+    if (!called) {
+      called = true;
+      result = fn();
+    }
+    return result;
+  };
+};
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+// Users could have also disabled third-party cookies within these browsers, but
+// we don't know. We also assume "unknown" browsers support third-party cookies,
+// though we don't really know that either. We're making best guesses.
+const browsersSupportingThirdPartyCookie = [
+  CHROME,
+  EDGE,
+  EDGE_CHROMIUM,
+  IE,
+  UNKNOWN,
+];
+
+var injectAreThirdPartyCookiesSupportedByDefault = ({ getBrowser }) =>
+  lazy(() => browsersSupportingThirdPartyCookie.includes(getBrowser()));
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+const IDENTITY = "identity";
+
+/*
+Copyright 2020 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+var injectDoesIdentityCookieExist = ({ orgId }) => {
+  const identityCookieName = getNamespacedCookieName(orgId, IDENTITY);
+  /**
+   * Returns whether the identity cookie exists.
+   */
+  return () => Boolean(cookieJar.get(identityCookieName));
+};
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+const matchUserAgent = (regexs, userAgent) => {
+  const keys = Object.keys(regexs);
+  for (let i = 0; i < keys.length; i += 1) {
+    const key = keys[i];
+    const regex = regexs[key];
+    if (regex.test(userAgent)) {
+      return key;
+    }
+  }
+  return UNKNOWN;
+};
+
+var injectGetBrowser = ({ userAgent }) => {
+  return lazy(() =>
+    matchUserAgent(
+      {
+        /*
+      The MIT License (MIT)
+
+      Copyright (c) 2019 Damon Oehlman damon.oehlman@gmail.com
+
+      Permission is hereby granted, free of charge, to any person obtaining a copy
+      of this software and associated documentation files (the "Software"), to
+      deal in the Software without restriction, including without limitation the
+      rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+      sell copies of the Software, and to permit persons to whom the Software is
+      furnished to do so, subject to the following conditions:
+
+      The above copyright notice and this permission notice shall be included in
+      all copies or substantial portions of the Software.
+
+      THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+      IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+      FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+      AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+      LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+      FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+      DEALINGS IN THE SOFTWARE.
+      */
+        // Regular expression patterns were copied from
+        // https://github.com/DamonOehlman/detect-browser
+        // These are only the browsers that Alloy officially supports.
+        /* eslint-disable */
+        [EDGE]: /Edge\/([0-9\._]+)/,
+        // Edge Chromium can dynamically change its user agent string based
+        // on the host site:
+        // https://winaero.com/blog/microsoft-edge-chromium-dynamically-changes-its-user-agent/
+        [EDGE_CHROMIUM]: /Edg\/([0-9\.]+)/,
+        [CHROME]: /(?!Chrom.*OPR)Chrom(?:e|ium)\/([0-9\.]+)(:?\s|$)/,
+        [FIREFOX]: /Firefox\/([0-9\.]+)(?:\s|$)/,
+        // This only covers version 11 of IE, but that's all we support.
+        [IE]: /Trident\/7\.0.*rv\:([0-9\.]+).*\).*Gecko$/,
+        [SAFARI]: /Version\/([0-9\._]+).*Safari/,
+        /* eslint-enable */
+      },
+      userAgent,
+    ),
+  );
+};
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+const getStorageByType = (context, storageType, namespace) => {
+  // When storage is disabled on Safari, the mere act of referencing
+  // window.localStorage or window.sessionStorage throws an error.
+  // For this reason, we wrap in a try-catch.
+  return {
+    /**
+     * Reads a value from storage.
+     * @param {string} name The name of the item to be read.
+     * @returns {string}
+     */
+    getItem(name) {
+      try {
+        return context[storageType].getItem(namespace + name);
+      } catch {
+        return null;
+      }
+    },
+    /**
+     * Saves a value to storage.
+     * @param {string} name The name of the item to be saved.
+     * @param {string} value The value of the item to be saved.
+     * @returns {boolean} Whether the item was successfully saved to storage.
+     */
+    setItem(name, value) {
+      try {
+        context[storageType].setItem(namespace + name, value);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    /**
+     * Clear all values in storage that match the namespace.
+     */
+    clear() {
+      try {
+        Object.keys(context[storageType]).forEach((key) => {
+          if (key.startsWith(namespace)) {
+            context[storageType].removeItem(key);
+          }
+        });
+        return true;
+      } catch {
+        return false;
+      }
+    },
+  };
+};
+
+var injectStorage = (context) => (additionalNamespace) => {
+  const finalNamespace = baseNamespace + additionalNamespace;
+  return {
+    session: getStorageByType(context, "sessionStorage", finalNamespace),
+    persistent: getStorageByType(context, "localStorage", finalNamespace),
+  };
+};
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+/**
+ * Returns items that are found within both arrays.
+ * @param {Array} a
+ * @param {Array} b
+ * @returns {Array}
+ */
+var intersection = (a, b) => a.filter((x) => b.includes(x));
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/**
+ * Returns whether the value is a boolean.
+ * @param {*} value
+ * @returns {boolean}
+ */
+var isBoolean = (value) => typeof value === "boolean";
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/**
+ * Returns whether the value is a number.
+ * @param {*} value
+ * @returns {boolean}
+ */
+var isNumber = (value) => typeof value === "number" && !Number.isNaN(value);
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+/**
+ * Returns whether the value is an integer.
+ * @param {*} value
+ * @returns {boolean}
+ */
+var isInteger = (value) => {
+  const parsed = parseInt(value, 10);
+
+  return isNumber(parsed) && value === parsed;
+};
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+/**
+ * Determines whether a cookie name is namespaced according to the contract
+ * defined by the server.
+ * @param {String} orgId The org ID configured for the Alloy instance.
+ * @param {String} name The cookie name.
+ * @returns {boolean}
+ */
+var isNamespacedCookieName = (orgId, name) =>
+  name.indexOf(
+    `${COOKIE_NAME_PREFIX}_${sanitizeOrgIdForCookieName(orgId)}_`,
+  ) === 0;
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/**
+ * Returns whether the value is a string.
+ * @param {*} value
+ * @returns {boolean}
+ */
+var isString = (value) => typeof value === "string";
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+/**
+ * Returns whether the value is a populated string.
+ * @param {*} value
+ * @returns {boolean}
+ */
+var isNonEmptyString = (value) => isString(value) && value.length > 0;
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/**
+ * A function that performs no operations.
+ */
+var noop = () => {};
+
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+const parseDomainBasic = (host) => {
+  const result = {};
+  const domainParts = host.split(".");
+
+  switch (domainParts.length) {
+    case 1:
+      result.subdomain = "";
+      result.domain = host;
+      result.topLevelDomain = "";
+      break;
+    case 2:
+      result.subdomain = "";
+      result.domain = host;
+      result.topLevelDomain = domainParts[1];
+      break;
+    case 3:
+      result.subdomain = domainParts[0] === "www" ? "" : domainParts[0];
+      result.domain = host;
+      result.topLevelDomain = domainParts[2];
+      break;
+    case 4:
+      result.subdomain = domainParts[0] === "www" ? "" : domainParts[0];
+      result.domain = host;
+      result.topLevelDomain = `${domainParts[2]}.${domainParts[3]}`;
+      break;
+  }
+
+  return result;
+};
+
+/**
+ * @typedef {Object} ParseUriResult
+ * @property {string} host
+ * @property {string} path
+ * @property {string} query
+ * @property {string} anchor
+ *
+ * @param {string} url
+ * @returns {ParseUriResult}
+ */
+const parseUri = (url) => {
+  try {
+    const parsed = new URL(url);
+    let path = parsed.pathname;
+    if (!url.endsWith("/") && path === "/") {
+      path = "";
+    }
+    return {
+      host: parsed.hostname,
+      path,
+      query: parsed.search.replace(/^\?/, ""),
+      anchor: parsed.hash.replace(/^#/, ""),
+    };
+  } catch {
+    return {
+      host: "",
+      path: "",
+      query: "",
+      anchor: "",
+    };
+  }
+};
+
+const parseUrl = (url, parseDomain = parseDomainBasic) => {
+  if (!isString(url)) {
+    url = "";
+  }
+
+  const parsed = parseUri(url);
+  const { host, path, query, anchor } = parsed;
+
+  return {
+    path,
+    query,
+    fragment: anchor,
+    ...parseDomain(host),
+  };
+};
+
+/*
+Copyright 2022 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+// We want to avoid mapping between specific keys because we want Konductor
+// to be able to add overrides in the future without us needing to make
+// any changes to the Web SDK
+var prepareConfigOverridesForEdge = (configuration) => {
+  if (isNil(configuration) || typeof configuration !== "object") {
+    return null;
+  }
+  // remove entries that are empty strings or arrays
+  const configOverrides = filterObject(configuration, (value) => {
+    if (isNil(value)) {
+      return false;
+    }
+    if (isBoolean(value)) {
+      return true;
+    }
+    if (isNumber(value)) {
+      return true;
+    }
+    if (isNonEmptyString(value)) {
+      return true;
+    }
+    if (isNonEmptyArray(value)) {
+      return true;
+    }
+    return false;
+  });
+  if (isEmptyObject(configOverrides)) {
+    return null;
+  }
+
+  return configOverrides;
+};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+/***************************************************************************************
+ * (c) 2017 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ ****************************************************************************************/
+
+var reactorQueryString;
+var hasRequiredReactorQueryString;
+
+function requireReactorQueryString () {
+	if (hasRequiredReactorQueryString) return reactorQueryString;
+	hasRequiredReactorQueryString = 1;
+
+	/**
+	 * Parse a query string into an object. Leading `?` or `#` are ignored, so you
+	 * can pass `location.search` or `location.hash` directly.
+	 *
+	 * URL components are decoded with decode-uri-component.
+	 *
+	 * Parse arrays with elements using duplicate keys, e.g. ?a=1&a=2 becomes
+	 * {a: ['1', '2']}.
+	 *
+	 * Query keys are sorted alphabetically.
+	 *
+	 * Numbers and booleans are NOT parsed; they are left as strings.
+	 * @param {string} query the query part of a url
+	 * @returns {{ [key: string]: string | string[] | undefined }} the parsed query string
+	 */
+	var parseQueryString = function (query) {
+	  /** @type {{[key: string]: string | string[] | undefined }} */
+	  var result = {};
+
+	  if (!query || typeof query !== 'string') {
+	    return result;
+	  }
+
+	  var cleanQuery = query.trim().replace(/^[?#&]/, '');
+	  var params = new URLSearchParams(cleanQuery);
+
+	  var iter = params.keys();
+	  do {
+	    var v = iter.next();
+	    var key = v.value;
+
+	    if (key) {
+	      var values = params.getAll(key);
+	      if (values.length === 1) {
+	        result[key] = values[0];
+	      } else {
+	        result[key] = values;
+	      }
+	    }
+	  } while (v.done === false);
+
+	  return result;
+	};
+
+	/**
+	 * Transform an object into a query string.
+	 *
+	 * Keys having object values are ignored.
+	 *
+	 * @param {object} the object to transform into a query string
+	 * @returns {string} the parsed query string
+	 */
+
+	var stringifyObject = function (object) {
+	  var spaceToken = '{{space}}';
+	  var params = new URLSearchParams();
+
+	  Object.keys(object).forEach(function (key) {
+	    var value = object[key];
+
+	    if (typeof object[key] === 'string') {
+	      value = value.replace(/ /g, spaceToken);
+	    } else if (
+	      ['object', 'undefined'].includes(typeof value) &&
+	      !Array.isArray(value)
+	    ) {
+	      value = '';
+	    }
+
+	    if (Array.isArray(value)) {
+	      value.forEach(function (arrayValue) {
+	        params.append(key, arrayValue);
+	      });
+	    } else {
+	      params.append(key, value);
+	    }
+	  });
+
+	  return params
+	    .toString()
+	    .replace(new RegExp(encodeURIComponent(spaceToken), 'g'), '%20');
+	};
+
+	// We proxy the underlying querystring module so we can limit the API we expose.
+	// This allows us to more easily make changes to the underlying implementation later without
+	// having to worry about breaking extensions. If extensions demand additional functionality, we
+	// can make adjustments as needed.
+	reactorQueryString = {
+	  parse: function (string) {
+	    return parseQueryString(string);
+	  },
+	  stringify: function (object) {
+	    return stringifyObject(object);
+	  }
+	};
+	return reactorQueryString;
+}
+
+var reactorQueryStringExports = requireReactorQueryString();
+var queryString = /*@__PURE__*/getDefaultExportFromCjs(reactorQueryStringExports);
+
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/**
+ * Recursively sorts the properties of all objects within the provided data structure.
+ * @param {Object|Array} data - The data structure to serialize. It can be an object or an array.
+ * @returns {Object|Array} - A new object or array with allo the container object having properties sorted.
+ */
+const sortObjectPropertiesDeep = (data) => {
+  if (Array.isArray(data)) {
+    return data.map((value) => sortObjectPropertiesDeep(value));
+  }
+
+  if (typeof data === "object" && data !== null) {
+    return Object.keys(data)
+      .sort()
+      .reduce((memo, key) => {
+        memo[key] = sortObjectPropertiesDeep(data[key]);
+        return memo;
+      }, {});
+  }
+
+  return data;
+};
+
+/**
+ * This utility helps create consistent serialized representations of objects
+ * by eliminating variations caused by property order. This is useful for creating
+ * reliable hashes or checksums containing these objects.
+ * @param {Object|Array} data - The data structure to serialize. It can be an object or an array.
+ * @returns {Object|Array} - A new object or array with allo the container object having properties sorted.
+ */
+var sortObjectKeysRecursively = (data) => sortObjectPropertiesDeep(data);
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/**
+ * Creates and returns a new error using the provided value as a message.
+ * If the provided value is already an Error, it will be returned unmodified.
+ * @param {*} value
+ * @returns {Error}
+ */
+var toError = (value) => {
+  return value instanceof Error ? value : new Error(value);
+};
+
+/*
+Copyright 2020 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+var updateErrorMessage = ({ error, message }) => {
+  try {
+    error.message = message;
+  } catch {
+    // We'll set a new message when we can, but some errors, like DOMException,
+    // have a read-only message property, which limits our options.
+  }
+};
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+/**
+ * Augments an error's message with additional context as it bubbles up the call stack.
+ * @param {Object} options
+ * @param {String} options.message The message to be added to the error.
+ * @param {Error} options.error Optimally, this is an instance of Error. If it is not,
+ * this is used as the basis for the message of a newly created Error instance.
+ * @returns {*}
+ */
+var stackError = ({ error, message }) => {
+  const errorToStack = toError(error);
+  const newMessage = `${message}\nCaused by: ${errorToStack.message}`;
+  updateErrorMessage({
+    error: errorToStack,
+    message: newMessage,
+  });
+  return errorToStack;
+};
+
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+var stringToBoolean = (str) => {
+  return isString(str) && str.toLowerCase() === "true";
+};
+
+/*
+Copyright 2022 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+/*
+ * coerce `value` to a number or return `defaultValue` if it cannot be.
+ *
+ * The coersion is attempted if value is a number or string.
+ */
+var toInteger = (value, defaultValue) => {
+  if (isNumber(value) || isString(value)) {
+    const n = Math.round(Number(value));
+    if (!Number.isNaN(n)) {
+      return n;
+    }
+  }
+  return defaultValue;
+};
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/**
+ * Add padString to the start of the string until it reaches the target length
+ *
+ * Different from String.prototype.padStart because this function coerces the
+ * input to a string before padding.
+ * @param {any} string
+ * @param {number} targetLength
+ * @param {string} padString
+ * @returns {string}
+ */
+const padStart = (string, targetLength, padString) => {
+  return `${string}`.padStart(targetLength, padString);
+};
+
+/**
+ * Formats the date into an ISO date-time string in the local timezone
+ * @param {Date} date
+ * @returns {string}
+ */
+var toISOStringLocal = (date) => {
+  const YYYY = date.getFullYear();
+  const MM = padStart(date.getMonth() + 1, 2, "0");
+  const DD = padStart(date.getDate(), 2, "0");
+
+  const hh = padStart(date.getHours(), 2, "0");
+  const mm = padStart(date.getMinutes(), 2, "0");
+  const ss = padStart(date.getSeconds(), 2, "0");
+  const mmm = padStart(date.getMilliseconds(), 3, "0");
+
+  // The time-zone offset is the difference, in minutes, from local time to UTC. Note that this
+  // means that the offset is positive if the local timezone is behind UTC and negative if it is
+  // ahead. For example, for time zone UTC+10:00, -600 will be returned.
+  const timezoneOffset = toInteger(date.getTimezoneOffset(), 0);
+  const ts = timezoneOffset > 0 ? "-" : "+";
+  const th = padStart(Math.floor(Math.abs(timezoneOffset) / 60), 2, "0");
+  const tm = padStart(Math.abs(timezoneOffset) % 60, 2, "0");
+
+  return `${YYYY}-${MM}-${DD}T${hh}:${mm}:${ss}.${mmm}${ts}${th}:${tm}`;
+};
+
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/**
+ * Wraps a validator returning the value if it is null or undefined, otherwise
+ * it will call the original validator and return the result.
+ *
+ * @param {function} validator - the validator to call if the value is not null
+ */
+const skipIfNull = (validator) =>
+  function skipIfNullValidator(value, path) {
+    return value == null ? value : validator.call(this, value, path);
+  };
+
+/**
+ * Returns a new validator that calls the first validator and then calls the second
+ * validator with the result of the first validator. The result of the second validator
+ * is returned.
+ *
+ * @param {function} firstValidator - validator to call first
+ * @param {function} secondValidator - validator to call second
+ * @returns {function} - a new validator that calls the first and second validators
+ */
+const callSequentially = (firstValidator, secondValidator) =>
+  function callSequentiallyValidator(value, path) {
+    return secondValidator.call(
+      this,
+      firstValidator.call(this, value, path),
+      path,
+    );
+  };
+
+/**
+ * Just like callSequentially, but if either validator throws an error, the errors
+ * are collected and thrown at the end.
+ *
+ * @param {function} firstValidator
+ * @param {function} secondValidator
+ * @returns {function}
+ */
+const callSequentiallyJoinErrors = (firstValidator, secondValidator) =>
+  function callSequentiallyJoinErrorsValidator(value, path) {
+    const errors = [];
+    const newValue = [firstValidator, secondValidator].reduce(
+      (memo, validator) => {
+        try {
+          return validator.call(this, memo, path);
+        } catch (e) {
+          errors.push(e);
+          return memo;
+        }
+      },
+      value,
+    );
+    if (errors.length) {
+      throw new Error(errors.join("\n"));
+    }
+    return newValue;
+  };
+
+/**
+ * Chains two validators together. In addition to calling the validators in
+ * sequence, this will also copy over methods from the base validator to the
+ * resulting validator and include any additional methods.
+ *
+ * @param {function} baseValidator - This validator will be called first, and its
+ * methods will be copied over to the returned validator.
+ * @param {function} newValidator - This validator will be called second.
+ * @param {object} additionalMethods - Additional methods to include on the returned
+ * validator.
+ * @returns {function}
+ */
+const chain = (baseValidator, newValidator, additionalMethods) => {
+  return Object.assign(
+    callSequentially(baseValidator, newValidator),
+    baseValidator,
+    additionalMethods,
+  );
+};
+
+/**
+ * Chains two validators together, but skips the second validator if the value
+ * is null. In addition to calling the validators in sequence, this will also
+ * copy over methods from the base validator to the resulting validator and
+ * include any additional methods.
+ *
+ * @param {function} baseValidator - This validator will be called first, and its
+ * methods will be copied over to the returned validator.
+ * @param {function} newValidator - This validator will be called second. If the value
+ * is null after the first validator is called, this validator will not be
+ * called.
+ * @param {object} additionalMethods - Additional methods to include on the returned
+ * validator.
+ * @returns {function}
+ */
+const nullSafeChain = (
+  baseValidator,
+  newValidator,
+  additionalMethods,
+) => {
+  return Object.assign(
+    callSequentially(baseValidator, skipIfNull(newValidator)),
+    baseValidator,
+    additionalMethods,
+  );
+};
+
+/**
+ * Same as nullSafeChain, but calls the new validator first.
+ *
+ * @param {function} baseValidator - This validator will be called second, and its
+ * methods will be copied over to the returned validator.
+ * @param {function} newValidator - This validator will be called first. If the value
+ * is null, this validator will not be called.
+ * @param {function} additionalMethods - Additional methods to include on the returned
+ * validator.
+ * @returns {function}
+ */
+const reverseNullSafeChainJoinErrors = (
+  baseValidator,
+  newValidator,
+  additionalMethods,
+) => {
+  return Object.assign(
+    callSequentiallyJoinErrors(skipIfNull(newValidator), baseValidator),
+    baseValidator,
+    additionalMethods,
+  );
+};
+
+/**
+ * Throws an error if the value is not valid.
+ *
+ * @param {boolean} isValid - Whether or not the value is valid.
+ * @param {*} value - The value to validate.
+ * @param {string} path - The path to the value.
+ * @param {string} message - The expected part of the error message.
+ * @throws {Error} - Throws an error if the value is not valid.
+ * @returns {void}
+ */
+const assertValid = (isValid, value, path, message) => {
+  if (!isValid) {
+    throw new Error(
+      `'${path}': Expected ${message}, but got ${JSON.stringify(value)}.`,
+    );
+  }
+};
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+var booleanValidator = (value, path) => {
+  assertValid(isBoolean(value), value, path, "true or false");
+  return value;
+};
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+var callbackValidator = (value, path) => {
+  assertValid(isFunction(value), value, path, "a function");
+  return value;
+};
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+var createAnyOfValidator = (validators, message) =>
+  function anyOf(value, path) {
+    let newValue;
+    const valid = validators.find((validator) => {
+      try {
+        newValue = validator.call(this, value, path);
+        return true;
+      } catch {
+        return false;
+      }
+    });
+    assertValid(valid, value, path, message);
+    return newValue;
+  };
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+var createArrayOfValidator = (elementValidator) =>
+  function arrayOf(value, path) {
+    assertValid(Array.isArray(value), value, path, "an array");
+    const errors = [];
+    const validatedArray = value.map((subValue, i) => {
+      try {
+        return elementValidator.call(this, subValue, `${path}[${i}]`, value);
+      } catch (e) {
+        errors.push(e.message);
+        return undefined;
+      }
+    });
+    if (errors.length) {
+      throw new Error(errors.join("\n"));
+    }
+    return validatedArray;
+  };
+
+/*
+Copyright 2020 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+var createDefaultValidator = (defaultValue) => (value) => {
+  if (value == null) {
+    return defaultValue;
+  }
+  return value;
+};
+
+/*
+Copyright 2024 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+var createDeprecatedValidator = (warning = "This field has been deprecated") =>
+  function deprecated(value, path) {
+    let message = warning;
+    if (value !== undefined) {
+      if (path) {
+        message = `'${path}': ${message}`;
+      }
+      if (this && this.logger) {
+        this.logger.warn(message);
+      }
+    }
+    return value;
+  };
+
+/*
+Copyright 2020 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+var createLiteralValidator = (literalValue) => (value, path) => {
+  assertValid(value === literalValue, value, path, `${literalValue}`);
+  return value;
+};
+
+/*
+Copyright 2020 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+var createMapOfValuesValidator = (valueValidator) =>
+  function mapOfValues(value, path) {
+    assertValid(isObject(value), value, path, "an object");
+
+    const errors = [];
+    const validatedObject = {};
+    Object.keys(value).forEach((subKey) => {
+      const subValue = value[subKey];
+      const subPath = path ? `${path}.${subKey}` : subKey;
+      try {
+        const validatedValue = valueValidator.call(this, subValue, subPath);
+        if (validatedValue !== undefined) {
+          validatedObject[subKey] = validatedValue;
+        }
+      } catch (e) {
+        errors.push(e.message);
+      }
+    });
+
+    if (errors.length) {
+      throw new Error(errors.join("\n"));
+    }
+
+    return validatedObject;
+  };
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+var createMinimumValidator = (typeName, minimum) => (value, path) => {
+  assertValid(
+    value >= minimum,
+    value,
+    path,
+    `${typeName} greater than or equal to ${minimum}`,
+  );
+  return value;
+};
+
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+var createMaximumValidator = (typeName, maximum) => (value, path) => {
+  assertValid(
+    value <= maximum,
+    value,
+    path,
+    `${typeName} less than or equal to ${maximum}`,
+  );
+  return value;
+};
+
+/*
+Copyright 2020 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+var createNoUnknownFieldsValidator = (schema) => (value, path) => {
+  const errors = [];
+  Object.keys(value).forEach((subKey) => {
+    if (!schema[subKey]) {
+      const subPath = path ? `${path}.${subKey}` : subKey;
+      errors.push(`'${subPath}': Unknown field.`);
+    }
+  });
+
+  if (errors.length) {
+    throw new Error(errors.join("\n"));
+  }
+
+  return value;
+};
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+var createNonEmptyValidator = (message) => (value, path) => {
+  if (isObject(value)) {
+    assertValid(!isEmptyObject(value), value, path, message);
+  } else {
+    assertValid(value.length > 0, value, path, message);
+  }
+  return value;
+};
+
+/*
+Copyright 2020 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+var createObjectOfValidator = (schema) =>
+  function objectOf(value, path) {
+    assertValid(isObject(value), value, path, "an object");
+
+    const errors = [];
+    const validatedObject = {};
+    Object.keys(schema).forEach((subKey) => {
+      const subValue = value[subKey];
+      const subSchema = schema[subKey];
+      const subPath = path ? `${path}.${subKey}` : subKey;
+      try {
+        const validatedValue = subSchema.call(this, subValue, subPath);
+        if (validatedValue !== undefined) {
+          validatedObject[subKey] = validatedValue;
+        }
+      } catch (e) {
+        errors.push(e.message);
+      }
+    });
+
+    // copy over unknown properties
+    Object.keys(value).forEach((subKey) => {
+      if (!Object.prototype.hasOwnProperty.call(validatedObject, subKey)) {
+        validatedObject[subKey] = value[subKey];
+      }
+    });
+
+    if (errors.length) {
+      throw new Error(errors.join("\n"));
+    }
+    return validatedObject;
+  };
+
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+var createRenamedValidator = (oldField, oldSchema, newField) =>
+  function deprecated(value, path) {
+    assertValid(isObject(value), value, path, "an object");
+
+    const {
+      [oldField]: oldValue,
+      [newField]: newValue,
+      ...otherValues
+    } = value;
+    const validatedOldValue = oldSchema(oldValue, path);
+
+    if (validatedOldValue !== undefined) {
+      let message = `The field '${oldField}' is deprecated. Use '${newField}' instead.`;
+      if (path) {
+        message = `'${path}': ${message}`;
+      }
+      if (newValue !== undefined && newValue !== validatedOldValue) {
+        throw new Error(message);
+      } else if (this && this.logger) {
+        this.logger.warn(message);
+      }
+    }
+    return {
+      [newField]: newValue || validatedOldValue,
+      ...otherValues,
+    };
+  };
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+var createUniqueValidator = () => {
+  const values = [];
+  return (value, path) => {
+    assertValid(
+      values.indexOf(value) === -1,
+      value,
+      path,
+      "a unique value across instances",
+    );
+    values.push(value);
+    return value;
+  };
+};
+
+/*
+Copyright 2022 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+/**
+ * Returns whether an array contains unique values.
+ * @param {*} value
+ * @returns {boolean}
+ */
+var isUnique = (values) => {
+  const storedVals = Object.create(null);
+  for (let i = 0; i < values.length; i += 1) {
+    const item = values[i];
+    if (item in storedVals) {
+      return false;
+    }
+    storedVals[item] = true;
+  }
+  return true;
+};
+
+/*
+Copyright 2022 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+var createUniqueItemsValidator = () => {
+  return (value, path) => {
+    assertValid(isUnique(value), value, path, "array values to be unique");
+    return value;
+  };
+};
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+const DOMAIN_REGEX = /^[a-z0-9.-]{1,}$/i;
+
+var domainValidator = (value, path) => {
+  assertValid(DOMAIN_REGEX.test(value), value, path, "a valid domain");
+  return value;
+};
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+var integerValidator = (value, path) => {
+  assertValid(isInteger(value), value, path, "an integer");
+  return value;
+};
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+var numberValidator = (value, path) => {
+  assertValid(isNumber(value), value, path, "a number");
+  return value;
+};
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/**
+ * Determines whether the value is a valid regular expression.
+ * @param {*} value
+ * @returns {boolean}
+ */
+var isValidRegExp = (value) => {
+  try {
+    return RegExp(value) !== null;
+  } catch {
+    return false;
+  }
+};
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+var regexpValidator = (value, path) => {
+  assertValid(isValidRegExp(value), value, path, "a regular expression");
+  return value;
+};
+
+/*
+Copyright 2020 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+var requiredValidator = (value, path) => {
+  if (value == null) {
+    throw new Error(`'${path}' is a required option`);
+  }
+  return value;
+};
+
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+var stringValidator = (value, path) => {
+  assertValid(isString(value), value, path, "a string");
+  return value;
+};
+
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+var matchesRegexpValidator = (regexp) => (value, path) => {
+  assertValid(
+    regexp.test(value),
+    value,
+    path,
+    `does not match the ${regexp.toString()}`,
+  );
+  return value;
+};
+
+/*
+Copyright 2020 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+// The base validator does no validation and just returns the value unchanged
+const base = (value) => value;
+
+// The 'default', 'required', and 'deprecated' methods are available after any
+// data-type method. Don't use the nullSafeChain on 'default' or 'required'
+// because they need to handle the null or undefined case
+base.default = function _default(defaultValue) {
+  return chain(this, createDefaultValidator(defaultValue));
+};
+base.required = function required() {
+  return chain(this, requiredValidator);
+};
+base.deprecated = function deprecated(message) {
+  return chain(this, createDeprecatedValidator(message));
+};
+
+// helper validators
+const domain = function domain() {
+  return nullSafeChain(this, domainValidator);
+};
+const minimumInteger = function minimumInteger(minValue) {
+  return nullSafeChain(this, createMinimumValidator("an integer", minValue));
+};
+const minimumNumber = function minimumNumber(minValue) {
+  return nullSafeChain(this, createMinimumValidator("a number", minValue));
+};
+const maximumNumber = function maximumNumber(maxValue) {
+  return nullSafeChain(this, createMaximumValidator("a number", maxValue));
+};
+const integer = function integer() {
+  return nullSafeChain(this, integerValidator, { minimum: minimumInteger });
+};
+const nonEmptyString = function nonEmptyString() {
+  return nullSafeChain(this, createNonEmptyValidator("a non-empty string"));
+};
+const nonEmptyArray = function nonEmptyArray() {
+  return nullSafeChain(this, createNonEmptyValidator("a non-empty array"));
+};
+const nonEmptyObject = function nonEmptyObject() {
+  return nullSafeChain(this, createNonEmptyValidator("a non-empty object"));
+};
+const regexp = function regexp() {
+  return nullSafeChain(this, regexpValidator);
+};
+const matches = function matches(regexpPattern) {
+  return nullSafeChain(this, matchesRegexpValidator(regexpPattern));
+};
+const unique = function createUnique() {
+  return nullSafeChain(this, createUniqueValidator());
+};
+const uniqueItems = function createUniqueItems() {
+  return nullSafeChain(this, createUniqueItemsValidator());
+};
+
+// top-level validators.  These are the first functions that are called to create a validator.
+const anyOf = function anyOf(validators, message) {
+  // use chain here because we don't want to accept null or undefined unless at least
+  // one of the validators accept null or undefined.
+  return chain(this, createAnyOfValidator(validators, message));
+};
+const anything = function anything() {
+  return this;
+};
+const arrayOf = function arrayOf(elementValidator) {
+  return nullSafeChain(this, createArrayOfValidator(elementValidator), {
+    nonEmpty: nonEmptyArray,
+    uniqueItems,
+  });
+};
+const boolean = function boolean() {
+  return nullSafeChain(this, booleanValidator);
+};
+const callback = function callback() {
+  return nullSafeChain(this, callbackValidator);
+};
+const literal = function literal(literalValue) {
+  return nullSafeChain(this, createLiteralValidator(literalValue));
+};
+const number = function number() {
+  return nullSafeChain(this, numberValidator, {
+    minimum: minimumNumber,
+    maximum: maximumNumber,
+    integer,
+    unique,
+  });
+};
+const mapOfValues = function mapOfValues(valuesValidator) {
+  return nullSafeChain(this, createMapOfValuesValidator(valuesValidator), {
+    nonEmpty: nonEmptyObject,
+  });
+};
+const createObjectOfAdditionalProperties = (schema) => ({
+  noUnknownFields: function noUnknownFields() {
+    return nullSafeChain(this, createNoUnknownFieldsValidator(schema));
+  },
+  nonEmpty: nonEmptyObject,
+  concat: function concat(otherObjectOfValidator) {
+    // combine the schema so that noUnknownFields, and concat have the combined schema
+    const newSchema = { ...schema, ...otherObjectOfValidator.schema };
+    return nullSafeChain(
+      this,
+      otherObjectOfValidator,
+      createObjectOfAdditionalProperties(newSchema),
+    );
+  },
+  renamed: function renamed(oldField, oldSchema, newField) {
+    // Run the deprecated validator first so that the deprecated field is removed
+    // before the objectOf validator runs.
+    return reverseNullSafeChainJoinErrors(
+      this,
+      createRenamedValidator(oldField, oldSchema, newField),
+    );
+  },
+  schema,
+});
+const objectOf = function objectOf(schema) {
+  return nullSafeChain(
+    this,
+    createObjectOfValidator(schema),
+    createObjectOfAdditionalProperties(schema),
+  );
+};
+const string = function string() {
+  return nullSafeChain(this, stringValidator, {
+    regexp,
+    domain,
+    nonEmpty: nonEmptyString,
+    unique,
+    matches,
+  });
+};
+
+const boundAnyOf = anyOf.bind(base);
+anything.bind(base);
+const boundArrayOf = arrayOf.bind(base);
+const boundBoolean = boolean.bind(base);
+callback.bind(base);
+const boundLiteral = literal.bind(base);
+number.bind(base);
+const boundMapOfValues = mapOfValues.bind(base);
+const boundObjectOf = objectOf.bind(base);
+const boundString = string.bind(base);
+
+// compound validators
+const boundEnumOf = function boundEnumOf(...values) {
+  return boundAnyOf(
+    values.map(boundLiteral),
+    `one of these values: ${JSON.stringify(values)}`,
+  );
+};
+
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+const AMBIGUOUS = "ambiguous";
+const AUTHENTICATED = "authenticated";
+const LOGGED_OUT = "loggedOut";
+
+/*
+Copyright 2020 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+var validateIdentityMap = boundMapOfValues(
+  boundArrayOf(
+    boundObjectOf({
+      authenticatedState: boundEnumOf(AMBIGUOUS, AUTHENTICATED, LOGGED_OUT),
+      id: boundString(),
+      namespace: boundObjectOf({
+        code: boundString(),
+      }).noUnknownFields(),
+      primary: boundBoolean(),
+      xid: boundString(),
+    }).noUnknownFields(),
+  ).required(),
+);
+
+/*
+Copyright 2022 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+
+var validateConfigOverride = boundObjectOf({});
+
+exports.assignConcatArrayValues = assignConcatArrayValues;
+exports.clone = clone;
+exports.cookieJar = cookieJar;
+exports.createCallbackAggregator = createCallbackAggregator;
+exports.createEventMergeId = createEventMergeId;
+exports.createLoggingCookieJar = createLoggingCookieJar;
+exports.createMerger = createMerger;
+exports.createTaskQueue = createTaskQueue;
+exports.deduplicateArray = deduplicateArray;
+exports.deepAssign = deepAssign;
+exports.defer = defer;
+exports.filterObject = filterObject;
+exports.fireImage = fireImageInDocument;
+exports.fnv1a32Hex = fnv1a32Hex;
+exports.getApexDomain = getApexDomain;
+exports.getLastArrayItems = getLastArrayItems;
+exports.getNamespacedCookieName = getNamespacedCookieName;
+exports.groupBy = groupBy;
+exports.injectAreThirdPartyCookiesSupportedByDefault = injectAreThirdPartyCookiesSupportedByDefault;
+exports.injectDoesIdentityCookieExist = injectDoesIdentityCookieExist;
+exports.injectFireReferrerHideableImage = injectFireReferrerHideableImage;
+exports.injectGetBrowser = injectGetBrowser;
+exports.injectStorage = injectStorage;
+exports.intersection = intersection;
+exports.isBoolean = isBoolean;
+exports.isEmptyObject = isEmptyObject;
+exports.isFunction = isFunction;
+exports.isInteger = isInteger;
+exports.isNamespacedCookieName = isNamespacedCookieName;
+exports.isNil = isNil;
+exports.isNonEmptyArray = isNonEmptyArray;
+exports.isNonEmptyString = isNonEmptyString;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isString = isString;
+exports.noop = noop;
+exports.parseUrl = parseUrl;
+exports.prepareConfigOverridesForEdge = prepareConfigOverridesForEdge;
+exports.queryString = queryString;
+exports.sanitizeOrgIdForCookieName = sanitizeOrgIdForCookieName;
+exports.sortObjectKeysRecursively = sortObjectKeysRecursively;
+exports.stackError = stackError;
+exports.stringToBoolean = stringToBoolean;
+exports.toArray = toArray;
+exports.toError = toError;
+exports.toISOStringLocal = toISOStringLocal;
+exports.toInteger = toInteger;
+exports.updateErrorMessage = updateErrorMessage;
+exports.uuid = v4;
+exports.validateConfigOverride = validateConfigOverride;
+exports.validateIdentityMap = validateIdentityMap;