@adobe/alloy 2.27.0 → 2.28.0-beta.1

package/dist/utils.js

@@ -0,0 +1,3206 @@
+/*
+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({});
+
+export { assignConcatArrayValues, clone, cookieJar, createCallbackAggregator, createEventMergeId, createLoggingCookieJar, createMerger, createTaskQueue, deduplicateArray, deepAssign, defer, filterObject, fireImageInDocument as fireImage, fnv1a32Hex, getApexDomain, getLastArrayItems, getNamespacedCookieName, groupBy, injectAreThirdPartyCookiesSupportedByDefault, injectDoesIdentityCookieExist, injectFireReferrerHideableImage, injectGetBrowser, injectStorage, intersection, isBoolean, isEmptyObject, isFunction, isInteger, isNamespacedCookieName, isNil, isNonEmptyArray, isNonEmptyString, isNumber, isObject, isString, noop, parseUrl, prepareConfigOverridesForEdge, queryString, sanitizeOrgIdForCookieName, sortObjectKeysRecursively, stackError, stringToBoolean, toArray, toError, toISOStringLocal, toInteger, updateErrorMessage, v4 as uuid, validateConfigOverride, validateIdentityMap };